get-claudia 1.55.21 → 1.57.0

package/memory-daemon/claudia_memory/services/consolidate.py

@@ -2613,7 +2613,7 @@ class ConsolidateService:
                 f"Possible duplicate entities: '{candidate['entity_1']['name']}' "
                 f"and '{candidate['entity_2']['name']}' "
                 f"({candidate['similarity']:.0%} similar via {candidate['method']}). "
-                f"Consider merging with memory.merge_entities."
+                f"Consider merging with memory_merge_entities."
             )
             # Check for existing dedupe prediction
             existing = self.db.execute(

package/memory-daemon/claudia_memory/services/remember.py

@@ -1345,7 +1345,7 @@ class RememberService:
         # Validate episode exists before any DB operations
         episode = self.db.get_one("episodes", where="id = ?", where_params=(episode_id,))
         if not episode:
-            result["error"] = f"Episode {episode_id} not found. Call memory.buffer_turn first to create an episode."
+            result["error"] = f"Episode {episode_id} not found. Call memory_buffer_turn first to create an episode."
             logger.warning(f"end_session called with non-existent episode_id={episode_id}")
             return result
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.55.21",
+  "version": "1.57.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",
@@ -39,7 +39,11 @@
   ],
   "dependencies": {},
   "devDependencies": {},
-  "scripts": {},
+  "scripts": {
+    "generate-manifest": "node scripts/generate-manifest.js",
+    "test": "node --test test/",
+    "prepublishOnly": "node scripts/generate-manifest.js"
+  },
   "engines": {
     "node": ">=18.0.0"
   },

package/template-v2/.claude/hooks/hooks.json

@@ -15,13 +15,13 @@
         "on_missing_me": "trigger_onboarding",
         "memory_verification": {
           "step_1_check_cli": "BEFORE anything else, verify the `claudia` CLI is available by running `claudia system-health --project-dir \"$PWD\"` via Bash tool. This checks that the claudia-memory daemon is configured and responsive. If the command fails or is not found: (1) Do NOT fall back to plugin:episodic-memory, mcp__plugin_episodic-memory_*, or any other memory search tool as a substitute — these give inferior, unrelated results and mask the real problem. (2) Tell the user: 'My memory tools are not available. The claudia-memory daemon may not be running or may not be configured as an MCP server. Check that the daemon is listed in your .mcp.json and that it starts without errors. Your context files are preserved.' (3) Continue with context files only (context/me.md, etc.) until fixed.",
-          "step_2_load_context": "Call the `memory.session_context` MCP tool to get a formatted context block with recent memories, commitments, and unsummarized session alerts. If the MCP tool is not available, the daemon may not be properly configured. Suggest: 'The claudia-memory daemon may need to be configured in .mcp.json. Run claudia system-health for diagnostics.'",
+          "step_2_load_context": "Call the `memory_session_context` MCP tool to get a formatted context block with recent memories, commitments, and unsummarized session alerts. If the MCP tool is not available, the daemon may not be properly configured. Suggest: 'The claudia-memory daemon may need to be configured in .mcp.json. Run claudia system-health for diagnostics.'",
           "fallback": "If memory MCP tools are not available: (1) Do NOT use plugin:episodic-memory or any other memory search tool as a substitute. (2) Tell the user: 'My memory tools are not available. The claudia-memory daemon may not be configured as an MCP server.' (3) Read context files directly (context/me.md, context/commitments.md, context/learnings.md, context/patterns.md, context/waiting.md) as the fallback. Make clear to the user they are in degraded mode with no semantic search or cross-session learning."
         },
         "enhanced_memory": {
-          "context_load": "Call the `memory.session_context` MCP tool to get a formatted context block with recent memories, commitments, and unsummarized session alerts.",
-          "catch_up": "If unsummarized sessions are reported in the context block, review buffered turns and call the `memory.end_session` MCP tool with a retroactive narrative and structured extractions for each.",
-          "recall_context": "Use the loaded context for greeting. For deeper search on specific topics, call the `memory.recall` MCP tool with the relevant query."
+          "context_load": "Call the `memory_session_context` MCP tool to get a formatted context block with recent memories, commitments, and unsummarized session alerts.",
+          "catch_up": "If unsummarized sessions are reported in the context block, review buffered turns and call the `memory_end_session` MCP tool with a retroactive narrative and structured extractions for each.",
+          "recall_context": "Use the loaded context for greeting. For deeper search on specific topics, call the `memory_recall` MCP tool with the relevant query."
         },
         "proactive_surfacing": {
           "description": "Surface urgent items naturally in the greeting. Keep it to a brief mention, not a full report.",
@@ -30,12 +30,12 @@
             {
               "type": "overdue_commitments",
               "description": "Commitments older than 7 days without resolution",
-              "query_hint": "Call the `memory.recall` MCP tool with query about overdue commitments and check dates"
+              "query_hint": "Call the `memory_recall` MCP tool with query about overdue commitments and check dates"
             },
             {
               "type": "cooling_relationships",
               "description": "Important people not mentioned in >30 days",
-              "query_hint": "Call the `memory.search_entities` MCP tool with type: person and check last_mentioned dates"
+              "query_hint": "Call the `memory_search_entities` MCP tool with type: person and check last_mentioned dates"
             }
           ],
           "examples": [
@@ -58,7 +58,7 @@
         ],
         "save_mode": "merge",
         "enhanced_memory": {
-          "summarize": "Call the `memory.end_session` MCP tool with a narrative summary and structured extractions from the session's buffered turns. The narrative should enhance stored information with tone, context, unresolved threads, and nuance that structured fields cannot capture."
+          "summarize": "Call the `memory_end_session` MCP tool with a narrative summary and structured extractions from the session's buffered turns. The narrative should enhance stored information with tone, context, unresolved threads, and nuance that structured fields cannot capture."
         }
       }
     },
