plumjam/nixos - Change EVBXGRCFNANXS3OW6CEFN433ZCMDCPXPO2ZTVAYXARZYLRKCQE5AC

ai: Drop claude-code.

Created by PlumJam on February 13, 2026

EVBXGRCFNANXS3OW6CEFN433ZCMDCPXPO2ZTVAYXARZYLRKCQE5AC

Dependencies

In channels

main

Change contents

Deletion in modules/ai.nix at line 16 [6.3345]
B:BD[4.1060] → [5.2136:2311]
∅:D[7.307] → [4.1242:1286]
∅:D[8.806] → [4.1242:1286]
∅:D[5.2311] → [4.1242:1286]
B:BD[4.1242] → [4.1242:1286]
B:BD[4.1286] → [5.2312:2392]
B:BD[5.2392] → [9.4155:4235]
∅:D[9.4235] → [5.2474:2488]
B:BD[5.2474] → [5.2474:2488]
∅:D[5.2488] → [4.1447:1456]
B:BD[4.1447] → [4.1447:1456]
∅:D[10.428] → [11.7835:7836]
∅:D[12.463] → [11.7835:7836]
∅:D[4.1456] → [11.7835:7836]
B:BD[11.7835] → [11.7835:7836]
```
      claudeCodePackage = pkgs.symlinkJoin {
        name = "claude-code-wrapped";
        paths = [ inputs.claude-code.packages.${pkgs.stdenv.hostPlatform.system}.default ];
        buildInputs = [ pkgs.makeWrapper ];
        postBuild = # sh
          ''
            wrapProgram $out/bin/claude \
              --run 'export ANTHROPIC_AUTH_TOKEN=$(cat ${secrets.zaiKey.path})'
          '';
      };
```
Deletion in modules/ai.nix at line 33 [6.3345]
∅:D[13.952] → [4.1720:1721]
∅:D[5.2902] → [4.1720:1721]
B:BD[4.1720] → [4.1720:1721]
B:BD[4.1721] → [13.953:1045]
∅:D[14.264] → [4.1887:1888]
∅:D[13.1045] → [4.1887:1888]
∅:D[5.3181] → [4.1887:1888]
B:BD[4.1887] → [4.1887:1888]
B:BD[4.1888] → [13.1046:1074]
```
          # claude-code sandboxing deps.
          # pkgs.socat
          # pkgs.bubblewrap
          claudeCodePackage
```

Deletion in modules/ai.nix at line 35 [6.3345]

∅:D[13.1111] → [15.117:118]

∅:D[5.3315] → [15.117:118]

B:BD[15.117] → [15.117:118]

B:BD[15.118] → [13.1112:1389]

∅:D[13.1389] → [15.632:633]

∅:D[5.3719] → [15.632:633]

B:BD[15.632] → [15.632:633]

B:BD[15.633] → [13.1390:1531]

∅:D[16.288] → [15.985:986]

∅:D[13.1531] → [15.985:986]

∅:D[5.3845] → [15.985:986]

B:BD[15.985] → [15.985:986]

B:BD[15.986] → [13.1532:1962]

∅:D[17.283] → [4.2056:2057]

∅:D[15.1368] → [4.2056:2057]

∅:D[13.1962] → [4.2056:2057]

∅:D[5.4015] → [4.2056:2057]

B:BD[4.2056] → [4.2056:2057]

B:BD[4.2057] → [13.1963:2092]

∅:D[13.2092] → [4.2068:2069]

∅:D[5.4202] → [4.2068:2069]

B:BD[4.2068] → [4.2068:2069]

B:BD[4.2069] → [2.260:433]

∅:D[18.338] → [19.105:106]

∅:D[2.433] → [19.105:106]

∅:D[13.2268] → [19.105:106]

∅:D[5.4735] → [19.105:106]

B:BD[17.504] → [19.105:106]

B:BD[19.106] → [13.2269:2513]

∅:D[18.434] → [19.107:108]

∅:D[13.2513] → [19.107:108]

∅:D[5.5100] → [19.107:108]

B:BD[20.201] → [19.107:108]

B:BD[19.108] → [13.2514:3064]

∅:D[18.487] → [19.109:110]

∅:D[13.3064] → [19.109:110]

∅:D[5.5806] → [19.109:110]

B:BD[7.356] → [19.109:110]

B:BD[19.110] → [13.3065:3441]

∅:D[18.675] → [19.287:288]

∅:D[13.3441] → [19.287:288]

∅:D[5.6130] → [19.287:288]

B:BD[19.287] → [19.287:288]

B:BD[19.288] → [13.3442:4187]

∅:D[18.835] → [17.515:516]

∅:D[13.4187] → [17.515:516]

