get-claudia 1.55.21 → 1.57.0

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

@@ -0,0 +1,73 @@
+{
+  "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",
+    ".claude/skills/agent-dispatcher.md": "b48fc5283f0a88d1ebbc692b30b6c326fef012d4168dcf721a94e3c954b76b90",
+    ".claude/skills/archetypes/_base-structure.md": "c0d8df77c07aa48cd9ba9c5ba3eddb533fcea790c7f98440fa3d31405fd5c75d",
+    ".claude/skills/archetypes/consultant.md": "1e0ccbf89115f92a1fa0c86b48edcce22668c4bb828ba4268376fcd6b5c05680",
+    ".claude/skills/archetypes/creator.md": "c364b60963c9794923fe9353d843bfca2f3ff86ca48dcb4b5539bf4545babd7a",
+    ".claude/skills/archetypes/executive.md": "0d43c5c2c6315f5a4d6d36150778b55229cc922e0491a80af54824d87ac52e82",
+    ".claude/skills/archetypes/founder.md": "a5bf3f22439c7c5f554c13966899a4af4de80f90c8f6a25eb62be1c68de6d54f",
+    ".claude/skills/archetypes/solo.md": "cc26332b96394775e62a0f1a06f32093be6147bb75fa3783aa271e554d323c6b",
+    ".claude/skills/brain/SKILL.md": "710d0defa5725a758868391f22f8518c189a5068ff376403eda431585b546b56",
+    ".claude/skills/brain-monitor/SKILL.md": "86d73e43ea09acdaa44db08454abfd0701805fe3e297d3f568119c9cb5a1f0cf",
+    ".claude/skills/capability-suggester.md": "33e559078098a532f216fa3668e48c248d10d5a7a9647c38ef6defe0e4a37361",
+    ".claude/skills/capture-meeting/SKILL.md": "c193bfd237a0f456ef04202d6eac609b2dd54dc6caabbb75c9df6456b563ea36",
+    ".claude/skills/capture-meeting/evals/basic.yaml": "47c4eb1479aeda8067bc877cebfe8688c9b2bb3ce09297e42375cdf558f412e3",
+    ".claude/skills/client-health/SKILL.md": "fed639e6f2c4433cab6a6b4b59776985492dda16be3bd1e843c3e94175936655",
+    ".claude/skills/commitment-detector.md": "66f9e919349d1880eb12636cec6f583be1b3fbe3b28f6180ec732d3c284af3b6",
+    ".claude/skills/connector-discovery.md": "8cf1067e840c377e0d65aae04e41fb7858da614c548cbf973421700915ad0ab3",
+    ".claude/skills/databases/SKILL.md": "b2ce4ae30aafa2487dabd7befd067976f0092fcef31dea7601e1683ceca0ef50",
+    ".claude/skills/deep-context/SKILL.md": "2d21f93e33191c226f46909a66d21c64c84df2ac261082adef78cd68093d7b07",
+    ".claude/skills/diagnose/SKILL.md": "8bfbae6c19afc64df9cc2a7048ee62a737d41cad33e22ba099a59369814ed50f",
+    ".claude/skills/diagnose/evals/basic.yaml": "7fa4e3a255f14d7dc883f59f8fd1d796a62db92d62a543ef87b5dda92a1c0c0b",
+    ".claude/skills/diagnose/references/common-issues.md": "f80b13d4b70e656151a4cb9db8c1f042378d1f6cb9f5ba8c550741d6bf34917c",
+    ".claude/skills/draft-reply/SKILL.md": "9f8210af7515c06ec15a65fa3692124c5482bdf661d82373604eb7fb670d3b97",
+    ".claude/skills/feedback/SKILL.md": "a8b5a1e82eca177461d11c87839dbf933e358fc3214d5f1975dd2d4fff9f3be7",
+    ".claude/skills/file-document/SKILL.md": "eb74255204f00d85909b7a3e083e1e5f6495cf4cdfedd3234aa7fabcde03d0d1",
+    ".claude/skills/financial-snapshot/SKILL.md": "33ddabb7d60024eadd8e6772229d8b17db3c3fa02d1289c80330c74aa86ae00a",
+    ".claude/skills/fix-duplicates/SKILL.md": "bd3d6aae0bce09bc844ba93f76abb4a97ff0286c6a4da29cd369763864fd4a86",
+    ".claude/skills/follow-up-draft/SKILL.md": "020f4bfab0845fecafd79fb72bb3a8655f8c50d6aa22c26427b489ae7f40a503",
+    ".claude/skills/growth-check/SKILL.md": "71ab16c6535d759397d97b2454cd007c1f6a3e2cab1bd6415b40989e61d987fe",
+    ".claude/skills/hire-agent.md": "c07014addd14ea132fb4b366fbeeccea000af85b7827db616da475be5ebf57ce",
+    ".claude/skills/inbox-check/SKILL.md": "c6746bd16b4f135cd4f28ebf4ce8dfe0c27c2a9a1fd6bda5676179fe02ed8666",
+    ".claude/skills/ingest-sources/SKILL.md": "07bbe32f7922e40b782314f3e0b968e547b755ede687ed3ab903caa954da6b4c",
+    ".claude/skills/ingest-sources/references/extraction-patterns.md": "28d6dc604c4a11eacfe4523e705ad430ba8fe26632bafcccaef656e9618e5aea",
+    ".claude/skills/judgment-awareness.md": "7dfb4b457319e7f33f18c5295a64cce88aae26feef5afac8b93a00376aeb939c",
+    ".claude/skills/map-connections/SKILL.md": "92f42d86a76185bced7d64739489f10b0a8b129c8902e5d9508a471e611b8692",
+    ".claude/skills/meditate/SKILL.md": "b67f030413c4b5327cb209e543ccce0b35f5e970f70d370ce21f65426f076e37",
+    ".claude/skills/meditate/evals/basic.yaml": "daba441b2fd9d1d4afddcff6eaa9673884198b1d0f85d9d06edbe0738012291a",
+    ".claude/skills/meeting-prep/SKILL.md": "f8e4a17b795b5bc1a098cfffba09992fb4eab0db36157525605984edf50b2463",
+    ".claude/skills/memory-audit/SKILL.md": "b1f44da062c9f51381e878c20043e28336850c5180b2839a191ecb23bb73ddb0",
+    ".claude/skills/memory-health/SKILL.md": "a8a6881c33b6f1c5249267edd4cdb6315c6f23764ca04ab1dce66b94d759a78a",
+    ".claude/skills/memory-manager.md": "62edf1ed340687da9d8896dc4a21934b39b12c8269ea7a8de1beb9d25fd894e6",
+    ".claude/skills/morning-brief/SKILL.md": "b3354754ce2d0bf43c202e0b0ccb40b473b695f37bd9085ea575b649de194cfa",
+    ".claude/skills/morning-brief/evals/basic.yaml": "537de9adcde134161de9ffb9602b8c920bf1464bf224d99ad6f95f854d8480b7",
+    ".claude/skills/new-person/SKILL.md": "46a08baf49f2eb9df2527772df6de9fa4cb47eaeb841d3ec26a4c52aeea91542",
+    ".claude/skills/new-person/evals/basic.yaml": "f3c09a37c05d420e67520d8132a46356fed81575dcfb817cc97caf47f230392b",
+    ".claude/skills/new-workspace/SKILL.md": "c3f838b44a016b87445c66555398b666970a156288320efb183bc8cb8af2f0df",
+    ".claude/skills/new-workspace/references/workspace-templates.md": "6b36e961f112d46f32fdcf19cdacf3b05b4246201be315eee79659d606a7e243",
+    ".claude/skills/onboarding.md": "72fe133672f61929de0cfc7ff77699eb8856ca1e283b13acd3becffff75fca55",
+    ".claude/skills/pattern-recognizer.md": "05aad9b25a259e437d8b25dc57f0e14af81a6e53152475a571e373117b59132c",
+    ".claude/skills/pipeline-review/SKILL.md": "7891ceb3b6f4fb19e5255ae71c5894b6da8a9c566bc317e566bd4bc282ea1a6f",
+    ".claude/skills/relationship-tracker.md": "02316fc25b141c5783b3428e297bf6513a530e8e89782115e65ad01add8bd869",
+    ".claude/skills/research/SKILL.md": "0d317e6350b043ee774916b923957f61dbc174e3caafc0187198fa236a2fd28d",
+    ".claude/skills/research/references/source-evaluation.md": "64614b7eff83468d7ff76dd640252579f23e69e760969672e9aebe5ceb00f695",
+    ".claude/skills/risk-surfacer.md": "c69e720660c1a8cfe340fcaa56b0c30db672856d6ea75296fc94781c9efe12af",
+    ".claude/skills/skill-index.json": "043c86f1b07f28bb54db80117437f60fb3d79ad0d18549fdc2c74921b996a56f",
+    ".claude/skills/structure-generator.md": "dbe70841ab60599a632687aaa3c3652361483df2fe854640c56982b60622eb19",
+    ".claude/skills/summarize-doc/SKILL.md": "f8119d070bd66d8a448276bcd355bf26a9e69de777760d376dcd9e68bd9d64ad",
+    ".claude/skills/vault-awareness.md": "5a9c3d3f0b907750b9941a51ec9308c2bd465aa9bf3c513124f640696e0a4c2c",
+    ".claude/skills/weekly-review/SKILL.md": "fe7df64d3df18a0a47f98f7d4ef83cf98cef78cd9e0170a9316005035a2c6df7",
+    ".claude/skills/what-am-i-missing/SKILL.md": "56736397717c4f0a25cab17e7258702e5b04d20b48727c262fdf66e3b2e5899f",
+    "CLAUDE.md": "8cbbebee457366978a9b7b1d8788ac569ab0670874728fd9324fed53df8845c2"
+  }
+}

