create-claude-cabinet 0.40.0 → 0.42.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

@@ -4,7 +4,7 @@ const fs = require('fs');
 const os = require('os');
 const crypto = require('crypto');
 const { copyTemplates } = require('./copy');
-const { mergeSettings, healUserSettings, mergeWatchtowerHooks, mergeMuxHooks } = require('./settings-merge');
+const { mergeSettings, healUserSettings, mergeWatchtowerHooks, mergeMuxHooks, mergeBashCompressHooks } = require('./settings-merge');
 const { create: createMetadata, read: readMetadata } = require('./metadata');
 const { setupDb } = require('./db-setup');
 const { setupVerifyRuntime } = require('./verify-setup');
@@ -471,7 +471,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: true,
-    templates: ['hooks/git-guardrails.sh', 'hooks/cc-upstream-guard.sh', 'hooks/skill-telemetry.sh', 'hooks/skill-tool-telemetry.sh', 'hooks/work-tracker-guard.sh', 'hooks/action-quality-gate.sh', 'hooks/action-completion-gate.sh', 'hooks/memory-index-guard.sh', 'scripts/cc-drift-check.cjs'],
+    templates: ['hooks/git-guardrails.sh', 'hooks/cc-upstream-guard.sh', 'hooks/skill-telemetry.sh', 'hooks/skill-tool-telemetry.sh', 'hooks/work-tracker-guard.sh', 'hooks/action-quality-gate.sh', 'hooks/action-completion-gate.sh', 'hooks/memory-index-guard.sh', 'scripts/cc-drift-check.cjs', 'scripts/skill-usage.mjs'],
   },
   'work-tracking': {
     name: 'Work Tracking (pib-db or markdown)',
@@ -488,7 +488,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: true,
-    templates: ['skills/plan', 'skills/execute', 'skills/execute/phases/post-impl-checklist.md', 'skills/debrief/phases/checklist-feedback.md', 'skills/checklist-discover', 'skills/generate-plan-groups', 'skills/execute-group', 'workflows/execute-group-implement.js', 'workflows/execute-group-complete.js', 'skills/investigate', 'cabinet/checkpoint-protocol.md', 'cabinet/qa-dimensions-template.yaml', 'scripts/qa-dimensions-validator.cjs', 'skills/orient/phases/checklist-status.md'],
+    templates: ['skills/plan', 'skills/execute', 'skills/execute/phases/post-impl-checklist.md', 'skills/debrief/phases/checklist-feedback.md', 'skills/checklist-discover', 'skills/generate-plan-groups', 'skills/execute-group', 'workflows/execute-group-implement.js', 'workflows/execute-group-complete.js', 'skills/investigate', 'cabinet/checkpoint-protocol.md', 'cabinet/elicitation-methods.md', 'cabinet/qa-dimensions-template.yaml', 'scripts/qa-dimensions-validator.cjs', 'skills/orient/phases/checklist-status.md'],
   },
   'compliance': {
     name: 'Compliance Stack (rules + enforcement)',
@@ -496,7 +496,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: false,
-    templates: ['rules/enforcement-pipeline.md', 'rules/maintainability.md', 'memory/patterns/_pattern-template.md', 'memory/patterns/pattern-intelligence-first.md'],
+    templates: ['rules/enforcement-pipeline.md', 'rules/maintainability.md', 'rules/markdown-prose.md', 'skills/unwrap', 'memory/patterns/_pattern-template.md', 'memory/patterns/pattern-intelligence-first.md'],
   },
   'memory': {
     name: 'Built-In Memory (cc-remember + reader + validator)',
@@ -533,10 +533,12 @@ const MODULES = {
       'skills/cabinet-boundary-man',
       'skills/cabinet-anthropic-insider', 'skills/cabinet-cc-health',
       'skills/cabinet-data-integrity',
-      'skills/cabinet-debugger', 'skills/cabinet-historian',
+      'skills/cabinet-debugger', 'skills/cabinet-deployment',
+      'skills/cabinet-historian',
       'skills/cabinet-organized-mind', 'skills/cabinet-process-therapist',
       'skills/cabinet-qa', 'skills/cabinet-record-keeper',
       'skills/cabinet-roster-check', 'skills/cabinet-security',
+      'skills/cabinet-seo',
       'skills/cabinet-small-screen', 'skills/cabinet-speed-freak',
       'skills/cabinet-system-advocate', 'skills/cabinet-technical-debt',
       'skills/cabinet-usability', 'skills/cabinet-workflow-cop',
@@ -559,7 +561,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: true,
-    templates: ['skills/onboard', 'skills/seed', 'skills/cc-upgrade', 'skills/cc-link', 'skills/cc-unlink', 'skills/cc-extract', 'skills/cc-feedback'],
+    templates: ['skills/onboard', 'skills/seed', 'skills/cc-upgrade', 'skills/cc-link', 'skills/cc-unlink', 'skills/cc-extract', 'skills/cc-feedback', 'cabinet/elicitation-methods.md'],
   },
   'validate': {
     name: 'Validate',
@@ -654,6 +656,7 @@ const MODULES = {
       'scripts/watchtower-ring3-close.mjs',
       'scripts/watchtower-status.sh',
       'skills/briefing',
+      'skills/threads',
     ],
   },
   mux: {
@@ -675,6 +678,15 @@ const MODULES = {
     postInstall: 'engagement-server-setup',
     templates: [],
   },
+  'bash-compress': {
+    name: 'Bash Output Compression Hook',
+    description: 'PostToolUse hook that compresses noisy Bash stdout (git status walls, npm/yarn install output, find/ls dumps) to reclaim context in long sessions. Off by default. stderr and error/warning lines pass through verbatim; every rewrite carries a visible [compressed] marker; fail-open on any error. Requires the hooks module (it wires into .claude/settings.json).',
+    mandatory: false,
+    default: false,
+    lean: false,
+    requires: ['hooks'],
+    templates: ['hooks/bash-output-compress.sh'],
+  },
 };
 
 /** Recursively collect all relative file paths under a directory. */
@@ -1292,6 +1304,11 @@ async function run() {
       mergeMuxHooks(settingsPath);
       console.log('  ⚙️  Registered mux worktree health SessionStart hook');
     }
+
+    if (selectedModules.includes('bash-compress')) {
+      mergeBashCompressHooks(settingsPath);
+      console.log('  ⚙️  Registered bash-output compression PostToolUse hook');
+    }
   }
 
   // --- Heal user-level ~/.claude/settings.json ---
