get-claudia 1.55.21 → 1.57.0

package/template-v2/.claude/rules/memory-commitment.md

@@ -0,0 +1,92 @@
+# Memory Commitment
+
+This rule is always active. Follow it silently. Do not cite this file by name in conversation.
+
+---
+
+## The principle
+
+**Save canonical facts to memory IMMEDIATELY when they emerge. Do not batch to /meditate.**
+
+The memory database is what makes information recoverable across sessions. Artifacts on disk (markdown files, GitHub repos, PDFs) are not searchable from future sessions unless I happen to remember the path. Memory entries with proper entity links surface through both semantic search and entity browsing.
+
+If a fact lives only in a file, it does not exist for future-me.
+
+---
+
+## Save now when ANY of these happen
+
+1. **User states a canonical fact** that is unlikely to change: hex code, URL, EIN, address, password location, locked decision, version number, identifier, credential location.
+
+2. **User shares substantive source material** (>500 words, a transcript, a document, a brief, a prompt, a strategy doc). File it via `memory_file` BEFORE extracting from it.
+
+3. **User overrides or corrects a stored memory or preference.** The correction is more important than the original. Save it with high importance and reference what it supersedes.
+
+4. **A new project, repo, entity, integration, credential, or tool is created** during the session. Create the entity, then attach facts about it.
+
+5. **User uses a trigger phrase**: "lock this in," "remember this," "this is canonical," "this is locked," "save this for later," "important to remember," "for the record," "don't forget."
+
+6. **A judgment-relevant decision is made** (priorities, escalations, overrides, surfacing rules, delegation preferences). These also feed `context/judgment.yaml` via /meditate, but the fact itself goes into memory immediately.
+
+---
+
+## The test
+
+Before deciding "I'll save this later," ask:
+
+> **If I came back tomorrow with no transcript, would I need this fact to do good work?**
+
+If yes, save it now. The test is meant to be cheap to apply: when in doubt, save.
+
+---
+
+## How to save
+
+| Need | Tool | Use when |
+|------|------|----------|
+| One fact | `memory_remember` | Single fact emerges in conversation |
+| Bundled save (entity + facts + relationships) | `memory_batch` | Processing a substantive artifact, transcript, document, or multi-fact moment |
+| Raw source material before extraction | `memory_file` | User shares a document, transcript, email, brief |
+| New relationship between entities | `memory_relate` | Two existing entities connect in a new way |
+| Verify or build on prior memory | `memory_recall` / `memory_about` | Before saving, check if a related memory exists to update instead of duplicate |
+
+**Prefer `memory_batch` over multiple `memory_remember` calls.** One round-trip handles entity creation, fact-saves, and relationships together. Faster, cleaner, less likely to be skipped.
+
+---
+
+## What NOT to save
+
+Per the data-freshness rule:
+
+- Volatile counts, statuses, progress numbers ("13K subscribers," "9 interviews completed," "94% stall rate")
+- Dated state snapshots that can be re-derived from source files
+- Anything that should live in a context file or canonical source instead
+- Information already documented in CLAUDE.md or auto-memory MEMORY.md
+
+When you encounter a useful but volatile fact, save a **pointer** to where the canonical source lives, not the value itself. Example: instead of "subscriber count is 13,000," save "subscriber count lives on the live homepage; check there for current."
+
+---
+
+## Substantive-artifact discipline
+
+When producing a substantive artifact (brand bible, multi-doc plan, comprehensive analysis, custom skill, deployed integration), end the artifact-production block with a memory commitment pass:
+
+1. List the canonical facts the artifact embodies.
+2. Call `memory_batch` to save them as one bundle, with proper entity links and source context referencing the artifact location.
+3. Mark the highest-leverage fact as `critical: true` only when it's a personal-identity-class fact (life motto, ethical lock, security-relevant rule).
+
+The artifact lives on disk. The facts must live in memory too.
+
+---
+
+## Why this rule exists
+
+A common failure mode: an agent produces a multi-file artifact (brand bible, integration setup, comprehensive plan) over the course of a session. The artifact contains canonical facts (color palettes, credentials, decisions, URLs). End-of-session reflection captures only high-level reflections, not the specific facts. Days later, when those facts are needed again, they exist only on disk and the agent has no way to surface them through memory queries.
+
+Result: the same facts get re-elicited, re-decided, re-committed. The memory system was the substrate, but it was treated as the afterthought.
+
+This rule prevents that pattern.
+
+---
+
+*Memory is the substrate, not the afterthought. Save as you go.*

package/template-v2/.claude/settings.local.json

@@ -39,6 +39,32 @@
           }
         ]
       }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/user-prompt-capture.py\" 2>/dev/null || python \"$CLAUDE_PROJECT_DIR/.claude/hooks/user-prompt-capture.py\" 2>/dev/null || true",
+            "timeout": 3000,
+            "statusMessage": ""
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-summary.py\" 2>/dev/null || python \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-summary.py\" 2>/dev/null || true",
+            "timeout": 10000,
+            "statusMessage": "Generating daily session summary..."
+          }
+        ]
+      }
     ]
   }
 }