∅:D[5.6379] → [17.515:516]

B:BD[17.515] → [17.515:516]

B:BD[17.516] → [13.4188:4535]

∅:D[13.4535] → [7.366:367]

∅:D[5.6479] → [7.366:367]

B:BD[7.366] → [7.366:367]

B:BD[7.367] → [13.4536:4800]

∅:D[15.1737] → [7.712:713]

∅:D[13.4800] → [7.712:713]

∅:D[5.6536] → [7.712:713]

B:BD[7.712] → [7.712:713]

B:BD[7.713] → [13.4801:4904]

∅:D[13.4904] → [7.1737:1738]

∅:D[5.6734] → [7.1737:1738]

B:BD[7.1737] → [7.1737:1738]

B:BD[7.1738] → [13.4905:4965]

∅:D[13.4965] → [7.1914:1915]

∅:D[5.6906] → [7.1914:1915]

B:BD[7.1914] → [7.1914:1915]

B:BD[7.1915] → [13.4966:5357]

∅:D[13.5357] → [7.2093:2094]

∅:D[5.8296] → [7.2093:2094]

B:BD[7.2093] → [7.2093:2094]

B:BD[7.2094] → [13.5358:5515]

∅:D[13.5515] → [5.8517:8549]

B:BD[5.8517] → [5.8517:8549]

B:BD[5.8549] → [13.5516:6788]


        # TODO: Add claude-code and opencode config files.
        files.".claude/settings.json" = {
          generator = toJSON { };
          value = {
            cleanupPeriodDays = 1000;
            alwaysThinkingEnabled = false;
            includeCoAuthoredBy = false;
            statusLine = {
              type = "command";
              command = "python3 ~/.claude/scripts/statusline.py";
            };
            sandbox = {
              enabled = false;
              autoAllowBashIfSandboxed = true;
              excludedCommands = [
                "git"
                "jj"
                "docker"
                "just"
              ];
              allowUnsandboxedCommands = true;
              network.allowUnixSockets = [ "/run/user/1000/docker.sock" ];
              network.allowLocalBinding = true;
            };
            env = {
              ANTHROPIC_BASE_URL = "https://api.z.ai/api/anthropic";
              API_TIMEOUT_MS = 3000000;
              ANTHROPIC_DEFAULT_HAIKU_MODEL = "glm-4.7-flash";
              ANTHROPIC_DEFAULT_SONNET_MODEL = "glm-5";
              ANTHROPIC_DEFAULT_OPUS_MODEL = "glm-5";
              CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR = 1;
              CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = 1;
              CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = 1;
              DISABLE_NON_ESSENTIAL_MODEL_CALLS = 1;
            };
            hooks = {
              # Unreliable right now: https://github.com/anthropics/claude-code/issues/11947
              # Stop = [{
              #   hooks = [{
              #     type    = "prompt";
              #     prompt  = ''You are evaluating whether Claude should stop working. Context: $ARGUMENTS\n\nAnalyze the conversation and determine if:\n1. All user-requested tasks are complete\n2. Any errors need to be addressed\n3. Follow-up work is needed.'';
              #     timeout = 30;
              #   }];
              # }];
              # SubagentStop = [{
              #   hooks = [{
              #     type    = "prompt";
              #     prompt = ''Evaluate if this subagent should stop. Input: $ARGUMENTS\n\nCheck if:\n- The subagent completed its assigned task\n- Any errors occurred that need fixing\n- Additional context gathering is needed.'';
              #   }];
              # }];
              Notification = [
                {
                  matcher = "permission_prompt|elicitation_dialog";
                  hooks = [
                    {
                      type = "command";
                      command = "${pkgs.libnotify}/bin/notify-send --expire-time=15000 'Claude' 'Waiting for approval.'";
                    }
                  ];
                }
                {
                  matcher = "idle_prompt";
                  hooks = [
                    {
                      type = "command";
                      command = "${pkgs.libnotify}/bin/notify-send --expire-time=15000 'Claude' 'Waiting for next message.'";
                    }
                  ];
                }
              ];
              PostToolUse = [
                {
                  matcher = "Edit|MultiEdit|Write";
                  hooks = [
                    {
                      type = "command";
                      command = "~/.claude/hooks/format-files";
                    }
                  ];
                }
              ];
            };
            permissions = {
              allow = [
                "Edit(PROJECT.md)"
                "Edit(CURRENT.md)"
                "Edit(STATE.md)"
                "Update(PROJECT.md)"
                "Update(CURRENT.md)"
                "Update(STATE.md)"
                "Bash(curl http://localhost:*)"
                "Bash(curl -X GET http://localhost:*)"
                "Bash(find:*)"
                "Bash(rg:*)"
                "Bash(fj issue search:*)"
                "Bash(fj issue view:*)"
                "Bash(fj actions tasks:*)"
                "Bash(fj wiki contents:*)"
                "Bash(fj wiki view:*)"
                "mcp__context7"
                "mcp__gh_grep"
                "mcp__web-reader"
                "mcp__web-search-prime"
                "mcp__nixos"
              ];
              deny = [
                "Read(*.env)"
                "Read(*.envrc)"
                "Bash(git push:*)"
                "Bash(git commit:*)"
              ];
            };
            mcpServers = {
              gh_grep = {
                type = "http";
                url = "https://mcp.grep.app";
              };
              # No support for reading secrets from files yet. These are added with
              # `~/.claude/claude-mcps.sh` instead.
              # context7 = {
              #   type    = "http";
              #   url     = "https://mcp.context7.com/mcp";
              #   headers = {
              #     # We need this for higher limits but for now it's fine and doesn't stop us using it.
              #     CONTEXT7_API_KEY = "{file:${secrets.context7Key.path}}";
              #   };
              # };
              #
              # web-reader = {
              #   type    = "http";
              #   url     = "https://api.z.ai/api/mcp/web_reader/mcp";
              #   headers = {
              #     Authorization = "Bearer {file:${secrets.zaiKey.path}}";
              #   };
              # };
              #
              # web-search-prime = {
              #   type    = "http";
              #   url     = "https://api.z.ai/api/mcp/web_search_prime/mcp";
              #   headers = {
              #     Authorization = "Bearer {file:${secrets.zaiKey.path}}";
              #   };
              # };

Deletion in modules/ai.nix at line 36 [6.3345]

B:BD[5.8550] → [13.6789:7246]

∅:D[13.7246] → [5.8711:8750]

B:BD[5.8711] → [5.8711:8750]

∅:D[21.880] → [22.203:204]

B:BD[4.2223] → [22.203:204]

              nixos = {
                type = "stdio";
                command = "/run/current-system/sw/bin/nix";
                args = [
                  "run"
                  "github:utensils/mcp-nixos"
                  "--"
                ];
              };
              playwriter = {
                type = "stdio";
                command = "/run/current-system/sw/bin/npx";
                args = [ "playwriter@latest" ];
              };
            };
          };
        };

