create-claude-cabinet 0.8.3 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "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

@@ -51,7 +51,15 @@ Memory types: `decision`, `lesson`, `preference`, `constraint`, `pattern`
 
 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.
+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.
+
+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.

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

@@ -149,6 +149,7 @@ def cmd_store():
         text: the memory content (required)
         type: event_type for omega (default: "lesson")
         tags: list of tags (stored in metadata, optional)
+        project: project name (default: basename of cwd)
     """
     data = _read_stdin()
     omega = _import_omega()
@@ -163,12 +164,14 @@ def cmd_store():
 
     try:
         event_type = data.get("type", "lesson")
+        project = data.get("project", os.path.basename(os.getcwd()))
         metadata = {}
         if data.get("tags"):
             metadata["tags"] = data["tags"]
         result = omega.store(
             text,
             event_type=event_type,
+            project=project,
             metadata=metadata if metadata else None,
         )
         _output({"ok": True, "id": result if isinstance(result, str) else None})
@@ -177,11 +180,17 @@ def cmd_store():
 
 
 def cmd_query():
-    """Query memories by text.
+    """Query memories by text with tiered project scoping.
 
     Reads JSON from stdin with fields:
         text: the query text (required)
         limit: max results (default: 5)
+        type: filter by event_type (optional)
+        project: project name for scoping (default: basename of cwd)
+        scope: "project" (default), "all", or "tiered"
+            - "project": only memories from this project
+            - "all": memories from all projects
+            - "tiered": project-scoped first, then cross-project to fill limit
     """
     data = _read_stdin()
     omega = _import_omega()
@@ -197,29 +206,131 @@ def cmd_query():
     try:
         limit = data.get("limit", 5)
         event_type = data.get("type")
-        results = omega.query(
-            text,
-            limit=limit,
-            event_type=event_type,
-        )
+        project = data.get("project", os.path.basename(os.getcwd()))
+        scope = data.get("scope", "tiered")
+
+        def _parse_results(results):
+            """Normalize query results into a list of dicts.
+
+            omega.query() returns a formatted markdown string. We parse it
+            back into structured data. Also queries the DB to get the project
+            field for each memory (not included in the formatted output).
+            """
+            if isinstance(results, (list, tuple)):
+                out = []
+                for r in results:
+                    if isinstance(r, dict):
+                        out.append({
+                            "text": r.get("content", r.get("text", str(r))),
+                            "type": r.get("event_type", "unknown"),
+                            "score": r.get("score", 0),
+                            "project": r.get("project", ""),
+                            "id": r.get("node_id", ""),
+                        })
+                    else:
+                        out.append({"text": str(r)})
+                return out
+
+            if not isinstance(results, str) or not results.strip():
+                return []
+
+            # Parse formatted markdown from omega.query()
+            # Format: ## N. [type] `mem-xxx` (str: 0.xx)\ncontent\n*timestamp*
+            import re
+            entries = []
+            blocks = re.split(r'\n## \d+\.', results)
+            for block in blocks:
+                block = block.strip()
+                if not block:
+                    continue
+                id_match = re.search(r'`(mem-[a-f0-9]+)`', block)
+                type_match = re.search(r'\[(\w+)\]', block)
+                score_match = re.search(r'str: ([\d.]+)', block)
+                # Content is everything after the first line, minus the timestamp
+                lines = block.split('\n')
+                content_lines = [l for l in lines[1:] if not l.startswith('*')]
+                content = '\n'.join(content_lines).strip()
+
+                if not id_match:
+                    continue  # skip header/noise lines
+                entry = {
+                    "text": content,
+                    "type": type_match.group(1) if type_match else "unknown",
+                    "score": float(score_match.group(1)) if score_match else 0,
+                    "id": id_match.group(1) if id_match else "",
+                    "project": "",
+                }
+                entries.append(entry)
+
+            # Enrich with project from DB
+            if entries:
+                try:
+                    import sqlite3
+                    db_path = os.path.expanduser("~/.omega/omega.db")
+                    conn = sqlite3.connect(db_path)
+                    ids = [e["id"] for e in entries if e["id"]]
+                    if ids:
+                        placeholders = ",".join("?" * len(ids))
+                        rows = conn.execute(
+                            f"SELECT node_id, project FROM memories WHERE node_id IN ({placeholders})",
+                            ids,
+                        ).fetchall()
+                        proj_map = {r[0]: r[1] or "" for r in rows}
+                        for e in entries:
+                            e["project"] = proj_map.get(e["id"], "")
+                    conn.close()
+                except Exception:
+                    pass  # D3: project enrichment is best-effort
+
+            return entries
+
+        # All scopes fetch from omega broadly, then filter in the adapter.
+        # omega.query() doesn't reliably pass project_path to the store,
+        # so we do project filtering ourselves.
+        over_fetch = limit * 3  # fetch extra so filtering still yields enough
+
+        if scope == "all":
+            results = omega.query(text, limit=over_fetch, event_type=event_type)
+            parsed = _parse_results(results)[:limit]
+            _output({"ok": True, "results": parsed, "scope": "all"})
+
+        elif scope == "project":
+            results = omega.query(text, limit=over_fetch, event_type=event_type)
+            parsed = _parse_results(results)
+            filtered = [m for m in parsed if m.get("project") == project][:limit]
+            _output({"ok": True, "results": filtered, "scope": "project", "project": project})
+
+        else:  # tiered (default)
+            results = omega.query(text, limit=over_fetch, event_type=event_type)
+            parsed = _parse_results(results)
+
+            # Tier 1: project-scoped
+            project_memories = [m for m in parsed if m.get("project") == project][:limit]
+            for m in project_memories:
+                m["tier"] = "project"
+
+            # Tier 2: cross-project to fill remaining slots
+            remaining = limit - len(project_memories)
+            cross_memories = []
+            if remaining > 0:
+                seen_ids = {m["id"] for m in project_memories if m["id"]}
+                for m in parsed:
+                    if m.get("project") != project and m.get("id") not in seen_ids:
+                        m["tier"] = "cross-project"
+                        cross_memories.append(m)
+                        if len(cross_memories) >= remaining:
+                            break
+
+            combined = project_memories + cross_memories
+            _output({
+                "ok": True,
+                "results": combined,
+                "scope": "tiered",
+                "project": project,
+                "project_count": len(project_memories),
+                "cross_project_count": len(cross_memories),
+            })
 
