create-claude-cabinet 0.9.0 → 0.11.0

package/lib/cli.js

@@ -12,6 +12,177 @@ const { reset } = require('./reset');
 
 const VERSION = require('../package.json').version;
 
+/**
+ * Parse YAML frontmatter from a SKILL.md file (between first two --- lines).
+ * Returns an object with extracted fields, or null if no frontmatter found.
+ * Supports one level of nesting (e.g., directives: { orient: "...", debrief: "..." }).
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fm = {};
+  let currentKey = null;
+  let currentValue = '';
+  let nestedKey = null;   // Parent key when parsing a nested map
+  let nestedMap = null;    // The nested map being built
+  let nestedSubKey = null; // Current sub-key within the nested map
+  let nestedSubValue = '';
+
+  function flushNested() {
+    if (nestedSubKey && nestedMap) {
+      nestedMap[nestedSubKey] = nestedSubValue.trim();
+      nestedSubKey = null;
+      nestedSubValue = '';
+    }
+    if (nestedKey && nestedMap) {
+      fm[nestedKey] = nestedMap;
+      nestedKey = null;
+      nestedMap = null;
+    }
+  }
+
+  function flushCurrent() {
+    if (currentKey) {
+      fm[currentKey] = currentValue.trim();
+      currentKey = null;
+      currentValue = '';
+    }
+  }
+
+  for (const line of match[1].split('\n')) {
+    // Inside a nested map?
+    if (nestedKey) {
+      // Nested sub-key (indented key: value)
+      const subKv = line.match(/^  ([a-z][a-z0-9_-]*)\s*:\s*(.*)/);
+      if (subKv) {
+        // Save previous sub-key
+        if (nestedSubKey) {
+          nestedMap[nestedSubKey] = nestedSubValue.trim();
+        }
+        nestedSubKey = subKv[1];
+        nestedSubValue = subKv[2].replace(/^[>|]\s*$/, '');
+        continue;
+      }
+      // Continuation of nested sub-value (deeply indented)
+      if (nestedSubKey && /^    /.test(line)) {
+        nestedSubValue += ' ' + line.trim();
+        continue;
+      }
+      // Not indented — end of nested map
+      if (nestedSubKey) {
+        nestedMap[nestedSubKey] = nestedSubValue.trim();
+        nestedSubKey = null;
+        nestedSubValue = '';
+      }
+      fm[nestedKey] = nestedMap;
+      nestedKey = null;
+      nestedMap = null;
+      // Fall through to parse this line as a top-level key
+    }
+
+    // Continuation line (indented, for scalar values)
+    if (currentKey && /^[\s]/.test(line)) {
+      currentValue += ' ' + line.trim();
+      continue;
+    }
+
+    flushCurrent();
+
+    // New key-value pair
+    const kvMatch = line.match(/^([a-z][a-z0-9_-]*)\s*:\s*(.*)/);
+    if (kvMatch) {
+      const val = kvMatch[2].trim();
+      // Empty value after colon = start of nested map or block scalar
+      if (val === '' || val === '>' || val === '|') {
+        // Peek: could be a nested map or a block scalar.
+        // We'll treat it as a nested map if the next indented line has a colon.
+        // For now, start as nested and fall back if no sub-keys found.
+        nestedKey = kvMatch[1];
+        nestedMap = {};
+        currentKey = null;
+      } else {
+        currentKey = kvMatch[1];
+        currentValue = val;
+      }
+    }
+  }
+  // Flush remaining
+  if (nestedSubKey && nestedMap) {
+    nestedMap[nestedSubKey] = nestedSubValue.trim();
+  }
+  if (nestedKey && nestedMap) {
+    fm[nestedKey] = Object.keys(nestedMap).length > 0 ? nestedMap : '';
+  }
+  flushCurrent();
+  return fm;
+}
+
+/**
+ * Generate .claude/skills/_index.json from all installed SKILL.md files.
+ * Consumers (menu, cabinet, audit, plan, execute) read this instead of
+ * scanning and parsing dozens of individual files.
+ */
+function generateSkillIndex(projectDir) {
+  const skillsDir = path.join(projectDir, '.claude', 'skills');
+  if (!fs.existsSync(skillsDir)) return 0;
+
+  const entries = [];
+  const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
+  for (const dir of dirs) {
+    if (!dir.isDirectory()) continue;
+    const skillFile = path.join(skillsDir, dir.name, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) continue;
+
+    const content = fs.readFileSync(skillFile, 'utf8');
+    const fm = parseFrontmatter(content);
+    if (!fm || !fm.name) continue;
+
+    // Extract first sentence of description (before "Use when:")
+    let shortDesc = (fm.description || '').replace(/\s*Use when:.*$/is, '').trim();
+    // Collapse to first sentence
+    const sentenceEnd = shortDesc.match(/\.\s/);
+    if (sentenceEnd) shortDesc = shortDesc.slice(0, sentenceEnd.index + 1);
+
+    const isCabinet = dir.name.startsWith('cabinet-');
+    const entry = {
+      name: fm.name,
+      path: `.claude/skills/${dir.name}/SKILL.md`,
+      description: shortDesc,
+      type: isCabinet ? 'cabinet' : 'workflow',
+    };
+
+    // Invocability flags
+    if (fm['disable-model-invocation'] === 'true') entry.manual = true;
+    if (fm['user-invocable'] === 'false') entry.userInvocable = false;
+
+    // Standing mandate (for audit/plan/execute/orient/debrief member selection)
+    if (fm['standing-mandate']) {
+      entry.standingMandate = fm['standing-mandate'].split(/,\s*/).map(s => s.trim());
+    }
+
+    // Directives (scoped tasks for orient/debrief/etc.)
+    if (fm.directives && typeof fm.directives === 'object') {
+      entry.directives = fm.directives;
+    }
+
+    entries.push(entry);
+  }
+
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+
+  const index = {
+    skills: entries,
+    generatedAt: new Date().toISOString(),
+    version: VERSION,
+  };
+
+  fs.writeFileSync(
+    path.join(skillsDir, '_index.json'),
+    JSON.stringify(index, null, 2) + '\n'
+  );
+  return entries.length;
+}
+
 const MODULES = {
   'session-loop': {
     name: 'Session Loop (orient + debrief)',
@@ -33,7 +204,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: false,
-    templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql', 'scripts/work-tracker-server.mjs', 'scripts/work-tracker-ui.html'],
+    templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql', 'scripts/work-tracker-server.mjs', 'scripts/work-tracker-ui.html', 'skills/work-tracker'],
     needsDb: true,
   },
   'planning': {
@@ -59,7 +230,7 @@ const MODULES = {
     default: true,
     lean: true,
     templates: [
-      'skills/audit', 'skills/pulse', 'skills/triage-audit',
+      'skills/audit', 'skills/pulse', 'skills/triage-audit', 'skills/cabinet',
       'cabinet', 'briefing',
       'skills/cabinet-accessibility', 'skills/cabinet-anti-confirmation',
       'skills/cabinet-architecture', 'skills/cabinet-boundary-man',
@@ -103,7 +274,7 @@ 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'],
   },
 };
 
@@ -558,8 +729,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)}`);
   }
 
@@ -737,6 +907,14 @@ async function run() {
     }
   }
 
+  // --- Generate skill index ---
+  if (!flags.dryRun) {
+    const indexCount = generateSkillIndex(projectDir);
+    if (indexCount > 0) {
+      console.log(`  📇 Indexed ${indexCount} skills in .claude/skills/_index.json`);
+    }
+  }
+
   // --- Write metadata ---
   if (!flags.dryRun) {
     createMetadata(projectDir, {

package/lib/copy.js

@@ -75,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

@@ -106,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)
@@ -135,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.9.0",
+  "version": "0.11.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.

package/templates/scripts/cabinet-memory-adapter.py

@@ -1,21 +1,23 @@
 #!/usr/bin/env python3
 """
-Cabinet Memory Adapter — single Python file wrapping all omega interaction.
+Cabinet Memory Adapter — single Python file wrapping omega interaction.
 
-Called by hook scripts via the venv Python. All omega calls go through here.
+Called by skills and scripts via the venv Python. Provides project-scoped
+tiered retrieval (omega's main gap) and a stable JSON-in/JSON-out interface.
 Designed for D2 (never block Claude Code) and D3 (graceful degradation).
 
+Note: Session-level hooks (welcome, capture, session start/stop) are handled
+by omega's native hooks configured in ~/.claude/settings.json (global).
+This adapter handles skill-invoked operations only.
+
 Usage:
     cabinet-memory-adapter.py <command> [options]
 
 Commands:
-    welcome         Surface relevant memories for session start
-    capture         Store a memory from hook input (PostCompact)
-    store           Store a memory directly (called by debrief)
-    query           Query memories by text
+    store           Store a memory directly (called by debrief, /memory)
+    query           Query memories by text (with project-scoped tiering)
     delete          Delete a memory by full node_id
     list            List all memories with full node_ids
-    status          Check omega health
 
 All commands read JSON from stdin when applicable.
 All commands output JSON to stdout.
@@ -59,87 +61,15 @@ def _import_omega():
         return None
 
 
-def cmd_welcome():
-    """Surface relevant memories for session start.
-
-    Reads session context from stdin (session_id, cwd, source).
-    Calls omega.welcome() to get relevant memories.
-    Outputs memories as context text for SessionStart hook stdout.
-    """
-    data = _read_stdin()
-    omega = _import_omega()
-    if not omega:
-        _error("omega not available")
-        return
-
-    try:
-        cwd = data.get("cwd", os.getcwd())
-        project_name = os.path.basename(cwd)
-
-        result = omega.welcome(project=project_name)
-        if not result:
-            _output({"ok": True, "context": ""})
-            return
-
-        # welcome() returns a dict with memory count, recent memories, etc.
-        if isinstance(result, dict):
-            context = (
-                result.get("observation_prefix", "")
-                or result.get("summary", "")
-                or result.get("context", "")
-            )
-            if not context and result.get("memory_count", 0) == 0:
-                _output({"ok": True, "context": ""})
-                return
-            if not context:
-                context = json.dumps(result, indent=2)
-            _output({"ok": True, "context": context})
-        elif isinstance(result, str):
-            _output({"ok": True, "context": result})
-        else:
-            _output({"ok": True, "context": str(result)})
-    except Exception as e:
-        _error(f"welcome failed: {e}")
-
-
-def cmd_capture():
-    """Capture context from PostCompact summary.
-
-    Reads compact_summary from stdin.
-    Extracts key decisions, lessons, and reasoning chains.
-    Stores them in omega.
-    """
-    data = _read_stdin()
-    omega = _import_omega()
-    if not omega:
-        _error("omega not available")
-        return
-
-    summary = data.get("compact_summary", "")
-    if not summary:
-        _output({"ok": True, "stored": 0, "reason": "no summary"})
-        return
-
-    session_id = data.get("session_id", "unknown")
-    cwd = data.get("cwd", os.getcwd())
-    project_name = os.path.basename(cwd)
-
-    try:
-        result = omega.auto_capture(
-            summary,
-            event_type="compaction",
-            session_id=session_id,
-            project=project_name,
-        )
-        count = 0
-        if isinstance(result, dict):
-            count = result.get("stored", 0)
-        elif isinstance(result, (list, tuple)):
-            count = len(result)
-
-        _output({"ok": True, "stored": count})
-    except Exception as e:
-        _error(f"capture failed: {e}")
+# Map friendly type names to omega's native event_type values.
+# This ensures permanent TTL for types that should never expire.
+_TYPE_MAP = {
+    "lesson": "lesson_learned",
+    "preference": "user_preference",
+    "error": "error_pattern",
+    # These already match omega's native types:
+    # "decision", "constraint", "error_pattern", "lesson_learned", "user_preference"
+}
 
 
 def cmd_store():
@@ -147,7 +77,9 @@ def cmd_store():
 
     Reads JSON from stdin with fields:
         text: the memory content (required)
-        type: event_type for omega (default: "lesson")
+        type: event_type for omega (default: "lesson_learned")
+              Accepts friendly names: lesson, preference, error
+              which are mapped to omega native types.
         tags: list of tags (stored in metadata, optional)
         project: project name (default: basename of cwd)
     """
@@ -163,7 +95,8 @@ def cmd_store():
         return
 
     try:
-        event_type = data.get("type", "lesson")
+        raw_type = data.get("type", "lesson")
+        event_type = _TYPE_MAP.get(raw_type, raw_type)
         project = data.get("project", os.path.basename(os.getcwd()))
         metadata = {}
         if data.get("tags"):
@@ -335,23 +268,6 @@ def cmd_query():
         _error(f"query failed: {e}")
 
 
-def cmd_status():
-    """Check omega health status."""
-    omega = _import_omega()
-    if not omega:
-        _output({"ok": False, "status": "omega not available"})
-        return
-
-    try:
-        result = omega.status()
-        if isinstance(result, dict):
-            _output({"ok": True, **result})
-        else:
-            _output({"ok": True, "status": str(result)})
-    except Exception as e:
-        _error(f"status failed: {e}")
-
-
 def cmd_delete():
     """Delete a memory by its full node_id.
 
@@ -433,13 +349,10 @@ def cmd_list():
 
 
 COMMANDS = {
-    "welcome": cmd_welcome,
-    "capture": cmd_capture,
     "store": cmd_store,
     "query": cmd_query,
     "delete": cmd_delete,
     "list": cmd_list,
-    "status": cmd_status,
 }
 
 if __name__ == "__main__":