Deletion in modules/ai.nix at line 179 [6.3345]

∅:D[14.309] → [15.2750:2751]

∅:D[5.11977] → [15.2750:2751]

B:BD[15.2750] → [15.2750:2751]

B:BD[15.2751] → [13.10426:10683]

∅:D[14.356] → [15.2875:2876]

∅:D[13.10683] → [15.2875:2876]

∅:D[5.12221] → [15.2875:2876]

B:BD[15.2875] → [15.2875:2876]

B:BD[15.2876] → [13.10684:10734]

∅:D[13.10734] → [23.294:295]

∅:D[5.12270] → [23.294:295]

B:BD[22.380] → [23.294:295]

B:BD[23.295] → [13.10735:10871]

∅:D[13.10871] → [23.586:587]

∅:D[5.12403] → [23.586:587]

B:BD[23.586] → [23.586:587]

B:BD[23.587] → [13.10872:11318]

∅:D[13.11318] → [5.12818:12834]

B:BD[5.12818] → [5.12818:12834]

B:BD[5.12834] → [13.11319:11424]

∅:D[13.11424] → [23.692:693]

∅:D[5.12945] → [23.692:693]

B:BD[23.692] → [23.692:693]

B:BD[23.693] → [13.11425:11745]

∅:D[13.11745] → [23.862:863]

∅:D[5.13248] → [23.862:863]

B:BD[23.862] → [23.862:863]

B:BD[23.863] → [13.11746:11871]

∅:D[13.11871] → [23.1018:1019]

∅:D[5.13364] → [23.1018:1019]

B:BD[23.1018] → [23.1018:1019]

B:BD[23.1019] → [13.11872:12053]

∅:D[13.12053] → [23.1159:1160]

∅:D[5.13540] → [23.1159:1160]

B:BD[23.1159] → [23.1159:1160]

B:BD[23.1160] → [13.12054:12221]

∅:D[23.1299] → [15.3271:3272]

∅:D[13.12221] → [15.3271:3272]

∅:D[5.13702] → [15.3271:3272]

B:BD[22.380] → [15.3271:3272]

B:BD[15.3272] → [13.12222:12370]

∅:D[13.12370] → [23.1571:1572]

∅:D[5.13847] → [23.1571:1572]

B:BD[23.1571] → [23.1571:1572]

B:BD[23.1572] → [13.12371:12522]

∅:D[13.12522] → [23.1872:1873]

∅:D[5.13993] → [23.1872:1873]