package/template-v2/.claude/skills/capture-meeting/SKILL.md

@@ -30,7 +30,7 @@ User provides one of:
 
 **Always file the raw transcript/notes FIRST.** This is not optional. Source preservation creates provenance: every extracted fact can trace back to where it came from.
 
-Call the `memory.file` MCP tool with:
+Call the `memory_file` MCP tool with:
 - `filename`: "YYYY-MM-DD-[person]-[topic].md"
 - `source_type`: "transcript"
 - `summary`: "Brief 1-line summary of the meeting"
@@ -71,7 +71,7 @@ The file is automatically routed to the right folder:
    - Confirm entity names match existing entities
    - Adjust or remove any questionable extractions
 
-4. Call the `memory.batch` MCP tool with the reviewed operations array
+4. Call the `memory_batch` MCP tool with the reviewed operations array
 ```
 
 **Fallback: Manual extraction** (use when agent is unavailable or for very short notes)
@@ -101,9 +101,9 @@ The file is automatically routed to the right folder:
 
 ### 4. Link Provenance
 
-After extracting memories (facts, commitments) via the `memory.batch` or `memory.remember` MCP tools:
+After extracting memories (facts, commitments) via the `memory_batch` or `memory_remember` MCP tools:
 
-Call the `memory.file` MCP tool with the `memory_ids` parameter set to the IDs of the memories you extracted. This links the stored transcript to the memories extracted from it, creating the provenance chain: memory -> document -> file on disk.
+Call the `memory_file` MCP tool with the `memory_ids` parameter set to the IDs of the memories you extracted. This links the stored transcript to the memories extracted from it, creating the provenance chain: memory -> document -> file on disk.
 
 Now the user can ask "where did you learn that Sarah prefers async communication?" and you can point to the exact transcript.
 
@@ -128,7 +128,7 @@ For each participant in the meeting:
 
 - Add new commitments to `context/commitments.md` (ask for confirmation on wording and deadline)
 - Add new waiting items to `context/waiting.md`
-- If memory MCP tools are available, also store via the `memory.remember` MCP tool
+- If memory MCP tools are available, also store via the `memory_remember` MCP tool
 
 #### 5c. Update workspace files (if applicable)
 
@@ -226,7 +226,7 @@ Ask for confirmation on:
 
 ## Quality Checklist
 
-- [ ] **Raw transcript/notes filed** (`memory.file` MCP tool called with full content)
+- [ ] **Raw transcript/notes filed** (`memory_file` MCP tool called with full content)
 - [ ] Memories linked to source document (provenance chain complete)
 - [ ] Every action item has an owner
 - [ ] Every commitment has a deadline (even approximate)

package/template-v2/.claude/skills/capture-meeting/evals/basic.yaml

@@ -5,7 +5,7 @@ prompts:
   - prompt: "Here are my notes from a call with Sarah Chen about the Q4 roadmap. She mentioned they're moving to microservices, the migration is due by March 15. I promised to send her our API docs by Friday. Also met her colleague James Wright who leads the platform team."
     expectations:
       - "extracts at least one commitment (send API docs by Friday)"
-      - "files the source material via memory.file before extracting"
+      - "files the source material via memory_file before extracting"
       - "identifies Sarah Chen and James Wright as entities"
       - "detects the March 15 deadline"
       - "uses structured output format with emoji headers"

package/template-v2/.claude/skills/deep-context/SKILL.md

@@ -18,7 +18,7 @@ Comprehensive deep analysis that leverages the full context window. Pulls memori
 
 ## The Deep Pull
 
-Call the `memory.deep_context` MCP tool with the target entity or topic. This compound tool executes the full pipeline server-side in a single call:
+Call the `memory_deep_context` MCP tool with the target entity or topic. This compound tool executes the full pipeline server-side in a single call:
 
 1. **Entity core** (limit=50): Everything known about the target (memories, relationships, metadata)
 2. **Semantic recall** (limit=50): Broad search to catch indirect references and related topics
@@ -44,13 +44,13 @@ All limits are configurable via the tool's input:
 
 ### Fallback (when memory daemon is unavailable)
 
-If the MCP tool is not available, execute these queries manually using `memory.about` and `memory.recall` MCP tools sequentially:
+If the MCP tool is not available, execute these queries manually using `memory_about` and `memory_recall` MCP tools sequentially:
 
-1. `memory.about` with the target (limit=50)
-2. `memory.recall` with the target (limit=50)
-3. `memory.about` for each of the top 3 connected entities (limit=10)
-4. `memory.recall` with types=["observation","learning","commitment"] (limit=30)
-5. `memory.recall` for "session with [target]" (limit=20)
+1. `memory_about` with the target (limit=50)
+2. `memory_recall` with the target (limit=50)
+3. `memory_about` for each of the top 3 connected entities (limit=10)
+4. `memory_recall` with types=["observation","learning","commitment"] (limit=30)
+5. `memory_recall` for "session with [target]" (limit=20)
 6. Deduplicate by memory ID across all steps
 
 If the memory daemon itself is down, fall back to reading `context/` files and `people/*.md` directly. Note degraded mode in output.

package/template-v2/.claude/skills/meditate/SKILL.md

@@ -40,8 +40,8 @@ Silently retrieve:
 - Existing reflections to avoid duplication
 - Active commitments and relationship states
 
-- Call the `memory.reflections` MCP tool to see what already exists
-- Call the `memory.session_context` MCP tool for recent context (if available)
+- Call the `memory_reflections` MCP tool to see what already exists
+- Call the `memory_session_context` MCP tool for recent context (if available)
 
 ### Step 2: Generate Reflections
 
@@ -148,7 +148,7 @@ User responses:
 
 ### Step 5: Store and Close
 
-Call the `memory.end_session` MCP tool with:
+Call the `memory_end_session` MCP tool with:
 - `narrative`: Brief session summary
 - `reflections`: Array of approved reflections with type, content, and optional about fields
 - Other structured extractions (facts, commitments, entities) as needed
@@ -203,8 +203,8 @@ When similar reflections accumulate over time:
 ### Retrieval
 
 Reflections surface through:
-- The `memory.reflections` MCP tool for explicit retrieval
-- The `memory.session_context` MCP tool includes relevant reflections
+- The `memory_reflections` MCP tool for explicit retrieval
+- The `memory_session_context` MCP tool includes relevant reflections
 - Semantic search matches reflections to current context
 
 ---
@@ -236,8 +236,8 @@ User: "That thing you learned about me preferring bullet points -
        that's only for technical content, not conversations."
 
 Claudia:
-1. Call the `memory.reflections` MCP tool with query: "bullet points" to find the reflection
-2. Call the `memory.reflections` MCP tool with action: "update", id: <id>, content: "..." to update
+1. Call the `memory_reflections` MCP tool with query: "bullet points" to find the reflection
+2. Call the `memory_reflections` MCP tool with action: "update", id: <id>, content: "..." to update
 3. Confirm: "Updated. I'll keep that distinction in mind."
 ```
 
@@ -245,8 +245,8 @@ Claudia:
 User: "Delete the reflection about Monday mornings"
 
 Claudia:
-1. Search for the reflection via `memory.reflections` MCP tool
-2. Call the `memory.reflections` MCP tool with action: "delete", id: <id> to delete
+1. Search for the reflection via `memory_reflections` MCP tool
+2. Call the `memory_reflections` MCP tool with action: "delete", id: <id> to delete
 3. Confirm: "Done, I've removed that."
 ```
 
@@ -254,7 +254,7 @@ Claudia:
 User: "Show me all your reflections about me"
 
 Claudia:
-1. Call the `memory.reflections` MCP tool with limit: 50
+1. Call the `memory_reflections` MCP tool with limit: 50
 2. Format nicely with timeline info
 3. Offer to edit or delete any
 ```

package/template-v2/.claude/skills/meditate/evals/basic.yaml

@@ -8,7 +8,7 @@ prompts:
       - "generates reflections, not just a session summary"
       - "captures communication preferences observed during the session"
       - "extracts judgment rules from decisions (e.g., pricing approach)"
-      - "calls memory.end_session with narrative, facts, and reflections"
+      - "calls memory_end_session with narrative, facts, and reflections"
       - "narrative captures emotional tone (frustration about pricing)"
       - "identifies unresolved threads worth revisiting"
 

package/template-v2/.claude/skills/meeting-prep/SKILL.md

@@ -21,12 +21,12 @@ Or naturally:
 
 ### Primary: Deep Context (one call)
 
-Call the `memory.deep_context` MCP tool with the person's name. This returns everything in one round trip: entity info, all memories, connected entities, temporal items (commitments, observations), and episode history. Use this data for all sections below.
+Call the `memory_deep_context` MCP tool with the person's name. This returns everything in one round trip: entity info, all memories, connected entities, temporal items (commitments, observations), and episode history. Use this data for all sections below.
 
-If deep_context is unavailable, fall back to sequential calls: `memory.about` for the entity, then `memory.recall` for broader context.
+If deep_context is unavailable, fall back to sequential calls: `memory_about` for the entity, then `memory_recall` for broader context.
 
 ### 1. Person Context
-From `memory.deep_context` result (or `people/[person].md` as fallback):
+From `memory_deep_context` result (or `people/[person].md` as fallback):
 - Role and organization
 - Relationship history
 - Last contact and topics

package/template-v2/.claude/skills/memory-health/SKILL.md

@@ -38,7 +38,7 @@ Provide a dashboard view of the memory system's health, including entity counts,
 
 ### Step 1: Gather Statistics
 
-Use the `memory.system_health` MCP tool or direct SQLite queries with the schema above.
+Use the `memory_system_health` MCP tool or direct SQLite queries with the schema above.
 
 Alternatively, use the Claudia CLI to get current system state: