create-claude-cabinet 0.7.5 → 0.8.0

package/lib/cli.js

@@ -7,6 +7,7 @@ const { copyTemplates } = require('./copy');
 const { mergeSettings } = require('./settings-merge');
 const { create: createMetadata, read: readMetadata } = require('./metadata');
 const { setupDb } = require('./db-setup');
+const { setupOmega } = require('./omega-setup');
 const { reset } = require('./reset');
 
 const VERSION = require('../package.json').version;
@@ -95,6 +96,15 @@ const MODULES = {
     lean: false,
     templates: ['skills/validate'],
   },
+  'memory': {
+    name: 'Semantic Memory (omega)',
+    description: 'Rich session memory via omega-memory. Captures decisions, reasoning chains, and lessons between sessions. Requires Python 3.11+.',
+    mandatory: false,
+    default: true,
+    lean: false,
+    needsOmega: true,
+    templates: ['hooks/memory-session-start.sh', 'hooks/memory-post-compact.sh', 'scripts/cabinet-memory-adapter.py', 'rules/memory-capture.md'],
+  },
 };
 
 // Signals that a directory contains a real project (not just empty)
@@ -532,7 +542,8 @@ async function run() {
 
   // --- Merge hooks into settings.json ---
   if (selectedModules.includes('hooks') && !flags.dryRun) {
-    const settingsPath = mergeSettings(projectDir, { includeDb });
+    const includeMemory = selectedModules.includes('memory');
+    const settingsPath = mergeSettings(projectDir, { includeDb, includeMemory });
     console.log(`  ⚙️  Merged hooks into ${path.relative(projectDir, settingsPath)}`);
   }
 
@@ -547,6 +558,20 @@ async function run() {
     }
   }
 
+  // --- Set up omega memory ---
+  const needsOmega = selectedModules.some(m => MODULES[m].needsOmega);
+  if (needsOmega && !flags.dryRun) {
+    try {
+      console.log('');
+      const omegaResults = setupOmega();
+      for (const r of omegaResults) console.log(`  🧠 ${r}`);
+    } catch (err) {
+      console.log(`  ⚠ Omega memory setup skipped: ${err.message}`);
+      console.log('    Memory module will be inactive until Python 3.11+ is available.');
+      console.log('    Re-run the installer after installing Python to enable it.');
+    }
+  }
+
   // --- 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.

package/lib/omega-setup.js