B:BD[23.1872] → [23.1872:1873]

B:BD[23.1873] → [13.12523:12810]

∅:D[13.12810] → [23.2467:2468]

∅:D[5.14273] → [23.2467:2468]

B:BD[23.2467] → [23.2467:2468]

B:BD[23.2468] → [13.12811:13127]

∅:D[13.13127] → [23.2670:2671]

∅:D[5.14582] → [23.2670:2671]

B:BD[23.2670] → [23.2670:2671]

B:BD[23.2671] → [13.13128:13758]

∅:D[13.13758] → [23.3221:3222]

∅:D[5.15195] → [23.3221:3222]

B:BD[23.3221] → [23.3221:3222]

B:BD[23.3222] → [13.13759:13973]

∅:D[13.13973] → [23.3747:3748]

∅:D[5.15404] → [23.3747:3748]

B:BD[23.3747] → [23.3747:3748]

B:BD[23.3748] → [13.13974:14560]

∅:D[13.14560] → [23.3858:3859]

∅:D[5.15973] → [23.3858:3859]

B:BD[23.3858] → [23.3858:3859]

B:BD[23.3859] → [13.14561:15122]

∅:D[13.15122] → [23.3889:3890]

∅:D[5.16517] → [23.3889:3890]

B:BD[23.3889] → [23.3889:3890]

B:BD[23.3890] → [13.15123:15241]

∅:D[13.15241] → [23.3979:3980]

∅:D[5.16632] → [23.3979:3980]

B:BD[23.3979] → [23.3979:3980]

B:BD[23.3980] → [13.15242:15276]

∅:D[13.15276] → [23.4139:4140]

∅:D[5.16665] → [23.4139:4140]

B:BD[23.4139] → [23.4139:4140]

B:BD[23.4140] → [13.15277:15374]

∅:D[13.15374] → [23.4247:4248]

∅:D[5.16759] → [23.4247:4248]

B:BD[23.4247] → [23.4247:4248]

B:BD[23.4248] → [13.15375:15546]

∅:D[13.15546] → [23.4431:4432]

∅:D[5.16925] → [23.4431:4432]

B:BD[23.4431] → [23.4431:4432]

B:BD[23.4432] → [13.15547:15662]

∅:D[13.15662] → [23.4513:4514]

∅:D[5.17037] → [23.4513:4514]

B:BD[23.4513] → [23.4513:4514]

B:BD[23.4514] → [13.15663:15862]

∅:D[13.15862] → [23.4699:4700]

∅:D[5.17229] → [23.4699:4700]

B:BD[23.4699] → [23.4699:4700]

B:BD[23.4700] → [13.15863:15948]

∅:D[13.15948] → [23.5263:5264]

∅:D[5.17313] → [23.5263:5264]

B:BD[23.5263] → [23.5263:5264]

B:BD[23.5264] → [13.15949:16146]

∅:D[13.16146] → [23.5553:5554]

∅:D[5.17505] → [23.5553:5554]

B:BD[23.5553] → [23.5553:5554]

B:BD[23.5554] → [13.16147:16758]

∅:D[13.16758] → [23.5578:5579]

∅:D[5.18093] → [23.5578:5579]

B:BD[23.5578] → [23.5578:5579]

B:BD[23.5579] → [13.16759:17076]

∅:D[13.17076] → [23.5720:5721]

∅:D[5.18397] → [23.5720:5721]

B:BD[23.5720] → [23.5720:5721]

B:BD[23.5721] → [13.17077:17263]

∅:D[13.17263] → [23.5979:5980]

∅:D[5.18424] → [23.5979:5980]

B:BD[23.5979] → [23.5979:5980]

B:BD[23.5980] → [13.17264:17538]

∅:D[13.17538] → [23.6088:6089]

∅:D[5.18574] → [23.6088:6089]

B:BD[23.6088] → [23.6088:6089]

B:BD[23.6089] → [13.17539:17651]

∅:D[13.17651] → [23.6169:6170]

∅:D[5.18841] → [23.6169:6170]

B:BD[23.6169] → [23.6169:6170]

B:BD[23.6170] → [13.17652:17736]

∅:D[13.17736] → [23.6303:6304]

∅:D[5.18952] → [23.6303:6304]

B:BD[23.6303] → [23.6303:6304]

B:BD[23.6304] → [13.17737:17878]

∅:D[13.17878] → [23.6445:6446]

∅:D[5.19035] → [23.6445:6446]

B:BD[23.6445] → [23.6445:6446]

B:BD[23.6446] → [13.17879:18028]

∅:D[13.18028] → [23.6571:6572]

∅:D[5.19173] → [23.6571:6572]

B:BD[23.6571] → [23.6571:6572]

