create-claude-cabinet 0.9.0 → 0.10.0

package/lib/cli.js

@@ -103,7 +103,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 +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)}`);
   }
 

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.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.

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__":

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

@@ -397,17 +397,16 @@ If the memory module is installed (check `.ccrc.json` modules list for
   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.
+  exist in the project? Skills use it for project-scoped queries.
 
-- **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.
+- **Hook registration.** Check `~/.claude/settings.json` (global) for
+  omega native hooks (`fast_hook.py session_start`, etc.). Run
+  `omega hooks doctor` to verify. Missing hooks mean omega was installed
+  but `omega hooks setup` was never run.
 
-- **Omega database.** Run the adapter's `status` command:
+- **Omega database.** Run `omega status` to check health:
   ```bash
-  echo '{}' | ~/.claude-cabinet/omega-venv/bin/python3 \
-    scripts/cabinet-memory-adapter.py status
+  ~/.claude-cabinet/omega-venv/bin/omega status
   ```
   Check: is the database growing? Zero memories after multiple sessions
   suggests capture isn't working.

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

@@ -105,6 +105,28 @@ to help you do your job.
    Omega data lives at `~/.omega/omega.db` (SQLite). The `/memory` skill
    gives users self-serve access to browse, search, and manage memories.
 
+   **Graph traversal** (follow connections from a memory):
+   ```bash
+   ~/.claude-cabinet/omega-venv/bin/python3 -c "
+   from omega import traverse
+   result = traverse('MEM_ID', max_hops=2)
+   print(result)
+   "
+   ```
+   After finding a relevant memory, traverse its graph connections to
+   discover related decisions, contradictions, or how understanding evolved.
+   Edge types: `related`, `evolution`, `contradicts`, `temporal_cluster`.
+
+   **Contradiction detection** (find conflicting memories):
+   ```bash
+   ~/.claude-cabinet/omega-venv/bin/python3 -c "
+   from omega import SQLiteStore
+   s = SQLiteStore()
+   edges = s.get_edges_by_type('contradicts')
+   for e in edges: print(f\"{e['source_id']} <-> {e['target_id']} ({e['weight']:.2f})\")
+   "
+   ```
+
    Omega returns memories ranked by relevance. This is the richest source
    of institutional memory when available. If omega queries return nothing
    or fail, fall through to source 1 (flat memory files).
@@ -190,10 +212,10 @@ 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:
+**Omega and compaction:** If omega memory is active, omega's native hooks
+automatically capture key context at session boundaries (session_stop,
+auto_capture, assistant_capture). After compaction, query omega to see
+what was preserved:
 
 ```bash
 echo '{"text": "session context before compaction", "limit": 5}' | \
@@ -229,11 +251,64 @@ You are responsible for the health of the memory system:
    they can be catalogued — if the team keeps re-deriving solutions, if
    memory files are growing too large to scan, if conversation history
    search isn't surfacing what it should — advocate for better tooling.
-   This might mean:
-   - A new skill for structured lesson capture
-   - Better memory file organization (by domain, by date, by type)
-   - Improving search strategies or adding new query patterns
-   - A periodic "memory review" to prune, consolidate, and re-index
+
+### Memory Health Measurement
+
+When activated during audit or review, evaluate omega memory health:
+
+**Growth & Coverage:**
+```bash
+~/.claude-cabinet/omega-venv/bin/omega stats --json 2>&1
+```
+Check: Is the memory count growing session over session? Are all
+permanent types represented (decision, lesson_learned, user_preference,
+constraint, error_pattern)? Gaps suggest capture isn't working for
+certain categories.
+
+**Graph Connectivity:**
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import SQLiteStore
+s = SQLiteStore()
+import sqlite3
+conn = sqlite3.connect(s.db_path)
+total = conn.execute('SELECT COUNT(*) FROM memories').fetchone()[0]
+edges = s.edge_count()
+connected = conn.execute('SELECT COUNT(DISTINCT source_id) + COUNT(DISTINCT target_id) FROM memory_relationships').fetchone()[0]
+print(f'Memories: {total}, Edges: {edges}, Connected: {connected}/{total} ({100*connected//max(total,1)}%)')
+"
+```
+Target: >50% of memories should participate in at least one edge.
+Below 30% means discover_connections isn't running or memories are
+too diverse to auto-relate.
+
+**Contradiction Health:**
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import SQLiteStore
+s = SQLiteStore()
+contradictions = s.get_edges_by_type('contradicts')
+print(f'{len(contradictions)} contradiction(s) detected')
+for c in contradictions:
+    print(f'  {c[\"source_id\"]} <-> {c[\"target_id\"]} (confidence: {c[\"weight\"]:.2f})')
+"
+```
+Unresolved contradictions are technical debt in the knowledge graph.
+Surface them and recommend resolution.
+
+**Consolidation Effectiveness:**
+```bash
+~/.claude-cabinet/omega-venv/bin/omega consolidate --prune-days 30 2>&1
+```
+Check: Are duplicates accumulating? Are zero-access memories growing?
+If consolidation consistently prunes many entries, capture quality
+may need improvement (storing noise instead of signal).
+
+**Retrieval Quality (spot check):**
+Pick 2-3 recent decisions or lessons from the session. Query omega
+for each one. Does the query return the correct memory in the top 3
+results? If not, embeddings may be degraded or the memory text may
+be too generic to differentiate.
 
 ## Output Format
 

package/templates/skills/cc-upgrade/SKILL.md

@@ -129,6 +129,35 @@ the upstream guard hook because it runs as a separate process using
 the filesystem directly. This is by design — the installer is the
 authorized update path for manifest-tracked files.
 
+### 2.4. Memory Hook Migration (v0.9.x → v0.10+)
+
+**This step runs when upgrading from v0.9.x or earlier** (detected by
+the presence of `memory-session-start.sh` or `memory-post-compact.sh`
+in `.claude/settings.json`).
+
+Starting in v0.10, omega's native hooks handle memory capture/recall
+directly (configured in global `~/.claude/settings.json`). The old
+project-level CC memory hooks are now redundant and cause double
+context injection if left in place.
+
+**Check and clean:**
+1. Read `.claude/settings.json` — look for `memory-session-start.sh`
+   in `SessionStart` hooks and `memory-post-compact.sh` in `PostCompact`
+2. If found, remove those entries. Keep other hooks (git-guardrails,
+   cc-upstream-guard, telemetry) untouched.
+3. Verify omega native hooks are configured: run `omega hooks doctor`.
+   If not configured, the installer's omega-setup already ran
+   `omega hooks setup` — verify by checking `~/.claude/settings.json`
+   for `fast_hook.py` entries.
+4. The old shell scripts (`hooks/memory-session-start.sh`,
+   `hooks/memory-post-compact.sh`) can be deleted from the project's
+   `.claude/hooks/` directory — they're no longer called.
+
+**Tell the user:** "Memory hooks have been upgraded to omega native.
+You now get 3 additional capabilities: real-time decision capture,
+assistant insight extraction, and relevant memory surfacing before
+file edits."
+
 ### 2.5. Legacy Detection and Migration
 
 **This step runs ONLY when upgrading from v0.5.x or earlier** (detected

package/templates/skills/debrief/SKILL.md

@@ -116,9 +116,44 @@ Read `phases/close-work.md` for how to match session work against open
 items and close them. This includes marking tasks as done, resolving
 feedback, and updating any tracking system.
 
-**Skip (absent/empty).** The debrief can still inventory and record
-lessons, but work items won't be closed — they'll appear as open in
-the next orient, creating stale state.
+**Default (absent/empty):** Match the session's work against open items
+in pib-db and propose closing what was completed. If pib-db is not
+initialized, skip gracefully.
+
+1. **Get session work:** `git log --oneline` for this session's commits
+   (since session start or last 2 hours)
+2. **Get open actions:**
+   ```bash
+   sqlite3 pib.db "SELECT fid, text, project_fid FROM actions WHERE completed = 0 AND deleted_at IS NULL ORDER BY flagged DESC, sort_order ASC"
+   ```
+3. **Match:** For each open action, check if the session's commits
+   address it (compare action text/notes against commit messages and
+   changed files)
+4. **Propose:** Present matched actions and ask the user to confirm
+   which to close
+5. **Close confirmed:**
+   ```bash
+   sqlite3 pib.db "UPDATE actions SET completed = 1, completed_at = date('now') WHERE fid = '<fid>'"
+   ```
+
+**Project completion scan:** After closing actions, check for projects
+where all actions are now done:
+
+```bash
+sqlite3 pib.db "
+  SELECT p.fid, p.name,
+    (SELECT COUNT(*) FROM actions a WHERE a.project_fid = p.fid) as total,
+    (SELECT COUNT(*) FROM actions a WHERE a.project_fid = p.fid AND a.completed = 1) as done
+  FROM projects p
+  WHERE p.status = 'active'
+    AND p.deleted_at IS NULL
+    AND (SELECT COUNT(*) FROM actions a WHERE a.project_fid = p.fid) > 0
+    AND (SELECT COUNT(*) FROM actions a WHERE a.project_fid = p.fid AND a.completed = 0 AND a.deleted_at IS NULL) = 0
+"
+```
+
+For each result, propose completing the project (show name + action
+count, confirm before closing).
 
 For each open item, determine:
 - **Clearly complete** — mark it done with a reference to what was built
@@ -377,7 +412,7 @@ Read `phases/report.md` for how to present the debrief summary.
 | Phase | Absent = | What it customizes |
 |-------|----------|-------------------|
 | `inventory.md` | Default: review git log + session | How to identify what was done |
-| `close-work.md` | Skip | How to close work items |
+| `close-work.md` | Default: match pib-db actions against git log | How to close work items |
 | `auto-maintenance.md` | Skip | Recurring session-end tasks |
 | `update-state.md` | Default: check system-status.md | What state files to update |
 | `health-checks.md` | Skip | Session-end health checks |

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

@@ -61,6 +61,35 @@ Review the session and ask:
 - Anything already in CLAUDE.md files
 - Ephemeral task details only relevant to this session
 
+## After Storing — Link and Check
+
+After storing each memory, omega auto-relates it to similar existing
+memories. Surface this to the user:
+
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import find_similar_memories
+result = find_similar_memories('THE_NEW_MEMORY_ID')
+print(result)
+"
+```
+
+If the new memory is similar to existing ones, mention it:
+"This connects to your earlier memory about [topic]."
+
+Also check for contradictions — if the new memory conflicts with an
+existing one, ask the user which is correct:
+
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import SQLiteStore
+s = SQLiteStore()
+edges = s.get_edges_by_type('contradicts')
+for e in edges: print(f\"{e['source_id']} <-> {e['target_id']} ({e['weight']:.2f})\")
+"
+```
+
 ## Report What Was Recorded
 Tell the user what memories were created or updated so they know what
-the system will remember next time. Include the count and types.
+the system will remember next time. Include the count, types, and any
+new connections discovered in the knowledge graph.

package/templates/skills/memory/SKILL.md

@@ -27,9 +27,11 @@ If not available, tell the user:
 
 ## Adapter Reference
 
-The adapter (`scripts/cabinet-memory-adapter.py`) is the single interface
-to omega. All commands read JSON from stdin, output JSON to stdout, and
-exit 0 even on failure. Always call it via the venv Python:
+The adapter (`scripts/cabinet-memory-adapter.py`) provides project-scoped
+queries and a stable JSON interface. Session-level capture and recall are
+handled by omega's native hooks (configured globally). The adapter handles
+skill-invoked operations. All commands read JSON from stdin, output JSON
+to stdout, and exit 0 even on failure.
 
 ```bash
 echo '<json>' | ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py <command>
@@ -37,16 +39,13 @@ echo '<json>' | ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-
 
 | Command | Input | Output |
 |---------|-------|--------|
-| `welcome` | `{}` or hook JSON | `{ok, context}` — relevant memories |
 | `store` | `{text, type, tags?, project?}` | `{ok, id}` — stored memory ID |
-| `query` | `{text, limit?, type?, project?, scope?}` | `{ok, results}` — semantic search |
+| `query` | `{text, limit?, type?, project?, scope?}` | `{ok, results}` — semantic search with project scoping |
 | `delete` | `{id}` | `{ok, deleted}` — requires full node_id |
 | `list` | `{type?, project?, limit?}` | `{ok, memories, count}` — all memories with full IDs |
-| `capture` | hook JSON with `compact_summary` | `{ok, stored}` — auto-capture count |
-| `status` | `{}` | `{ok, ...health info}` |
 
-Memory types: `decision`, `lesson`, `preference`, `constraint`, `pattern`,
-`compaction`.
+Memory types: `decision`, `lesson_learned`, `user_preference`, `constraint`,
+`error_pattern`.
 
 ## Commands
 
@@ -83,6 +82,25 @@ Present results conversationally — highlight the most relevant matches,
 their types, and which project they came from when cross-project results
 appear.
 
+**Graph enrichment:** For the top 1-2 results, check for related memories
+via omega's graph traversal. This surfaces the knowledge network — not
+just what matched, but what's connected to what matched:
+
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import traverse
+result = traverse('THE_MEMORY_ID', max_hops=2)
+print(result)
+"
+```
+
+If traversal returns connected memories, present them as "Related:"
+under the main result. Edge types tell the story:
+- `related` — semantically similar
+- `evolution` — this understanding has developed over time
+- `contradicts` — conflicts with another memory (surface both sides)
+- `temporal_cluster` — captured in the same session
+
 ### Remember — user wants to store something
 
 ```bash
@@ -91,13 +109,59 @@ echo '{"text": "what to remember", "type": "preference"}' | \
 ```
 
 Pick the type based on what the user said:
-- `decision` — they made a choice and want it recorded
-- `lesson` — they learned something
-- `preference` — they want something done a certain way
-- `constraint` — a limitation or prerequisite
-- `pattern` — a convention or recurring approach
+- `decision` — they made a choice and want it recorded (permanent)
+- `lesson` — they learned something (maps to `lesson_learned`, permanent)
+- `preference` — they want something done a certain way (maps to `user_preference`, permanent)
+- `constraint` — a limitation or prerequisite (permanent)
+- `error` — a failure pattern to avoid (maps to `error_pattern`, permanent)
+
+The adapter maps friendly names to omega's native types for correct TTL.
+
+Confirm what was stored. After storing, check for similar existing memories
+and link them if relevant:
+
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import find_similar_memories
+result = find_similar_memories('THE_NEW_MEMORY_ID')
+print(result)
+"
+```
+
+If similar memories exist, tell the user: "This connects to N existing
+memories about [topic]." Omega auto-relates on store, but surfacing it
+builds user confidence that the knowledge graph is working.
+
+### Link — user wants to connect memories
+
+If the user says "link these" or "these are related":
+
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import SQLiteStore
+s = SQLiteStore()
+s.add_edge('MEM_ID_1', 'MEM_ID_2', edge_type='related', weight=1.0)
+print('Linked')
+"
+```
+
+Edge types: `related`, `contradicts`, `supersedes`, `evolves`.
+
+### Contradictions — user asks what conflicts
+
+```bash
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega import SQLiteStore
+s = SQLiteStore()
+edges = s.get_edges_by_type('contradicts')
+for e in edges:
+    print(f\"{e['source_id']} <-> {e['target_id']} (confidence: {e['weight']:.2f})\")
+if not edges: print('No contradictions found')
+"
+```
 
-Confirm what was stored.
+For each contradiction pair, query both memories to show the user what
+conflicts. Ask which one is correct, then supersede the wrong one.
 
 ### Forget — user wants to remove something
 

package/templates/skills/onboard/SKILL.md

@@ -171,7 +171,7 @@ Read `phases/work-tracking.md` for how to present work tracking options.
 tasks.md, GitHub Issues, custom phase files). Present two built-in
 options — SQLite database (pib-db) or markdown file (tasks.md) — plus
 bring-your-own for external systems. User picks one, the other, or
-neither. The choice is recorded in `.corrc.json` under `workTracking`
+neither. The choice is recorded in `.ccrc.json` under `workTracking`
 and feeds into generate-briefing and generate-session-loop.
 
 ### 4. Options

package/templates/skills/onboard/phases/detect-state.md

@@ -49,7 +49,7 @@ early vs mature re-run:
 | CLAUDE.md | Root `CLAUDE.md` | Project instructions exist |
 | Rules files | `.claude/rules/*.md` | Scoped instructions exist |
 | Hook config | `.claude/settings.json` or `.claude/settings.local.json` | Enforcement hooks exist |
-| Omega memory | `~/.claude-cabinet/omega-venv/` and `scripts/cabinet-memory-adapter.py` | Semantic memory is active |
+| Omega memory | `~/.claude-cabinet/omega-venv/` and `omega hooks doctor` OK | Semantic memory is active |
 
 **Early re-run:** Fewer than 5 of the above are populated.
 **Mature re-run:** 5 or more are populated.

package/templates/skills/orient/SKILL.md

@@ -89,16 +89,17 @@ sessions, and project-specific context.
 - `.claude/memory/patterns/` — enforcement patterns from prior sessions.
   Scan the directory, read each pattern file. These are project-level
   feedback that guides behavior (what to avoid, what to keep doing).
-- **Omega semantic memory** — if `~/.claude-cabinet/omega-venv/bin/python3`
-  and `scripts/cabinet-memory-adapter.py` both exist, query omega for
-  relevant context:
+- **Omega semantic memory** — omega's native SessionStart hook
+  automatically surfaces recalled memories. During orient, query for
+  additional project-scoped context via the adapter:
   ```bash
   echo '{"text": "session context project status recent decisions", "limit": 10}' | \
     ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
   ```
   Surface any relevant memories (decisions, lessons, constraints) that
-  inform the current session. If the venv is missing but `.ccrc.json`
-  lists the memory module as installed, warn the user:
+  inform the current session. If omega is unavailable, run `omega hooks
+  doctor` to diagnose. If the venv is missing but `.ccrc.json` lists
+  the memory module as installed, warn the user:
   > ⚠ Memory module is installed but omega venv is missing.
   > Run `npx create-claude-cabinet` to restore it.
 
@@ -211,9 +212,11 @@ Read `phases/auto-maintenance.md` for recurring automated tasks that
 should run every session. These are operations that would decay if left
 to human memory — the anti-entropy principle in action.
 
-**Skip (absent/empty).** Projects add maintenance tasks as they discover
-operations that need regular execution but aren't worth remembering to
-invoke manually.
+**Default (absent/empty):** If omega is active (`~/.claude-cabinet/omega-venv/bin/omega`
+exists), run memory hygiene: `omega consolidate` every session (prune stale,
+dedup), `omega compact` weekly (cluster similar memories), `omega backup`
+weekly. Projects add additional maintenance tasks as they discover operations
+that need regular execution.
 
 ### 6. Activate Cabinet Members (core)
 
@@ -259,7 +262,7 @@ stated a focus, ask.
 | `data-sync.md` | Skip | How to sync remote data |
 | `work-scan.md` | Default: pib-db scan + staleness detection | What work items to check |
 | `health-checks.md` | Skip | System health checks |
-| `auto-maintenance.md` | Skip | Recurring session-start tasks |
+| `auto-maintenance.md` | Default: omega memory hygiene | Recurring session-start tasks |
 | `cabinet.md` | Skip | Which cabinet members to activate |
 | `briefing.md` | Default: simple summary | How to present orientation |
 

package/templates/skills/orient/phases/auto-maintenance.md

@@ -6,43 +6,87 @@ applied to session management.
 
 The distinction from health checks: health checks DETECT problems;
 auto-maintenance DOES work. A health check reports "data is stale."
+An auto-maintenance task runs the sync to fix it.
 
 When this file is absent or empty, this step is skipped. (`skip: true`
 is equivalent to absent here.)
-An auto-maintenance task runs the sync to fix it.
 
-## What to Include
+## Omega Memory Hygiene
 
-For each task, provide:
-- **What** — the operation to perform
-- **Why every session** — what decays if this is skipped
-- **Command** — how to run it
-- **Auto-execute?** — yes (run silently) or surface (ask user first)
+If omega is active (`~/.claude-cabinet/omega-venv/bin/omega` exists),
+run these maintenance tasks every session:
 
-## Example Maintenance Tasks
+### Consolidate (every session)
 
-Uncomment and adapt these for your project:
+Prune zero-access memories older than 30 days and deduplicate. Silent,
+non-destructive — only removes never-accessed entries and exact duplicates.
 
-<!--
-### Process Pending Queue Items
 ```bash
-# Check for items queued by external systems
-curl -s https://your-api.example.com/api/queue/pending
+~/.claude-cabinet/omega-venv/bin/omega consolidate --prune-days 30 2>&1
 ```
-Items queued from a UI or external integration since last session.
-Auto-execute routine items; surface unusual ones for confirmation.
 
-### Rotate Logs
+Report only if something was actually pruned or merged (non-zero counts).
+
+### Compact (weekly)
+
+Cluster and summarize similar memories by type. Only run if 7+ days
+since last compact. Check by looking for the most recent `compaction`
+type memory via the adapter:
+
+```bash
+echo '{"type": "compaction", "limit": 1}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py list
+```
+
+If the most recent compaction memory is older than 7 days (or none exists):
+
 ```bash
-# Truncate logs that grow unbounded
-tail -1000 sync/app.log > sync/app.log.tmp && mv sync/app.log.tmp sync/app.log
+~/.claude-cabinet/omega-venv/bin/omega compact -t lesson_learned 2>&1
+~/.claude-cabinet/omega-venv/bin/omega compact -t decision 2>&1
+~/.claude-cabinet/omega-venv/bin/omega compact -t error_pattern 2>&1
 ```
-Prevents log files from consuming disk. Silent, no user interaction.
 
-### Refresh Cached Computations
+Report results only if clusters were found and compacted.
+
+### Discover Connections (weekly)
+
+Scan for unlinked memories that should be related and create graph edges.
+Auto-relate runs after each store but only checks the 3 nearest memories.
+discover_connections does a broader sweep, turning isolated memories into
+a connected knowledge graph. Runs alongside compact (same weekly cadence).
+
 ```bash
-./scripts/rebuild-index.sh
+~/.claude-cabinet/omega-venv/bin/python3 -c "
+from omega.bridge import discover_connections
+result = discover_connections(lookback_hours=168)  # 7 days
+print(result if result else 'No new connections found')
+"
 ```
-Regenerates derived data that may have drifted from source files.
-Run if source files changed since last session.
+
+Report: "Discovered N new connections between memories" if non-zero.
+
+### Backup (weekly)
+
+Back up the omega database. Runs alongside compact (same weekly cadence).
+Omega keeps the last 5 backups automatically.
+
+```bash
+~/.claude-cabinet/omega-venv/bin/omega backup 2>&1
+```
+
+<!--
+## Project-Specific Maintenance
+
+Add your own recurring tasks below. For each task, provide:
+- **What** — the operation to perform
+- **Why every session** — what decays if this is skipped
+- **Command** — how to run it
+- **Auto-execute?** — yes (run silently) or surface (ask user first)
+
+### Example: Process Pending Queue Items
+```bash
+curl -s https://your-api.example.com/api/queue/pending
+```
+Items queued from a UI or external integration since last session.
+Auto-execute routine items; surface unusual ones for confirmation.
 -->

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

@@ -41,18 +41,9 @@ 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:
+Omega's native SessionStart hook (in `~/.claude/settings.json` global)
+automatically surfaces recalled memories at session start. During orient,
+you can query for additional specific context using the adapter:
 
 ```bash
 echo '{"text": "recent decisions and lessons", "limit": 5}' | \
@@ -60,9 +51,11 @@ echo '{"text": "recent decisions and lessons", "limit": 5}' | \
   scripts/cabinet-memory-adapter.py query
 ```
 
+To verify omega is healthy, run `omega hooks doctor` or `omega status`.
+
 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:
+venv 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.