@@ -75,10 +75,10 @@
   "notes": {
     "implementation": "These hooks define intended behaviors. Claude Code will execute them as behavioral guidelines rather than traditional script execution.",
     "memory_verification": "CRITICAL: At session start, verify memory availability by running `claudia system-health --project-dir \"$PWD\"` BEFORE proceeding. If memory MCP tools are not available, do NOT use plugin:episodic-memory as a substitute. Tell the user the claudia-memory daemon may need to be configured. Fall back to context files only (context/me.md, etc.) in the meantime.",
-    "session_start": "At session start: (1) Verify claudia system-health passes, (2) Call the `memory.session_context` MCP tool, (3) Read context files, (4) Check for unsummarized sessions. If me.md is missing, trigger onboarding.",
-    "session_end": "Before session ends, Claudia should generate a session summary via the `memory.end_session` MCP tool (enhanced memory) or update context files (markdown fallback). The summary includes both a free-form narrative and structured extractions.",
+    "session_start": "At session start: (1) Verify claudia system-health passes, (2) Call the `memory_session_context` MCP tool, (3) Read context files, (4) Check for unsummarized sessions. If me.md is missing, trigger onboarding.",
+    "session_end": "Before session ends, Claudia should generate a session summary via the `memory_end_session` MCP tool (enhanced memory) or update context files (markdown fallback). The summary includes both a free-form narrative and structured extractions.",
     "first_run": "The absence of context/me.md signals a first-run scenario requiring onboarding.",
-    "turn_buffering": "During sessions with enhanced memory, Claudia buffers each meaningful conversation turn via the `memory.buffer_turn` MCP tool. This ensures nothing is lost even if the session ends abruptly. The buffered turns are summarized at session end or caught up at next session start.",
-    "source_filing": "CRITICAL: When processing transcripts, emails, or documents, ALWAYS call the `memory.file` MCP tool BEFORE extracting information. The Source Preservation principle (#12) is non-negotiable. Raw sources must be filed for provenance."
+    "turn_buffering": "During sessions with enhanced memory, Claudia buffers each meaningful conversation turn via the `memory_buffer_turn` MCP tool. This ensures nothing is lost even if the session ends abruptly. The buffered turns are summarized at session end or caught up at next session start.",
+    "source_filing": "CRITICAL: When processing transcripts, emails, or documents, ALWAYS call the `memory_file` MCP tool BEFORE extracting information. The Source Preservation principle (#12) is non-negotiable. Raw sources must be filed for provenance."
   }
 }