B:BD[23.6572] → [13.18029:18158]

∅:D[13.18158] → [23.6779:6780]

∅:D[5.19319] → [23.6779:6780]

B:BD[23.6779] → [23.6779:6780]

B:BD[23.6780] → [13.18159:18374]

∅:D[13.18374] → [23.6923:6924]

∅:D[5.19447] → [23.6923:6924]

B:BD[23.6923] → [23.6923:6924]

B:BD[23.6924] → [13.18375:18526]

∅:D[13.18526] → [23.6961:6962]

∅:D[5.19659] → [23.6961:6962]

B:BD[23.6961] → [23.6961:6962]

B:BD[23.6962] → [13.18527:18568]

∅:D[13.18568] → [23.7083:7084]

∅:D[5.19807] → [23.7083:7084]

B:BD[23.7083] → [23.7083:7084]

B:BD[23.7084] → [13.18569:18702]

∅:D[13.18702] → [23.7142:7143]

∅:D[5.19847] → [23.7142:7143]

B:BD[23.7142] → [23.7142:7143]

B:BD[23.7143] → [13.18703:18769]

∅:D[13.18769] → [23.7155:7156]

∅:D[5.19975] → [23.7155:7156]

B:BD[23.7155] → [23.7155:7156]

B:BD[23.7156] → [13.18770:18786]

∅:D[13.18786] → [23.7163:7164]

∅:D[5.20038] → [23.7163:7164]

B:BD[23.7163] → [23.7163:7164]

B:BD[23.7164] → [13.18787:18798]

∅:D[13.18798] → [5.20053:20054]

B:BD[5.20053] → [5.20053:20054]