package/template-v2/.claude/rules/claudia-principles.md

@@ -191,7 +191,7 @@ Each significant action gets confirmed individually. "Go ahead with everything"
 
 **I always file raw source material before extracting from it.**
 
-When someone shares a transcript, email, document, or any substantive source, I file the original via the `memory.file` MCP tool before extracting memories. This creates a provenance chain: every fact traces back to where I learned it.
+When someone shares a transcript, email, document, or any substantive source, I file the original via the `memory_file` MCP tool before extracting memories. This creates a provenance chain: every fact traces back to where I learned it.
 
 | Source Type | source_type |
 |-------------|-------------|
@@ -250,7 +250,7 @@ When you need to reference something volatile, store a pointer instead of a valu
 **Good:** "Beemok interview files are at workspaces/beemok/interviews/. Count files for current total."
 
 **Bad:** "Active commitments: send proposal to Sarah, review contract with Jim"
-**Good:** "Active commitments are tracked in context/commitments.md and via the `memory.recall` MCP tool"
+**Good:** "Active commitments are tracked in context/commitments.md and via the `memory_recall` MCP tool"
 
 ### The Timestamp Rule
 

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

@@ -6,15 +6,15 @@ This rule is always active and applies to every session. Follow it silently - do
 
 ## How Memory Works
 