package/template-v2/.claude/hooks/post-tool-capture.py

@@ -1,37 +1,137 @@
 #!/usr/bin/env python3
 """PostToolUse hook: passively captures tool invocations to a JSONL file.
 
+Reads hook input from stdin (Claude Code's actual contract), not env vars.
 Writes observations to ~/.claudia/observations.jsonl for later ingestion
-by the memory daemon. Designed to complete in ~1ms (file append only).
+by the memory daemon and by the session-summary generator.
+
+Designed to complete in <50ms (file append only, no network).
+
+Captured per-tool-call:
+- tool name + truncated input/output
+- file paths touched (for Write/Edit/MultiEdit/NotebookEdit)
+- external actions (git push, gh repo create, vercel deploy, etc.)
+- session_id for linking observations to a session
 """
 
 import json
-import os
+import re
 import sys
 import time
 from pathlib import Path
 
-SKIP_PREFIXES = ("memory.", "mcp__plugin_episodic", "cognitive.")
-SKIP_NAMES = {"Read", "Glob", "Grep", "LS", "ListMcpResourcesTool", "ReadMcpResourceTool"}
+# Skip noisy or read-only tools that don't need observation
+SKIP_PREFIXES = ("memory_", "memory.", "mcp__plugin_episodic", "cognitive.")
+SKIP_NAMES = {
+    "Read", "Glob", "Grep", "LS", "TodoRead",
+    "ListMcpResourcesTool", "ReadMcpResourceTool",
+    "TaskList", "TaskGet", "TaskOutput", "ToolSearch",
+}
+
+# Bash command patterns that signal an "external action" worth flagging in
+# the daily summary. Anchored so the candidate command must appear at the
+# start of the line or after a shell separator (`;`, `&&`, `|`, `\n`, `(`),
+# with optional transparent prefixes (`sudo`, `nohup`, `time`, `env VAR=`).
+# This rejects echo'd test JSON ("git push for testing") and prefixed
+# look-alikes ("git pushd", "ungit push") while still firing on real
+# invocations including chained ones (`cd foo && git push`).
+_BASH_CMD_ANCHOR = (
+    r"(?:^|[;&|\n(])\s*"
+    r"(?:sudo\s+|nohup\s+|time\s+|env\s+\w+=\S+\s+)*"
+)
+EXTERNAL_ACTION_PATTERNS: list[tuple[str, re.Pattern]] = [
+    ("git push", re.compile(_BASH_CMD_ANCHOR + r"git\s+push\b")),
+    ("gh repo create", re.compile(_BASH_CMD_ANCHOR + r"gh\s+repo\s+create\b")),
+    ("gh pr create", re.compile(_BASH_CMD_ANCHOR + r"gh\s+pr\s+create\b")),
+    ("gh release", re.compile(_BASH_CMD_ANCHOR + r"gh\s+release\b")),
+    ("vercel --prod", re.compile(_BASH_CMD_ANCHOR + r"vercel\s+(?:[^\n]*\s)?--prod\b")),
+    ("vercel deploy", re.compile(_BASH_CMD_ANCHOR + r"vercel\s+deploy\b")),
+    ("netlify deploy", re.compile(_BASH_CMD_ANCHOR + r"netlify\s+deploy\b")),
+    ("supabase db push", re.compile(_BASH_CMD_ANCHOR + r"supabase\s+db\s+push\b")),
+    ("npx supabase", re.compile(_BASH_CMD_ANCHOR + r"npx\s+supabase\b")),
+]
+
+
+def is_external_action(tool_name: str, tool_input) -> str | None:
+    """Return a short label if this tool call looks like an external action."""
+    if tool_name == "Bash":
+        cmd = (tool_input or {}).get("command", "") if tool_input else ""
+        if not cmd:
+            return None
+        for label, regex in EXTERNAL_ACTION_PATTERNS:
+            if regex.search(cmd):
+                return label
+    elif tool_name in {
+        "mcp__claudia-private-email__claudia_email_send",
+        "mcp__gmail__send_email", "mcp__gmail__draft_email",
+    }:
+        return "email send/draft"
+    elif tool_name in {
+        "mcp__google-calendar__create_event",
+        "mcp__google-calendar__update_event",
+        "mcp__google-calendar__delete_event",
+    }:
+        return "calendar event"
+    elif tool_name.startswith("mcp__claude_ai_Slack__slack_send"):
+        return "slack send"
+    return None
+
+
+def extract_file_path(tool_name: str, tool_input: dict) -> str | None:
+    """For Write/Edit/MultiEdit/NotebookEdit, return the file path being modified."""
+    if tool_name in {"Write", "Edit", "MultiEdit", "NotebookEdit"}:
+        return (tool_input or {}).get("file_path")
+    return None
 
 
 def main():