B:BD[5.20054] → [13.18799:19689]


        # Create hooks with home-manager to avoid permissions issues.
        files.".claude/hooks/format-files" = {
          text = # nu
            ''
              #!/usr/bin/env nu
              let json_input = (^cat)
              let file_path = ""
              if (which jq | is-empty) { exit 2 }
              let $file_path = ($json_input | from json | get tool_input.file_path)
              if ($file_path | is-empty) { exit 2 }
              let extension = ($file_path | path parse | get extension)
              let command = match ($extension | str trim) {
                "rs" if (which cargo | is-not-empty) => { ["rustfmt" $file_path] }
                "toml" if (which taplo | is-not-empty) => { ["taplo" "fmt" $file_path] }
                _ => {
                  print "This file extension is not covered by this script"
                  exit 0
                }
              }
              ^$command.0 ...($command | skip 1)
            '';
          executable = true;
        };
        # Statusline script.
        files.".claude/scripts/statusline.py" = {
          text = # py
            ''
              #!/usr/bin/env python3
              """
              PlumJam's Claude Code Statusline
              <https://git.plumj.am/plumjam/nixos/src/branch/master/modules/ai.nix>
              """
              import json
              import sys
              import os
              import re
              import time
              def parse_context_from_transcript(transcript_path):
                  if not transcript_path or not os.path.exists(transcript_path):
                      return None
                  try:
                      with open(transcript_path, 'r', encoding='utf-8', errors='replace') as f:
                          lines = f.readlines()
                      # Check last 15 lines for context information.
                      recent_lines = lines[-15:] if len(lines) > 15 else lines
                      for line in reversed(recent_lines):
                          try:
                              data = json.loads(line.strip())
                              # Method 1: Parse usage tokens from assistant messages.
                              if data.get('type') == 'assistant':
                                  message = data.get('message', {})
                                  usage = message.get('usage', {})
                                  if usage:
                                      input_tokens = usage.get('input_tokens', 0)
                                      cache_read = usage.get('cache_read_input_tokens', 0)
                                      cache_creation = usage.get('cache_creation_input_tokens', 0)
                                      # Estimate context usage (assume 200k).
                                      total_tokens = input_tokens + cache_read + cache_creation
                                      if total_tokens > 0:
                                          percent_used = min(100, (total_tokens / 200000) * 100)
                                          return {
                                              'percent': percent_used,
                                              'tokens': total_tokens,
                                              'method': 'usage'
                                          }
                              # Method 2: Parse system context warnings.
                              elif data.get('type') == 'system_message':
                                  content = data.get('content', "")
                                  # "Context left until auto-compact: X%"
                                  match = re.search(r'Context left until auto-compact: (\d+)%', content)
                                  if match:
                                      percent_left = int(match.group(1))
                                      return {
                                          'percent': 100 - percent_left,
                                          'warning': 'auto-compact',
                                          'method': 'system'
                                      }
                                  # "Context low (X% remaining)"
                                  match = re.search(r'Context low \((\d+)% remaining\)', content)
                                  if match:
                                      percent_left = int(match.group(1))
                                      return {
                                          'percent': 100 - percent_left,
                                          'warning': 'low',
                                          'method': 'system'
                                      }
                          except (json.JSONDecodeError, KeyError, ValueError):
                              continue
                      return None
                  except (FileNotFoundError, PermissionError):
                      return None
              def get_context_display(context_info):
                  if not context_info:
                      return f"\033[38;5;109m━┫          ┣━ 0%\033[0m"
                  percent = context_info.get('percent', 0)
                  warning = context_info.get('warning')
                  # Create progress bar.
                  segments = 10
                  filled = int((percent / 100) * segments)
                  bar = "█" * filled + " " * (segments - filled)
                  return f"\033[38;5;109m━┫ [{bar}] ┣━{percent:.0f}%\033[0m"
              def get_directory_display(workspace_data):
                  current_dir = workspace_data.get('current_dir', "")
                  project_dir = workspace_data.get('project_dir', "")
                  if current_dir and project_dir:
                      if current_dir.startswith(project_dir):
                          rel_path = current_dir[len(project_dir):].lstrip('/')
                          return rel_path or os.path.basename(project_dir)
                      else:
                          return os.path.basename(current_dir)
                  elif project_dir:
                      return os.path.basename(project_dir)
                  elif current_dir:
                      return os.path.basename(current_dir)
                  else:
                      return "unknown"
              def get_session_duration(duration_ms):
                  if duration_ms > 0:
                      minutes = duration_ms / 60000
                      if minutes < 1:
                          return f"{duration_ms//1000}s"
                      else:
                          return f"{minutes:.0f}m"
                  return ""
              def main():
                  try:
                      # Read JSON input from claude-code.
                      data = json.load(sys.stdin)
                      model_name = data.get('model', {}).get('display_name', 'Claude')
                      workspace = data.get('workspace', {})
                      transcript_path = data.get('transcript_path', "")
                      cost_data = data.get('cost', {})
                      thinking_enabled = os.environ.get('THINKING_ENABLED', "").lower() in ('true', '1', 'yes')
                      context_info = parse_context_from_transcript(transcript_path)
                      context_display = get_context_display(context_info)
                      directory = get_directory_display(workspace)
                      duration_ms = cost_data.get('total_duration_ms', 0)
                      session_duration = get_session_duration(duration_ms)
                      thinking_indicator = " \033[38;5;172m|\033[0m \033[38;5;142mTHINKING\033[0m " if thinking_enabled else " "
                      # Combine all components in the correct format.
                      status_line = f"\033[38;5;142m[{model_name}]\033[0m \033[38;5;214m{directory}\033[0m{thinking_indicator}{context_display}"
                      if session_duration:
                          status_line += f" \033[38;5;172m|\033[0m \033[38;5;214m{session_duration}\033[0m"
                      print(status_line)
                  except Exception as e:
                      # Fallback display on any error.
                      print("error")
              if __name__ == "__main__":
                  main()
            '';
        };
        # Helper script to add MCPs.
        files.".claude/claude-mcps.sh" = {
          text = # bash
            ''
              #!/usr/bin/env bash
              # Run this once to add the MCP servers that need API keys
              claude mcp add -s user -t http context7 https://mcp.context7.com/mcp --header "CONTEXT7_API_KEY: $(cat ${secrets.context7Key.path})"
              claude mcp add -s user -t http web-reader https://api.z.ai/api/mcp/web_reader/mcp --header "Authorization: Bearer $(cat ${secrets.zaiKey.path})"
              claude mcp add -s user -t http web-search-prime https://api.z.ai/api/mcp/web_search_prime/mcp --header "Authorization: Bearer $(cat ${secrets.zaiKey.path})"
              claude mcp add -s user -t http zread https://api.z.ai/api/mcp/zread/mcp --header "Authorization: Bearer your_api_key"
            '';
          executable = true;
        };

