create-claude-cabinet 0.8.5 → 0.10.0

package/lib/cli.js

@@ -33,7 +33,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: false,
-    templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql'],
+    templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql', 'scripts/work-tracker-server.mjs', 'scripts/work-tracker-ui.html'],
     needsDb: true,
   },
   'planning': {
@@ -42,7 +42,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: true,
-    templates: ['skills/plan', 'skills/execute', 'skills/investigate'],
+    templates: ['skills/plan', 'skills/execute', 'skills/execute-plans', 'skills/investigate'],
   },
   'compliance': {
     name: 'Compliance Stack (rules + enforcement)',
@@ -103,10 +103,26 @@ const MODULES = {
     default: true,
     lean: false,
     needsOmega: true,
-    templates: ['skills/memory', 'hooks/memory-session-start.sh', 'hooks/memory-post-compact.sh', 'scripts/cabinet-memory-adapter.py', 'rules/memory-capture.md'],
+    templates: ['skills/memory', 'scripts/cabinet-memory-adapter.py', 'rules/memory-capture.md'],
   },
 };
 
+/** Recursively collect all relative file paths under a directory. */
+function walkDir(dir, base) {
+  if (!base) base = dir;
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir(full, base));
+    } else {
+      results.push(path.relative(base, full));
+    }
+  }
+  return results;
+}
+
 // Signals that a directory contains a real project (not just empty)
 const PROJECT_SIGNALS = [
   'package.json', 'Cargo.toml', 'requirements.txt', 'pyproject.toml',
@@ -542,8 +558,7 @@ async function run() {
 
   // --- Merge hooks into settings.json ---
   if (selectedModules.includes('hooks') && !flags.dryRun) {
-    const includeMemory = selectedModules.includes('memory');
-    const settingsPath = mergeSettings(projectDir, { includeDb, includeMemory });
+    const settingsPath = mergeSettings(projectDir, { includeDb });
     console.log(`  ⚙️  Merged hooks into ${path.relative(projectDir, settingsPath)}`);
   }
 
@@ -572,24 +587,152 @@ async function run() {
     }
   }
 
-  // --- Clean up files removed upstream ---
-  // Phase files are excluded from the manifest (they're user-customized),
-  // so skip them during cleanup even if they were in the old manifest.
+  // --- Manifest key migration (act:d1f16bee) ---
+  // When CC renames directories (e.g., perspectives/ → cabinet-*/), old manifest
+  // keys no longer match new template paths. Migrate keys BEFORE cleanup so the
+  // cleanup loop doesn't treat renamed files as removed.
+  if (Object.keys(existingManifest).length > 0) {
+    const existing = readMetadata(projectDir);
+    const fromVersion = existing.version;
+    let migrationCount = 0;
+    // v0.5.x → v0.6.x: perspectives/ → cabinet-*/
+    if (fromVersion && /^0\.[0-5]\./.test(fromVersion)) {
+      for (const key of Object.keys(existingManifest)) {
+        const match = key.match(/\.claude\/skills\/perspectives\/([^/]+)\//);
+        if (match) {
+          const newKey = key.replace(`perspectives/${match[1]}/`, `cabinet-${match[1]}/`);
+          existingManifest[newKey] = existingManifest[key];
+          delete existingManifest[key];
+          migrationCount++;
+        }
+      }
+    }
+    // Future manifest key migrations go here
+    if (migrationCount > 0) {
+      console.log(`  🔄 Migrated ${migrationCount} manifest key${migrationCount === 1 ? '' : 's'} for directory rename`);
+    }
+  }
+
+  // --- Clean up files removed upstream (safeguarded) ---
+  // Four safeguards prevent the v0.6.8 incident from recurring:
+  //   S1: Classify — only delete files that map to a known CC template path
+  //   S2: Scope — only delete files from modules the user selected
+  //   S3: Itemize — list all deletions and confirm before proceeding
+  //   S4: Backup — copy files to .cc-backup/<timestamp>/ before deletion
   if (Object.keys(existingManifest).length > 0) {
-    let totalRemoved = 0;
+    // S1: Build complete template path set (ALL modules) for classification
+    const allTemplatePaths = new Set();
+    for (const mod of Object.values(MODULES)) {
+      for (const tmpl of mod.templates || []) {
+        const srcPath = path.join(templateRoot, tmpl);
+        if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+          for (const rel of walkDir(srcPath)) {
+            allTemplatePaths.add(manifestPath(tmpl) + '/' + rel);
+          }
+        } else if (fs.existsSync(srcPath)) {
+          allTemplatePaths.add(manifestPath(tmpl));
+        }
+      }
+    }
+
+    // S2: Build selected-module template paths for scoping
+    const selectedTemplatePaths = new Set();
+    for (const modKey of selectedModules) {
+      const mod = MODULES[modKey];
+      for (const tmpl of mod.templates || []) {
+        const srcPath = path.join(templateRoot, tmpl);
+        if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+          for (const rel of walkDir(srcPath)) {
+            selectedTemplatePaths.add(manifestPath(tmpl) + '/' + rel);
+          }
+        } else if (fs.existsSync(srcPath)) {
+          selectedTemplatePaths.add(manifestPath(tmpl));
+        }
+      }
+    }
+
+    // Build CC template skill name set for project-skill guard (act:4ac281ba)
+    const ccSkillNames = new Set();
+    for (const mod of Object.values(MODULES)) {
+      for (const tmpl of mod.templates || []) {
+        if (tmpl.startsWith('skills/')) {
+          const skillName = tmpl.split('/')[1];
+          ccSkillNames.add(skillName);
+        }
+      }
+    }
+
+    // Collect files that would be removed
+    const toRemove = [];
     for (const oldPath of Object.keys(existingManifest)) {
       if (!allManifest[oldPath]) {
         // Skip phase files — they may be user-customized
         if (/\/phases\//.test(oldPath)) continue;
+
+        // S1: Only delete if the path maps to a known CC template
+        if (!allTemplatePaths.has(oldPath)) {
+          console.log(`  Keeping non-template file: ${oldPath}`);
+          continue;
+        }
+
+        // S2: Only delete from selected modules (don't purge deselected modules)
+        if (!selectedTemplatePaths.has(oldPath)) {
+          continue;
+        }
+
+        // Project-skill guard: never delete skills CC didn't create
+        const skillDirMatch = oldPath.match(/^\.claude\/skills\/([^/]+)\//);
+        if (skillDirMatch && !ccSkillNames.has(skillDirMatch[1])) {
+          console.log(`  Keeping project skill: ${oldPath}`);
+          continue;
+        }
+
         const fullPath = path.join(projectDir, oldPath);
         if (fs.existsSync(fullPath)) {
-          if (!flags.dryRun) fs.unlinkSync(fullPath);
-          totalRemoved++;
+          toRemove.push(oldPath);
         }
       }
     }
-    if (totalRemoved > 0) {
-      console.log(`  🧹 Removed ${totalRemoved} file${totalRemoved === 1 ? '' : 's'} no longer in upstream`);
+
+    // S3: Itemize and confirm before deleting
+    if (toRemove.length > 0) {
+      console.log(`\n  Files no longer in upstream (${toRemove.length}):`);
+      for (const f of toRemove) {
+        console.log(`    - ${f}`);
+      }
+
+      let confirmed = flags.yes;
+      if (!confirmed && !flags.dryRun) {
+        const response = await prompts({
+          type: 'confirm',
+          name: 'confirmed',
+          message: `Remove ${toRemove.length} file${toRemove.length === 1 ? '' : 's'}?`,
+          initial: false,
+        });
+        confirmed = response.confirmed;
+      }
+
+      if (confirmed && !flags.dryRun) {
+        // S4: Backup before deleting
+        const backupDir = path.join(projectDir, '.cc-backup', new Date().toISOString().replace(/[:.]/g, '-'));
+        fs.mkdirSync(backupDir, { recursive: true });
+        for (const filePath of toRemove) {
+          const src = path.join(projectDir, filePath);
+          const dest = path.join(backupDir, filePath);
+          fs.mkdirSync(path.dirname(dest), { recursive: true });
+          fs.copyFileSync(src, dest);
+        }
+        console.log(`  📦 Backed up ${toRemove.length} file${toRemove.length === 1 ? '' : 's'} to ${path.relative(projectDir, backupDir)}/`);
+
+        for (const filePath of toRemove) {
+          fs.unlinkSync(path.join(projectDir, filePath));
+        }
+        console.log(`  🧹 Removed ${toRemove.length} file${toRemove.length === 1 ? '' : 's'} no longer in upstream`);
+      } else if (flags.dryRun) {
+        console.log(`  [dry run — ${toRemove.length} file${toRemove.length === 1 ? '' : 's'} would be removed]`);
+      } else {
+        console.log('  Skipped file removal.');
+      }
     }
   }
 

package/lib/copy.js

@@ -45,6 +45,19 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
       if (fs.existsSync(destPath)) {
         const existing = fs.readFileSync(destPath, 'utf8');
 
+        // Phase file guard (act:98d74381) — independent of skipPhases flag.
+        // If a phase file on disk has been customized (differs from template
+        // and isn't empty), never overwrite it regardless of other flags.
+        if (relPath.includes('phases' + path.sep) || relPath.includes('phases/')) {
+          const trimmedExisting = existing.trim();
+          if (trimmedExisting !== '' && trimmedExisting !== incoming.trim()) {
+            results.skipped.push(relPath);
+            results.manifest[relPath] = hashContent(existing);
+            console.log(`  Preserved customized phase: ${displayPath}`);
+            continue;
+          }
+        }
+
         if (existing === incoming) {
           results.skipped.push(relPath);
           results.manifest[relPath] = incomingHash;
@@ -62,6 +75,7 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
             if (!dryRun) fs.copyFileSync(srcPath, destPath);
             results.overwritten.push(relPath);
             results.manifest[relPath] = incomingHash;
+            console.log(`  Updated: ${displayPath}`);
           } else {
             results.skipped.push(relPath);
             // Record the hash of what's actually on disk, not the template —

package/lib/omega-setup.js

@@ -7,17 +7,18 @@ const OMEGA_HOME = path.join(os.homedir(), '.claude-cabinet');
 const VENV_DIR = path.join(OMEGA_HOME, 'omega-venv');
 const VENV_PYTHON = path.join(VENV_DIR, 'bin', 'python3');
 
-// Ordered by preference: stable Cellar symlinks first, newest Python first.
+// Ordered by preference: 3.13 first (ONNX runtime segfaults on 3.14 during
+// shutdown — exit 139, triggers macOS crash dialogs). 3.14 last as fallback.
 // Apple Silicon paths, then Intel Mac paths, then PATH fallback.
 const PYTHON_CANDIDATES = [
-  '/opt/homebrew/opt/python@3.14/bin/python3.14',
   '/opt/homebrew/opt/python@3.13/bin/python3.13',
   '/opt/homebrew/opt/python@3.12/bin/python3.12',
   '/opt/homebrew/opt/python@3.11/bin/python3.11',
-  '/usr/local/opt/python@3.14/bin/python3.14',
+  '/opt/homebrew/opt/python@3.14/bin/python3.14',
   '/usr/local/opt/python@3.13/bin/python3.13',
   '/usr/local/opt/python@3.12/bin/python3.12',
   '/usr/local/opt/python@3.11/bin/python3.11',
+  '/usr/local/opt/python@3.14/bin/python3.14',
   '/opt/homebrew/bin/python3',
   '/usr/local/bin/python3',
 ];
@@ -105,6 +106,21 @@ function setupOmega() {
     try {
       execSync(`"${VENV_PYTHON}" -c "import omega"`, { stdio: 'pipe' });
       results.push('Existing omega venv is valid');
+      // Ensure cross-encoder model is downloaded (added in v0.9.1)
+      try {
+        const hasReranker = execSync(
+          `"${VENV_PYTHON}" -c "from omega.reranker import _get_model_dir; print('yes' if _get_model_dir() else 'no')"`,
+          { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+        ).trim();
+        if (hasReranker === 'no') {
+          console.log('  Downloading cross-encoder model...');
+          execSync(`"${VENV_PYTHON}" -c "from omega.reranker import download_model; download_model()"`, {
+            stdio: 'pipe',
+            timeout: 120000,
+          });
+          results.push('Downloaded cross-encoder reranker model');
+        }
+      } catch { /* non-fatal */ }
       return results;
     } catch {
       // Venv is broken — nuke and rebuild (D5)
@@ -134,6 +150,35 @@ function setupOmega() {
   });
   results.push('Downloaded ONNX embedding model (bge-small-en-v1.5)');
 
+  // 6. Download cross-encoder reranker model (improves query result ranking)
+  console.log('  Downloading cross-encoder model...');
+  try {
+    execSync(`"${VENV_PYTHON}" -c "from omega.reranker import download_model; download_model()"`, {
+      stdio: 'pipe',
+      timeout: 120000,
+    });
+    results.push('Downloaded cross-encoder reranker model');
+  } catch {
+    // Non-fatal — queries work without it, just less accurate ranking
+    results.push('Cross-encoder model download skipped (optional)');
+  }
+
+  // 7. Configure omega native hooks in global settings
+  //    Omega hooks live in ~/.claude/settings.json (global) — they run for all
+  //    projects and handle memory capture/recall natively. This is idempotent:
+  //    omega checks if hooks already exist before adding them.
+  console.log('  Configuring omega hooks...');
+  try {
+    execSync(`"${VENV_PYTHON}" -m omega.cli hooks setup`, {
+      stdio: 'pipe',
+      timeout: 30000,
+    });
+    results.push('Configured omega native hooks (global settings)');
+  } catch {
+    // Non-fatal — hooks can be set up manually with `omega hooks setup`
+    results.push('Omega hooks setup skipped (run `omega hooks setup` manually)');
+  }
+
   return results;
 }
 

package/lib/settings-merge.js

@@ -1,31 +1,6 @@
 const fs = require('fs');
 const path = require('path');
 
-const MEMORY_HOOKS = {
-  SessionStart: [
-    {
-      matcher: 'startup|resume|compact',
-      hooks: [
-        {
-          type: 'command',
-          command: '.claude/hooks/memory-session-start.sh',
-        },
-      ],
-    },
-  ],
-  PostCompact: [
-    {
-      matcher: '',
-      hooks: [
-        {
-          type: 'command',
-          command: '.claude/hooks/memory-post-compact.sh',
-        },
-      ],
-    },
-  ],
-};
-
 const DEFAULT_HOOKS = {
   PreToolUse: [
     {
@@ -75,7 +50,7 @@ const DEFAULT_HOOKS = {
  * Merge PIB hooks into the project's .claude/settings.json.
  * Creates the file if it doesn't exist. Preserves existing hooks.
  */
-function mergeSettings(projectDir, { includeDb = true, includeMemory = false } = {}) {
+function mergeSettings(projectDir, { includeDb = true } = {}) {
   const settingsDir = path.join(projectDir, '.claude');
   const settingsPath = path.join(settingsDir, 'settings.json');
 
@@ -90,16 +65,24 @@ function mergeSettings(projectDir, { includeDb = true, includeMemory = false } =
 
   if (!settings.hooks) settings.hooks = {};
 
-  // Build the complete hook set for this install
-  const allHooks = { ...DEFAULT_HOOKS };
-  if (includeMemory) {
-    for (const [event, hooks] of Object.entries(MEMORY_HOOKS)) {
-      allHooks[event] = [...(allHooks[event] || []), ...hooks];
-    }
+  // Remove legacy CC memory hooks (v0.9.x and earlier).
+  // These are now handled by omega's native hooks in global settings.
+  const LEGACY_MEMORY_COMMANDS = [
+    'memory-session-start.sh',
+    'memory-post-compact.sh',
+  ];
+  for (const [event, entries] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(entries)) continue;
+    settings.hooks[event] = entries.filter(entry => {
+      if (!entry.hooks || !Array.isArray(entry.hooks)) return true;
+      return !entry.hooks.some(h =>
+        LEGACY_MEMORY_COMMANDS.some(cmd => (h.command || '').includes(cmd))
+      );
+    });
   }
 
   // Merge each hook event type
-  for (const [event, newHooks] of Object.entries(allHooks)) {
+  for (const [event, newHooks] of Object.entries(DEFAULT_HOOKS)) {
     if (!settings.hooks[event]) {
       settings.hooks[event] = newHooks;
     } else {
@@ -123,4 +106,4 @@ function mergeSettings(projectDir, { includeDb = true, includeMemory = false } =
   return settingsPath;
 }
 
-module.exports = { mergeSettings, DEFAULT_HOOKS, MEMORY_HOOKS };
+module.exports = { mergeSettings, DEFAULT_HOOKS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.8.5",
+  "version": "0.10.0",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"

package/templates/rules/memory-capture.md

@@ -1,43 +1,42 @@
 # Memory Capture Rules
 
-When omega memory is active (check: `~/.claude-cabinet/omega-venv/bin/python3`
-exists and `scripts/cabinet-memory-adapter.py` exists), these rules govern
-what gets captured and when.
+When omega memory is active (check: `omega hooks doctor` reports OK),
+these rules govern what gets captured and when.
 
-## During Sessions — What to Capture
+## How Capture Works
 
-Capture to omega when you observe any of these during a session:
+Omega handles memory capture natively through its hooks in
+`~/.claude/settings.json` (global). No project-level hook scripts needed.
 
-**Decisions with reasoning.** When the user makes a non-obvious choice
-(architecture, naming, tradeoffs, tool selection), capture the decision
-AND the reasoning. "Chose SQLite over Postgres because single-user,
-no server dependency" — not just "uses SQLite."
+**Automatic capture (omega native hooks):**
+- `auto_capture` (UserPromptSubmit) — detects decisions/lessons from user messages in real time
+- `assistant_capture` (Stop) — extracts insights from assistant responses at session end
+- `session_stop` (Stop) — session summary, activity report, auto-reflection
+- `surface_memories` (PostToolUse) — surfaces relevant memories before file edits
 
-**Discovered constraints.** When something that seemed possible turns
-out to have a limitation, gotcha, or prerequisite. "Python venv on
-Debian requires separate python3-venv package" — the kind of thing
-that wastes 30 minutes if you don't know it.
+**Manual capture (adapter or omega MCP tools):**
+- Use `omega_store()` MCP tool directly, or
+- Use the adapter for project-scoped storage:
+  ```bash
+  echo '{"text": "the memory", "type": "decision"}' | \
+    ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
+  ```
 
-**User preferences revealed through correction.** When the user says
-"no, not like that" or redirects your approach, capture what they
-actually want. "User prefers single bundled PRs for refactors, not
-many small ones."
+**Memory types:** `decision`, `lesson_learned`, `user_preference`, `constraint`, `error_pattern`
 
-**Pattern establishment.** When a convention is established for the
-first time — naming pattern, file organization, workflow step. Not
-the convention itself (that's in the code), but that it was a
-deliberate choice.
+## What to Capture Manually
 
-## How to Capture
+Omega's auto_capture hook catches many decisions and lessons from
+conversation flow. Manual capture is for things the hooks miss:
 
-Use the adapter — never call omega directly from shell:
+**Decisions with reasoning.** Non-obvious architectural choices where
+the "why" matters as much as the "what."
 
-```bash
-echo '{"text": "the memory", "type": "decision"}' | \
-  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
-```
+**Discovered constraints.** Limitations or gotchas that waste time
+if you don't know them in advance.
 
-Memory types: `decision`, `lesson`, `preference`, `constraint`, `pattern`
+**User preferences revealed through correction.** When the user
+redirects your approach — capture what they actually want.
 
 ## What NOT to Capture
 
@@ -49,17 +48,11 @@ Memory types: `decision`, `lesson`, `preference`, `constraint`, `pattern`
 
 ## Capture Cadence
 
-Do NOT capture after every interaction. Capture when something worth
-remembering actually happens. Most messages in a session produce nothing
-worth storing.
-
-Cadence scales with session length and discovery density. A short
-focused session might produce 0-1 memories. A long session with
-multiple discoveries, corrections, and decisions could produce 5-10+.
-The right number is however many genuinely worth-remembering things
-happened — no artificial cap.
+Omega's native hooks handle most capture automatically. Manual capture
+should be rare — only when something important happened that the hooks
+wouldn't detect (e.g., a nuanced architectural decision discussed
+verbally, or a constraint discovered through external research).
 
 Over-capturing degrades retrieval quality. The test: *"Would a future
 session benefit from knowing this?"* If yes, capture it. If it's just
-noise or ephemera, skip it. The debrief sweep catches anything
-important that was missed during the session.
+noise or ephemera, skip it.