-    tool_name = os.environ.get("CLAUDE_TOOL_NAME", "")
+    # Claude Code passes hook payload as JSON on stdin.
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return
+        payload = json.loads(raw)
+    except (json.JSONDecodeError, OSError):
+        return
+
+    tool_name = payload.get("tool_name", "")
     if not tool_name:
         return
 
     if any(tool_name.startswith(p) for p in SKIP_PREFIXES) or tool_name in SKIP_NAMES:
         return
 
-    tool_input = os.environ.get("CLAUDE_TOOL_INPUT", "")[:200]
-    tool_output = os.environ.get("CLAUDE_TOOL_OUTPUT", "")[:200]
+    tool_input = payload.get("tool_input") or {}
+    tool_response = payload.get("tool_response") or {}
+    session_id = payload.get("session_id", "")
+
+    input_summary = json.dumps(tool_input)[:300] if tool_input else ""
+    output_summary = ""
+    if isinstance(tool_response, dict):
+        for key in ("stdout", "output", "result", "content"):
+            if key in tool_response:
+                val = tool_response[key]
+                output_summary = str(val)[:300] if val else ""
+                break
+        if not output_summary:
+            output_summary = json.dumps(tool_response)[:300]
+    else:
+        output_summary = str(tool_response)[:300]
+
+    file_path = extract_file_path(tool_name, tool_input)
+    external_action = is_external_action(tool_name, tool_input)
 
     observation = {
-        "tool": tool_name,
-        "input": tool_input,
-        "output": tool_output,
         "ts": time.time(),
+        "session_id": session_id,
+        "tool": tool_name,
+        "input": input_summary,
+        "output": output_summary,
     }
+    if file_path:
+        observation["file_path"] = file_path
+    if external_action:
+        observation["external_action"] = external_action
 
     obs_file = Path.home() / ".claudia" / "observations.jsonl"
     obs_file.parent.mkdir(parents=True, exist_ok=True)

package/template-v2/.claude/hooks/pre-compact.py

@@ -12,10 +12,10 @@ print(json.dumps({
     "additionalContext": (
         "Context compaction advisory: If important information was discussed recently, "
         "ensure it has been stored via MCP tools. Check: (1) Commitments: call the "
-        "memory.remember MCP tool for any promises not yet stored. (2) People: call the "
-        "memory.entity MCP tool for anyone discussed in detail. (3) Relationships: call the "
-        "memory.relate MCP tool for connections mentioned. (4) Buffer: call the "
-        "memory.buffer_turn MCP tool with a summary if recent exchanges were not buffered. "
+        "memory_remember MCP tool for any promises not yet stored. (2) People: call the "
+        "memory_entity MCP tool for anyone discussed in detail. (3) Relationships: call the "
+        "memory_relate MCP tool for connections mentioned. (4) Buffer: call the "
+        "memory_buffer_turn MCP tool with a summary if recent exchanges were not buffered. "
         "With 1M context, compaction is less frequent, but proactive capture remains good practice."
     )
 }))