Deletion in modules/ai.nix at line 201 [6.3345]
B:BD[13.20029] → [13.20029:20074]
```
      inputs.nixpkgs.follows = "os";
    };
```
Deletion in modules/ai.nix at line 202 [6.3345]
B:BD[13.20075] → [13.20075:20141]
```
    claude-code = {
      url = "github:sadjow/claude-code-nix";
```
Deletion in flake.nix at line 33 [26.24075]
∅:D[24.638] → [25.5030:5057]
B:BD[25.5030] → [25.5030:5057]
B:BD[25.5057] → [27.222:259]
∅:D[27.259] → [25.5094:5139]
∅:D[28.1030] → [25.5094:5139]
B:BD[25.5094] → [25.5094:5139]
```
    };
    claude-code = {
      inputs.nixpkgs.follows = "os";
      url = "github:sadjow/claude-code-nix";
```
Deletion in flake.lock at line 97 [26.25342]
B:BD[24.1150] → [24.1150:1190]
∅:D[24.1190] → [7.3238:3259]
B:BD[29.1426] → [7.3238:3259]
∅:D[7.3259] → [30.28668:28686]
B:BD[30.28668] → [30.28668:28686]
B:BD[30.28686] → [27.564:602]
∅:D[31.414] → [30.28752:28773]
∅:D[27.602] → [30.28752:28773]
∅:D[28.1554] → [30.28752:28773]
∅:D[7.3300] → [30.28752:28773]
B:BD[30.28752] → [30.28752:28773]
B:BD[30.28773] → [32.2391:2406]
∅:D[32.2406] → [30.28793:28830]
B:BD[30.28793] → [30.28793:28830]
B:BD[30.28830] → [3.271:381]
∅:D[3.381] → [33.244:244]
∅:D[34.407] → [33.244:244]
∅:D[35.542] → [33.244:244]
∅:D[36.545] → [33.244:244]
∅:D[37.552] → [33.244:244]
∅:D[38.552] → [33.244:244]
∅:D[24.1301] → [33.244:244]
B:BD[39.338] → [33.244:244]
∅:D[33.244] → [7.3411:3473]
∅:D[40.298] → [7.3411:3473]
∅:D[41.299] → [7.3411:3473]
∅:D[42.301] → [7.3411:3473]
∅:D[43.317] → [7.3411:3473]
∅:D[44.318] → [7.3411:3473]
∅:D[45.318] → [7.3411:3473]
∅:D[46.318] → [7.3411:3473]
∅:D[47.318] → [7.3411:3473]
∅:D[48.318] → [7.3411:3473]
∅:D[49.318] → [7.3411:3473]
∅:D[50.318] → [7.3411:3473]
∅:D[51.318] → [7.3411:3473]
∅:D[52.318] → [7.3411:3473]
∅:D[53.318] → [7.3411:3473]
∅:D[54.330] → [7.3411:3473]
∅:D[55.330] → [7.3411:3473]
∅:D[56.330] → [7.3411:3473]
∅:D[57.330] → [7.3411:3473]
∅:D[58.333] → [7.3411:3473]
∅:D[59.338] → [7.3411:3473]
∅:D[39.338] → [7.3411:3473]
∅:D[60.444] → [7.3411:3473]
∅:D[61.509] → [7.3411:3473]
∅:D[27.713] → [7.3411:3473]
B:BD[7.3411] → [7.3411:3473]
B:BD[7.3473] → [3.382:441]
∅:D[62.266] → [30.29056:29110]
∅:D[63.320] → [30.29056:29110]
∅:D[40.358] → [30.29056:29110]
∅:D[41.359] → [30.29056:29110]
∅:D[42.361] → [30.29056:29110]
∅:D[43.377] → [30.29056:29110]
∅:D[44.378] → [30.29056:29110]
∅:D[45.378] → [30.29056:29110]
∅:D[46.378] → [30.29056:29110]
∅:D[47.378] → [30.29056:29110]
∅:D[48.378] → [30.29056:29110]
∅:D[49.378] → [30.29056:29110]
∅:D[50.378] → [30.29056:29110]
∅:D[51.378] → [30.29056:29110]
∅:D[52.378] → [30.29056:29110]
∅:D[53.378] → [30.29056:29110]
∅:D[54.390] → [30.29056:29110]
∅:D[55.390] → [30.29056:29110]
∅:D[56.390] → [30.29056:29110]
∅:D[57.390] → [30.29056:29110]
∅:D[58.393] → [30.29056:29110]
∅:D[59.398] → [30.29056:29110]
∅:D[39.398] → [30.29056:29110]
∅:D[3.441] → [30.29056:29110]
∅:D[34.467] → [30.29056:29110]
∅:D[60.504] → [30.29056:29110]
∅:D[64.562] → [30.29056:29110]
∅:D[61.569] → [30.29056:29110]
∅:D[35.602] → [30.29056:29110]
∅:D[36.605] → [30.29056:29110]
∅:D[37.612] → [30.29056:29110]
∅:D[38.612] → [30.29056:29110]
∅:D[65.617] → [30.29056:29110]
∅:D[27.773] → [30.29056:29110]
∅:D[66.774] → [30.29056:29110]
∅:D[24.1361] → [30.29056:29110]
∅:D[7.3532] → [30.29056:29110]
∅:D[67.35889] → [30.29056:29110]
B:BD[30.29056] → [30.29056:29110]
B:BD[30.29110] → [7.3533:3595]
```
        "type": "github"
      }
    },
    "claude-code": {
      "inputs": {
        "flake-utils": "flake-utils",
        "nixpkgs": [
          "os"
        ]
      },
      "locked": {
        "lastModified": 1771013219,
        "narHash": "sha256-EyR1pOL4vWyefDij3/HyZd3qjG6gzfk2BcjbAFQiXdY=",
        "owner": "sadjow",
        "repo": "claude-code-nix",
        "rev": "3f8cff15b530cc4f09ed2497932a66662f7a8422",
        "type": "github"
      },
      "original": {
        "owner": "sadjow",
        "repo": "claude-code-nix",
```
Replacement in flake.lock at line 309 [26.25342]
B:BD[27.2217] → [68.1306:1337]
```
        "systems": "systems_3"
```
[27.2217]
[27.2248]
```
        "systems": "systems_4"
```