@@ -1315,6 +1332,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 +1589,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

@@ -121,6 +121,25 @@ const MUX_HOOKS = {
   ],
 };
 
+// Opt-in bash-output compression. PostToolUse hook on Bash that compresses
+// known-noisy stdout (git status walls, npm/yarn install output) to reclaim
+// context. Off by default; registered only when the `bash-compress` module
+// is selected. The hook itself is fail-open (passes output through untouched
+// on any error) — see templates/hooks/bash-output-compress.sh.
+const BASH_COMPRESS_HOOKS = {
+  PostToolUse: [
+    {
+      matcher: 'Bash',
+      hooks: [
+        {
+          type: 'command',
+          command: '.claude/hooks/bash-output-compress.sh',
+        },
+      ],
+    },
+  ],
+};
+
 // Legacy hook script names that should be stripped on any merge.
 // Centralizes cleanup so a user who skips --migrate-memory but runs
 // any other CC operation still gets omega-era hooks pruned.
@@ -153,6 +172,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 = {};
 
@@ -303,4 +327,35 @@ function mergeMuxHooks(settingsPath) {
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
 }
 
-module.exports = { mergeSettings, healUserSettings, mergeWatchtowerHooks, mergeMuxHooks, DEFAULT_HOOKS, WATCHTOWER_HOOKS, MUX_HOOKS, LEGACY_HOOK_COMMANDS };
+/**
+ * Merge the opt-in bash-output compression hook into project settings.
+ * Called from the bash-compress module's install path in cli.js — only
+ * registers the PostToolUse Bash hook when that module is selected.
+ * Idempotent (de-dupes by command path).
+ */
+function mergeBashCompressHooks(settingsPath) {
+  if (!fs.existsSync(settingsPath)) return;
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  if (!settings.hooks) settings.hooks = {};
+
+  for (const [event, newHooks] of Object.entries(BASH_COMPRESS_HOOKS)) {
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = newHooks;
+    } else {
+      for (const newHook of newHooks) {
+        const hookKey = h => h.command || h.prompt || '';
+        const existingKeys = settings.hooks[event].flatMap(h =>
+          h.hooks.map(hh => hookKey(hh))
+        );
+        const newKeys = newHook.hooks.map(h => hookKey(h));
+        if (!newKeys.every(k => existingKeys.includes(k))) {
+          settings.hooks[event].push(newHook);
+        }
+      }
+    }
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+module.exports = { mergeSettings, healUserSettings, mergeWatchtowerHooks, mergeMuxHooks, mergeBashCompressHooks, DEFAULT_HOOKS, WATCHTOWER_HOOKS, MUX_HOOKS, BASH_COMPRESS_HOOKS, LEGACY_HOOK_COMMANDS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.40.0",
+  "version": "0.42.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/cabinet/advisories-state-schema.md

@@ -0,0 +1,68 @@
+# Advisory dismissal state — schema and rules
+
+Orient surfaces stack-aware advisories (install the Ruby language server, register the Railway MCP, install `hookify`, …). Without memory, every advisory re-nags every session — the same attention-fatigue pattern the watchtower rings were built to eliminate. This file defines the per-project state that gives advisories a memory, and the exact rules orient follows so an advisory is never *permanently* silenced by accident.
+
+## Where it lives
+
+`.claude/cabinet/advisories-state.json` — **per project, generated at runtime**, NOT shipped as a template. Orient creates it on first write. It must never be added to a module's template array: a shipped stub would overwrite a project's real dismissal history on reinstall (the `.ccrc.json` clobber class of bug). If the file is absent, every advisory is treated as never-seen.
+
+> Worktree note: `.claude/cabinet/` is copied per worktree, so dismissal state can diverge between a worktree and its main checkout. That is acceptable — advisories are advisory — and is the reason this is project-local, not user-global.
+
+## Schema
+
+```json
+{
+  "<advisoryId>": {
+    "status": "suggested" | "declined" | "installed",
+    "count": 2,
+    "last_shown": "2026-06-07",
+    "signal": "gemfile+rb"
+  }
+}
+```
+
+- **`advisoryId`** — a stable id per advisory, e.g. `lsp:ruby`, `lsp:typescript`, `mcp:railway`, `plugin:hookify`.
+- **`status`**
+  - `suggested` — shown, not yet acted on.
+  - `declined` — the user explicitly waved it off.
+  - `installed` — the thing is present (probe confirmed). **Terminal** — never surface again.
+- **`count`** — how many sessions it has been surfaced while still actionable. Drives the "stop nagging" rule.
+- **`last_shown`** — ISO date of the most recent surfacing.
+- **`signal`** — *the key field that makes "resurface if the stack changed" actually work.* A short, deterministic fingerprint of the stack indicators present when the advisory was last shown/declined. For a multi-indicator advisory like Ruby (`Gemfile` OR `*.rb`), the fingerprint records *which* indicators were present (e.g. `gemfile` vs `gemfile+rb`), so a later change is detectable. Without this stored snapshot, orient has only the *current* indicators and no baseline to diff against — which is the gap this schema closes.
+
+## The rules orient follows
+
+Before surfacing any advisory, orient computes the advisory's **current signal** (fingerprint of the indicators present now) and reads the stored entry:
+
+1. **No entry / file absent** → surface it. Write `{status:"suggested", count:1, last_shown:today, signal:current}`.
+2. **`installed`** → never surface (terminal). (Re-probe may flip a `suggested`/`declined` entry to `installed`; never the reverse automatically.)
+3. **`declined`**
+   - current signal **==** stored signal → **silent.** (Optionally surfaced in `/pulse` only.)
+   - current signal **!=** stored signal → the stack changed since the user declined → **re-surface exactly once.** Reset to `{status:"suggested", count:1, signal:current}`.
+4. **`suggested`**
+   - `count < 2` and signal unchanged → surface again, `count++`, `last_shown=today`.
+   - `count >= 2` and signal unchanged → **go quiet** (mention only in `/pulse`). Do not keep incrementing.
+   - signal **!=** stored signal (at any count) → the stack changed → reset to `{count:1, signal:current}` and surface.
+
+### The anti-trap guarantee
+
+**Any change in the stack signal resets an advisory to actionable** — so no advisory is permanently invisible while the thing it suggests is still relevant *and the project keeps evolving*.
+
+The one deliberately-sticky case: an advisory whose signal **never changes** once it fires. Example: `plugin:hookify`, keyed on the existence of `.claude/rules/enforcement-pipeline.md` — a file that, once created, stays. A `declined` hookify therefore stays declined. That is intended (the user said no, and nothing about the project changed to revisit it), but it must remain **escapable, not a black hole**:
+
+- It is still listed in `/pulse` (quiet, not gone).
+- Clearing its entry from `advisories-state.json` (or setting `status` back to `suggested`) re-arms it.
+
+Document any new advisory's signal source here when you add it, and call out explicitly if its signal is static (like hookify) so the sticky behavior is a known property, not a surprise.
+
+## Advisory ids in use
+
+| advisoryId | indicator(s) → signal | install action shown (advisory only — orient never runs it) |
+|---|---|---|
+| `lsp:typescript` | `tsconfig.json` or `*.ts` | `/plugin install typescript-lsp` |
+| `lsp:python` | `pyproject.toml` / `requirements.txt` / `*.py` | `/plugin install pyright-lsp` |
+| `lsp:rust` | `Cargo.toml` | `/plugin install rust-analyzer-lsp` |
+| `lsp:go` | `go.mod` | `/plugin install gopls-lsp` |
+| `lsp:ruby` | `Gemfile` or `*.rb` | `/plugin install ruby-lsp@claude-plugins-official` (also needs `gem install ruby-lsp` AND `ENABLE_LSP_TOOL=1`) |
+| `mcp:railway` | `railway.toml` and no railway key in `~/.claude.json` | local: `railway setup agent -y` · remote: register `mcp.railway.com` (OAuth) |
+| `plugin:hookify` | `.claude/rules/enforcement-pipeline.md` exists and hookify not in `claude plugin list` (signal is **static**) | `/plugin install hookify` |

package/templates/cabinet/elicitation-methods.md

@@ -0,0 +1,70 @@
+# Elicitation Methods — structured ways to draw out what the user knows
+
+CC's interviewing moments (onboard, seed, `/plan` scoping, checklist-discover, debrief) improvise their questioning. This is the shared shelf of structured elicitation techniques skills can consult when they need to draw something out — surfacing a hidden assumption, pressure-testing a plan, widening the option space. It sits on the same shelf as `skill-output-conventions.md`: a reference skills *cite*, not a phase they run.
+
+Derived from the BMAD-METHOD advanced-elicitation method set (Apache-2.0; see attribution at the end), curated and adapted to CC's constraints. Several entries are classic requirements-elicitation / creative-thinking craft that BMAD also draws on; those are noted.
+
+## How to use this file
+
+A skill at an interview step consults this file to *choose how to ask* — it does not run a menu. Pick the one or two techniques that fit the moment and the gap you're trying to close, then ask. The technique shapes the question; the conversation stays a conversation.
+
+## Fit criteria (why these and not the other 70-odd)
+
+A technique earns a place here only if it meets all four:
+
+1. **Conversational register** — it works as plain dialogue, not a worksheet or a numbered menu (terminal prose constraint).
+2. **One question at a time** — it can be run as a sequence of single questions, never a batch. This is a CC hard rule (`CLAUDE.md`): write interview questions one at a time, never batched.
+3. **Fits a named CC moment** — onboard, seed, `/plan` scoping, checklist-discover, or debrief.
+4. **No persona-roleplay dependency** — it doesn't require the user (or Claude) to adopt and switch between named personas to function.
+
+## The methods
+
+### First-Principles Thinking
+*Moments: /plan scoping, onboard.* Strip away how it's done today and rebuild from what the thing actually needs to do. Use when a plan is anchored on an existing implementation and you suspect the real requirement is simpler or different.
+- Ask: *"Ignore how this works today — what does it actually need to accomplish, at minimum?"* then, one at a time, *"Which of those are truly required versus inherited from the current approach?"*
+
+### Pre-mortem
+*Moments: /plan scoping, checklist-discover.* Assume the work shipped and failed; reason backward to the cause. Surfaces risks and edge cases the optimistic framing hides. (BMAD-named.)
+- Ask: *"Imagine this shipped and quietly failed a month later — what's the single most likely reason?"* then *"What would we have needed to know up front to prevent that?"*
+
+### Inversion
+*Moments: /plan, checklist-discover.* Ask how to *guarantee* failure, then avoid those things. Often easier to enumerate than success conditions. (BMAD-named.)
+- Ask: *"What's the surest way to make this go wrong?"* then *"Which of those are we closest to doing by accident?"*
+
+### Assumption Surfacing
+*Moments: /plan scoping (pairs with the plan-completeness `[NEEDS CLARIFICATION]` marker), investigate.* Name the unspoken assumptions a plan rests on so the shaky ones get checked before building. (Classic requirements-elicitation craft.)
+- Ask: *"What are we assuming is true here that we haven't actually verified?"* then take them one at a time: *"How would we confirm that one cheaply?"*
+
+### Socratic Questioning
+*Moments: any.* Challenge a claim with "why?" and "how do you know?" until it rests on something solid. Use sparingly — it's a scalpel, not a default. (BMAD-named.)
+- Ask: *"What makes you confident that's the right call?"* then follow the answer down one level at a time.
+
+### Constraint Removal
+*Moments: onboard (vision), seed (member design), /plan (widen options).* Drop a constraint, see what becomes possible, then add it back deliberately. Widens the option space when thinking feels boxed in. (BMAD-named.)
+- Ask: *"If [time / scope / the existing schema] weren't a limit, what would you do instead?"* then *"What's the smallest version of that we could actually do?"*
+
+### Stakeholder Lens
+*Moments: onboard (who is served), seed (whose perspective the member encodes).* Re-ask the question from one stakeholder's point of view at a time — the user, a future maintainer, the end customer. One lens per question; never a round-table battery. (Adapted from BMAD's Stakeholder Mapping to honor the one-question rule.)
+- Ask: *"From the end user's point of view, what would make this a win?"* then, next turn, *"Now from the person who maintains it a year from now — same question."*
+
+### Analogical Reasoning
+*Moments: seed (member design), onboard (mental model).* Find the closest parallel in another domain and borrow its lessons. Good for naming a fuzzy concept or designing something with no obvious precedent. (BMAD-named.)
+- Ask: *"What existing thing — in or out of software — is this most like?"* then *"What does that parallel get right that we should copy, and where does it break down?"*
+
+### Five Whys
+*Moments: investigate, /plan problem-framing, debrief.* Trace a stated problem to its root by asking "why" about each answer in turn. Naturally one-at-a-time. (Classic root-cause craft BMAD draws on.)
+- Ask: *"Why is that a problem?"* — and about each answer, *"And why is that?"* — usually three to five levels reaches the root.
+
+### Expand or Contract for Audience
+*Moments: checklist-discover, onboard, debrief presentation.* Deliberately widen or narrow the level of detail to fit who the output serves. Use when scope or depth feels mismatched to the audience. (BMAD-named.)
+- Ask: *"Who reads this, and do they need more breadth or more depth than we have?"* then adjust one dimension at a time.
+
+## Considered, not kept
+
+- **Red Team vs Blue Team** — a multi-round attack/defend battery; the full technique needs adversarial persona-switching and several exchanges. The useful core (steelman the opposing case) is covered by Socratic Questioning and Inversion as single questions.
+- **Six Thinking Hats** — a six-perspective battery requiring sequential persona adoption; fails the no-persona-roleplay and one-question criteria. The Stakeholder Lens covers the salvageable part, one lens at a time.
+- **Any numbered-menu / "pick 1-9" selection flows** — BMAD presents methods as an interactive numbered menu; that interaction model fails the terminal-prose constraint. CC skills choose a technique themselves and just ask.
+
+## Attribution
+
+Several methods here are derived from the BMAD-METHOD advanced-elicitation method set (`bmad-code-org/BMAD-METHOD`, Apache License 2.0). Method *names and descriptions* that originate there are marked "(BMAD-named)" above; the adaptations to one-question-at-a-time conversational flow, the CC-moment mapping, and the classic-craft additions are CC's own. BMAD is Apache-2.0 licensed; this derived reference preserves that attribution.

package/templates/cabinet/eval-protocol.md

@@ -70,6 +70,26 @@ Also check:
 If a skill hasn't been invoked 3 times in the last month, that itself is
 a finding (coverage gap or trigger problem).
 
+**Invocation data — don't eyeball it.** The hooks module's skill-telemetry
+hooks log every skill run to `~/.claude/telemetry/telemetry.jsonl`. Read it
+with the dead-skill reader instead of guessing:
+
+```
+node scripts/skill-usage.mjs            # human report (dead / stale / active)
+node scripts/skill-usage.mjs --quiet    # prints only if there's something to flag
+node scripts/skill-usage.mjs --json     # structured, for programmatic checks
+node scripts/skill-usage.mjs --days 60  # widen the stale threshold
+```
+
+It cross-references installed user-invocable skills against the telemetry and
+surfaces **DEAD** (never invoked — removal or trigger-phrase candidates) and
+**STALE** (not invoked within the threshold). Telemetry is global across
+projects, so a skill flagged DEAD was invoked in *no* project — a strong
+signal. Cabinet members and other `user-invocable: false` skills are excluded
+(they run as agents, not slash/Skill calls, so they never appear). Treat the
+output as candidates for judgment, not a verdict — a never-invoked skill may
+have bad trigger phrasing rather than no purpose.
+
 ### 3. Score Each Assertion
 
 For each assertion, review the sampled executions and score:

package/templates/cabinet/skill-output-conventions.md

@@ -53,9 +53,27 @@ behaves unexpectedly.
   pick more than one.
 - **"Other" is auto-added** by the harness. Never add an "Other" /
   "Something else" option manually — it duplicates.
-- **No reliable preview/comparison field.** The official schema has no
-  dependable preview surface; don't build conventions on preview
-  behavior or expect side-by-side rendering.
+- **A dialog swallows same-turn prose. Never pair one with an
+  explanation the user must read.** When AskUserQuestion fires, the
+  dialog takes over the screen — any prose streamed in the same turn
+  is effectively invisible at decision time. Two compliant shapes
+  (user-confirmed 2026-06-06, after being bitten twice in one day):
+  1. **Explanation-first (default for read-then-decide loops):** end
+     the turn with the full explanation as prose and a plain-text
+     question ("Accept, edit, or skip?"). Take the user's prose
+     answer. No dialog at all — this also satisfies the bounded-list
+     caveat below for sequential same-shaped decisions.
+  2. **Self-sufficient dialog (for small, comparable artifacts):**
+     the dialog carries ALL decision content itself. Single-select
+     options support a `preview` field (markdown, side-by-side) —
+     put the artifact in the preview, attach the SAME preview to
+     every option so it stays visible whichever option is focused,
+     tradeoffs in option `description`s. Same-turn prose: one-line
+     pointer max. If the content doesn't fit a preview pane, you're
+     in shape 1.
+  (Updated 2026-06-06: earlier guidance said preview was
+  undependable; the harness now renders it reliably for single-select
+  questions. multiSelect still has no preview.)
 - **Unavailable in Task-spawned subagents.** Agents launched via the
   Task tool (execute-group worktree agents, Workflow agents,
   `context:fork`) cannot call AskUserQuestion — they must use prose.