package/template-v2/.claude/hooks/pre-compact.sh

@@ -6,7 +6,7 @@
 # Inject advisory into compacted context
 cat <<EOF
 {
-  "additionalContext": "Context compaction advisory: If important information was discussed recently, ensure it has been stored via MCP tools. Check: (1) Commitments: call the memory.remember MCP tool for any promises not yet stored. (2) People: call the memory.entity MCP tool for anyone discussed in detail. (3) Relationships: call the memory.relate MCP tool for connections mentioned. (4) Buffer: call the memory.buffer_turn MCP tool with a summary if recent exchanges were not buffered. With 1M context, compaction is less frequent, but proactive capture remains good practice."
+  "additionalContext": "Context compaction advisory: If important information was discussed recently, ensure it has been stored via MCP tools. Check: (1) Commitments: call the memory_remember MCP tool for any promises not yet stored. (2) People: call the memory_entity MCP tool for anyone discussed in detail. (3) Relationships: call the memory_relate MCP tool for connections mentioned. (4) Buffer: call the memory_buffer_turn MCP tool with a summary if recent exchanges were not buffered. With 1M context, compaction is less frequent, but proactive capture remains good practice."
 }
 EOF
 exit 0

package/template-v2/.claude/hooks/session-health-check.py

@@ -24,6 +24,50 @@ def _fetch_briefing():
         return None
 
 
+def _recent_sessions_summary(max_days: int = 3) -> str:
+    """Return a compact recap of the last N days of session summaries.
+
+    Reads ~/.claudia/sessions/YYYY-MM-DD/INDEX.md files. Returns a short
+    multi-day digest showing what was worked on. Bounded to keep startup fast.
+
+    Empty string when no session history exists yet (fresh installs).
+    """
+    sessions_dir = Path.home() / ".claudia" / "sessions"
+    if not sessions_dir.exists():
+        return ""
+
+    date_folders = sorted(
+        [d for d in sessions_dir.iterdir() if d.is_dir() and d.name[:4].isdigit()],
+        reverse=True,
+    )[:max_days]
+
+    if not date_folders:
+        return ""
+
+    lines = []
+    for date_dir in date_folders:
+        summaries = sorted(date_dir.glob("[0-9][0-9]-*.md"))
+        if not summaries:
+            continue
+        topics = []
+        for f in summaries:
+            try:
+                first_line = f.read_text(encoding="utf-8").split("\n", 1)[0]
+                topic = first_line.lstrip("#").strip()
+                if "—" in topic:
+                    topic = topic.split("—", 1)[1].strip()
+                topics.append(topic)
+            except OSError:
+                continue
+        if topics:
+            lines.append(f"  {date_dir.name}: {' · '.join(topics[:5])}")
+
+    if not lines:
+        return ""
+
+    return "Recent sessions (from ~/.claudia/sessions/):\n" + "\n".join(lines)
+
+
 def _run_claudia(*args):
     """Run claudia CLI and return parsed JSON output, or None on failure."""
     claudia_bin = shutil.which("claudia")
@@ -65,11 +109,15 @@ def check_health():
 
         summary = " ".join(parts) if parts else "System ready."
         briefing = _fetch_briefing()
+        recent = _recent_sessions_summary()
+
+        sections = [f"Memory system healthy. {summary}"]
+        if recent:
+            sections.append("--- Recent Sessions ---\n" + recent)
         if briefing:
-            output = f"Memory system healthy. {summary}\n\n--- Session Briefing ---\n{briefing}"
-        else:
-            output = f"Memory system healthy. {summary}"
-        print(json.dumps({"additionalContext": output}))
+            sections.append("--- Session Briefing ---\n" + briefing)
+
+        print(json.dumps({"additionalContext": "\n\n".join(sections)}))
         return
 
     # CLI not available -- provide fallback guidance