@@ -0,0 +1,153 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+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.
+// 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',
+  '/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',
+  '/opt/homebrew/bin/python3',
+  '/usr/local/bin/python3',
+];
+
+/**
+ * Find a Python >= 3.11 on this system.
+ * Returns the absolute path or null if none found.
+ */
+function findPython() {
+  for (const candidate of PYTHON_CANDIDATES) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const version = execSync(`"${candidate}" --version 2>&1`, { encoding: 'utf8' }).trim();
+      const match = version.match(/Python (\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        if (major === 3 && minor >= 11) return candidate;
+      }
+    } catch { /* skip */ }
+  }
+
+  // Last resort: bare python3 on PATH
+  try {
+    const version = execSync('python3 --version 2>&1', { encoding: 'utf8' }).trim();
+    const match = version.match(/Python (\d+)\.(\d+)/);
+    if (match) {
+      const major = parseInt(match[1], 10);
+      const minor = parseInt(match[2], 10);
+      if (major === 3 && minor >= 11) {
+        const which = execSync('which python3', { encoding: 'utf8' }).trim();
+        return which;
+      }
+    }
+  } catch { /* skip */ }
+
+  return null;
+}
+
+/**
+ * Set up the omega-memory venv and download the embedding model.
+ *
+ * Steps:
+ * 1. Find Python 3.11+
+ * 2. Create venv at ~/.claude-cabinet/omega-venv/
+ * 3. pip install omega-memory
+ * 4. Run omega setup --download-model (downloads ONNX model at install time)
+ *
+ * Returns an array of status messages (like db-setup.js).
+ * Throws on failure.
+ */
+function setupOmega() {
+  const results = [];
+
+  // 1. Find Python
+  const pythonPath = findPython();
+  if (!pythonPath) {
+    throw new Error(
+      'Python 3.11+ not found. Install via Homebrew: brew install python@3.13\n' +
+      '    On Debian/Ubuntu: sudo apt install python3.13 python3.13-venv'
+    );
+  }
+  results.push(`Found Python: ${pythonPath}`);
+
+  // 2. Check ensurepip (Debian/Ubuntu strips it)
+  try {
+    execSync(`"${pythonPath}" -c "import ensurepip"`, { stdio: 'pipe' });
+  } catch {
+    const version = execSync(`"${pythonPath}" --version`, { encoding: 'utf8' }).trim();
+    const match = version.match(/Python (\d+)\.(\d+)/);
+    const pkg = match ? `python${match[1]}.${match[2]}-venv` : 'python3-venv';
+    throw new Error(
+      `Python venv module not found. On Debian/Ubuntu, install it:\n` +
+      `    sudo apt install ${pkg}`
+    );
+  }
+
+  // 3. Create or verify venv
+  if (!fs.existsSync(OMEGA_HOME)) {
+    fs.mkdirSync(OMEGA_HOME, { recursive: true });
+  }
+
+  if (fs.existsSync(VENV_PYTHON)) {
+    // Venv already exists — verify it works
+    try {
+      execSync(`"${VENV_PYTHON}" -c "import omega"`, { stdio: 'pipe' });
+      results.push('Existing omega venv is valid');
+      return results;
+    } catch {
+      // Venv is broken — nuke and rebuild (D5)
+      results.push('Existing venv broken, rebuilding...');
+      fs.rmSync(VENV_DIR, { recursive: true, force: true });
+    }
+  }
+
+  console.log('  Creating Python venv...');
+  execSync(`"${pythonPath}" -m venv "${VENV_DIR}"`, { stdio: 'pipe' });
+  results.push('Created venv at ~/.claude-cabinet/omega-venv/');
+
+  // 4. Install omega-memory
+  console.log('  Installing omega-memory...');
+  execSync(`"${VENV_PYTHON}" -m pip install --quiet omega-memory`, {
+    stdio: 'pipe',
+    timeout: 120000,
+  });
+  results.push('Installed omega-memory');
+
+  // 5. Download embedding model at install time (D4)
+  console.log('  Downloading embedding model...');
+  execSync(`"${VENV_PYTHON}" -m omega.cli setup --download-model`, {
+    stdio: 'pipe',
+    timeout: 120000,
+    env: { ...process.env, OMEGA_TELEMETRY: '0' },
+  });
+  results.push('Downloaded ONNX embedding model (bge-small-en-v1.5)');
+
+  return results;
+}
+
+/**
+ * Check if omega is already set up and functional.
+ */
+function isOmegaReady() {
+  if (!fs.existsSync(VENV_PYTHON)) return false;
+  try {
+    execSync(`"${VENV_PYTHON}" -c "import omega"`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { setupOmega, isOmegaReady, findPython, VENV_DIR, VENV_PYTHON };

package/lib/settings-merge.js

@@ -1,6 +1,31 @@
 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: [
     {
@@ -50,7 +75,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 } = {}) {
+function mergeSettings(projectDir, { includeDb = true, includeMemory = false } = {}) {
   const settingsDir = path.join(projectDir, '.claude');
   const settingsPath = path.join(settingsDir, 'settings.json');
 
@@ -65,8 +90,16 @@ function mergeSettings(projectDir, { includeDb = true } = {}) {
 
   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];
+    }
+  }
+
   // Merge each hook event type
-  for (const [event, newHooks] of Object.entries(DEFAULT_HOOKS)) {
+  for (const [event, newHooks] of Object.entries(allHooks)) {
     if (!settings.hooks[event]) {
       settings.hooks[event] = newHooks;
     } else {
@@ -90,4 +123,4 @@ function mergeSettings(projectDir, { includeDb = true } = {}) {
   return settingsPath;
 }
 
-module.exports = { mergeSettings, DEFAULT_HOOKS };
+module.exports = { mergeSettings, DEFAULT_HOOKS, MEMORY_HOOKS };

package/package.json

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

package/templates/hooks/memory-post-compact.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# PostCompact hook — capture session context before it's lost
+#
+# Fires on: manual (/compact) and auto (context limit) compaction
+# Output: read-only (observability only, 10K char cap)
+# Design: D1 (absolute venv path), D2 (never block), D3 (graceful degradation)
+
+VENV_PYTHON="$HOME/.claude-cabinet/omega-venv/bin/python3"
+ADAPTER="scripts/cabinet-memory-adapter.py"
+
+# D3: graceful degradation — if venv or adapter missing, exit silently
+if [ ! -x "$VENV_PYTHON" ] || [ ! -f "$ADAPTER" ]; then
+    exit 0
+fi
+
+# Read hook input from stdin (includes compact_summary)
+INPUT=$(cat)
+
+# Call adapter — pipe hook input as stdin for capture
+RESULT=$(echo "$INPUT" | "$VENV_PYTHON" "$ADAPTER" capture 2>/dev/null)
+
+# Log result for observability (PostCompact output is read-only)
+STORED=$(echo "$RESULT" | "$VENV_PYTHON" -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    if data.get('ok'):
+        count = data.get('stored', 0)
+        if count:
+            print(f'cabinet-memory: captured {count} memories from compaction')
+        else:
+            print('cabinet-memory: no memories captured (nothing noteworthy)')
+    else:
+        print(f'cabinet-memory: {data.get(\"error\", \"unknown error\")}')
+except:
+    pass
+" 2>/dev/null)
+
+if [ -n "$STORED" ]; then
+    echo "$STORED"
+fi
+
+exit 0

package/templates/hooks/memory-session-start.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# SessionStart hook — surface relevant memories via omega
+#
+# Fires on: startup, resume, compact (not clear — fresh context)
+# Output: relevant memories injected into session context
+# Design: D1 (absolute venv path), D2 (never block), D3 (graceful degradation)
+
+VENV_PYTHON="$HOME/.claude-cabinet/omega-venv/bin/python3"
+ADAPTER="scripts/cabinet-memory-adapter.py"
+
+# D3: graceful degradation — if venv or adapter missing, warn but don't block
+if [ ! -x "$VENV_PYTHON" ] || [ ! -f "$ADAPTER" ]; then
+    echo ""
+    echo "**Note:** Memory module is installed but omega is not available."
+    echo "Semantic memory (decisions, lessons, preferences) is not being captured or recalled."
+    echo "Run \`npx create-claude-cabinet\` to set up the omega venv."
+    exit 0
+fi
+
+# Read hook input from stdin
+INPUT=$(cat)
+
+# Extract source field to skip /clear (fresh context, no memories needed)
+SOURCE=$(echo "$INPUT" | "$VENV_PYTHON" -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('source', 'startup'))
+except:
+    print('startup')
+" 2>/dev/null)
+
+if [ "$SOURCE" = "clear" ]; then
+    exit 0
+fi
+
+# Call adapter — pipe hook input as stdin
+RESULT=$(echo "$INPUT" | "$VENV_PYTHON" "$ADAPTER" welcome 2>/dev/null)
+
+# Extract context from result
+CONTEXT=$(echo "$RESULT" | "$VENV_PYTHON" -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    if data.get('ok') and data.get('context'):
+        print(data['context'])
+except:
+    pass
+" 2>/dev/null)
+
+# Output context to stdout — SessionStart hook stdout becomes session context
+if [ -n "$CONTEXT" ]; then
+    echo ""
+    echo "## Recalled Memories (omega)"
+    echo ""
+    echo "$CONTEXT"
+fi
+
+exit 0

package/templates/rules/memory-capture.md

@@ -0,0 +1,57 @@
+# 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.
+
+## During Sessions — What to Capture
+
+Capture to omega when you observe any of these during a session:
+
+**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."
+
+**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.
+
+**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."
+
+**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.
+
+## How to Capture
+
+Use the adapter — never call omega directly from shell:
+
+```bash
+echo '{"text": "the memory", "type": "decision"}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
+```
+
+Memory types: `decision`, `lesson`, `preference`, `constraint`, `pattern`
+
+## What NOT to Capture
+
+- Code patterns visible by reading current files
+- Git history (use `git log`)
+- Anything already in CLAUDE.md or briefing files
+- Ephemeral debugging details
+- Information that changes frequently (use state files instead)
+
+## Capture Cadence
+
+Do NOT capture after every interaction. Capture when something worth
+remembering actually happens. Most messages in a session produce nothing
+worth storing. A typical session might generate 0-3 memories.
+
+Over-capturing degrades retrieval quality. When in doubt, don't capture.
+The debrief sweep catches anything important that was missed.

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

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""
+Cabinet Memory Adapter — single Python file wrapping all omega interaction.
+
+Called by hook scripts via the venv Python. All omega calls go through here.
+Designed for D2 (never block Claude Code) and D3 (graceful degradation).
+
+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
+    status          Check omega health
+
+All commands read JSON from stdin when applicable.
+All commands output JSON to stdout.
+All commands exit 0 even on failure (D2: never block).
+"""
+
+import json
+import os
+import sys
+
+# Disable omega telemetry (PB2: opt-in only, we opt out)
+os.environ["OMEGA_TELEMETRY"] = "0"
+
+
+def _output(data):
+    """Write JSON to stdout and exit cleanly."""
+    print(json.dumps(data))
+    sys.exit(0)
+
+
+def _error(msg):
+    """Log error to stderr, output empty result, exit 0 (D2: never block)."""
+    print(f"cabinet-memory: {msg}", file=sys.stderr)
+    _output({"ok": False, "error": msg})
+
+
+def _read_stdin():
+    """Read JSON from stdin, return dict or empty dict on failure."""
+    try:
+        return json.load(sys.stdin)
+    except Exception:
+        return {}
+
+
+def _import_omega():
+    """Import omega, returning the module or None on failure."""
+    try:
+        import omega
+        return omega
+    except ImportError:
+        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}")
+
+
+def cmd_store():
+    """Store a memory directly.
+
+    Reads JSON from stdin with fields:
+        text: the memory content (required)
+        type: event_type for omega (default: "lesson")
+        tags: list of tags (stored in metadata, optional)
+    """
+    data = _read_stdin()
+    omega = _import_omega()
+    if not omega:
+        _error("omega not available")
+        return
+
+    text = data.get("text", "")
+    if not text:
+        _error("no text provided")
+        return
+
+    try:
+        event_type = data.get("type", "lesson")
+        metadata = {}
+        if data.get("tags"):
+            metadata["tags"] = data["tags"]
+        result = omega.store(
+            text,
+            event_type=event_type,
+            metadata=metadata if metadata else None,
+        )
+        _output({"ok": True, "id": result if isinstance(result, str) else None})
+    except Exception as e:
+        _error(f"store failed: {e}")
+
+
+def cmd_query():
+    """Query memories by text.
+
+    Reads JSON from stdin with fields:
+        text: the query text (required)
+        limit: max results (default: 5)
+    """
+    data = _read_stdin()
+    omega = _import_omega()
+    if not omega:
+        _error("omega not available")
+        return
+
+    text = data.get("text", "")
+    if not text:
+        _error("no query text provided")
+        return
+
+    try:
+        limit = data.get("limit", 5)
+        event_type = data.get("type")
+        results = omega.query(
+            text,
+            limit=limit,
+            event_type=event_type,
+        )
+
+        # query() returns a formatted string of results
+        if isinstance(results, str):
+            _output({"ok": True, "results": results})
+        elif isinstance(results, (list, tuple)):
+            memories = []
+            for r in results:
+                if isinstance(r, dict):
+                    memories.append({
+                        "text": r.get("content", r.get("text", str(r))),
+                        "type": r.get("event_type", "unknown"),
+                        "score": r.get("score", 0),
+                    })
+                else:
+                    memories.append({"text": str(r)})
+            _output({"ok": True, "memories": memories})
+        else:
+            _output({"ok": True, "results": str(results)})
+    except Exception as e:
+        _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}")
+
+
+COMMANDS = {
+    "welcome": cmd_welcome,
+    "capture": cmd_capture,
+    "store": cmd_store,
+    "query": cmd_query,
+    "status": cmd_status,
+}
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:
+        cmds = ", ".join(COMMANDS.keys())
+        _error(f"usage: cabinet-memory-adapter.py <{cmds}>")
+    else:
+        try:
+            COMMANDS[sys.argv[1]]()
+        except Exception as e:
+            # Outermost catch — D2: never block, never crash
+            _error(f"unexpected error: {e}")

package/templates/skills/cabinet-cc-health/SKILL.md

@@ -384,7 +384,52 @@ directory structure:
 and the expected state. These are typically easy fixes but indicate an
 incomplete migration.
 
-### 8. Anti-Bloat
+### 8. Memory System Health
+
+If the memory module is installed (check `.ccrc.json` modules list for
+`"memory"`), verify the omega memory infrastructure:
+
+- **Venv integrity.** Does `~/.claude-cabinet/omega-venv/bin/python3`
+  exist? Can it import omega? Run:
+  ```bash
+  ~/.claude-cabinet/omega-venv/bin/python3 -c "import omega; print('ok')"
+  ```
+  A broken venv means all memory hooks silently degrade.
+
+- **Adapter availability.** Does `scripts/cabinet-memory-adapter.py`
+  exist in the project? Without it, hooks have nothing to call.
+
+- **Hook registration.** Check `.claude/settings.json` for:
+  - `memory-session-start.sh` in `SessionStart` hooks
+  - `memory-post-compact.sh` in `PostCompact` hooks
+  Missing hooks mean omega was installed but never wired in.
+
+- **Omega database.** Run the adapter's `status` command:
+  ```bash
+  echo '{}' | ~/.claude-cabinet/omega-venv/bin/python3 \
+    scripts/cabinet-memory-adapter.py status
+  ```
+  Check: is the database growing? Zero memories after multiple sessions
+  suggests capture isn't working.
+
+- **ONNX model presence.** Check `~/.cache/omega/models/` for the
+  embedding model directory. Missing model means semantic search falls
+  back to hash-based pseudo-embeddings (much lower quality).
+
+- **Rules file.** Does `.claude/rules/memory-capture.md` exist? Without
+  it, in-session capture guidance is missing.
+
+**What to report:** Infrastructure gaps (broken venv, missing hooks,
+missing model), capture failures (zero memories after active sessions),
+configuration mismatches (module installed but hooks not registered).
+
+**Severity guidance:**
+- Broken venv or missing adapter → **warn** (all memory silently disabled)
+- Missing hooks → **warn** (capture not happening)
+- Missing ONNX model → **info** (degraded but functional)
+- Zero memories after 3+ sessions → **warn** (capture failing silently)
+
+### 9. Anti-Bloat
 
 Apply `_lifecycle.md` retirement criteria proactively. A lean cabinet is
 better than a comprehensive one with dead weight:

package/templates/skills/cabinet-historian/SKILL.md

@@ -61,6 +61,20 @@ to help you do your job.
 
 ### Sources of Institutional Memory (check in this order)
 
+0. **Omega semantic memory** — if `~/.claude-cabinet/omega-venv/bin/python3`
+   and `scripts/cabinet-memory-adapter.py` both exist, query omega FIRST.
+   It stores decisions, lessons, preferences, and constraints with semantic
+   retrieval — meaning you can search by concept, not just keyword.
+
+   ```bash
+   echo '{"text": "your query here", "limit": 10}' | \
+     ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
+   ```
+
+   Omega returns memories ranked by relevance. This is the richest source
+   of institutional memory when available. If omega is not available, skip
+   to source 1.
+
 1. **Memory files** — `.claude/memory/*.md` and any project-level memory
    index (e.g., `MEMORY.md`). These are the distilled, catalogued lessons.
    Check here first. Read the index for orientation, then read relevant
@@ -142,6 +156,18 @@ what was about to happen next. This is the historian's moment.
    in a session should survive compaction because it's been written
    down *during* the session, not just summarized after truncation.
 
+**Omega and compaction:** If omega memory is active, the PostCompact
+hook (`memory-post-compact.sh`) automatically captures key context from
+the compaction summary. After compaction, query omega to see what was
+preserved:
+
+```bash
+echo '{"text": "session context before compaction", "limit": 5}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
+```
+
+This supplements (not replaces) the manual recovery protocol above.
+
 **The meta-lesson:** Compaction is an entropy event. The historian's
 job is to ensure the memory system is robust enough that compaction
 merely loses conversational tone, not institutional knowledge. If

package/templates/skills/debrief/SKILL.md

@@ -205,6 +205,26 @@ anything that future sessions need to know? A new pattern, a gotcha,
 a process gap, a user preference? Lessons are perishable — capture
 them now while context is fresh.
 
+**Omega-primary:** If `~/.claude-cabinet/omega-venv/bin/python3` and
+`scripts/cabinet-memory-adapter.py` both exist, write lessons to omega
+as the primary destination — not flat markdown. Use the adapter:
+
+```bash
+echo '{"text": "the lesson", "type": "lesson"}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
+```
+
+Types: `decision`, `lesson`, `preference`, `constraint`, `pattern`.
+Fall back to flat markdown memory only if omega is unavailable.
+
+**Omega broken:** If the memory module is installed (check `.ccrc.json`
+for `"memory": true`) but the venv or adapter is missing, surface this
+in the debrief report:
+
+> **⚠ Memory module is installed but omega is not working.**
+> Lessons from this session were saved to flat markdown instead of omega.
+> Run `npx create-claude-cabinet` to rebuild the omega venv.
+
 > **Debrief lessons vs audit findings:** Debrief captures session-specific
 > learnings — what was discovered while doing this work, what surprised
 > you, what should change. Audit captures systematic observations from

package/templates/skills/debrief/phases/record-lessons.md

@@ -12,19 +12,34 @@ Lessons are perishable. A lesson captured while context is fresh is worth
 ten captured from memory next week. This is why recording happens during
 debrief, not "sometime later."
 
-## What to Include
+## Where to Record — Omega Primary
 
-- **What to look for** — types of lessons worth capturing
-- **Where to record them** — memory files, logs, documentation
-- **How to organize** — categories, patterns, cross-references
-- **What NOT to record** — ephemeral details, things derivable from code
+Check whether omega memory is available:
+- `~/.claude-cabinet/omega-venv/bin/python3` exists AND
+- `scripts/cabinet-memory-adapter.py` exists
 
-## Example Lesson Recording
+**When omega is available (primary path):** Write lessons to omega via
+the adapter. This is the durable, semantic memory store that persists
+across sessions and supports retrieval by meaning, not just keyword.
 
-Uncomment and adapt these for your project:
+```bash
+echo '{"text": "the lesson", "type": "lesson", "tags": ["tag1"]}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
+```
 
-<!--
-### What to Look For
+Memory types to use:
+- `decision` — architectural choices, tradeoff resolutions
+- `lesson` — gotchas, discoveries, things that surprised
+- `preference` — user corrections, style choices, workflow preferences
+- `constraint` — limitations discovered, prerequisites found
+- `pattern` — conventions established, recurring solutions
+
+**When omega is NOT available (fallback):** Use the flat markdown memory
+system (auto-memory in `~/.claude/projects/` memory directory). This is
+the same system Claude Code uses natively. It works, but lacks semantic
+retrieval.
+
+## What to Look For
 
 Review the session and ask:
 - Did we learn something future sessions need to know?
@@ -36,32 +51,16 @@ Review the session and ask:
   of problem keeps recurring, the lesson is "create a prevention mechanism"
   not just "remember this."
 - Did the session's work contradict any existing recorded knowledge?
-  If so, update or remove the stale record.
-
-### Where to Record
-
-**Feedback patterns** (corrections, confirmations):
-Write to memory/patterns/ if it matches an existing pattern; write to
-memory/archive/ as a raw observation if it's new. If 3+ raw observations
-accumulate around a theme, consolidate into a pattern.
-
-**Project state** (decisions, milestones, architecture changes):
-Update the relevant project memory file or create one.
-
-**User context** (preferences, role changes, domain knowledge):
-Update the user context memory file.
-
-**References** (external resources, tool URLs, account details):
-Create or update a reference memory file.
+  If so, update or remove the stale record (in omega: use `query` to
+  find it, then note the contradiction in the new memory).
 
-### What NOT to Record
+## What NOT to Record
 - Code patterns derivable by reading current files
 - Git history (use git log)
 - Debugging solutions (the fix is in the code)
 - Anything already in CLAUDE.md files
 - Ephemeral task details only relevant to this session
 
-### Report What Was Recorded
+## Report What Was Recorded
 Tell the user what memories were created or updated so they know what
-the system will remember next time.
--->
+the system will remember next time. Include the count and types.

package/templates/skills/orient/phases/context.md

@@ -39,6 +39,38 @@ but know they exist — if work in this session touches something that
 relates to another project, mention it. "This API change might affect
 your investor-reports project too."
 
+### Omega Semantic Memory
+
+If `~/.claude-cabinet/omega-venv/bin/python3` and
+`scripts/cabinet-memory-adapter.py` both exist, surface relevant
+memories from omega at session start:
+
+```bash
+echo '{}' | ~/.claude-cabinet/omega-venv/bin/python3 \
+  scripts/cabinet-memory-adapter.py welcome
+```
+
+The `welcome` command returns memories relevant to the current project.
+The SessionStart hook (`memory-session-start.sh`) also does this
+automatically, but during orient you can query for specific context:
+
+```bash
+echo '{"text": "recent decisions and lessons", "limit": 5}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 \
+  scripts/cabinet-memory-adapter.py query
+```
+
+If omega is not available, check whether the memory module is installed
+(look for `"memory": true` in `.ccrc.json`). If it IS installed but the
+venv or adapter is missing, surface a warning:
+
+> **⚠ Memory module is installed but omega is not available.**
+> The venv at `~/.claude-cabinet/omega-venv/` may be missing or broken.
+> Re-run `npx create-claude-cabinet` to rebuild it.
+
+If the memory module is NOT installed, skip silently — the user opted
+out. Fall back to flat markdown memory (MEMORY.md) either way.
+
 ## Additional Context Sources
 
 Uncomment and adapt these for your project: