Commit bcfb674b6942

@@ -83,7 +83,7 @@ jobs:
         run: |
           # FIXME temporary hack to make system build successfully
           #       I need to create dumb file for mkOutOfStoreSymlink
-          sudo mkdir -p /home/vincent/src/home/tools/emacs /home/vincent/desktop/documents
+          sudo mkdir -p /home/vincent/src/home/dots/.config/emacs /home/vincent/desktop/documents
           sudo touch /home/vincent/desktop/documents/.oath
           # build the system
           nix build --accept-flake-config -L ".#nixosConfigurations.${{ matrix.name }}.config.system.build.toplevel"

@@ -0,0 +1,16 @@
+/home/vincent/src
+/home/vincent
+/home/vincent/desktop/downloads
+~/src/gitlab.com/chmouel/rc-config/aichat
+/ssh:aomi.home:~/src/home
+/sshx:aomi.home:~/src/home
+/ssh:aomi.home:~/src/home
+~/src/home
+~/src/tektoncd/pipeline
+/sshx:aomi.home:~/src/home
+~/src/home
+/home/vincent/src/tektoncd/pipeline/main
+~
+/home/vincent/src/home
+/home/vincent/src/tektoncd
+/home/vincent/src/home

@@ -0,0 +1,3 @@
+alias l exa -lah $*
+alias ll exa -l $*
+alias ls exa $*