-        # 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}")
 
@@ -278,6 +389,7 @@ def cmd_list():
     Returns all memories so delete can target the correct ID.
     Reads JSON from stdin with optional fields:
         type: filter by event_type (optional)
+        project: filter by project (optional)
         limit: max results (default: 50)
     """
     data = _read_stdin()
@@ -291,21 +403,28 @@ def cmd_list():
 
         conn = sqlite3.connect(db_path)
         event_type = data.get("type")
+        project = data.get("project")
         limit = data.get("limit", 50)
 
+        where_clauses = []
+        params = []
         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()
+            where_clauses.append("event_type = ?")
+            params.append(event_type)
+        if project:
+            where_clauses.append("project = ?")
+            params.append(project)
+
+        where = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
+        params.append(limit)
+
+        rows = conn.execute(
+            f"SELECT node_id, content, event_type, project, created_at FROM memories {where} ORDER BY created_at DESC LIMIT ?",
+            params,
+        ).fetchall()
 
         memories = [
-            {"id": r[0], "text": r[1], "type": r[2], "created": r[3]}
+            {"id": r[0], "text": r[1], "type": r[2], "project": r[3] or "", "created": r[4]}
             for r in rows
         ]
         _output({"ok": True, "memories": memories, "count": len(memories)})

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

@@ -71,12 +71,16 @@ to help you do your job.
    echo '{"text": "your query here", "limit": 10}' | \
      ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
    ```
+   Queries use **tiered scoping** by default: project memories first,
+   then cross-project to fill remaining slots. Use `"scope": "project"`
+   for strict project-only, or `"scope": "all"` for global search.
 
    **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
    ```
+   Stores are automatically tagged with the current project name.
 
    Memory types: `decision` (architectural choices), `lesson` (gotchas,
    discoveries), `preference` (user corrections), `constraint` (limitations

package/templates/skills/memory/SKILL.md

@@ -38,10 +38,10 @@ 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?}` | `{ok, id}` — stored memory ID |
-| `query` | `{text, limit?, type?}` | `{ok, results}` — semantic search |
+| `store` | `{text, type, tags?, project?}` | `{ok, id}` — stored memory ID |
+| `query` | `{text, limit?, type?, project?, scope?}` | `{ok, results}` — semantic search |
 | `delete` | `{id}` | `{ok, deleted}` — requires full node_id |
-| `list` | `{type?, limit?}` | `{ok, memories, count}` — all memories with full IDs |
+| `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}` |
 
@@ -71,8 +71,17 @@ echo '{"text": "the user query", "limit": 10}' | \
   ~/.claude-cabinet/omega-venv/bin/python3 scripts/cabinet-memory-adapter.py query
 ```
 
-Present results conversationally — highlight the most relevant matches
-and their types.
+**Scope options** (pass `scope` in the JSON):
+- `"tiered"` (default) — project memories first, then cross-project to fill
+- `"project"` — only memories from this project
+- `"all"` — memories from all projects equally
+
+The `project` field defaults to the current directory name. Results
+include a `tier` field ("project" or "cross-project") in tiered mode.
+
+Present results conversationally — highlight the most relevant matches,
+their types, and which project they came from when cross-project results
+appear.
 
 ### Remember — user wants to store something