create-claude-cabinet 0.8.1 → 0.8.2

package/package.json

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

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

@@ -13,6 +13,8 @@ Commands:
     capture         Store a memory from hook input (PostCompact)
     store           Store a memory directly (called by debrief)
     query           Query memories by text
+    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.
@@ -239,11 +241,85 @@ def cmd_status():
         _error(f"status failed: {e}")
 
 
+def cmd_delete():
+    """Delete a memory by its full node_id.
+
+    Reads JSON from stdin with fields:
+        id: the full node_id (e.g. "mem-077e6037742e") (required)
+
+    Note: omega uses full node_ids, not the truncated display IDs
+    shown in timeline output. Query first to get the full ID.
+    """
+    data = _read_stdin()
+    omega = _import_omega()
+    if not omega:
+        _error("omega not available")
+        return
+
+    memory_id = data.get("id", "")
+    if not memory_id:
+        _error("no id provided")
+        return
+
+    try:
+        result = omega.delete_memory(memory_id)
+        if isinstance(result, dict) and result.get("success"):
+            _output({"ok": True, "deleted": memory_id})
+        else:
+            error = result.get("error", "unknown error") if isinstance(result, dict) else str(result)
+            _error(f"delete failed: {error}")
+    except Exception as e:
+        _error(f"delete failed: {e}")
+
+
+def cmd_list():
+    """List all memories with their full node_ids.
+
+    Returns all memories so delete can target the correct ID.
+    Reads JSON from stdin with optional fields:
+        type: filter by event_type (optional)
+        limit: max results (default: 50)
+    """
+    data = _read_stdin()
+
+    try:
+        import sqlite3
+        db_path = os.path.expanduser("~/.omega/omega.db")
+        if not os.path.exists(db_path):
+            _error("omega database not found")
+            return
+
+        conn = sqlite3.connect(db_path)
+        event_type = data.get("type")
+        limit = data.get("limit", 50)
+
+        if event_type:
+            rows = conn.execute(
+                "SELECT node_id, content, event_type, created_at FROM memories WHERE event_type = ? ORDER BY created_at DESC LIMIT ?",
+                (event_type, limit),
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                "SELECT node_id, content, event_type, created_at FROM memories ORDER BY created_at DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+
+        memories = [
+            {"id": r[0], "text": r[1], "type": r[2], "created": r[3]}
+            for r in rows
+        ]
+        _output({"ok": True, "memories": memories, "count": len(memories)})
+    except Exception as e:
+        _error(f"list failed: {e}")
+
+
 COMMANDS = {
     "welcome": cmd_welcome,
     "capture": cmd_capture,
     "store": cmd_store,
     "query": cmd_query,
+    "delete": cmd_delete,
+    "list": cmd_list,
     "status": cmd_status,
 }
 

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

@@ -66,14 +66,44 @@ to help you do your job.
    It stores decisions, lessons, preferences, and constraints with semantic
    retrieval — meaning you can search by concept, not just keyword.
 
+   **Querying** (search by meaning, not just keyword):
    ```bash
    echo '{"text": "your query here", "limit": 10}' | \
      ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
    ```
 
+   **Storing** (when you discover something worth remembering):
+   ```bash
+   echo '{"text": "the lesson or decision", "type": "lesson"}' | \
+     ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
+   ```
+
+   Memory types: `decision` (architectural choices), `lesson` (gotchas,
+   discoveries), `preference` (user corrections), `constraint` (limitations
+   found), `pattern` (conventions established), `compaction` (auto-captured
+   from context compaction).
+
+   **Listing** (browse all memories with full IDs):
+   ```bash
+   echo '{"limit": 20}' | \
+     ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py list
+   ```
+
+   **Deleting** (remove stale or incorrect memories):
+   ```bash
+   echo '{"id": "mem-077e6037742e"}' | \
+     ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py delete
+   ```
+   Note: deletion requires the **full node_id** (e.g. `mem-077e6037742e`),
+   not the truncated display ID shown in `omega timeline`. Use `list` to
+   get full IDs.
+
+   Omega data lives at `~/.omega/omega.db` (SQLite). The `/memory` skill
+   gives users self-serve access to browse, search, and manage memories.
+
    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.
+   of institutional memory when available. If omega queries return nothing
+   or fail, fall through to source 1 (flat memory files).
 
 1. **Memory files** — `.claude/memory/*.md` and any project-level memory
    index (e.g., `MEMORY.md`). These are the distilled, catalogued lessons.
@@ -178,9 +208,10 @@ advocate for improvements.
 
 You are responsible for the health of the memory system:
 
-1. **After significant work:** Ensure lessons are captured in memory files.
-   If a session produced important context that isn't in any memory file,
-   create or update one.
+1. **After significant work:** Ensure lessons are captured. If omega is
+   available, store lessons there (they persist across sessions and support
+   semantic retrieval). If not, use flat memory files. If a session produced
+   important context that isn't captured anywhere, store it now.
 
 2. **Cataloguing:** Memory files should be indexed with clear one-line
    descriptions. A memory file that exists but isn't indexed is invisible

package/templates/skills/memory/SKILL.md

@@ -1,18 +1,20 @@
 ---
 name: memory
 description: |
-  Browse and search semantic memory. Shows what omega remembers — decisions,
-  lessons, preferences, constraints. Use when: "what's in memory", "memory",
-  "/memory", "what do you remember", "show memories", "search memory".
+  Browse, search, and manage semantic memory. Shows what omega remembers —
+  decisions, lessons, preferences, constraints. Supports browse, search,
+  remember, and forget. Use when: "what's in memory", "memory", "/memory",
+  "what do you remember", "show memories", "search memory", "forget",
+  "delete memory", "remember this".
 user-invocable: true
 ---
 
-# /memory — Browse Semantic Memory
+# /memory — Semantic Memory
 
 ## Purpose
 
-Give the user visibility into what omega remembers. Browse, search, and
-manage the semantic memory store.
+Give the user visibility into what omega remembers. Browse, search, store,
+and delete memories.
 
 ## Prerequisites
 
@@ -23,6 +25,29 @@ Check that omega is available:
 If not available, tell the user:
 > Memory module is not set up. Run `npx create-claude-cabinet` to install it.
 
+## 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:
+
+```bash
+echo '<json>' | ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py <command>
+```
+
+| Command | Input | Output |
+|---------|-------|--------|
+| `welcome` | `{}` or hook JSON | `{ok, context}` — relevant memories |
+| `store` | `{text, type, tags?}` | `{ok, id}` — stored memory ID |
+| `query` | `{text, limit?, type?}` | `{ok, results}` — semantic search |
+| `delete` | `{id}` | `{ok, deleted}` — requires full node_id |
+| `list` | `{type?, 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`.
+
 ## Commands
 
 Parse the user's intent from their prompt:
@@ -36,24 +61,21 @@ Show the timeline and stats:
 ~/.claude-cabinet/omega-venv/bin/omega stats 2>&1
 ```
 
-Present both outputs. The timeline shows what's stored chronologically,
-stats shows the type distribution.
+Present both outputs conversationally. The timeline shows what's stored
+chronologically, stats shows the type distribution.
 
 ### Search — user provides a topic
 
-Query omega for memories matching the topic:
-
 ```bash
 echo '{"text": "the user query", "limit": 10}' | \
   ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
 ```
 
-Present the results conversationally — don't just dump JSON.
+Present results conversationally — highlight the most relevant matches
+and their types.
 
 ### Remember — user wants to store something
 
-Store a new memory:
-
 ```bash
 echo '{"text": "what to remember", "type": "preference"}' | \
   ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
@@ -70,25 +92,36 @@ Confirm what was stored.
 
 ### Forget — user wants to remove something
 
-Look up the memory first with a query, show them what matched, confirm
-which one to remove. Use omega's delete:
+**Step 1:** Find the memory. Use `list` to get full node_ids:
 
 ```bash
-~/.claude-cabinet/omega-venv/bin/omega query "the topic" 2>&1
+echo '{"type": "preference", "limit": 20}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py list
 ```
 
-Then delete by ID:
+Or search by content:
 
 ```bash
-echo '{"text": "delete mem-XXXX", "type": "memory"}' | \
-  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py store
+echo '{"text": "the topic to forget"}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
+```
+
+**Step 2:** Show the user what matched. Confirm which one(s) to delete.
+
+**Step 3:** Delete by full node_id (e.g. `mem-077e6037742e`, NOT the
+truncated `mem-077e6037` shown in timeline):
+
+```bash
+echo '{"id": "mem-077e6037742e"}' | \
+  ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py delete
 ```
 
-Note: omega doesn't have a direct delete API in the adapter yet. For now,
-tell the user the memory ID and that direct deletion requires the omega CLI.
+The `list` command returns full node_ids. The `timeline` CLI shows
+truncated IDs — always use `list` to get the correct ID for deletion.
 
 ## Presentation
 
-Keep it conversational. Don't dump raw CLI output — summarize it.
+Keep it conversational. Don't dump raw CLI output or JSON — summarize it.
 For timeline, present as a readable list. For search results, highlight
-the most relevant matches and their types.
+the most relevant matches and their types. For forget, always confirm
+before deleting.

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

@@ -49,6 +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 |
 
 **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,6 +89,18 @@ 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:
+  ```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:
+  > ⚠ Memory module is installed but omega venv is missing.
+  > Run `npx create-claude-cabinet` to restore it.
 
 The goal: build a mental model of where things stand before doing
 anything else.