get-claudia 1.56.1 → 1.57.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.57.0 (2026-05-13)
+
+### The Curated Memory Release
+
+Five PRs that complete one thesis: **curated, judgment-driven memory capture, enforced at prompt time and persisted across sessions.** Claudia now catches the user's intent when it matters, persists canonical facts as they emerge, and writes a daily session summary so context survives across days.
+
+#### Fixed
+- **PostToolUse hook actually runs (#38)** -- The hook was reading `os.environ.get("CLAUDE_TOOL_NAME")`, which Claude Code never sets. Every install since the hook landed had been silently no-op'ing, so `~/.claudia/observations.jsonl` was never written. The hook now reads its payload from stdin per the documented hook contract. Includes a sibling fix to the legacy `claudia/.claude/hooks/post-tool-capture.py` for codebase consistency.
+
+#### Added
+- **Memory-commitment rule (#39)** -- A new always-active rule (`template-v2/.claude/rules/memory-commitment.md`) codifies when to save canonical facts immediately via `memory_remember` / `memory_batch` rather than batching to end-of-session reflection. Trigger phrases include "lock this in," "remember this," "this is canonical." Substantive-artifact discipline: at the end of producing a multi-file artifact, do a memory commitment pass and save the canonical facts as one bundled `memory_batch` call.
+- **UserPromptSubmit hook with intent detection (#42)** -- A new hook (`template-v2/.claude/hooks/user-prompt-capture.py`) inspects the user's prompt at submit time and injects reminder context for two trigger classes. Class 1: canonical-fact phrases ("lock this in," "remember this," etc.) tell the agent to save immediately rather than wait for `/meditate`. Class 2: destructive command patterns (`rm -rf`, `git push --force`, `DROP TABLE`, etc.) trigger a "verify before acting" reminder per the safety-first principle. Destructive patterns are surfaced to the model as human-readable labels (`rm -rf (recursive delete)`), not raw regex, so the agent can reason about them clearly.
+- **Daily session summary system (#40)** -- A new SessionEnd hook (`template-v2/.claude/hooks/session-summary.py`) writes a per-session markdown summary to `~/.claudia/sessions/YYYY-MM-DD/NN-slug.md` covering opening prompt, files touched, external actions, and find-this-again references. SessionStart now surfaces a 3-day digest of recent sessions via the existing health-check hook, so future-Claudia knows what past-Claudia worked on. PostToolUse hook gained `file_path` extraction for Write/Edit/MultiEdit/NotebookEdit and `external_action` labels for git push, gh repo create, vercel/netlify deploy, supabase db push, and direct MCP sends.
+- **Explicit upgrade messaging (#50)** -- The installer now names `~/.claudia/` explicitly after an upgrade and lists what is preserved (entities, relationships, reflections, embeddings) instead of the generic "data preserved" phrasing. Users care about their accumulated memory graph; the previous wording did not signal that the database is safe.
+
+#### Changed
+- **External-action detection uses word-boundary regex (#40)** -- Previously a substring match, so `echo "git push for testing"` falsely fired the `external_action` flag. The new patterns anchor on command separators (line start, `;`, `&&`, `|`, `(`) and skip transparent prefixes (`sudo`, `nohup`, `time`, `env`). False positives on echoed/quoted strings are eliminated; real commands still fire.
+- **PostToolUse output truncation 200 -> 300 chars (#40)** -- Room for the richer output context that includes `file_path` and `external_action` labels alongside the truncated stdout/stderr.
+
+#### Stats
+- 41 new hook tests in `tests/hooks/` (stdlib `unittest`, zero new dependencies), all passing in ~1.5s
+- TDD sensitivity proofs for every behavior change: tests fail on the un-modified hook, pass after the fix
+- 5 PRs merged, 0 regressions
+
+#### Notes
+- The brief that drove this chain emphasized one principle: **trust the existing user-file preservation policy (commit `efce9f2`)** rather than inventing a new upgrade framework. The installer's behavior didn't change; only the messaging did.
+- The four hook PRs each landed with their own automated tests and TDD sensitivity proofs. The legacy `claudia/` subdirectory was kept in sync with the canonical `template-v2/` to avoid maintenance drift.
+
+---
+
 ## 1.56.1 (2026-04-11)
 
 ### Preserve User-Modified Skills on Upgrade

package/bin/index.js

@@ -877,7 +877,10 @@ async function main() {
     }
 
     console.log('');
-    console.log(` ${colors.cyan}✓${colors.reset} Framework updated (data preserved)`);
+    console.log(` ${colors.cyan}✓${colors.reset} Framework updated`);
+    console.log(`   • Your memory at ${colors.bold}~/.claudia/${colors.reset} is preserved (entities, relationships, reflections, embeddings).`);
+    console.log(`   • Skills and hooks refreshed; any modifications you chose to keep were respected.`);
+    console.log(`   • Restart Claude Code for changes to take effect.`);
   }
 
   // Self-heal: strip CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS from settings (#24)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.56.1",
+  "version": "1.57.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

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 noisy or read-only tools that don't need observation
 SKIP_PREFIXES = ("memory_", "memory.", "mcp__plugin_episodic", "cognitive.")
-SKIP_NAMES = {"Read", "Glob", "Grep", "LS", "ListMcpResourcesTool", "ReadMcpResourceTool"}
+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/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

package/template-v2/.claude/hooks/session-summary.py

@@ -0,0 +1,399 @@
+#!/usr/bin/env python3
+"""Generate a daily session summary markdown file from observations.jsonl.
+
+Designed to run from a SessionEnd hook OR manually for retrospective summaries.
+
+Output path: ~/.claudia/sessions/YYYY-MM-DD/NN-slug.md
+Plus an INDEX.md per day, auto-regenerated.
+
+Usage:
+    session-summary.py                    # uses CLAUDE_SESSION_ID env var or stdin JSON
+    session-summary.py <session_id>       # explicit session id
+    session-summary.py --rebuild-index    # regenerate today's INDEX.md only
+"""
+
+import json
+import os
+import re
+import sys
+import time
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+OBS_FILE = Path.home() / ".claudia" / "observations.jsonl"
+SESSIONS_DIR = Path.home() / ".claudia" / "sessions"
+
+# Words to filter out when deriving topic slugs
+STOPWORDS = {
+    "the", "a", "an", "and", "or", "but", "if", "of", "to", "for", "with",
+    "in", "on", "at", "by", "is", "are", "was", "were", "be", "been", "being",
+    "i", "you", "we", "us", "they", "this", "that", "these", "those",
+    "have", "has", "had", "do", "does", "did", "can", "could", "will",
+    "would", "should", "may", "might", "must", "let", "let's", "ok", "okay",
+    "yes", "no", "now", "go", "ahead", "please", "thanks", "today",
+    "use", "make", "get", "see", "look", "want",
+}
+
+
+def load_observations(session_id: str = None) -> list[dict]:
+    """Load observations from the JSONL file, optionally filtered by session_id."""
+    if not OBS_FILE.exists():
+        return []
+    obs = []
+    try:
+        with open(OBS_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    o = json.loads(line)
+                    if session_id and o.get("session_id") != session_id:
+                        continue
+                    obs.append(o)
+                except json.JSONDecodeError:
+                    continue
+    except OSError:
+        return []
+    return obs
+
+
+def first_user_prompt(transcript_path: str) -> str | None:
+    """Try to extract the first user prompt from a transcript file (JSONL of turns)."""
+    if not transcript_path or not Path(transcript_path).exists():
+        return None
+    try:
+        with open(transcript_path, "r", encoding="utf-8") as f:
+            for line in f:
+                try:
+                    turn = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                role = turn.get("role") or turn.get("type")
+                if role == "user":
+                    content = turn.get("content") or turn.get("text") or ""
+                    if isinstance(content, list):
+                        for block in content:
+                            if isinstance(block, dict) and block.get("type") == "text":
+                                return block.get("text", "")[:500]
+                    elif isinstance(content, str):
+                        return content[:500]
+    except OSError:
+        return None
+    return None
+
+
+def derive_topic_slug(observations: list[dict], first_prompt: str | None) -> str:
+    """Derive a 2-4 word topic slug from observations and first prompt."""
+    text_pool = []
+
+    if first_prompt:
+        text_pool.append(first_prompt)
+
+    for o in observations:
+        if o.get("file_path"):
+            parts = Path(o["file_path"]).parts
+            if len(parts) >= 2:
+                text_pool.append(parts[-2])
+
+    text_blob = " ".join(text_pool).lower()
+    words = re.findall(r"[a-z]{3,}", text_blob)
+    words = [w for w in words if w not in STOPWORDS]
+
+    if not words:
+        return "session"
+
+    counter = Counter(words)
+    top_words = [w for w, _ in counter.most_common(4)]
+    slug = "-".join(top_words[:3]) if top_words else "session"
+    return slug[:60]
+
+
+def session_window(observations: list[dict]) -> tuple[float, float]:
+    """Return (start_ts, end_ts) from observation timestamps."""
+    if not observations:
+        return (time.time(), time.time())
+    timestamps = [o.get("ts", 0) for o in observations if o.get("ts")]
+    if not timestamps:
+        return (time.time(), time.time())
+    return (min(timestamps), max(timestamps))
+
+
+def files_touched(observations: list[dict]) -> list[str]:
+    """Return unique file paths touched in this session, in order of first appearance."""
+    seen = []
+    seen_set = set()
+    for o in observations:
+        fp = o.get("file_path")
+        if fp and fp not in seen_set:
+            seen.append(fp)
+            seen_set.add(fp)
+    return seen
+
+
+def external_actions(observations: list[dict]) -> list[dict]:
+    """Return observations flagged with external_action."""
+    return [
+        {
+            "ts": o.get("ts"),
+            "tool": o.get("tool"),
+            "action": o.get("external_action"),
+            "input": o.get("input", "")[:200],
+        }
+        for o in observations if o.get("external_action")
+    ]
+
+
+def memory_entries_in_window(start_ts: float, end_ts: float) -> list[dict]:
+    """Best-effort fetch of memory entries created during the session window.
+
+    Relies on the claudia-memory daemon's HTTP endpoint if available.
+    Returns empty list if not reachable. The daemon does not currently
+    expose a /recent_memories endpoint; this is a placeholder for a
+    future enhancement.
+    """
+    try:
+        import urllib.request
+        url = f"http://localhost:3848/recent_memories?since={start_ts}&until={end_ts}"
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=2) as resp:
+            return json.loads(resp.read().decode("utf-8")).get("memories", [])
+    except Exception:
+        return []
+
+
+def next_session_number(date_dir: Path) -> int:
+    """Return the next sequential session number for the day."""
+    if not date_dir.exists():
+        return 1
+    existing = []
+    for f in date_dir.glob("[0-9][0-9]-*.md"):
+        match = re.match(r"^(\d{2})-", f.name)
+        if match:
+            existing.append(int(match.group(1)))
+    return (max(existing) + 1) if existing else 1
+
+
+def render_summary(
+    session_id: str,
+    date_str: str,
+    session_num: int,
+    topic_slug: str,
+    start_ts: float,
+    end_ts: float,
+    files: list[str],
+    actions: list[dict],
+    memories: list[dict],
+    first_prompt: str | None,
+    transcript_path: str | None,
+) -> str:
+    """Render the session summary markdown."""
+    duration_min = max(1, round((end_ts - start_ts) / 60))
+    started = datetime.fromtimestamp(start_ts, tz=timezone.utc).astimezone()
+    ended = datetime.fromtimestamp(end_ts, tz=timezone.utc).astimezone()
+
+    lines = [
+        f"# Session {session_num:02d} — {topic_slug.replace('-', ' ').title()}",
+        "",
+        f"**Date:** {date_str}",
+        f"**Started:** {started.strftime('%H:%M %Z')}",
+        f"**Ended:** {ended.strftime('%H:%M %Z')}",
+        f"**Duration:** ~{duration_min} min",
+        f"**Session ID:** `{session_id}`",
+        "",
+    ]
+
+    if first_prompt:
+        lines += [
+            "## Opening prompt",
+            "",
+            "> " + first_prompt.strip().split("\n")[0][:300],
+            "",
+        ]
+
+    lines += ["## Files touched", ""]
+    if files:
+        for f in files:
+            lines.append(f"- `{f}`")
+    else:
+        lines.append("- (none)")
+    lines.append("")
+
+    lines += ["## External actions", ""]
+    if actions:
+        for a in actions:
+            lines.append(f"- **{a.get('action')}** via `{a.get('tool')}` — `{a.get('input')[:120]}`")
+    else:
+        lines.append("- (none)")
+    lines.append("")
+
+    lines += ["## Memory entries created", ""]
+    if memories:
+        for m in memories[:30]:
+            mid = m.get("id") or m.get("memory_id") or "?"
+            content = (m.get("content") or "")[:200]
+            lines.append(f"- `mem-{mid}` — {content}")
+    else:
+        lines.append("- (none captured — memory daemon may not expose recent_memories endpoint)")
+    lines.append("")
+
+    if transcript_path:
+        lines += [
+            "## Find this again",
+            "",
+            f"- Transcript: `{transcript_path}`",
+            f"- Memory query: `\"{topic_slug.replace('-', ' ')}\"`",
+            "",
+        ]
+
+    lines += [
+        "---",
+        f"*Auto-generated by session-summary.py at {datetime.now().astimezone().strftime('%Y-%m-%d %H:%M %Z')}*",
+        "",
+    ]
+
+    return "\n".join(lines)
+
+
+def regenerate_index(date_dir: Path) -> None:
+    """Regenerate INDEX.md for a given day's folder."""
+    if not date_dir.exists():
+        return
+
+    sessions = []
+    for f in sorted(date_dir.glob("[0-9][0-9]-*.md")):
+        first_lines = f.read_text(encoding="utf-8").split("\n")[:6]
+        title = first_lines[0].lstrip("# ").strip() if first_lines else f.name
+        started = ""
+        for line in first_lines:
+            if line.startswith("**Started:**"):
+                started = line.replace("**Started:**", "").strip()
+                break
+        sessions.append((f.name, title, started))
+
+    date_str = date_dir.name
+    lines = [
+        f"# Sessions — {date_str}",
+        "",
+        f"*{len(sessions)} session(s) captured.*",
+        "",
+        "| # | Topic | Started | File |",
+        "|---|-------|---------|------|",
+    ]
+    for fname, title, started in sessions:
+        match = re.match(r"^(\d{2})-", fname)
+        num = match.group(1) if match else "??"
+        clean_title = title.split("—", 1)[1].strip() if "—" in title else title
+        lines.append(f"| {num} | {clean_title} | {started} | [`{fname}`](./{fname}) |")
+    lines += [
+        "",
+        f"*INDEX regenerated {datetime.now().astimezone().strftime('%Y-%m-%d %H:%M %Z')}*",
+        "",
+    ]
+    (date_dir / "INDEX.md").write_text("\n".join(lines), encoding="utf-8")
+
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] == "--rebuild-index":
+        date_str = sys.argv[2] if len(sys.argv) > 2 else datetime.now().astimezone().strftime("%Y-%m-%d")
+        regenerate_index(SESSIONS_DIR / date_str)
+        print(json.dumps({"action": "rebuild-index", "date": date_str}))
+        return
+
+    session_id = ""
+    transcript_path = ""
+
+    if len(sys.argv) > 1:
+        session_id = sys.argv[1]
+    else:
+        session_id = os.environ.get("CLAUDE_SESSION_ID", "")
+        # Try stdin (SessionEnd hook contract)
+        if not session_id and not sys.stdin.isatty():
+            try:
+                raw = sys.stdin.read()
+                if raw.strip():
+                    payload = json.loads(raw)
+                    session_id = payload.get("session_id", "")
+                    transcript_path = payload.get("transcript_path", "")
+            except (json.JSONDecodeError, OSError):
+                pass
+
+    if not session_id:
+        print(json.dumps({"error": "no session_id provided"}))
+        return
+
+    observations = load_observations(session_id)
+    if not observations:
+        print(json.dumps({"warning": "no observations for session", "session_id": session_id}))
+        return
+
+    start_ts, end_ts = session_window(observations)
+    date_str = datetime.fromtimestamp(start_ts, tz=timezone.utc).astimezone().strftime("%Y-%m-%d")
+    date_dir = SESSIONS_DIR / date_str
+    date_dir.mkdir(parents=True, exist_ok=True)
+
+    first_prompt = first_user_prompt(transcript_path) if transcript_path else None
+    topic_slug = derive_topic_slug(observations, first_prompt)
+
+    # Check if a summary for this session already exists; overwrite with latest data
+    existing_file = None
+    session_num = next_session_number(date_dir)
+    for existing in date_dir.glob("[0-9][0-9]-*.md"):
+        try:
+            content = existing.read_text(encoding="utf-8")
+            if f"`{session_id}`" in content:
+                existing_file = existing
+                match = re.match(r"^(\d{2})-", existing.name)
+                if match:
+                    session_num = int(match.group(1))
+                break
+        except OSError:
+            continue
+
+    files = files_touched(observations)
+    actions = external_actions(observations)
+    memories = memory_entries_in_window(start_ts, end_ts)
+
+    summary = render_summary(
+        session_id=session_id,
+        date_str=date_str,
+        session_num=session_num,
+        topic_slug=topic_slug,
+        start_ts=start_ts,
+        end_ts=end_ts,
+        files=files,
+        actions=actions,
+        memories=memories,
+        first_prompt=first_prompt,
+        transcript_path=transcript_path,
+    )
+
+    out_file = date_dir / f"{session_num:02d}-{topic_slug}.md"
+
+    # If existing file had a different topic slug, remove the stale name
+    if existing_file and existing_file != out_file:
+        try:
+            existing_file.unlink()
+        except OSError:
+            pass
+
+    out_file.write_text(summary, encoding="utf-8")
+    regenerate_index(date_dir)
+
+    print(json.dumps({
+        "ok": True,
+        "session_id": session_id,
+        "file": str(out_file),
+        "files_touched": len(files),
+        "external_actions": len(actions),
+        "memories_in_window": len(memories),
+        "updated": existing_file is not None,
+    }))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(json.dumps({"error": str(e)[:200]}))

package/template-v2/.claude/hooks/user-prompt-capture.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook: detect canonical-fact trigger phrases and destructive
+verbs in user prompts, inject reminder context for the agent.
+
+Reads hook payload from stdin (Claude Code hook contract).
+Outputs JSON with additionalContext when triggers fire. Outputs nothing otherwise.
+
+Designed to complete in <5ms (regex match + simple JSON output, no network).
+
+Two trigger classes:
+1. Memory-commitment phrases ("lock this in", "remember this", "this is canonical")
+   -> Inject reminder for the agent to save the fact to memory immediately,
+      per the memory-commitment rule (which governs tool selection).
+2. Destructive operation patterns (rm -rf, drop table, force push, etc.)
+   -> Inject "verify before acting" reminder per Claudia's safety-first principle.
+
+Both classes can fire on the same prompt; both messages are concatenated.
+"""
+
+import json
+import re
+import sys
+
+# Trigger phrases that signal the user is asserting a canonical fact.
+# Word boundaries (\b) used to avoid matching inside other words.
+COMMITMENT_TRIGGERS = [
+    r"\block this in\b",
+    r"\bremember this\b",
+    r"\bthis is canonical\b",
+    r"\bthis is locked\b",
+    r"\bsave this for later\b",
+    r"\bimportant to remember\b",
+    r"\bfor the record\b",
+    r"\bdon'?t forget\b",
+]
+
+# Destructive operation patterns. Narrow matches to limit false positives.
+# Conversation about deletion ("how do I undo a delete?") should NOT fire these.
+DESTRUCTIVE_PATTERNS = [
+    r"\brm\s+-rf\b",
+    r"\bdrop\s+(table|database|schema)\b",
+    r"\bgit\s+push\s+(?:-+f\b|--force\b)",
+    r"\bgit\s+reset\s+--hard\b",
+    r"\btruncate\s+table\b",
+    r"\bDELETE\s+FROM\b",  # SQL all-caps signals intent
+]
+
+# Human-readable labels for each destructive pattern. Keep keys in lockstep
+# with DESTRUCTIVE_PATTERNS so the model never sees raw regex syntax.
+PATTERN_LABELS = {
+    r"\brm\s+-rf\b": "rm -rf (recursive delete)",
+    r"\bdrop\s+(table|database|schema)\b": "DROP TABLE/DATABASE/SCHEMA",
+    r"\bgit\s+push\s+(?:-+f\b|--force\b)": "git push --force",
+    r"\bgit\s+reset\s+--hard\b": "git reset --hard",
+    r"\btruncate\s+table\b": "TRUNCATE TABLE",
+    r"\bDELETE\s+FROM\b": "DELETE FROM (SQL)",
+}
+
+# Fail-fast at import time if a pattern is missing a label (or vice versa).
+assert set(DESTRUCTIVE_PATTERNS) == set(PATTERN_LABELS), (
+    "Every DESTRUCTIVE_PATTERN must have a matching PATTERN_LABELS entry"
+)
+
+
+def detect(text: str, patterns: list) -> list:
+    """Return list of pattern strings that matched in the text."""
+    return [p for p in patterns if re.search(p, text, re.IGNORECASE)]
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return
+        payload = json.loads(raw)
+    except (json.JSONDecodeError, OSError):
+        return
+
+    # Claude Code passes the user's prompt under "prompt" (newer) or "text" (older).
+    prompt = payload.get("prompt") or payload.get("text") or ""
+    if not prompt:
+        return
+
+    commitment_hits = detect(prompt, COMMITMENT_TRIGGERS)
+    destructive_hits = detect(prompt, DESTRUCTIVE_PATTERNS)
+
+    if not commitment_hits and not destructive_hits:
+        return
+
+    sections = []
+
+    if commitment_hits:
+        sections.append(
+            "**Canonical-fact trigger detected.** Per the memory-commitment rule, "
+            "save the canonical fact to memory immediately. Do not batch to "
+            "/meditate. After saving, continue the conversation normally and "
+            "briefly surface that the fact has been recorded so the user knows "
+            "it is recoverable in future sessions."
+        )
+
+    if destructive_hits:
+        # Show up to three matched patterns for context, using human-readable
+        # labels so raw regex syntax never reaches the model.
+        labels_list = ", ".join(
+            f"`{PATTERN_LABELS[p]}`" for p in destructive_hits[:3]
+        )
+        sections.append(
+            f"**Destructive operation pattern detected** ({labels_list}). "
+            "Per the safety-first principle, verify with the user before executing: "
+            "show what will happen (recipients, content, irreversible effects), ask "
+            "for explicit confirmation, then proceed only on a clear yes. Silence or "
+            "ambiguity means do not proceed."
+        )
+
+    output = {"additionalContext": "\n\n".join(sections)}
+    print(json.dumps(output))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        pass  # Never block Claude

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

@@ -1,11 +1,12 @@
 {
-  "version": "1.56.1",
-  "generated": "2026-04-11T14:57:44.529Z",
+  "version": "1.57.0",
+  "generated": "2026-05-13T09:56:45.377Z",
   "algorithm": "sha256",
   "files": {
     ".claude/rules/claudia-principles.md": "b1c5e33aeb33857f3485231e5ed34a441c3cc4568b69e3341be770963418a240",
     ".claude/rules/data-freshness.md": "052b3b8f3f489a54fff065b29e0ffc46bfad6da1c3a42386170034f298599233",
     ".claude/rules/memory-availability.md": "48309e2683b267c0a17ebf019fb3ee1116150d811b1d93b4ddb52fed89ae1fe3",
+    ".claude/rules/memory-commitment.md": "49eee330b56c6ca0b5f1e01550931c4eef3dcb3249e3d0e2380de3e8dbfe31a8",
     ".claude/rules/shell-compatibility.md": "565977bc04e269b3ce7d8a7963173df4f44bb9634692ea76abb1b64f6a67513e",
     ".claude/rules/trust-north-star.md": "0188b17c26b791cf597ce975bb75d40f543aa3d6b84b7edb1309b78530b3d43f",
     ".claude/skills/README.md": "f84c553ff5bc01f7a9a479b7358dbd16a60ee2ba11e01467fe1ed3d91e33e68e",

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/gitignore

@@ -1,35 +0,0 @@
-# Dependencies
-node_modules/
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# Editor files
-*.swp
-*.swo
-*~
-.idea/
-.vscode/
-
-# Environment files
-.env
-.env.local
-.env.*.local
-
-# Logs
-*.log
-npm-debug.log*
-
-# Sensitive files
-credentials.json
-*.pem
-*.key
-
-# Build artifacts
-dist/
-build/
-
-# Temporary files
-*.tmp
-*.temp