@@ -0,0 +1,81 @@
+;;; tonski-modus-theme-ts-focus.el --- Semantic-focused theme without bolding -*- lexical-binding: t; no-byte-compile: t; -*-
+
+(deftheme tonski-modus-ts-focus "A highly accessible, semantic highlighting theme based on Modus/Tonski principles, optimized for Tree-sitter and without bolding.")
+
+(let* ((bg-main "#ffffff")
+       (fg-main "#000000")
+       (bg-subtle "#f8f8f8")
+       (bg-param "#eeeeee")    ; Subtle background for arguments/parameters
+       (fg-dim "#555555")      ; Comments/Fringe
+       
+       ;; Modus-inspired high-contrast colors (no bolding)
+       (color-keyword "#880088")   ; Magenta/Purple for Keywords/Control Flow (where desired)
+       (color-type "#000088")      ; Dark Blue for Types/Classes
+       (color-function "#006800")  ; Dark Green for Function Names
+       (color-constant "#804000")  ; Dark Ochre/Brown for Constants/Macros
+       (color-string "#004080")    ; Deep Blue for Strings
+       (color-warning "#a60000")   ; Dark Red for Errors/Warnings
+       (color-builtin "#008888")   ; Cyan/Teal for Builtins
+       )
+
+  (custom-theme-set-faces
+   'tonski-modus-ts-focus
+   
+   ;; --- Basic/Core Faces ---
+   `(default ((t (:background ,bg-main :foreground ,fg-main :weight normal))))
+   `(cursor ((t (:background ,fg-main))))
+   
+   ;; --- Base Font-Lock Faces (Used primarily as fallbacks/inheritance) ---
+   
+   ;; Use standard colors, but remove bolding
+   `(font-lock-keyword-face ((t (:foreground ,color-keyword :weight normal))))
+   `(font-lock-type-face ((t (:foreground ,color-type :weight normal))))
+   `(font-lock-function-name-face ((t (:foreground ,color-function :weight normal))))
+   `(font-lock-constant-face ((t (:foreground ,color-constant :weight normal))))
+   `(font-lock-string-face ((t (:foreground ,color-string :weight normal))))
+   `(font-lock-comment-face ((t (:foreground ,fg-dim :italic t :weight normal))))
+   
+   ;; Variables/Identifiers: Set to default FG
+   `(font-lock-variable-name-face ((t (:foreground ,fg-main :weight normal))))
+   
+   ;; --- Tree-sitter Faces (Granular Semantic Highlighting Focus) ---
+   ;; We define specific TS faces to adhere to Tonski's principles precisely
+   
+   ;; 1. Function and Method Names (Action/Behavior)
+   `(tree-sitter-hl-face:function ((t (:foreground ,color-function :weight normal))))
+   `(tree-sitter-hl-face:method ((t (:foreground ,color-function :weight normal))))
+   
+   ;; 2. Types and Classes (Structure/Data)
+   `(tree-sitter-hl-face:type ((t (:foreground ,color-type :weight normal))))
+   `(tree-sitter-hl-face:type.definition ((t (:foreground ,color-type :weight normal))))
+   
+   ;; 3. Constants and Macros (Stable/Immutable Data)
+   `(tree-sitter-hl-face:constant ((t (:foreground ,color-constant :weight normal))))
+   `(tree-sitter-hl-face:macro ((t (:foreground ,color-constant :weight normal))))
+   
+   ;; 4. Keywords (Control Flow)
+   ;; Keeping keywords colored for now, but you can change this to `fg-main`
+   ;; if you want to de-emphasize all keywords like the previous refinement.
+   `(tree-sitter-hl-face:keyword ((t (:foreground ,color-keyword :weight normal))))
+   
+   ;; 5. Variables/Identifiers (De-emphasized)
+   `(tree-sitter-hl-face:variable ((t (:foreground ,fg-main :weight normal))))
+   
+   ;; 6. Parameters/Arguments (The key background distinction)
+   `(tree-sitter-hl-face:parameter ((t (:background ,bg-param :foreground ,fg-main :weight normal))))
+   
+   ;; 7. Fields/Properties (Subtle visual cue)
+   `(tree-sitter-hl-face:field ((t (:foreground ,fg-main :italic t :weight normal))))
+   
+   ;; 8. Strings
+   `(tree-sitter-hl-face:string ((t (:foreground ,color-string :weight normal))))
+   
+   ;; 9. Errors/Warnings
+   `(tree-sitter-hl-face:error ((t (:foreground ,color-warning :weight normal))))
+   
+   ;; --- Other common faces ---
+   `(warning ((t (:foreground ,color-warning :weight normal))))
+   `(error ((t (:foreground ,color-warning :weight normal))))
+   ))
+
+(provide 'tonski-modus-theme-ts-focus)

@@ -0,0 +1,2 @@
+
+(("~/desktop/org/todos.org" #("cebe49a8-26b3-4e0f-b19a-f59e26ae44c9" 0 36 (fontified t face org-property-value jinx--pending t)) #("c5879aee-78e9-42c3-b890-003a2e608930" 0 36 (fontified t face org-property-value jinx--pending t))) ("~/desktop/org/archive/work" #("a7964503-3312-4479-b86a-f9ae29307b9b" 0 28 (fontified t face org-property-value jinx--pending t) 28 36 (fontified nil face org-property-value)) #("7b899463-a336-46ef-9f85-ae1676d43108" 0 36 (fontified t face org-property-value jinx--pending t))))

@@ -19,6 +19,9 @@ $(call rule.define,~,$(~))
 all += niri
 niri : ~/.config/niri/config.kdl
 
+all += emacs
+emacs : ~/.config/emacs
+
 all += claude-skills
 claude-skills : ~/.config/claude/skills
 

@@ -272,7 +272,7 @@ in
           always = true;
         }
         # Probably put a condition here.
-        { command = "emacs --init-directory=$HOME/src/home/tools/emacs --fg-daemon"; }
+        { command = "emacs --fg-daemon"; }
         { command = "i3-back"; }
         { command = "firefox"; }
         { command = "sleep 20; emacsclient --eval '(vde/agenda)'"; }

@@ -0,0 +1,100 @@
+---
+description: '4.1 Beast Mode'
+tools: ['changes', 'codebase', 'editFiles', 'extensions', 'fetch', 'findTestFiles', 'githubRepo', 'new', 'openSimpleBrowser', 'problems', 'readCellOutput', 'runCommands', 'runNotebooks', 'runTasks', 'runTests', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'updateUserPreferences', 'usages', 'vscodeAPI']
+----
+
+You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user.
+
+Your thinking should be thorough and so it's fine if it's very long. However, avoid unnecessary repetition and verbosity. You should be concise, but thorough.
+
+You MUST iterate and keep going until the problem is solved.
+
+I want you to fully solve this autonomously before coming back to me.
+
+Only terminate your turn when you are sure that the problem is solved and all items have been checked off. Go through the problem step by step, and make sure to verify that your changes are correct. NEVER end your turn without having truly and completely solved the problem, and when you say you are going to make a tool call, make sure you ACTUALLY make the tool call, instead of ending your turn.
+
+Always tell the user what you are going to do before making a tool call with a single concise sentence. This will help them understand what you are doing and why.
+
+If the user request is "resume" or "continue" or "try again", check the previous conversation history to see what the next incomplete step in the todo list is. Continue from that step, and do not hand back control to the user until the entire todo list is complete and all items are checked off. Inform the user that you are continuing from the last incomplete step, and what that step is.
+
+Take your time and think through every step - remember to check your solution rigorously and watch out for boundary cases, especially with the changes you made. Your solution must be perfect. If not, continue working on it. At the end, you must test your code rigorously using the tools provided, and do it many times, to catch all edge cases. If it is not robust, iterate more and make it perfect. Failing to test your code sufficiently rigorously is the NUMBER ONE failure mode on these types of tasks; make sure you handle all edge cases, and run existing tests if they are provided.
+
+You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
+
+# Workflow
+
+1. Understand the problem deeply. Carefully read the issue and think critically about what is required.
+2. Investigate the codebase. Explore relevant files, search for key functions, and gather context.
+3. Develop a clear, step-by-step plan. Break down the fix into manageable, incremental steps. Display those steps in a simple todo list using standard markdown format. Make sure you wrap the todo list in triple backticks so that it is formatted correctly.
+4. Implement the fix incrementally. Make small, testable code changes.
+5. Debug as needed. Use debugging techniques to isolate and resolve issues.
+6. Test frequently. Run tests after each change to verify correctness.
+7. Iterate until the root cause is fixed and all tests pass.
+8. Reflect and validate comprehensively. After tests pass, think about the original intent, write additional tests to ensure correctness, and remember there are hidden tests that must also pass before the solution is truly complete.
+
+Refer to the detailed sections below for more information on each step.
+
+## 1. Deeply Understand the Problem
+Carefully read the issue and think hard about a plan to solve it before coding.
+
+## 2. Codebase Investigation
+- Explore relevant files and directories.
+- Search for key functions, classes, or variables related to the issue.
+- Read and understand relevant code snippets.
+- Identify the root cause of the problem.
+- Validate and update your understanding continuously as you gather more context.
+
+## 3. Fetch Provided URLs
+- If the user provides a URL, use the `functions.fetch_webpage` tool to retrieve the content of the provided URL.
+- After fetching, review the content returned by the fetch tool.
+- If you find any additional URLs or links that are relevant, use the `fetch_webpage` tool again to retrieve those links.
+- Recursively gather all relevant information by fetching additional links until you have all the information you need.
+
+## 4. Develop a Detailed Plan 
+- Outline a specific, simple, and verifiable sequence of steps to fix the problem.
+- Create a todo list in markdown format to track your progress.
+- Each time you complete a step, check it off using `[x]` syntax.
+- Each time you check off a step, display the updated todo list to the user.
+- Make sure that you ACTUALLY continue on to the next step after checkin off a step instead of ending your turn and asking the user what they want to do next.
+
+## 5. Making Code Changes
+- Before editing, always read the relevant file contents or section to ensure complete context.
+- Always read 2000 lines of code at a time to ensure you have enough context.
+- If a patch is not applied correctly, attempt to reapply it.
+- Make small, testable, incremental changes that logically follow from your investigation and plan.
+
+## 6. Debugging
+- Make code changes only if you have high confidence they can solve the problem
+- When debugging, try to determine the root cause rather than addressing symptoms
+- Debug for as long as needed to identify the root cause and identify a fix
+- Use the #problems tool to check for any problems in the code
+- Use print statements, logs, or temporary code to inspect program state, including descriptive statements or error messages to understand what's happening
+- To test hypotheses, you can also add test statements or functions
+- Revisit your assumptions if unexpected behavior occurs.
+
+# Fetch Webpage
+Use the `fetch_webpage` tool when the user provides a URL. Follow these steps exactly.
+
+1. Use the `fetch_webpage` tool to retrieve the content of the provided URL.
+2. After fetching, review the content returned by the fetch tool.
+3. If you find any additional URLs or links that are relevant, use the `fetch_webpage` tool again to retrieve those links.
+4. Go back to step 2 and repeat until you have all the information you need.
+
+IMPORTANT: Recursively fetching links is crucial. You are not allowed skip this step, as it ensures you have all the necessary context to complete the task.
+
+# How to create a Todo List
+Use the following format to create a todo list:
+```markdown
+- [ ] Step 1: Description of the first step
+- [ ] Step 2: Description of the second step
+- [ ] Step 3: Description of the third step
+```
+
+Do not ever use HTML tags or any other formatting for the todo list, as it will not be rendered correctly. Always use the markdown format shown above.
+
+# Creating Files
+Each time you are going to create a file, use a single concise sentence inform the user of what you are creating and why.
+
+# Reading Files
+- Read 2000 lines of code at a time to ensure that you have enough context. 
+- Each time you read a file, use a single concise sentence to inform the user of what you are reading and why.
\ No newline at end of file

@@ -0,0 +1,1 @@
+Review the following code and report any obvious issues. Be brief and direct—no nitpicking, just major flaws or inefficiencies.

@@ -0,0 +1,7 @@
+This is is a list of files from a git change, the list of the changed have the
+original file prior to the changes and the diff with the changes. Can you
+careful analyze the changes and find if there is bug? or spelling mistakes or improvement of code to make it more idiomatic?
+
+Here is the list of files:
+
+__INPUT__

@@ -0,0 +1,6 @@
+can you suggest a git branch name out of this diff, just output the branch name
+nothing else. Do not add slash into the branch name or the type like
+feature/bugfix etc. Make sure to separate words with hyphens.
+
+if you see a SRVKP (jira ticket) always specify it branch name capitalized like
+SRVKP at the beginning.

@@ -0,0 +1,39 @@
+You are to generate a commit message based on the provided file list and diffs.
+Wait until I say **END OF INPUT** before responding.
+
+Format your response as follows:
+
+<type>: <subject>
+
+<body>
+
+**Rules:**
+
+* `type`: One of `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `chore`.
+* Subject:
+  * 50–70 characters.
+  * Capitalize only the first letter.
+  * Imperative mood.
+  * No ending period.
+  * No “and”.
+* Body:
+  * Cohesive long phrase or paragraph unless multiple points are needed.
+  * Use bullet points only if necessary for clarity.
+  * Past tense.
+  * State **what** and **why** only (no “how”).
+  * Skip obvious reasons.
+  * Skip really minor changes that are not important to mention.
+  * Avoid phrases like "for better visual clarity" unless essential.
+  * Wrap at 72 characters.
+  * Don't say obvious things like "This streamlined" avoid it.
+* For small changes, use `fix`.
+* Insert a blank line between subject and body.
+* Follow Conventional Commits 1.0.0.
+
+**Output:** Commit message only — no extra text.
+
+**Input:**
+
+```
+__INPUT__
+```

@@ -0,0 +1,1 @@
+Create a 3 lines release note for a jira ticket. The note should be concise and highlight the key changes or fixes made in the ticket. This should use red hat documentation style.

@@ -0,0 +1,71 @@
+---
+mode: 'ask'
+---
+I am going to copy you a jira template, and I will be copying to you a bunch of
+discussions and context after that, can you help me make the jira issue and
+provide a title for it?
+
+### IMPORTANT, make sure to follow these guidelines:
+
+- Make sure to don't add implementation details, just the high level
+context. We want to keep the implementation details for the engineers to figure.
+- Try to add link if you see something that can be linked in the jira issue.
+- Always output as Jira markdown formatting.
+- Make it easy to copy and paste to the jira input box.
+- Do not mention customer names. Just reference them as "customer".
+
+### Assistant instructions (use this when I paste template + context)
+
+- I will paste a Jira template followed by discussion/context. Produce:
+  - A concise Jira issue body that fills the provided template (Jira markdown).
+  - A short, descriptive issue title (one line).
+- Keep the issue high-level — do NOT add implementation details or design steps. Engineers will own those.
+- Prefer including links when available (use full URLs or JIRA-KEY format).
+- Use clear, testable Acceptance Criteria (Given / When / Then or numbered checklist).
+- Always add blockquote ```jira-markup at the start and finish ``` at the start and end of the output.
+- Output only Jira-compatible markdown (no code fences or extra commentary) and format so it’s copy-paste ready into the Jira input box.
+
+### Jira Template
+
+```jira-markup
+
+h1. Story (Required)
+
+As a <PERSONA> trying to <ACTION> I want <THIS OUTCOME>
+
+_<Describes high level purpose and goal for this story. Answers the questions: Who is impacted, what is it and why do we need it? How does it improve the customer’s experience?>_
+
+h2. *Background (Required)*
+
+_<Describes the context or background related to this story>_
+
+h2. *Out of scope*
+
+_<Defines what is not included in this story>_
+
+h2. *Approach (Required)*
+
+_<Description of the general technical path on how to achieve the goal of the story. Include details like json schema, class definitions>_
+
+h2. *Dependencies*
+
+_<Describes what this story depends on. Dependent Stories and EPICs should be linked to the story.>_
+
+h2. *Acceptance Criteria  (Mandatory)*
+
+_<Describe edge cases to consider when implementing the story and defining tests>_
+_<Provides a required and minimum list of acceptance tests for this story. More is expected as the engineer implements this story>_
+
+h1. *INVEST Checklist*
+
+ Dependencies identified
+
+ Blockers noted and expected delivery timelines set
+
+ Design is implementable
+
+ Acceptance criteria agreed upon
+
+ Story estimated
+
+```

@@ -0,0 +1,1 @@
+jira.md
\ No newline at end of file

@@ -0,0 +1,25 @@
+I am going to copy you a jira template, and I will be copying to you a bunch of
+discussions and context after that, can you help me make the jira issue and
+provide a title for it? Make sure to output as jira formatting and make it easy
+to copy and paste directly on the jira textbox, so no specific markdown
+
+Jira Template for a bug, using jira formtatting:
+
+h3. *Description of problem:*
+
+Workaround
+h3. *Prerequisites (if any, like setup, operators/versions):*
+h3. *Steps to Reproduce*
+
+# <steps>
+
+h3. *Actual results:*
+h3. *Expected results:*
+h3. *Reproducibility (Always/Intermittent/Only Once):*
+h3. *Acceptance criteria:*
+
+*Definition of Done:*
+h3. *Build Details:*
+h3. *Additional info (Such as Logs, Screenshots, etc):*
+
+h3.  *

@@ -0,0 +1,18 @@
+You are a technical writer at IBM, tasked with refining an engineer's draft documentation for OpenShift. Your responsibilities include:  
+
+1. Correcting spelling, grammar, punctuation, and formatting errors.  
+2. Rephrasing content for clarity, conciseness, and fluency while maintaining technical accuracy.  
+3. Ensuring the tone and style align with IBM's professional documentation standards.  
+4. Retaining any markdown formatting (e.g., headers, lists, inline code) and enhancing its usage to improve readability and structure.  
+5. Ensuring the content conforms to **Markdownlint rules**. The most common rules include:  
+   - Use a single `#` for the main heading and avoid skipping heading levels. (except keep metadata)
+   - Ensure line lengths do not exceed 80 characters (where possible).  
+   - Use consistent spacing after list markers (e.g., `-`, `*`, `1.`).  
+   - Include blank lines before and after headers, code blocks, and lists.  
+   - Avoid trailing spaces at the end of lines.  
+   - Use fenced code blocks (``` or ~~~) for code snippets.  
+   - Use unordered lists consistently (e.g., don't mix `-` and `*`).  
+   - Ensure links are formatted correctly `[text](url)` and avoid duplicate link definitions.  
+   - Include alt text for images: `![alt text](image_url)`.  
+6. Do not add initial ```markdown and end with a``` markers
+7. Do not remove the initial markdown metadata

@@ -0,0 +1,11 @@
+Here is the output of my releases changes, can you make a list of all notable
+changes and categorize it nicely between features/bugs/misc with emojis output
+as markdown and a one liner of the change?
+
+Make sure to link the commit url to a prefix with
+<https://github.com/openshift-pipelines/pipelines-as-code/commit/> at the end
+of each changes. Add a jira link like
+[SRVKP-XXX](https://issues.redhat.com/browse/SRKVP-XXX) for each change if there is
+one specified in the commit message.
+
+__INPUT__

@@ -0,0 +1,5 @@
+Rewrite this text to be better english or french if written in french, more concise, and more engaging. Maintain the original meaning and context and tone. Make sure to answer in the original language of the text.
+
+Only output the rewritten text, do not include any additional comments or explanations or any options.
+
+__INPUT__

@@ -0,0 +1,11 @@
+Vous êtes un modèle conçu pour corriger uniquement les fautes de français dans un
+texte. Répondez en renvoyant exclusivement le texte corrigé, sans
+explications, annotations, ou autre contenu.
+
+Si vous ne pouvez pas corriger le texte, renvoyez-le tel quel, inchangé.
+Si le texte est en Markdown, conservez la mise en forme à tout prix.
+Si le texte est en anglais, renvoyez la réponse en anglais.
+
+Voici le texte à corriger :
+
+__INPUT__

@@ -169,10 +169,6 @@ let
     ];
 in
 {
-  home.file.".config/emacs" = {
-    source = config.lib.file.mkOutOfStoreSymlink "/home/vincent/src/home/tools/emacs";
-    # recursive = true;
-  };
   home.file.".local/share/applications/org-protocol.desktop".source = ./emacs/org-protocol.desktop;
   home.file.".local/share/applications/capture.desktop".source = ./emacs/capture.desktop;
   home.packages = with pkgs; [

@@ -0,0 +1,47 @@
+#!/bin/bash
+set -euo pipefail
+
+# Example setup script for testing fedora-vm
+# This script demonstrates what you can do inside a provisioned VM
+
+echo "========================================="
+echo "Fedora VM Setup Script"
+echo "========================================="
+echo ""
+
+# Display system information
+echo "System Information:"
+echo "  Hostname: $(hostname)"
+echo "  OS: $(cat /etc/os-release | grep PRETTY_NAME | cut -d'"' -f2)"
+echo "  Kernel: $(uname -r)"
+echo "  Memory: $(free -h | awk '/^Mem:/ {print $2}')"
+echo "  CPUs: $(nproc)"
+echo ""
+
+# Update package database
+echo "Updating package database..."
+sudo dnf makecache --quiet
+
+# Install some packages
+echo "Installing example packages..."
+sudo dnf install -y \
+  htop \
+  tmux \
+  tree \
+  jq \
+  &> /dev/null
+
+echo "Installed packages:"
+rpm -qa | grep -E '^(htop|tmux|tree|jq)' | sort
+
+echo ""
+echo "Testing installed tools:"
+echo "  htop version: $(htop --version 2>&1 | head -1)"
+echo "  tmux version: $(tmux -V)"
+echo "  tree version: $(tree --version | head -1)"
+echo "  jq version: $(jq --version)"
+
+echo ""
+echo "========================================="
+echo "Setup completed successfully!"
+echo "========================================="

@@ -0,0 +1,10 @@
+#+TITLE: hl, home-lab dispatcher
+
+This is a tool that encapsulate behavior and knowledge from my home
+network. The idea is that for things like wake-on-lan, etc. I can
+easily run a command.
+
+#+begin_src bash
+  $ hl wake-up shikoku  # wakes up shikoku
+  $ hl poweroff shikoku # shuts down shikoku (using ssh, …)
+#+end_src

@@ -0,0 +1,198 @@
+#!/usr/bin/env bash
+# check-firmware-usage.sh
+# Analyzes which firmware is actually loaded/needed on your system
+
+set -euo pipefail
+
+# Colors
+BOLD='\033[1m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+echo -e "${BOLD}=== Firmware Usage Analysis ===${NC}"
+echo ""
+
+# 1. Check what firmware files are actually loaded
+echo -e "${BOLD}${CYAN}1. Firmware Files Currently Loaded${NC}"
+echo "---"
+echo "Checking dmesg for firmware loading..."
+echo ""
+
+LOADED_FW=$(dmesg | grep -i "firmware" | grep -i "load" | grep -v "failed" | sort -u || echo "")
+if [ -n "$LOADED_FW" ]; then
+    echo "$LOADED_FW" | while read -r line; do
+        # Extract firmware filename
+        fw=$(echo "$line" | grep -oP '(?<=firmware: ).*?(?=\s|$)' || echo "$line")
+        echo -e "  ${GREEN}✓${NC} $fw"
+    done
+else
+    echo "  No firmware load messages found in dmesg"
+fi
+echo ""
+
+# 2. Check for firmware loading failures
+echo -e "${BOLD}${CYAN}2. Firmware Loading Failures (if any)${NC}"
+echo "---"
+FAILED_FW=$(dmesg | grep -i "firmware" | grep -iE "fail|error|not found" | sort -u || echo "")
+if [ -n "$FAILED_FW" ]; then
+    echo "$FAILED_FW" | while read -r line; do
+        fw=$(echo "$line" | grep -oP '(?<=firmware: ).*?(?=\s|$)' || echo "$line")
+        echo -e "  ${YELLOW}⚠${NC} $fw"
+    done
+else
+    echo -e "  ${GREEN}✓ No firmware failures detected${NC}"
+fi
+echo ""
+
+# 3. Identify hardware that typically needs firmware
+echo -e "${BOLD}${CYAN}3. Hardware Components${NC}"
+echo "---"
+
+echo -e "${YELLOW}WiFi/Wireless:${NC}"
+lspci | grep -iE "network|wireless|wifi|802.11" || echo "  None found via lspci"
+lsusb | grep -iE "network|wireless|wifi|802.11" || echo "  None found via lsusb"
+echo ""
+
+echo -e "${YELLOW}Graphics:${NC}"
+lspci | grep -iE "vga|3d|display|graphics" || echo "  None found"
+echo ""
+
+echo -e "${YELLOW}Bluetooth:${NC}"
+lsusb | grep -i bluetooth || lspci | grep -i bluetooth || echo "  None found"
+echo ""
+
+echo -e "${YELLOW}Sound/Audio:${NC}"
+lspci | grep -i audio || echo "  None found"
+echo ""
+
+# 4. Check loaded kernel modules
+echo -e "${BOLD}${CYAN}4. Loaded Kernel Modules (firmware-heavy drivers)${NC}"
+echo "---"
+
+MODULES=$(lsmod | tail -n +2 | awk '{print $1}' | sort)
+
+# Common modules that need firmware
+FW_MODULES=(
+    "iwlwifi"      # Intel WiFi
+    "ath10k"       # Atheros WiFi
+    "ath9k"        # Atheros WiFi
+    "rtw88"        # Realtek WiFi
+    "mt76"         # MediaTek WiFi
+    "brcmfmac"     # Broadcom WiFi
+    "btusb"        # Bluetooth
+    "i915"         # Intel graphics
+    "amdgpu"       # AMD graphics
+    "nouveau"      # Nvidia (open)
+    "nvidia"       # Nvidia (proprietary)
+    "snd_hda"      # HD Audio
+)
+
+echo "Firmware-dependent modules currently loaded:"
+for mod in "${FW_MODULES[@]}"; do
+    if echo "$MODULES" | grep -q "^${mod}"; then
+        echo -e "  ${GREEN}✓${NC} $mod"
+    fi
+done
+echo ""
+
+# 5. List firmware files in /lib/firmware
+echo -e "${BOLD}${CYAN}5. Firmware Files Present in /lib/firmware${NC}"
+echo "---"
+if [ -d /lib/firmware ]; then
+    FW_COUNT=$(find /lib/firmware -type f 2>/dev/null | wc -l)
+    FW_SIZE=$(du -sh /lib/firmware 2>/dev/null | cut -f1)
+    echo "Total firmware files: $FW_COUNT"
+    echo "Total size: $FW_SIZE"
+    echo ""
+
+    echo "Largest firmware directories:"
+    du -sh /lib/firmware/* 2>/dev/null | sort -rh | head -10
+else
+    echo "  /lib/firmware not found"
+fi
+echo ""
+
+# 6. Check what's actually being used from linux-firmware
+echo -e "${BOLD}${CYAN}6. Specific Firmware Recommendations${NC}"
+echo "---"
+
+RECOMMENDATIONS=""
+
+# Check for Intel WiFi
+if echo "$MODULES" | grep -q "^iwlwifi"; then
+    RECOMMENDATIONS="${RECOMMENDATIONS}hardware.firmware = [ pkgs.linux-firmware ];  # Intel WiFi (iwlwifi)\n"
+fi
+
+# Check for AMD GPU
+if lspci | grep -q "AMD.*Radeon\|AMD.*Graphics" || echo "$MODULES" | grep -q "^amdgpu"; then
+    RECOMMENDATIONS="${RECOMMENDATIONS}hardware.firmware = [ pkgs.linux-firmware ];  # AMD GPU needs firmware\n"
+fi
+
+# Check for Atheros WiFi
+if echo "$MODULES" | grep -qE "^ath10k|^ath9k"; then
+    RECOMMENDATIONS="${RECOMMENDATIONS}hardware.firmware = [ pkgs.linux-firmware ];  # Atheros WiFi\n"
+fi
+
+# Check for Realtek
+if lspci | grep -qi "realtek" || echo "$MODULES" | grep -q "^rtw"; then
+    RECOMMENDATIONS="${RECOMMENDATIONS}hardware.firmware = [ pkgs.linux-firmware ];  # Realtek devices\n"
+fi
+
+# Check for Broadcom
+if lspci | grep -qi "broadcom" || echo "$MODULES" | grep -q "^brcm"; then
+    RECOMMENDATIONS="${RECOMMENDATIONS}hardware.firmware = [ pkgs.linux-firmware ];  # Broadcom WiFi\n"
+fi
+
+# Check for Intel graphics
+if lspci | grep -q "Intel.*Graphics\|Intel.*VGA" || echo "$MODULES" | grep -q "^i915"; then
+    echo -e "${GREEN}✓${NC} Intel graphics detected - usually works without firmware"
+fi
+
+if [ -n "$RECOMMENDATIONS" ]; then
+    echo ""
+    echo -e "${YELLOW}Based on your hardware, you likely need:${NC}"
+    echo ""
+    echo -e "$RECOMMENDATIONS"
+else
+    echo ""
+    echo -e "${GREEN}✓${NC} No obvious firmware dependencies detected"
+    echo "  Your hardware might work fine without linux-firmware package"
+fi
+
+echo ""
+echo -e "${BOLD}${CYAN}7. NixOS Configuration Recommendations${NC}"
+echo "---"
+
+cat << 'EOF'
+For a laptop, you have several options:
+
+Option 1: Keep redistributable firmware (safest for laptops)
+  hardware.enableRedistributableFirmware = true;
+  # Includes: WiFi, Bluetooth, GPU firmware (~730MB)
+
+Option 2: Minimal firmware (if WiFi/GPU work without it)
+  hardware.enableRedistributableFirmware = false;
+  hardware.firmware = with pkgs; [
+    # Only include what you actually need, e.g.:
+    # wireless-regdb  # Regulatory database for WiFi
+  ];
+
+Option 3: Disable entirely (test carefully!)
+  hardware.enableRedistributableFirmware = false;
+  # Only works if all hardware functions without firmware
+
+To test Option 2 or 3:
+1. Boot with current config
+2. Test all hardware (WiFi, Bluetooth, suspend/resume, graphics)
+3. Check 'dmesg | grep -i firmware' for failures
+4. If anything breaks, revert to Option 1
+EOF
+
+echo ""
+echo -e "${BOLD}Next Steps:${NC}"
+echo "1. Review the loaded firmware and hardware above"
+echo "2. Choose a configuration option"
+echo "3. Test thoroughly before committing to production"
+echo ""

@@ -0,0 +1,751 @@
+#!/usr/bin/env bash
+# nix-store-analyzer.sh
+# Analyzes Nix store usage and identifies old GC roots keeping packages alive
+#
+# Usage:
+#   ./nix-store-analyzer.sh              # Analyze local machine
+#   ./nix-store-analyzer.sh host.vpn     # Analyze remote host via SSH
+#   ./nix-store-analyzer.sh user@host    # Analyze remote host with specific user
+
+set -euo pipefail
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m' # No Color
+
+# Configuration
+TARGET="${1:-}"
+MIN_SIZE_MB=100  # Only show packages larger than this
+TOP_N=30         # Show top N largest packages
+
+# Determine if remote or local
+if [ -n "$TARGET" ]; then
+    SSH_PREFIX="ssh $TARGET"
+    HOSTNAME="$TARGET"
+else
+    SSH_PREFIX=""
+    HOSTNAME="$(hostname)"
+fi
+
+# Helper function to run command (local or remote)
+run_cmd() {
+    if [ -n "$SSH_PREFIX" ]; then
+        # For remote: use bash explicitly to avoid zsh glob issues
+        $SSH_PREFIX "bash -c $(printf '%q' "$@")"
+    else
+        bash -c "$@"
+    fi
+}
+
+# Helper to format sizes
+human_size() {
+    numfmt --to=iec-i --suffix=B "$1" 2>/dev/null || echo "$1"
+}
+
+echo -e "${BOLD}=== Nix Store Analysis for ${CYAN}${HOSTNAME}${NC}${BOLD} ===${NC}"
+echo ""
+
+# 1. Disk usage overview
+echo -e "${BOLD}${BLUE}1. Disk Usage Overview${NC}"
+echo "---"
+run_cmd 'df -h / | grep -E "Filesystem|^/dev"'
+echo ""
+run_cmd 'timeout 10 du -sh /nix/store 2>/dev/null || echo "  (calculating in background, see section 11 for full details)"'
+echo ""
+
+# 2. System generation info
+echo -e "${BOLD}${BLUE}2. System Generations${NC}"
+echo "---"
+CURRENT_SYSTEM=$(run_cmd 'readlink /run/current-system 2>/dev/null' || echo "unknown")
+echo -e "Current system: ${CYAN}${CURRENT_SYSTEM}${NC}"
+echo ""
+
+# Try to list generations (needs root/sudo)
+GEN_COUNT=$(run_cmd 'sudo nix-env --list-generations --profile /nix/var/nix/profiles/system 2>/dev/null | wc -l' || echo "0")
+if [ "$GEN_COUNT" -gt 0 ]; then
+    echo -e "System generations: ${YELLOW}${GEN_COUNT}${NC}"
+    echo ""
+    run_cmd 'sudo nix-env --list-generations --profile /nix/var/nix/profiles/system 2>/dev/null | tail -5'
+else
+    # Fallback: count boot entries
+    BOOT_COUNT=$(run_cmd 'ls -1 /nix/var/nix/profiles/system-*-link 2>/dev/null | wc -l' || echo "0")
+    echo -e "System profile links: ${YELLOW}${BOOT_COUNT}${NC} (may need sudo for full generation list)"
+fi
+echo ""
+
+# 3. Largest packages in store (sample-based, fast)
+echo -e "${BOLD}${BLUE}3. Largest Packages (top ${TOP_N}, >${MIN_SIZE_MB}MB)${NC}"
+echo "---"
+echo -e "${CYAN}Size      Package${NC}"
+echo "(Sampling method - fast estimation)"
+echo ""
+
+# Fast method: Check current system + known large package patterns
+run_cmd "timeout 10 bash -c '
+    {
+        # Check current system closure
+        nix path-info -rSh /run/current-system 2>/dev/null | tail -n +2 || true
+
+        # Check known large packages
+        find /nix/store -maxdepth 1 -type d \( \
+            -name \"*linux-firmware*\" -o \
+            -name \"*gcc-*\" -o \
+            -name \"*go-1.*\" -o \
+            -name \"*llvm-*\" -o \
+            -name \"*rust-*\" -o \
+            -name \"*python*\" -o \
+            -name \"*nodejs-*\" -o \
+            -name \"*chromium-*\" -o \
+            -name \"*firefox-*\" -o \
+            -name \"*kernel-*\" -o \
+            -name \"*emacs-*\" \
+        \) -exec du -sh {} \; 2>/dev/null || true
+    } |
+    grep -v \"\.drv\" |
+    awk \"{print \\\$1, \\\$2}\" |
+    sort -rh |
+    head -${TOP_N} |
+    while read -r size path; do
+        # Convert size to MB for filtering
+        size_val=\$(echo \$size | sed \"s/[GM]//\")
+        size_unit=\$(echo \$size | grep -o \"[GM]\" || echo \"M\")
+        if [ \"\$size_unit\" = \"G\" ]; then
+            size_mb=\$(echo \"\$size_val * 1000\" | bc 2>/dev/null || echo \"1000\")
+        else
+            size_mb=\$(echo \"\$size_val\" | cut -d\".\" -f1)
+        fi
+
+        if [ \"\$size_mb\" -ge ${MIN_SIZE_MB} ] 2>/dev/null; then
+            name=\$(basename \"\$path\" 2>/dev/null || echo \"\$path\")
+            printf \"%-10s %s\\\\n\" \"\$size\" \"\$name\"
+        fi
+    done
+' 2>/dev/null" || echo "  (timeout or error - use nix-du for full analysis)"
+
+echo ""
+
+# 4. Identify specific problematic packages
+echo -e "${BOLD}${BLUE}4. Potentially Outdated Packages${NC}"
+echo "---"
+
+# Check for old Go versions (actual Go compiler, not tools written in Go)
+echo -e "${YELLOW}Old Go compiler versions:${NC}"
+run_cmd 'shopt -s nullglob; du -sh /nix/store/*-go-1.* 2>/dev/null |
+    grep -E "/go-1\.[0-9]|/go-1\.[0-9][0-9]" |
+    grep -v "go-1.2[0-9]" |
+    grep -v "\.drv" |
+    sort -rh | head -10 || true' || echo "  None found"
+echo ""
+
+# Check for old GCC versions
+echo -e "${YELLOW}Old GCC compiler versions:${NC}"
+run_cmd 'du -sh /nix/store/*-gcc-[0-9]* 2>/dev/null |
+    grep -E "gcc-[0-9]\." |
+    grep -v "gcc-1[4-9]" |
+    grep -v "\.drv\|\.patch" |
+    sort -rh | head -10' || echo "  None found"
+echo ""
+
+# Check for large firmware
+echo -e "${YELLOW}Firmware packages:${NC}"
+run_cmd 'du -sh /nix/store/*firmware* 2>/dev/null | sort -rh | head -5' || echo "  None found"
+echo ""
+
+# Check for multiple versions of same tool (excluding .drv files)
+echo -e "${YELLOW}Multiple versions of common tools:${NC}"
+echo "(Multiple versions are normal - different tools depend on different Go versions)"
+run_cmd 'find /nix/store -maxdepth 1 -type d \( -name "*-helix-*" -o -name "*-difftastic-*" -o -name "*-emacs-[0-9]*" -o -name "*-go-1.*" \) 2>/dev/null |
+    sed "s|/nix/store/[a-z0-9]\{32\}-||" |
+    sed "s/-x86_64.*//" |
+    sort -u |
+    awk -F"-" "
+    {
+        # Extract base name and version
+        base = \$1;
+        version = \"\";
+
+        # Build base name (everything before version number)
+        for(i=2; i<=NF; i++) {
+            if (\$i ~ /^[0-9]+(\.[0-9]+)*/) {
+                # Found version, everything from here is version
+                for(j=i; j<=NF; j++) {
+                    if (j == i) version = \$j;
+                    else version = version \"-\" \$j;
+                }
+                break;
+            } else {
+                base = base \"-\" \$i;
+            }
+        }
+
+        # Store version for this base
+        if (version != \"\") {
+            versions[base] = versions[base] \" \" version;
+        }
+    }
+    END {
+        for (base in versions) {
+            # Get unique versions
+            split(versions[base], arr, \" \");
+            delete unique;
+            for (i in arr) {
+                if (arr[i] != \"\") {
+                    unique[arr[i]] = 1;
+                }
+            }
+
+            count = length(unique);
+            if (count > 1) {
+                printf \"  %s: %d versions\n\", base, count;
+
+                # Sort and display versions
+                n = asorti(unique, sorted);
+                printf \"    \"
+                for (i = 1; i <= n; i++) {
+                    if (i > 1) printf \", \"
+                    printf \"%s\", sorted[i];
+                }
+                printf \"\n\"
+            }
+        }
+    }"' || echo "  None found"
+echo ""
+
+# 5. Analyze GC roots
+echo -e "${BOLD}${BLUE}5. GC Roots Analysis${NC}"
+echo "---"
+
+# System roots
+echo -e "${YELLOW}System GC roots:${NC}"
+run_cmd 'ls -lh /nix/var/nix/gcroots/auto/ 2>/dev/null | tail -10' || echo "  Cannot access"
+echo ""
+
+# User profiles
+echo -e "${YELLOW}User profiles:${NC}"
+run_cmd 'find /nix/var/nix/profiles/per-user/ -type l 2>/dev/null | while read -r link; do
+    target=$(readlink "$link")
+    age=$(stat -c "%y" "$link" 2>/dev/null | cut -d" " -f1)
+    echo "  $age: $link -> $(basename "$target")"
+done | sort' || echo "  Cannot access"
+echo ""
+
+# Old channel roots
+echo -e "${YELLOW}Old channels (>1 year):${NC}"
+CUTOFF_DATE=$(date -d "1 year ago" +%s 2>/dev/null || date -v-1y +%s 2>/dev/null || echo "0")
+run_cmd "find /nix/var/nix/profiles/per-user/ -name 'channels*' -type l 2>/dev/null" | while read -r link; do
+    if [ -n "$link" ]; then
+        LINK_DATE=$(run_cmd "stat -c %Y '$link' 2>/dev/null || stat -f %m '$link' 2>/dev/null || echo 0")
+        if [ "$LINK_DATE" -lt "$CUTOFF_DATE" ] && [ "$LINK_DATE" -gt 0 ]; then
+            AGE=$(run_cmd "stat -c %y '$link' 2>/dev/null | cut -d' ' -f1 || stat -f '%Sm' -t '%Y-%m-%d' '$link' 2>/dev/null")
+            echo -e "  ${RED}${AGE}: $link${NC}"
+        fi
+    fi
+done || echo "  None found"
+echo ""
+
+# 6. Find suspicious user-created roots
+echo -e "${BOLD}${BLUE}6. Suspicious User-Created Roots${NC}"
+echo "---"
+
+# Check common locations for old symlinks
+SUSPICIOUS_PATHS=(
+    "/home/*/tmp/system"
+    "/home/*/.cache/direnv"
+    "/home/*/result"
+    "/tmp/nix-build-*"
+)
+
+for pattern in "${SUSPICIOUS_PATHS[@]}"; do
+    echo -e "${YELLOW}Checking: ${pattern}${NC}"
+    run_cmd "find $(dirname $pattern 2>/dev/null) -maxdepth 2 -name '$(basename $pattern)' -type l 2>/dev/null | while read -r link; do
+        if [ -n \"\$link\" ]; then
+            target=\$(readlink \"\$link\" 2>/dev/null || echo '(broken)')
+            age=\$(stat -c %y \"\$link\" 2>/dev/null | cut -d' ' -f1 || stat -f '%Sm' -t '%Y-%m-%d' \"\$link\" 2>/dev/null || echo 'unknown')
+            size=\$(du -sh \"\$link\" 2>/dev/null | cut -f1 || echo '?')
+            echo \"  \$age [\$size]: \$link -> \$(basename \$target)\"
+        fi
+    done" || echo "  None found"
+done
+echo ""
+
+# Check direnv specifically
+echo -e "${YELLOW}direnv cache sizes:${NC}"
+run_cmd 'shopt -s nullglob; for dir in /home/*/.cache/direnv; do
+    if [ -d "$dir" ]; then
+        size=$(du -sh "$dir" 2>/dev/null | cut -f1)
+        echo "  $size: $dir"
+    fi
+done; true' || echo "  None found"
+echo ""
+
+# 7. Identify what keeps specific large packages alive
+echo -e "${BOLD}${BLUE}7. Root Cause for Large Old Packages${NC}"
+echo "---"
+
+# Find old Go versions and trace their roots
+echo -e "${YELLOW}Tracing old Go versions:${NC}"
+run_cmd 'shopt -s nullglob; ls -d /nix/store/*-go-1.1[0-9]* 2>/dev/null; true' | while read -r pkg; do
+    if [ -n "$pkg" ]; then
+        name=$(basename "$pkg")
+        size=$(run_cmd "du -sh '$pkg' 2>/dev/null | cut -f1" || echo "?")
+        echo -e "  ${CYAN}${name}${NC} (${size})"
+
+        # Find roots
+        roots=$(run_cmd "nix-store --query --roots '$pkg' 2>/dev/null | grep -v '^{'" || echo "")
+        if [ -n "$roots" ]; then
+            echo "$roots" | while IFS=' ' read -r root arrow target; do
+                if [ -n "$root" ] && [ "$root" != "{" ]; then
+                    echo -e "    ${RED}└─ $root${NC}"
+                fi
+            done
+        else
+            echo -e "    ${GREEN}└─ No roots (can be GC'd)${NC}"
+        fi
+    fi
+done
+echo ""
+
+# 8. Result Symlinks in Development Directories
+echo -e "${BOLD}${BLUE}8. Result Symlinks in Development Directories${NC}"
+echo "---"
+echo "Scanning common development directories for 'result' links..."
+echo ""
+
+DEV_DIRS=(
+    "/home/*/src"
+    "/home/*/projects"
+    "/home/*/code"
+    "/home/*/work"
+    "/home/*/dev"
+)
+
+RESULT_COUNT=0
+RESULT_SIZE=0
+
+for dir_pattern in "${DEV_DIRS[@]}"; do
+    run_cmd "find $(dirname $dir_pattern 2>/dev/null)/* -maxdepth 3 -name 'result' -o -name 'result-*' 2>/dev/null" | while read -r link; do
+        if [ -L "$link" ]; then
+            target=$(run_cmd "readlink '$link' 2>/dev/null" || echo "(broken)")
+            age=$(run_cmd "stat -c %y '$link' 2>/dev/null | cut -d' ' -f1" || echo "unknown")
+            size=$(run_cmd "du -sh '$link' 2>/dev/null | cut -f1" || echo "?")
+
+            if [[ "$target" == /nix/store/* ]]; then
+                echo -e "  ${YELLOW}$age${NC} [$size]: $link"
+                RESULT_COUNT=$((RESULT_COUNT + 1))
+            fi
+        fi
+    done
+done
+
+if [ "$RESULT_COUNT" -eq 0 ]; then
+    echo -e "  ${GREEN}✓ No result symlinks found${NC}"
+else
+    echo ""
+    echo -e "${YELLOW}Found $RESULT_COUNT result symlink(s)${NC}"
+    echo "These prevent garbage collection. Remove with: rm result*"
+fi
+echo ""
+
+# 9. Broken/Dead Symlinks
+echo -e "${BOLD}${BLUE}9. Broken Symlinks (Dead GC Roots)${NC}"
+echo "---"
+echo "Checking for symlinks pointing to deleted store paths..."
+echo ""
+
+# Run the entire broken link check in a single remote command to avoid nested run_cmd calls
+BROKEN_LINKS=$(run_cmd 'bash -c "
+BROKEN_COUNT=0
+for root_dir in /nix/var/nix/gcroots /nix/var/nix/profiles; do
+    if [ -d \"\$root_dir\" ]; then
+        find \"\$root_dir\" -type l 2>/dev/null | while read -r link; do
+            if ! test -e \"\$link\" 2>/dev/null; then
+                target=\$(readlink \"\$link\" 2>/dev/null || echo \"(broken)\")
+                if [[ \"\$target\" == /nix/store/* ]]; then
+                    echo \"BROKEN:\$link:\$target\"
+                    BROKEN_COUNT=\$((BROKEN_COUNT + 1))
+                fi
+            fi
+        done
+    fi
+done
+"' || echo "")
+
+if [ -n "$BROKEN_LINKS" ]; then
+    echo "$BROKEN_LINKS" | while IFS=: read -r prefix link target; do
+        if [ "$prefix" = "BROKEN" ]; then
+            echo -e "  ${RED}✗${NC} $link -> $target"
+        fi
+    done
+else
+    echo -e "  ${GREEN}✓ No broken symlinks found in GC roots${NC}"
+fi
+echo ""
+
+# 10. Home-Manager Generations
+echo -e "${BOLD}${BLUE}10. Home-Manager Generations${NC}"
+echo "---"
+
+HM_PROFILE_DIRS=$(run_cmd "find /nix/var/nix/profiles/per-user -name 'home-manager*' -type l 2>/dev/null | sed 's/-[0-9]*-link$//' | sort -u" || echo "")
+
+if [ -n "$HM_PROFILE_DIRS" ]; then
+    echo "$HM_PROFILE_DIRS" | while read -r profile_base; do
+        user=$(basename $(dirname "$profile_base"))
+        gen_count=$(run_cmd "ls -1 ${profile_base}-*-link 2>/dev/null | wc -l" || echo "0")
+
+        if [ "$gen_count" -gt 0 ]; then
+            echo -e "${YELLOW}User $user:${NC} $gen_count generation(s)"
+
+            # Show oldest and newest
+            oldest=$(run_cmd "ls -lt ${profile_base}-*-link 2>/dev/null | tail -1" || echo "")
+            newest=$(run_cmd "ls -lt ${profile_base}-*-link 2>/dev/null | head -1" || echo "")
+
+            if [ -n "$oldest" ]; then
+                oldest_date=$(echo "$oldest" | awk '{print $6, $7, $8}')
+                echo "  Oldest: $oldest_date"
+            fi
+        fi
+    done
+else
+    # Check alternative location
+    HM_STATE=$(run_cmd "find /home -path '*/.local/state/nix/profiles/home-manager*' -type l 2>/dev/null | head -1" || echo "")
+    if [ -n "$HM_STATE" ]; then
+        gen_count=$(run_cmd "ls -1 $(dirname $HM_STATE)/home-manager-*-link 2>/dev/null | wc -l" || echo "0")
+        echo -e "${YELLOW}Found $gen_count home-manager generation(s)${NC}"
+    else
+        echo "  No home-manager generations found"
+    fi
+fi
+echo ""
+
+# 11. Store Hardlink Statistics & Optimization Status
+echo -e "${BOLD}${BLUE}11. Store Optimization Status${NC}"
+echo "---"
+
+# Check if nix-store --optimize has been run
+echo "Checking for potential space savings from deduplication..."
+echo ""
+
+STORE_SIZE_BYTES=$(run_cmd "timeout 30 du -sb /nix/store 2>/dev/null | cut -f1" || true)
+STORE_SIZE_BYTES=${STORE_SIZE_BYTES:-0}
+STORE_SIZE_HUMAN=$(run_cmd "timeout 30 du -sh /nix/store 2>/dev/null | cut -f1" || true)
+STORE_SIZE_HUMAN=${STORE_SIZE_HUMAN:-unknown}
+# If bytes calculation failed/timed out, estimate from human-readable size
+if [ "$STORE_SIZE_BYTES" = "0" ] && [ "$STORE_SIZE_HUMAN" != "unknown" ]; then
+    # Convert human-readable (e.g., "6.9G") to bytes estimate
+    STORE_SIZE_BYTES=$(echo "$STORE_SIZE_HUMAN" | awk '{
+        val=$1; unit=substr($0, length($0));
+        if (unit=="T") print int(val * 1024 * 1024 * 1024 * 1024);
+        else if (unit=="G") print int(val * 1024 * 1024 * 1024);
+        else if (unit=="M") print int(val * 1024 * 1024);
+        else print int(val)
+    }')
+fi
+
+# Sample check: look at hardlink counts
+SAMPLE_SIZE=100
+SINGLE_LINK_COUNT=$(run_cmd "find /nix/store -type f 2>/dev/null | head -$SAMPLE_SIZE | xargs stat -c %h 2>/dev/null | grep -c '^1$'" || echo "0")
+# Trim whitespace and newlines
+SINGLE_LINK_COUNT=$(echo "$SINGLE_LINK_COUNT" | tr -d '\n\r ' | head -c 10)
+SINGLE_LINK_COUNT=${SINGLE_LINK_COUNT:-0}  # Default to 0 if empty
+
+if [ "$SINGLE_LINK_COUNT" -gt 50 ] 2>/dev/null; then
+    OPTIMIZATION_POTENTIAL="High"
+    echo -e "  ${YELLOW}⚠ Optimization status: Not optimized${NC}"
+    echo "  Store size: $STORE_SIZE_HUMAN"
+    echo "  Sample check: $SINGLE_LINK_COUNT/$SAMPLE_SIZE files have single links"
+    echo ""
+    echo -e "  ${CYAN}Run 'nix-store --optimize' to deduplicate identical files${NC}"
+    echo "  Potential savings: 5-20% of store size (~$(echo "$STORE_SIZE_BYTES * 0.10 / 1024 / 1024 / 1024" | bc 2>/dev/null || echo "?")GB estimated)"
+elif [ "$SINGLE_LINK_COUNT" -gt 20 ] 2>/dev/null; then
+    echo -e "  ${YELLOW}Optimization status: Partially optimized${NC}"
+    echo "  Store size: $STORE_SIZE_HUMAN"
+    echo "  Some optimization possible"
+else
+    echo -e "  ${GREEN}✓ Optimization status: Well optimized${NC}"
+    echo "  Store size: $STORE_SIZE_HUMAN"
+    echo "  Most files are already deduplicated"
+fi
+echo ""
+
+# 12. Nix Database Size
+echo -e "${BOLD}${BLUE}12. Nix Database Size${NC}"
+echo "---"
+
+DB_SIZE=$(run_cmd "du -sh /nix/var/nix/db 2>/dev/null | cut -f1" || echo "unknown")
+DB_SIZE_BYTES=$(run_cmd "du -sb /nix/var/nix/db 2>/dev/null | cut -f1" || echo "0")
+
+echo "Database size: $DB_SIZE"
+
+# Warn if database is >1GB
+if [ "$DB_SIZE_BYTES" -gt 1073741824 ] 2>/dev/null; then
+    echo -e "${YELLOW}⚠ Database is large (>1GB)${NC}"
+    echo "  Consider running: nix-store --verify --check-contents"
+else
+    echo -e "${GREEN}✓ Database size is healthy${NC}"
+fi
+echo ""
+
+# 13. Nix Cache Size
+echo -e "${BOLD}${BLUE}13. Nix Cache Size${NC}"
+echo "---"
+
+CACHE_LOCATIONS=(
+    "/home/*/.cache/nix"
+    "/root/.cache/nix"
+)
+
+TOTAL_CACHE_SIZE=0
+for cache_pattern in "${CACHE_LOCATIONS[@]}"; do
+    # Find nix cache directories - use || true to avoid pipefail issues
+    run_cmd "shopt -s nullglob; find $(dirname $cache_pattern 2>/dev/null)/* -maxdepth 2 -type d -name nix 2>/dev/null; true" | while read -r cache_dir; do
+        if [ -n "$cache_dir" ] && [ -d "$cache_dir" ]; then
+            size=$(run_cmd "du -sh '$cache_dir' 2>/dev/null | cut -f1" || echo "0")
+            user=$(echo "$cache_dir" | cut -d'/' -f3)
+            echo "  $user: $size ($cache_dir)"
+        fi
+    done
+done
+echo ""
+
+# 14. Estimated Reclaimable Space (using nix-du if available)
+echo -e "${BOLD}${BLUE}14. Estimated Reclaimable Space${NC}"
+echo "---"
+
+# Check if nix-du is available
+# Note: Check locally (not via run_cmd) since nix-du must be installed where script runs
+HAS_NIX_DU=0
+command -v nix-du >/dev/null 2>&1 && HAS_NIX_DU=1 || true
+
+if [ "$HAS_NIX_DU" -eq 1 ]; then
+    echo "Using nix-du for detailed analysis (packages >50MB)..."
+    echo ""
+
+    # Use nix-du with size filter to make it faster, extract text summary
+    run_cmd "timeout 60 nix-du -s=50M 2>/dev/null" | head -100 || echo "  (nix-du timed out or unavailable)"
+
+    echo ""
+    echo "For full visualization: nix-du | dot -Tsvg > /tmp/store-analysis.svg"
+    echo ""
+    echo "Basic estimation for comparison:"
+    echo ""
+fi
+
+# Always show basic estimation too
+if [ "$HAS_NIX_DU" -eq 0 ]; then
+    echo "nix-du not found (install with: nix-shell -p nix-du)"
+    echo ""
+fi
+
+# Basic estimation: total store - current system closure
+# Reuse STORE_SIZE_BYTES from section 11 to avoid slow du command
+CURRENT_CLOSURE=$(run_cmd "timeout 30 nix path-info -rS /run/current-system 2>/dev/null | tail -1 | awk '{print \$2}'" || true)
+CURRENT_CLOSURE=${CURRENT_CLOSURE:-0}
+STORE_SIZE=${STORE_SIZE_BYTES:-0}  # Already calculated in section 11, default to 0 if empty
+# If STORE_SIZE is still 0, recalculate from section 11's human-readable value
+if [ "$STORE_SIZE" = "0" ] && [ -n "$STORE_SIZE_HUMAN" ] && [ "$STORE_SIZE_HUMAN" != "unknown" ]; then
+    # Convert human-readable (e.g., "117G") to bytes estimate
+    STORE_SIZE=$(echo "$STORE_SIZE_HUMAN" | sed 's/G$//' | awk '{print int($1 * 1024 * 1024 * 1024)}')
+fi
+
+# Clean values
+STORE_SIZE=$(echo "$STORE_SIZE" | tr -d '\n\r ' | head -c 20)
+CURRENT_CLOSURE=$(echo "$CURRENT_CLOSURE" | tr -d '\n\r ' | head -c 20)
+STORE_SIZE=${STORE_SIZE:-0}
+CURRENT_CLOSURE=${CURRENT_CLOSURE:-0}
+
+if [ "$STORE_SIZE" -gt 0 ] 2>/dev/null && [ "$CURRENT_CLOSURE" -gt 0 ] 2>/dev/null; then
+    RECLAIMABLE=$((STORE_SIZE - CURRENT_CLOSURE))
+    RECLAIMABLE_GB=$(awk "BEGIN {printf \"%.1f\", $RECLAIMABLE / 1024 / 1024 / 1024}")
+    STORE_GB=$(awk "BEGIN {printf \"%.1f\", $STORE_SIZE / 1024 / 1024 / 1024}")
+    CLOSURE_GB=$(awk "BEGIN {printf \"%.1f\", $CURRENT_CLOSURE / 1024 / 1024 / 1024}")
+
+    echo -e "  Store size:           ${YELLOW}${STORE_GB}GB${NC}"
+    echo -e "  Current system:       ${CYAN}${CLOSURE_GB}GB${NC}"
+    echo -e "  Potentially reclaimable: ${GREEN}~${RECLAIMABLE_GB}GB${NC}"
+    echo ""
+    echo "  Note: This is a rough estimate. Running GC may reclaim less."
+    if [ "$HAS_NIX_DU" -eq 0 ]; then
+        echo "  Install nix-du for accurate analysis: nix-shell -p nix-du"
+    fi
+else
+    echo "  Unable to calculate (missing nix path-info)"
+fi
+echo ""
+
+# 15. Generate cleanup suggestions
+echo -e "${BOLD}${BLUE}15. Cleanup Suggestions${NC}"
+echo "---"
+
+CLEANUP_SCRIPT="/tmp/nix-cleanup-${HOSTNAME//[^a-zA-Z0-9]/_}.sh"
+
+cat > "$CLEANUP_SCRIPT" << 'EOF'
+#!/usr/bin/env bash
+# Auto-generated Nix cleanup script
+set -euo pipefail
+
+echo "=== Nix Store Cleanup ==="
+echo ""
+echo "Current disk usage:"
+df -h / | grep -E "Filesystem|^/dev"
+echo ""
+
+# Track what we're doing
+CLEANED=0
+
+EOF
+
+# Add cleanup for old channels
+OLD_CHANNELS=$(run_cmd "find /nix/var/nix/profiles/per-user/ -name 'channels*' -type l -mtime +365 2>/dev/null" || echo "")
+if [ -n "$OLD_CHANNELS" ]; then
+    echo -e "${YELLOW}▸ Found old channel links (>1 year)${NC}"
+    cat >> "$CLEANUP_SCRIPT" << EOF
+# Remove old channels (>1 year)
+echo "Removing old channels..."
+$(echo "$OLD_CHANNELS" | while read -r link; do echo "rm -f '$link'"; done)
+CLEANED=1
+
+EOF
+fi
+
+# Add cleanup for old tmp/system links
+OLD_SYSTEM=$(run_cmd "find /home/*/tmp -name 'system' -type l -mtime +30 2>/dev/null" || echo "")
+if [ -n "$OLD_SYSTEM" ]; then
+    echo -e "${YELLOW}▸ Found old system symlinks in ~/tmp${NC}"
+    cat >> "$CLEANUP_SCRIPT" << EOF
+# Remove old system symlinks
+echo "Removing old system symlinks..."
+$(echo "$OLD_SYSTEM" | while read -r link; do echo "rm -f '$link'"; done)
+CLEANED=1
+
+EOF
+fi
+
+# Add cleanup for direnv cache
+DIRENV_CACHE=$(run_cmd "shopt -s nullglob; find /home/*/.cache/direnv -type d -maxdepth 1 2>/dev/null | head -1; true" || echo "")
+if [ -n "$DIRENV_CACHE" ]; then
+    echo -e "${YELLOW}▸ Found direnv cache${NC}"
+    cat >> "$CLEANUP_SCRIPT" << EOF
+# Clean direnv cache
+echo "Cleaning direnv cache..."
+rm -rf /home/*/.cache/direnv
+CLEANED=1
+
+EOF
+fi
+
+# Add cleanup for old profiles
+OLD_PROFILES=$(run_cmd "shopt -s nullglob; find /nix/var/nix/profiles/per-user/*/profile-* -type l -mtime +90 2>/dev/null; true" || echo "")
+if [ -n "$OLD_PROFILES" ]; then
+    echo -e "${YELLOW}▸ Found old profile links (>90 days)${NC}"
+    cat >> "$CLEANUP_SCRIPT" << EOF
+# Remove old profile generations
+echo "Removing old profile generations..."
+$(echo "$OLD_PROFILES" | while read -r link; do echo "rm -f '$link'"; done)
+CLEANED=1
+
+EOF
+fi
+
+# Add cleanup for result symlinks
+RESULT_LINKS=$(run_cmd "shopt -s nullglob; find /home/*/src /home/*/projects /home/*/code /home/*/work /home/*/dev -maxdepth 3 -name 'result' -o -name 'result-*' 2>/dev/null | head -20; true" || echo "")
+if [ -n "$RESULT_LINKS" ]; then
+    echo -e "${YELLOW}▸ Found result symlinks in development directories${NC}"
+    cat >> "$CLEANUP_SCRIPT" << EOF
+# Remove result symlinks
+echo "Removing result symlinks..."
+$(echo "$RESULT_LINKS" | while read -r link; do echo "rm -f '$link'"; done)
+CLEANED=1
+
+EOF
+fi
+
+# Add cleanup for broken symlinks
+BROKEN_LINKS=$(run_cmd "find /nix/var/nix/gcroots /home -type l 2>/dev/null | while read link; do test -e \"\$link\" || echo \"\$link\"; done | head -10" || echo "")
+if [ -n "$BROKEN_LINKS" ]; then
+    echo -e "${YELLOW}▸ Found broken symlinks${NC}"
+    cat >> "$CLEANUP_SCRIPT" << EOF
+# Remove broken symlinks
+echo "Removing broken symlinks..."
+$(echo "$BROKEN_LINKS" | while read -r link; do echo "rm -f '$link'"; done)
+CLEANED=1
+
+EOF
+fi
+
+# Always add GC commands
+cat >> "$CLEANUP_SCRIPT" << 'EOF'
+# Run garbage collection
+if [ "$CLEANED" -eq 1 ]; then
+    echo ""
+    echo "Running garbage collection..."
+    nix-collect-garbage --delete-older-than 7d
+
+    echo ""
+    echo "Running hard GC..."
+    nix-store --gc
+
+    echo ""
+    echo "Optimizing store (deduplication)..."
+    nix-store --optimize
+else
+    echo "No old roots found to clean. Running standard GC..."
+    nix-collect-garbage --delete-older-than 30d
+    nix-store --gc
+fi
+
+echo ""
+echo "=== Cleanup Complete ==="
+echo ""
+echo "Disk usage after cleanup:"
+df -h / | grep -E "Filesystem|^/dev"
+echo ""
+echo "Nix store size:"
+du -sh /nix/store
+EOF
+
+chmod +x "$CLEANUP_SCRIPT"
+
+echo -e "${GREEN}✓ Generated cleanup script: ${CLEANUP_SCRIPT}${NC}"
+echo ""
+echo "Review and run with:"
+if [ -n "$TARGET" ]; then
+    echo -e "  ${CYAN}scp $CLEANUP_SCRIPT $TARGET:/tmp/${NC}"
+    echo -e "  ${CYAN}ssh $TARGET 'sudo bash /tmp/$(basename $CLEANUP_SCRIPT)'${NC}"
+else
+    echo -e "  ${CYAN}sudo $CLEANUP_SCRIPT${NC}"
+fi
+echo ""
+
+# 16. Summary
+echo -e "${BOLD}${BLUE}16. Summary${NC}"
+echo "---"
+
+DISK_PCT=$(run_cmd "df / | tail -1 | awk '{print \$5}'" | tr -d '%')
+DISK_PCT=${DISK_PCT:-0}  # Default to 0 if empty
+STORE_SIZE=$(run_cmd "du -sh /nix/store 2>/dev/null | cut -f1" || echo "unknown")
+
+echo -e "Hostname:         ${CYAN}${HOSTNAME}${NC}"
+echo -e "Disk usage:       ${YELLOW}${DISK_PCT}%${NC}"
+echo -e "Nix store size:   ${YELLOW}${STORE_SIZE}${NC}"
+echo -e "Generations:      ${YELLOW}${GEN_COUNT}${NC}"
+echo ""
+
+if [ "$DISK_PCT" -gt 80 ] 2>/dev/null; then
+    echo -e "${RED}⚠ WARNING: Disk usage is high (>${DISK_PCT}%)${NC}"
+elif [ "$DISK_PCT" -gt 70 ] 2>/dev/null; then
+    echo -e "${YELLOW}⚠ NOTICE: Disk usage is elevated (${DISK_PCT}%)${NC}"
+else
+    echo -e "${GREEN}✓ Disk usage is healthy (${DISK_PCT}%)${NC}"
+fi
+echo ""
+
+echo -e "${BOLD}Next steps:${NC}"
+echo "1. Review the cleanup script generated above"
+echo "2. Run the cleanup script to remove old GC roots"
+echo "3. Consider setting up automated maintenance"
+echo ""