-Claudia's memory is provided by the **claudia-memory daemon**, a Python MCP server that registers memory tools (e.g., `memory.recall`, `memory.remember`, `memory.about`). When the daemon is running and configured as an MCP server, these tools appear as callable MCP tools alongside other integrations.
+Claudia's memory is provided by the **claudia-memory daemon**, a Python MCP server that registers memory tools (e.g., `memory_recall`, `memory_remember`, `memory_about`). When the daemon is running and configured as an MCP server, these tools appear as callable MCP tools alongside other integrations.
 
 The `claudia` npm binary handles **setup and health checks only** (`claudia setup`, `claudia system-health`). It does not provide memory operations. All memory operations are MCP tools from the daemon.
 
-> **Migration note:** Some skill files may still reference old CLI syntax like `claudia memory recall "query" --project-dir "$PWD"`. Interpret these as calls to the equivalent MCP tool (e.g., `memory.recall` with a query parameter). The CLI subcommands for memory were never built; the MCP tools are the real interface.
+> **Migration note:** Some skill files may still reference old CLI syntax like `claudia memory recall "query" --project-dir "$PWD"`. Interpret these as calls to the equivalent MCP tool (e.g., `memory_recall` with a query parameter). The CLI subcommands for memory were never built; the MCP tools are the real interface.
 
 ## Mandatory Disclosure
 
-**This is non-negotiable.** If you reach the Session Start Protocol and the `memory.briefing` tool is not available (not in your tool palette), you MUST disclose this to the user in your greeting. Do not wait to be asked. Do not silently fall back to context files. The user trusts that you will be honest about your capabilities in each session.
+**This is non-negotiable.** If you reach the Session Start Protocol and the `memory_briefing` tool is not available (not in your tool palette), you MUST disclose this to the user in your greeting. Do not wait to be asked. Do not silently fall back to context files. The user trusts that you will be honest about your capabilities in each session.
 
 A single sentence is sufficient: "Heads up: my memory daemon isn't running this session, so I'm working from context files only."