Deletion in flake.lock at line 343 [26.25342]

B:BD[68.1746] → [68.1746:1818]

∅:D[69.437] → [27.2720:2729]

∅:D[70.474] → [27.2720:2729]

∅:D[68.1818] → [27.2720:2729]

B:BD[27.2720] → [27.2720:2729]

∅:D[27.2729] → [71.5549:5908]

B:BD[71.5549] → [71.5549:5908]

B:BD[71.5908] → [68.1819:1859]

    "flake-utils_4": {
      "inputs": {
        "systems": "systems_6"
      },
      "locked": {
        "lastModified": 1731533236,
        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
        "owner": "numtide",
        "repo": "flake-utils",
        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
        "type": "github"
      },
      "original": {
        "owner": "numtide",
        "repo": "flake-utils",
        "type": "github"
      }
    },

Replacement in flake.lock at line 346 [26.25342]
B:BD[68.1936] → [68.1936:1976]
```
        "flake-utils": "flake-utils_2",
```
[68.1936]
[68.1976]
```
        "flake-utils": "flake-utils",
```
Replacement in flake.lock at line 710 [26.25342]
∅:D[24.2008] → [68.3065:3105]
B:BD[27.6944] → [68.3065:3105]
```
        "flake-utils": "flake-utils_3",
```
[24.2008]
[27.6984]
```
        "flake-utils": "flake-utils_2",
```
Replacement in flake.lock at line 733 [26.25342]
B:BD[71.6095] → [68.3106:3146]
```
        "flake-utils": "flake-utils_4",
```
[71.6095]
[71.6155]
```
        "flake-utils": "flake-utils_3",
```
Replacement in flake.lock at line 931 [26.25342]
∅:D[24.2503] → [68.3147:3178]
B:BD[69.903] → [68.3147:3178]
```
        "systems": "systems_7"
```
[24.2503]
[72.4809]
```
        "systems": "systems_6"
```
Deletion in flake.lock at line 954 [26.25342]
∅:D[73.1479] → [7.4451:4489]
∅:D[24.2532] → [7.4451:4489]
B:BD[30.30718] → [7.4451:4489]
```
        "claude-code": "claude-code",
```
Replacement in flake.lock at line 1126 [26.25342]
∅:D[24.3199] → [68.3210:3241]
B:BD[27.10559] → [68.3210:3241]
```
        "systems": "systems_4"
```
[24.3199]
[70.2074]
```
        "systems": "systems_3"
```

Deletion in flake.lock at line 1218 [26.25342]

B:BD[27.11864] → [68.3242:3660]

      "locked": {
        "lastModified": 1681028828,
        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
        "owner": "nix-systems",
        "repo": "default",
        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
        "type": "github"
      },
      "original": {
        "owner": "nix-systems",
        "repo": "default",
        "type": "github"
      }
    },
    "systems_7": {

ai: Drop claude-code.

Dependencies

In channels

Change contents

Deletion in modules/ai.nix at line 16 [6.3345]

Deletion in modules/ai.nix at line 33 [6.3345]

Deletion in modules/ai.nix at line 35 [6.3345]

Deletion in modules/ai.nix at line 36 [6.3345]

Deletion in modules/ai.nix at line 179 [6.3345]

Deletion in modules/ai.nix at line 201 [6.3345]

Deletion in modules/ai.nix at line 202 [6.3345]

Deletion in flake.nix at line 33 [26.24075]

Deletion in flake.lock at line 97 [26.25342]

Replacement in flake.lock at line 309 [26.25342]

Deletion in flake.lock at line 343 [26.25342]

Replacement in flake.lock at line 346 [26.25342]

Replacement in flake.lock at line 710 [26.25342]

Replacement in flake.lock at line 733 [26.25342]

Replacement in flake.lock at line 931 [26.25342]

Deletion in flake.lock at line 954 [26.25342]

Replacement in flake.lock at line 1126 [26.25342]

Deletion in flake.lock at line 1218 [26.25342]