create-claude-cabinet 0.40.0 → 0.41.0

package/README.md

@@ -230,7 +230,7 @@ customization. You can pass multiple modules: `--modules verify,audit`.
 | **engagement** | Client engagement management — packets, billing, feedback loops |
 | **engagement-server** | Central multi-engagement API server (Railway/Fly deploy) |
 | **watchtower** | Continuous background state management replacing orient/debrief |
-| **mux** | Multi-project terminal manager — desks, auto-worktrees with shared identity, trail logging, DX captures, portal color-switching |
+| **mux** | Multi-project terminal manager — desks, auto-worktrees with shared identity, trail logging, DX captures, portal color-switching, durable tmux bindings, clipboard copy with hard-wrap removal, screenshot-to-clipboard launchd watcher |
 
 ## CLI Options
 

package/lib/cli.js

@@ -1315,6 +1315,11 @@ async function run() {
         if (fs.existsSync(mcpJsonPath)) {
           existing = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));
         }
+        // Guard shape drift: .mcpServers set on a top-level array would be
+        // silently dropped on serialize.
+        if (typeof existing !== 'object' || existing === null || Array.isArray(existing)) {
+          existing = {};
+        }
         if (!existing.mcpServers) existing.mcpServers = {};
         Object.assign(existing.mcpServers, mcpConfig.mcpServers);
         fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2) + '\n');
@@ -1567,6 +1572,15 @@ async function run() {
       if (fs.existsSync(registryPath)) {
         registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
       }
+      // Normalize shape drift: a bare top-level array has been observed
+      // (ad-hoc edit dropped the {"projects": ...} wrapper). Re-wrap so
+      // the update below also heals the file on disk.
+      if (Array.isArray(registry)) {
+        registry = { projects: registry };
+      }
+      if (!Array.isArray(registry.projects)) {
+        registry.projects = [];
+      }
       const existingIdx = registry.projects.findIndex(p => p.path === projectDir);
       const entry = {
         path: projectDir,

package/lib/engagement-server-setup.js

@@ -57,7 +57,11 @@ function compareVersions(a, b) {
 function readGlobalManifest() {
   if (!fs.existsSync(GLOBAL_MANIFEST_PATH)) return { files: {} };
   try {
-    return JSON.parse(fs.readFileSync(GLOBAL_MANIFEST_PATH, 'utf8'));
+    const m = JSON.parse(fs.readFileSync(GLOBAL_MANIFEST_PATH, 'utf8'));
+    // Guard shape drift: manifest.files is indexed unconditionally below.
+    if (typeof m !== 'object' || m === null || Array.isArray(m)) return { files: {} };
+    if (typeof m.files !== 'object' || m.files === null || Array.isArray(m.files)) m.files = {};
+    return m;
   } catch {
     return { files: {} };
   }

package/lib/metadata.js

@@ -10,13 +10,20 @@ function metadataPath(projectDir) {
 
 function read(projectDir) {
   const file = metadataPath(projectDir);
-  if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (fs.existsSync(file)) return normalize(JSON.parse(fs.readFileSync(file, 'utf8')));
   // Fall back to legacy manifest from pre-v0.6.0 installs
   const legacyFile = path.join(projectDir, LEGACY_METADATA_FILE);
-  if (fs.existsSync(legacyFile)) return JSON.parse(fs.readFileSync(legacyFile, 'utf8'));
+  if (fs.existsSync(legacyFile)) return normalize(JSON.parse(fs.readFileSync(legacyFile, 'utf8')));
   return null;
 }
 
+// Guard shape drift: callers key into .modules/.manifest/.version — a
+// non-object top level must read as "no metadata", not crash the installer.
+function normalize(data) {
+  if (typeof data !== 'object' || data === null || Array.isArray(data)) return null;
+  return data;
+}
+
 function write(projectDir, data) {
   const file = metadataPath(projectDir);
   fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');

package/lib/mux-setup.js

@@ -45,6 +45,9 @@ const MANAGED_FILES = [
   { src: 'config/worktree-session-health.sh', dest: path.join(os.homedir(), '.config', 'mux', 'worktree-session-health.sh'), mode: 0o755 },
   { src: 'config/worktree-health-popup.sh', dest: path.join(os.homedir(), '.config', 'mux', 'worktree-health-popup.sh'), mode: 0o755 },
   { src: 'config/worktree-cleanup.sh', dest: path.join(os.homedir(), '.config', 'mux', 'worktree-cleanup.sh'), mode: 0o755 },
+  { src: 'config/mux.tmux.conf', dest: path.join(os.homedir(), '.config', 'mux', 'mux.tmux.conf') },
+  { src: 'config/unwrap-copy.py', dest: path.join(os.homedir(), '.config', 'mux', 'unwrap-copy.py'), mode: 0o755 },
+  { src: 'config/screenshot-to-clipboard.sh', dest: path.join(os.homedir(), '.config', 'mux', 'screenshot-to-clipboard.sh'), mode: 0o755 },
 ];
 
 const DATA_DIRS = [
@@ -75,7 +78,11 @@ function compareVersions(a, b) {
 function readGlobalManifest() {
   if (!fs.existsSync(GLOBAL_MANIFEST_PATH)) return { files: {} };
   try {
-    return JSON.parse(fs.readFileSync(GLOBAL_MANIFEST_PATH, 'utf8'));
+    const m = JSON.parse(fs.readFileSync(GLOBAL_MANIFEST_PATH, 'utf8'));
+    // Guard shape drift: manifest.files is indexed unconditionally below.
+    if (typeof m !== 'object' || m === null || Array.isArray(m)) return { files: {} };
+    if (typeof m.files !== 'object' || m.files === null || Array.isArray(m.files)) m.files = {};
+    return m;
   } catch {
     return { files: {} };
   }
@@ -187,7 +194,116 @@ function setupMux(opts = {}) {
 
   results.push(`  ${copiedCount} file${copiedCount !== 1 ? 's' : ''} installed to user paths`);
 
+  if (process.platform === 'darwin') {
+    setupDarwinIntegration({ dryRun, results });
+  }
+
   return { results, status: installedVersion ? 'upgraded' : 'installed' };
 }
 
+/**
+ * macOS-specific wiring: tmux.conf source line, live binding reload,
+ * and the screenshot-to-clipboard launchd watcher. All steps are
+ * idempotent and individually fault-tolerant — a failure in one is
+ * reported but never aborts the install.
+ */
+function setupDarwinIntegration({ dryRun, results }) {
+  const { execSync } = require('child_process');
+  const run = (cmd) => execSync(cmd, { stdio: ['ignore', 'pipe', 'pipe'] }).toString().trim();
+
+  // 1. ~/.tmux.conf sources mux.tmux.conf so mux bindings survive tmux
+  //    server restarts (inline bind-key calls from bin/mux evaporate).
+  const tmuxConf = path.join(os.homedir(), '.tmux.conf');
+  const sourceLine = 'source-file -q ~/.config/mux/mux.tmux.conf';
+  try {
+    const existing = fs.existsSync(tmuxConf) ? fs.readFileSync(tmuxConf, 'utf8') : '';
+    if (!existing.includes('mux.tmux.conf')) {
+      if (dryRun) {
+        results.push(`  [dry-run] append "${sourceLine}" to ~/.tmux.conf`);
+      } else {
+        const block = `\n# mux-managed bindings (CC) — keep this line; mux upgrades edit the sourced file\n${sourceLine}\n`;
+        fs.appendFileSync(tmuxConf, block);
+        results.push('  ~/.tmux.conf now sources mux.tmux.conf');
+      }
+    }
+  } catch (err) {
+    results.push(`  ⚠ Could not update ~/.tmux.conf: ${err.message}`);
+  }
+
+  // 2. Apply bindings to a running tmux server immediately.
+  if (!dryRun) {
+    try {
+      run('tmux source-file ~/.config/mux/mux.tmux.conf');
+      results.push('  mux.tmux.conf applied to running tmux server');
+    } catch {
+      // No server running — bindings load at next server start via ~/.tmux.conf.
+    }
+  }
+
+  // 3. Screenshot-to-clipboard launchd watcher. Watches the macOS
+  //    screenshot folder and puts each new screenshot on the clipboard
+  //    as a file reference.
+  const label = 'com.mux.screenshot-to-clipboard';
+  const agentDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(agentDir, `${label}.plist`);
+  const legacyLabel = 'com.orenmagid.screenshot-to-clipboard';
+  const legacyPlist = path.join(agentDir, `${legacyLabel}.plist`);
+  const scriptPath = path.join(os.homedir(), '.config', 'mux', 'screenshot-to-clipboard.sh');
+
+  let shotDir = path.join(os.homedir(), 'Desktop');
+  try {
+    const loc = run('defaults read com.apple.screencapture location');
+    if (loc) shotDir = loc.replace(/^~/, os.homedir());
+  } catch {
+    /* default location */
+  }
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${label}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>${scriptPath}</string>
+    </array>
+    <key>WatchPaths</key>
+    <array>
+        <string>${shotDir}</string>
+    </array>
+</dict>
+</plist>
+`;
+
+  if (dryRun) {
+    results.push(`  [dry-run] install launchd watcher ${label} (watching ${shotDir})`);
+    return;
+  }
+
+  try {
+    const uid = run('id -u');
+
+    // Migrate: unload + remove a pre-CC hand-rolled watcher so the two
+    // never double-fire. The old script file is left in place.
+    if (fs.existsSync(legacyPlist)) {
+      try { run(`launchctl bootout gui/${uid}/${legacyLabel}`); } catch { /* not loaded */ }
+      fs.unlinkSync(legacyPlist);
+      results.push(`  migrated legacy watcher (${legacyLabel} removed)`);
+    }
+
+    fs.mkdirSync(agentDir, { recursive: true });
+    const hadPlist = fs.existsSync(plistPath);
+    fs.writeFileSync(plistPath, plist);
+    if (hadPlist) {
+      try { run(`launchctl bootout gui/${uid}/${label}`); } catch { /* not loaded */ }
+    }
+    run(`launchctl bootstrap gui/${uid} ${plistPath}`);
+    results.push(`  screenshot-to-clipboard watcher loaded (watching ${shotDir})`);
+  } catch (err) {
+    results.push(`  ⚠ launchd watcher setup failed: ${err.message}`);
+  }
+}
+
 module.exports = { setupMux };

package/lib/settings-merge.js

@@ -153,6 +153,11 @@ function mergeSettings(projectDir, { includeDb = true } = {}) {
   if (fs.existsSync(settingsPath)) {
     settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
   }
+  // Guard shape drift: setting .hooks on a top-level array would silently
+  // drop it on serialize (JSON.stringify ignores non-index array props).
+  if (typeof settings !== 'object' || settings === null || Array.isArray(settings)) {
+    settings = {};
+  }
 
   if (!settings.hooks) settings.hooks = {};
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"
@@ -8,7 +8,9 @@
   "files": [
     "bin/",
     "lib/",
-    "templates/"
+    "templates/",
+    "!**/__pycache__",
+    "!**/*.pyc"
   ],
   "keywords": [
     "claude",

package/templates/cabinet/_cabinet-member-template.md

@@ -128,8 +128,10 @@ to anchor the boundaries.
 ```markdown
 ## Historically Problematic Patterns
 
-Read `patterns-project.md` in this skill directory for project-specific
-patterns from prior audits. Apply alongside universal patterns below.
+If `patterns-project.md` exists in this skill directory, read it for
+project-specific patterns from prior audits and apply alongside the
+universal patterns below. Absent is normal — it is seeded by debrief
+when recurring findings accumulate.
 
 <!-- Universal patterns below this line -->
 ```

package/templates/mux/bin/mux

@@ -167,12 +167,11 @@ setup_session_hooks() {
   tmux set-option -t "$project" window-status-current-format \
     '#[fg=#ffffff,bg=#4a4a8a,bold] #I:#W#{?@mux_worktree,#{?@wt_healthy,#[fg=#88ddcc],#[fg=#ff6666]}·wt#[default],} ' 2>/dev/null || true
 
-  # Global binding (root table, idempotent) — lives here because mux has
-  # no one-time init path; re-setting on each session open is harmless.
-  # select-window -t = switches to the clicked tab before the popup queries tmux.
-  tmux bind-key -T root DoubleClick1Status \
-    select-window -t = \; \
-    display-popup -E -h 14 -w 70 "${HOME}/.config/mux/worktree-health-popup.sh" 2>/dev/null || true
+  # Global bindings live in mux.tmux.conf (single source of truth), which
+  # ~/.tmux.conf sources at server start. Re-sourcing here applies upgrades
+  # to a running server — bindings no longer evaporate on server restart
+  # the way inline bind-key calls did.
+  tmux source-file "${HOME}/.config/mux/mux.tmux.conf" 2>/dev/null || true
 }
 
 MUX_WORKTREES_DIR="${HOME}/.mux/worktrees"
@@ -1099,6 +1098,7 @@ cmd_setup() {
 │  mux ls               List all desks   │
 │  mux note "..."       Leave a note     │
 │  mux dx "..."         DX idea capture  │
+│  mux copy             Copy w/o wraps   │
 │  mux close / done     Park this desk   │
 │  mux where            Where am I?      │
 │  mux help             This screen      │
@@ -1131,6 +1131,7 @@ HELPFILE
     python3 -c "
 import json, os
 reg = json.load(open(os.path.expanduser('~/.claude/cc-registry.json')))
+if isinstance(reg, list): reg = {'projects': reg}  # tolerate shape drift
 colors = ['#1a2744','#1a3a2a','#3a2a1a','#2a1a3a','#1a1a2e','#2a3a1a','#3a1a2a']
 projects = {}
 for i, p in enumerate(reg.get('projects', [])):
@@ -1235,6 +1236,29 @@ cmd_help() {
   fi
 }
 
+cmd_copy() {
+  # Copy text to the system clipboard with hard-wrap removal — prose
+  # produced in a Claude pane lands paste-ready for Gmail, D2L, docs.
+  # Input: stdin when piped, otherwise the most recent tmux buffer
+  # (i.e., the last copy-mode selection).
+  local input
+  if [[ ! -t 0 ]]; then
+    input=$(cat)
+  elif in_tmux; then
+    input=$(tmux show-buffer 2>/dev/null) || die "Nothing to copy — select text first, or pipe: cmd | mux copy"
+  else
+    die "Pipe text in: some-command | mux copy"
+  fi
+  [[ -n "$input" ]] || die "Nothing to copy."
+
+  command -v pbcopy >/dev/null 2>&1 || die "pbcopy not found — mux copy requires macOS."
+  printf '%s' "$input" | "${HOME}/.config/mux/unwrap-copy.py" | pbcopy
+
+  local chars
+  chars=$(pbpaste | wc -c | tr -d ' ')
+  printf '\033[32m✓\033[0m copied %s chars to clipboard (hard wraps removed)\n' "$chars"
+}
+
 cmd_resume() {
   local session_id="${1:-}"
   require_tmux
@@ -1278,6 +1302,7 @@ main() {
     split)     shift; cmd_split "${1:-}" ;;
     where)     cmd_where ;;
     note)      shift; cmd_note "$@" ;;
+    copy)      shift; cmd_copy "$@" ;;
     dx)        shift; cmd_dx "$@" ;;
     portal)    shift; cmd_portal "${1:-}" ;;
     worktree)  shift; cmd_worktree "$@" ;;

package/templates/mux/config/context-help.py

@@ -27,6 +27,9 @@ def main():
     if not is_shell:
         print(f"  {CYAN}Claude is running here.{R}")
         print(f"    F3 = quick shell    F2 = dashboard")
+        print(f"    {D}Opt-B / Opt-F  word back / forward{R}")
+        print(f"    {D}Ctrl-A/E line start/end · Ctrl-W del{R}")
+        print(f"    {D}Shift-Enter newline · ↑↓ history{R}")
         print()
     else:
         print(f"  {D}Shell window.{R}")
@@ -41,7 +44,10 @@ def main():
     print(f"    F1 Help    F2 Dashboard    F3 Shell")
     print(f"    F4 Trail   F5 Sessions")
     print(f"    Ctrl-Space d Detach  s Pick desk")
+    print(f"    Ctrl-Space [ scroll back   q = live")
+    print(f"    drag = copy   Y = copy w/o wraps")
     print()
+    print(f"  {D}Full list: mux help{R}")
     print(f"  {D}q = close{R}")
     print()
 

package/templates/mux/config/help.txt

@@ -14,6 +14,7 @@
 │  mux note rm <#>      Remove a note    │
 │  mux dx "..."         DX idea capture  │
 │  mux dx done <#>      Clear DX item    │
+│  mux copy             Copy w/o wraps   │
 │  mux split            Split pane       │
 │  mux portal on/off    Toggle voice     │
 │  mux worktree ls      List worktrees   │
@@ -32,6 +33,21 @@
 │  ·wt tab marker = worktree window      │
 │  green = healthy, red = issues         │
 │                                        │
+│  Terminal text (scroll + copy):        │
+│  wheel or Ctrl-Space [   scroll back   │
+│  PgUp/PgDn move    q = back to live    │
+│  Ctrl-r / Ctrl-s   search back / fwd   │
+│  drag = copy    Y = copy w/o wraps     │
+│  F3 popup: Shift-drag to select        │
+│                                        │
+│  Typing a message (Claude prompt):     │
+│  Opt-B / Opt-F     word back / fwd     │
+│  Ctrl-A / Ctrl-E   line start / end    │
+│  Ctrl-W del word   Ctrl-K del to end   │
+│  Ctrl-U del to start   Ctrl-Y paste    │
+│  Shift-Enter       newline (no send)   │
+│  ↑ / ↓             message history     │
+│                                        │
 │  Ctrl-Space shortcuts:                 │
 │  d     Detach (leave tmux)             │
 │  s     Session picker                  │

package/templates/mux/config/mux.tmux.conf

@@ -0,0 +1,27 @@
+# mux.tmux.conf — mux-owned tmux bindings (CC-managed, do not edit).
+#
+# Sourced from ~/.tmux.conf (line appended by mux-setup) so these survive
+# tmux server restarts, and re-sourced by mux on each desk open so upgrades
+# apply live. Single source of truth for mux's tmux bindings — bin/mux
+# delegates here instead of setting bindings inline.
+
+# --- Worktree health popup ---------------------------------------------
+# Double-click a window tab: switch to it, then show its health popup.
+bind-key -T root DoubleClick1Status \
+  select-window -t = \; \
+  display-popup -E -h 14 -w 70 "~/.config/mux/worktree-health-popup.sh"
+
+# --- Clipboard ----------------------------------------------------------
+# Copies land on the macOS clipboard, not just tmux's internal buffer.
+set -g set-clipboard on
+
+# Mouse-drag or y: copy selection verbatim to the system clipboard.
+bind-key -T copy-mode    MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"
+bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"
+bind-key -T copy-mode    y send-keys -X copy-pipe-and-cancel "pbcopy"
+bind-key -T copy-mode-vi y send-keys -X copy-pipe-and-cancel "pbcopy"
+
+# Y: unwrap-copy — joins hard-wrapped prose lines (Claude output → Gmail,
+# D2L, docs) while leaving code blocks and lists intact.
+bind-key -T copy-mode    Y send-keys -X copy-pipe-and-cancel "~/.config/mux/unwrap-copy.py | pbcopy"
+bind-key -T copy-mode-vi Y send-keys -X copy-pipe-and-cancel "~/.config/mux/unwrap-copy.py | pbcopy"

package/templates/mux/config/muxlib.py

@@ -34,6 +34,17 @@ CYAN = "\033[36m"
 
 
 def load_json(path):
+    # Shape-coercing by design: every caller treats the result as a dict
+    # (.get / key access), so a file whose top level drifted to a list or
+    # scalar must degrade to {} here — not crash 20 call sites downstream
+    # (the cc-registry bare-array incident took out F2/F4/F5 and the
+    # picker at once). Callers that can rescue a non-dict shape should
+    # use load_json_any and normalize themselves.
+    data = load_json_any(path)
+    return data if isinstance(data, dict) else {}
+
+
+def load_json_any(path):
     path = os.path.expanduser(path)
     if not os.path.exists(path):
         return {}
@@ -180,9 +191,17 @@ AUTO_COLORS = [
 
 def load_projects():
     manual = load_json(MUX_PROJECTS).get("projects", {})
-    registry = load_json(CC_REGISTRY)
-
-    if not isinstance(registry.get("projects"), list):
+    if not isinstance(manual, dict):
+        manual = {}
+    registry = load_json_any(CC_REGISTRY)
+
+    # Tolerate registry shape drift: canonical is {"projects": [...]}, but a
+    # bare top-level list has been observed in the wild (ad-hoc cleanup
+    # rewrote the file without the wrapper, crashing every load_projects
+    # caller — F2 dashboard, picker, sidebars). Degrade, never crash.
+    if isinstance(registry, list):
+        registry = {"projects": registry}
+    if not isinstance(registry, dict) or not isinstance(registry.get("projects"), list):
         return manual
 
     known_paths = {p.get("path") for p in manual.values() if isinstance(p, dict)}

package/templates/mux/config/screenshot-to-clipboard.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# screenshot-to-clipboard.sh — copy the newest screenshot to the clipboard
+# as BOTH representations on a single pasteboard item: PNG image data
+# (paste-able into Claude Code via Ctrl+V, Gmail, Slack) AND a file
+# reference (paste-able as a file in Finder / attach dialogs). Each paste
+# target picks the form it understands. Falls back to PNG-data-only if
+# the JXA dual-write fails for any reason.
+#
+# Triggered by launchd WatchPaths on the screenshots folder (plist written
+# by lib/mux-setup.js). Three guards keep it from misfiring:
+#   - `ls -t` glob: sorted newest-first, never matches macOS's in-progress
+#     hidden temp file (.Screenshot…), so we never copy a path that's
+#     about to be renamed out from under us
+#   - age guard: only fires for a file created in the last 15 seconds, so
+#     folder cleanups / syncs don't clobber the clipboard with an old shot
+#   - existence re-check after the settle sleep
+
+DIR=$(defaults read com.apple.screencapture location 2>/dev/null || echo "$HOME/Desktop")
+DIR="${DIR/#\~/$HOME}"
+
+sleep 1  # let macOS finish writing/renaming the file
+
+NEWEST=$(ls -t "$DIR"/*.png 2>/dev/null | head -1)
+[ -n "$NEWEST" ] || exit 0
+[ -f "$NEWEST" ] || exit 0
+
+NOW=$(date +%s)
+MTIME=$(stat -f %m "$NEWEST" 2>/dev/null || echo 0)
+AGE=$((NOW - MTIME))
+[ "$AGE" -le 15 ] || exit 0
+
+osascript -l JavaScript -e '
+function run(argv) {
+  ObjC.import("AppKit");
+  const path = argv[0];
+  const data = $.NSData.dataWithContentsOfFile(path);
+  if (data.isNil()) throw new Error("unreadable: " + path);
+  const item = $.NSPasteboardItem.alloc.init;
+  item.setDataForType(data, "public.png");
+  item.setStringForType($.NSURL.fileURLWithPath(path).absoluteString, "public.file-url");
+  const pb = $.NSPasteboard.generalPasteboard;
+  pb.clearContents;
+  if (!pb.writeObjects($([item]))) throw new Error("writeObjects failed");
+}' "$NEWEST" 2>/dev/null || \
+  osascript -e "set the clipboard to (read (POSIX file \"$NEWEST\") as «class PNGf»)"

package/templates/mux/config/unwrap-copy.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""unwrap-copy.py — join hard-wrapped prose lines, preserve structure.
+
+Pure filter: stdin → unwrapped text → stdout. Callers pipe to pbcopy
+(`mux copy`, and the copy-mode Y binding in mux.tmux.conf).
+
+Heuristic: a line is "wrap-broken" when it runs close to the longest
+line in the input — terminal-width wrapping leaves no short lines
+mid-paragraph. Blank lines (paragraph breaks), fenced code blocks,
+indented blocks, and list-item starts pass through untouched, so code
+survives while prose unwraps. List items join their own wrapped
+continuation lines.
+"""
+
+import re
+import sys
+
+
+LIST_RE = re.compile(r"^\s*([-*+•]|\d+[.)]|>)\s")
+
+
+def breaks_join(line):
+    """A line that must start fresh, never be appended to the previous."""
+    s = line.strip()
+    return (
+        not s
+        or s.startswith("```")
+        or line.startswith(("    ", "\t"))
+        or bool(LIST_RE.match(line))
+    )
+
+
+def unwrap(text):
+    lines = [l.rstrip() for l in text.split("\n")]
+
+    # Lines near the longest one were likely wrapped at that width.
+    maxlen = max((len(l) for l in lines), default=0)
+    threshold = max(40, maxlen - 15)
+
+    out = []
+    in_fence = False
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        if line.strip().startswith("```"):
+            in_fence = not in_fence
+            out.append(line)
+            i += 1
+            continue
+        # Pass through verbatim — except list items, which fall through so
+        # their wrapped continuation lines can join them.
+        if in_fence or (breaks_join(line) and not LIST_RE.match(line)):
+            out.append(line)
+            i += 1
+            continue
+
+        buf = line
+        j = i + 1
+        while j < len(lines) and len(lines[j - 1]) >= threshold:
+            nxt = lines[j]
+            if breaks_join(nxt):
+                break
+            buf += " " + nxt.strip()
+            j += 1
+        out.append(buf)
+        i = j
+
+    return "\n".join(out)
+
+
+if __name__ == "__main__":
+    sys.stdout.write(unwrap(sys.stdin.read()))

package/templates/scripts/watchtower-build-context.mjs

@@ -69,10 +69,12 @@ function fileAge(filePath) {
 
 function countQueueItems() {
   const queueDir = join(WATCHTOWER_DIR, 'queue', 'items');
-  if (!existsSync(queueDir)) return { total: 0, urgent: 0 };
+  if (!existsSync(queueDir)) return { total: 0, urgent: 0, byCategory: {}, draftsReady: 0 };
 
   let total = 0;
   let urgent = 0;
+  let draftsReady = 0;
+  const byCategory = {};
 
   try {
     const entries = readdirSync(queueDir, { withFileTypes: true });
@@ -82,12 +84,27 @@ function countQueueItems() {
       if (!item || item.status !== 'pending') continue;
       total++;
       if (item.urgency === 'urgent') urgent++;
+      const cat = item.category || 'uncategorized';
+      byCategory[cat] = (byCategory[cat] || 0) + 1;
+      if (cat === 'knowledge-extraction' && item.draft_artifact) draftsReady++;
     }
   } catch {
     // Queue unreadable — degrade gracefully
   }
 
-  return { total, urgent };
+  return { total, urgent, byCategory, draftsReady };
+}
+
+// A bare count is a scary number; a category breakdown is a work plan.
+// "33 knowledge-extraction (drafts ready), 9 worktree-unmerged, 6 routing-decision"
+function renderCategoryBreakdown(byCategory, draftsReady) {
+  const parts = Object.entries(byCategory)
+    .sort((a, b) => b[1] - a[1])
+    .map(([cat, n]) => {
+      const annotation = cat === 'knowledge-extraction' && draftsReady > 0 ? ' (drafts ready)' : '';
+      return `${n} ${cat}${annotation}`;
+    });
+  return parts.join(', ');
 }
 
 // --- Thread / focal zoom helpers ---
@@ -261,18 +278,16 @@ function main() {
     }
   }
 
-  // Step 6: Inbox summary
-  const { total, urgent } = countQueueItems();
-  if (urgent > 0) {
-    sections.push({
-      key: 'queue',
-      content: `--- Inbox ---\n⚡ ${urgent} urgent item(s) waiting — run /inbox. ${total > urgent ? `${total - urgent} more at normal priority.` : ''}`,
-      priority: 1,
-    });
-  } else if (total > 0) {
+  // Step 6: Inbox summary — one number, decomposed by category
+  const { total, urgent, byCategory, draftsReady } = countQueueItems();
+  if (total > 0) {
+    const breakdown = renderCategoryBreakdown(byCategory, draftsReady);
+    const headline = urgent > 0
+      ? `⚡ ${total} pending (${urgent} urgent) — run /inbox`
+      : `${total} pending — run /inbox when ready`;
     sections.push({
       key: 'queue',
-      content: `--- Inbox ---\n${total} item(s) waiting — run /inbox when ready.`,
+      content: `--- Inbox ---\n${headline}\n${breakdown}`,
       priority: 1,
     });
   }