kyp-mem 0.5.1 → 0.6.1

package/README.md

@@ -5,7 +5,7 @@
 
 KYP-MEM gives AI coding agents two-layer memory:
 
-- **Session Memory(Episodic)** → remembers what happened across coding sessions
+- **Session Memory (Episodic)** → remembers what happened across coding sessions
 
 - **Project Intelligence** → understands architecture, decisions, docs, and relationships
 
@@ -27,74 +27,74 @@ By intercepting the prompt, KYP-MEM automatically provided the agent with:
 - The vectorized semantic search results of past session logs.
 - The relevant markdown files from the project knowledge base.
 
-
-
-
-## How it works
+## How It Works
 
 KYP-MEM operates as a Model Context Protocol (MCP) server that runs silently in the background, integrating directly with Claude Code.
 
-## Two-Layer Memory System
+### 1. Episodic Memory (Sessions)
 
-### 1. Episodic Memory
+Every coding session is automatically captured with full context:
 
-Every coding session is automatically captured:
+- User prompts (what was asked)
+- File reads with content (what was found)
+- File edits with diffs (what changed and why)
+- Command outputs (what happened)
 
-- prompts
-- commands
-- files changed
-- bugs investigated
-- decisions made
+At session end, Claude Sonnet synthesizes raw activity into a structured summary with **Summary**, **Investigated**, **Learned**, **Completed**, and **Next Steps** sections. Sessions are semantically searchable via ChromaDB vector embeddings.
 
-Sessions are semantically searchable.
+### 2. Project Intelligence (Vault)
 
-### 2. Project Intelligence
+KYP-MEM maintains structured project knowledge as Markdown files with `[[wikilinks]]`:
 
-KYP-MEM maintains structured project knowledge:
+- Architecture docs, API references, setup guides
+- Known issues, decision history, linked concepts
 
-- architecture
-- APIs
-- setup docs
-- known issues
-- linked concepts
-- decision history
+The agent searches this on-demand via `kyp_search` when it needs project context.
 
-The agent continuously updates this knowledge as it learns.
+### How It All Connects
 
-1. **Vault Storage:** Your knowledge base and session logs are stored locally as Markdown files in your `~/.kyp-mem/vault` directory.
-2. **Vector Database:** Session logs are embedded into a local ChromaDB vector database, enabling semantic search ("Find me the session where we debugged the database connection").
-3. **Auto-Learning Hooks:** KYP-MEM hooks into Claude Code's execution lifecycle. It silently listens to prompts, file reads, edits, and terminal commands. When a session ends, it automatically generates a comprehensive summary and timeline using an LLM and saves it to your Vault.
-4. **Agent Tooling:** Claude is equipped with 14 custom MCP tools to read, write, search, and navigate your project's knowledge graph using `[[wikilinks]]`.
+1. **Session Start:** Recent session summaries are injected automatically — the agent knows what happened last time.
+2. **During Work:** Hooks capture tool activity (reads, edits, commands) with actual content, not just file names.
+3. **Session End:** Sonnet synthesizes a rich, semantic summary and saves it to the vault + vector DB.
+4. **Future Sessions:** The agent can search past sessions semantically or look up project knowledge on demand.
 
 ## Installation
 
 ```bash
-npm i kyp-mem
-
-pip install kyp-mem (coming soon)
+npm install -g kyp-mem
 ```
 
-## Setup
+That's it. The postinstall script automatically:
 
-Run the initialization commands to get started:
+1. Installs the Python package
+2. Creates the default vault at `~/.kyp-mem/vault`
+3. Registers the MCP server with Claude Code
+4. Installs session capture hooks
 
-```bash
-kyp-mem init              # Choose where to store your vault
-kyp-mem setup-claude      # Register the MCP server with Claude Code
-kyp-mem install-hooks     # Enable automatic session capture (Episodic Memory)
-```
+Restart Claude Code and you're ready to go.
+
+### Requirements
 
-Restart Claude Code. The agent will automatically have access to the memory tools.
+- Node.js 18+
+- Python 3.10+
+- Claude Code CLI
+- Anthropic API key (for session summarization with Sonnet)
 
-*(To enable globally for all projects run: `kyp-mem setup-claude --global` and `kyp-mem install-hooks --global`)*
+### Custom Vault Path
+
+If you want to store your vault somewhere other than `~/.kyp-mem/vault`:
+
+```bash
+kyp-mem init    # Interactive prompt to choose vault location
+```
 
 ## The Agent's Workflow
 
-KYP-MEM embeds behavioral instructions directly into its tools. Without any prompting required from you, the agent will automatically:
+KYP-MEM embeds behavioral instructions directly into its tools. Without any prompting from you, the agent will automatically:
 
-1. **Load Context:** On session start, it loads the project's ground truth (`Knowledge.md`) and recent session summaries.
-2. **Search Before Acting:** Before investigating bugs or making architectural decisions, it searches past episodic memory to avoid repeating work.
-3. **Persist Knowledge:** After fixing a bug or making a decision, it uses its tools to update the project's knowledge base for future sessions.
+1. **Load Context:** On session start, it loads recent session summaries so it knows what happened last time.
+2. **Search Before Acting:** Before investigating bugs or making decisions, it searches past sessions to avoid repeating work.
+3. **Persist Knowledge:** After fixing a bug or making a decision, it updates the project's knowledge base for future sessions.
 
 ## Web UI
 
@@ -109,14 +109,29 @@ kyp-mem ui
 
 | Command | Description |
 |---------|-------------|
-| `kyp-mem init` | First-time setup — choose vault location |
+| `kyp-mem init` | Choose vault location (default: `~/.kyp-mem/vault`) |
 | `kyp-mem setup-claude` | Register MCP server with Claude Code |
 | `kyp-mem install-hooks` | Enable automatic session capture |
 | `kyp-mem serve` | Start MCP server (stdio, used by the agent) |
 | `kyp-mem ui` | Open the local web UI |
 | `kyp-mem stats` | Print vault statistics |
 | `kyp-mem tree` | Print vault file tree |
+| `kyp-mem config` | View or set configuration (e.g. `kyp-mem config session_model`) |
 | `kyp-mem doctor` | Check installation and configuration health |
+| `kyp-mem uninstall` | Remove hooks and MCP server from Claude Code |
+
+## Uninstall
+
+```bash
+# Remove from Claude Code (keeps your vault data)
+kyp-mem uninstall
+
+# Remove from Claude Code AND delete all data
+kyp-mem uninstall --purge
+
+# Remove the npm package
+npm uninstall -g kyp-mem
+```
 
 ## License
 

package/bin/cli.mjs

@@ -84,22 +84,29 @@ if (args[0] === "hook") {
       if (tool.includes("kyp-mem") || tool.includes("kyp_mem")) process.exit(0);
 
       const input = data.tool_input || {};
+      const rawResp = data.tool_response || "";
+      const resp = (typeof rawResp === "string" ? rawResp : JSON.stringify(rawResp)).slice(0, 2000);
       const entry = { ts: new Date().toISOString(), tool, cwd: process.cwd() };
 
       if (tool === "Edit" || tool === "Write") {
         entry.file = input.file_path || "";
         entry.action = tool === "Edit" ? "edit" : "create";
+        if (input.old_string) entry.old_string = input.old_string.slice(0, 500);
+        if (input.new_string) entry.new_string = input.new_string.slice(0, 500);
       } else if (tool === "Read") {
         entry.file = input.file_path || "";
         entry.action = "read";
+        entry.content = resp;
       } else if (tool === "Bash") {
         entry.command = (input.command || "").slice(0, 300);
         entry.action = "command";
+        entry.output = resp;
       } else {
         entry.action = "other";
         entry.detail = tool;
       }
 
+      entry.response_chars = (typeof rawResp === "string" ? rawResp : JSON.stringify(rawResp)).length;
       mkdirSync(sessionDir, { recursive: true });
       appendFileSync(sessionFile, JSON.stringify(entry) + "\n");
     } catch (_) {
@@ -118,6 +125,16 @@ if (args[0] === "hook") {
     process.exit(0);
   }
 
+  if (hookType === "session-start") {
+    const py = findPython();
+    if (py) {
+      const [cmd, pre] = py;
+      const r = run(cmd, [...pre, "-m", "kyp_mem.cli", "hook", "session-start"], "inherit");
+      process.exit(r.status ?? 0);
+    }
+    process.exit(0);
+  }
+
   console.error("Unknown hook type:", hookType);
   process.exit(1);
 }

package/bin/install.mjs

@@ -1,12 +1,20 @@
 #!/usr/bin/env node
 
 import { spawnSync } from "child_process";
+import { mkdirSync } from "fs";
+import { homedir } from "os";
 import { fileURLToPath } from "url";
-import { dirname, resolve } from "path";
+import { dirname, join, resolve } from "path";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const root = resolve(__dirname, "..");
 
+const G = "\x1b[32m";
+const Y = "\x1b[33m";
+const C = "\x1b[36m";
+const D = "\x1b[90m";
+const R = "\x1b[0m";
+
 function run(command, args, options = {}) {
   return spawnSync(command, args, {
     cwd: root,
@@ -53,25 +61,68 @@ if (process.env.KYP_MEM_SKIP_PYTHON_INSTALL === "1") {
 const python = findPython();
 
 if (!python) {
-  console.log("  \x1b[33m!\x1b[0m Python 3 was not found.");
-  console.log("  \x1b[33m!\x1b[0m Install Python 3.10+ and run: python3 -m pip install --user .");
+  console.log(`  ${Y}!${R} Python 3 was not found.`);
+  console.log(`  ${Y}!${R} Install Python 3.10+ and run: python3 -m pip install --user .`);
   process.exit(0);
 }
 
 const [pythonCommand, pythonPrefixArgs] = python;
 
-console.log("  Installing kyp-mem Python package...");
+// Step 1: Install Python package
+console.log(`  Installing kyp-mem Python package...`);
 
-const result = run(
+const pipResult = run(
   pythonCommand,
   [...pythonPrefixArgs, "-m", "pip", "install", "--user", "."],
   { stdio: "inherit" },
 );
 
-if (result.status === 0) {
-  console.log("  \x1b[32m✓\x1b[0m kyp-mem installed successfully");
-} else {
-  console.log("  \x1b[33m!\x1b[0m Could not auto-install the Python package.");
-  console.log(`  \x1b[33m!\x1b[0m Run manually from ${root}:`);
+if (pipResult.status !== 0) {
+  console.log(`  ${Y}!${R} Could not auto-install the Python package.`);
+  console.log(`  ${Y}!${R} Run manually from ${root}:`);
   console.log("    python3 -m pip install --user .");
+  process.exit(0);
+}
+
+console.log(`  ${G}✓${R} Python package installed`);
+
+// Step 2: Create default vault directory
+const vaultDir = join(homedir(), ".kyp-mem", "vault");
+try {
+  mkdirSync(vaultDir, { recursive: true });
+  console.log(`  ${G}✓${R} Vault ready at ${D}${vaultDir}${R}`);
+} catch (_) {
+  console.log(`  ${Y}!${R} Could not create vault at ${vaultDir}`);
 }
+
+// Step 3: Register MCP server with Claude Code (global)
+const setupResult = run(
+  pythonCommand,
+  [...pythonPrefixArgs, "-m", "kyp_mem.cli", "setup-claude", "--global"],
+  { stdio: "inherit" },
+);
+
+if (setupResult.status === 0) {
+  console.log(`  ${G}✓${R} MCP server registered with Claude Code`);
+} else {
+  console.log(`  ${Y}!${R} Could not register MCP server — run manually: ${C}kyp-mem setup-claude --global${R}`);
+}
+
+// Step 4: Install hooks (global)
+const hooksResult = run(
+  pythonCommand,
+  [...pythonPrefixArgs, "-m", "kyp_mem.cli", "install-hooks", "--global"],
+  { stdio: "inherit" },
+);
+
+if (hooksResult.status === 0) {
+  console.log(`  ${G}✓${R} Session capture hooks installed`);
+} else {
+  console.log(`  ${Y}!${R} Could not install hooks — run manually: ${C}kyp-mem install-hooks --global${R}`);
+}
+
+console.log();
+console.log(`  ${C}KYP-MEM${R} is ready! Restart Claude Code to activate.`);
+console.log(`  ${D}Vault: ${vaultDir}${R}`);
+console.log(`  ${D}To customize vault path: kyp-mem init${R}`);
+console.log();

package/kyp_mem/cli.py

@@ -41,6 +41,8 @@ def main():
                     help="Add hooks to global ~/.claude/settings.json (default: project)")
     ih.add_argument("--remove", action="store_true", help="Remove KYP-MEM hooks")
 
+    un = subparsers.add_parser("uninstall", help="Remove KYP-MEM from Claude Code (hooks + MCP server)")
+    un.add_argument("--purge", action="store_true", help="Also delete vault data and config at ~/.kyp-mem")
     subparsers.add_parser("doctor", help="Check installation and config health")
 
     cfg_parser = subparsers.add_parser("config", help="Get or set configuration values")
@@ -77,6 +79,8 @@ def main():
         _run_install_hooks(global_config=args.global_config, remove=args.remove)
     elif args.command == "config":
         _run_config(args.key, args.value)
+    elif args.command == "uninstall":
+        _run_uninstall(purge=args.purge)
     elif args.command == "doctor":
         _run_doctor()
     elif args.command == "hook":
@@ -129,8 +133,24 @@ def _run_init():
     print(f"  {G}✓{R} Vault:  {vault_path}")
     print(f"  {G}✓{R} Config: {CONFIG_FILE}")
     print()
-    print(f"  {Y}Next step:{R} Connect to Claude Code:")
-    print(f"    {Y}kyp-mem setup-claude{R}")
+
+    claude_settings = Path.home() / ".claude" / "settings.json"
+    already_setup = False
+    if claude_settings.exists():
+        try:
+            cs = json.loads(claude_settings.read_text())
+            has_mcp = "kyp-mem" in cs.get("mcpServers", {})
+            has_hooks = any("kyp-mem" in str(h) for h in cs.get("hooks", {}).get("Stop", []))
+            already_setup = has_mcp and has_hooks
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    if already_setup:
+        print(f"  {G}✓{R} Claude Code already configured (MCP server + hooks)")
+        print(f"  {D}  Restart Claude Code if you changed the vault path.{R}")
+    else:
+        print(f"  {Y}Next step:{R} Connect to Claude Code:")
+        print(f"    {Y}kyp-mem setup-claude --global && kyp-mem install-hooks --global{R}")
     print()
 
 
@@ -267,7 +287,46 @@ def _write_legacy_claude_settings(
     return settings_path
 
 
-def _run_install_hooks(global_config: bool = False, remove: bool = False):
+def _run_uninstall(purge: bool = False):
+    from .config import CONFIG_DIR
+
+    print()
+    print(f"  {C}KYP-MEM{R} — Uninstall")
+    print()
+
+    # Remove hooks from global settings
+    _run_install_hooks(global_config=True, remove=True)
+
+    # Remove MCP server from Claude Code
+    claude_bin = shutil.which("claude")
+    if claude_bin:
+        subprocess.run(
+            [claude_bin, "mcp", "remove", "-s", "user", "kyp-mem"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, text=True,
+        )
+        print(f"  {G}✓{R} MCP server removed from Claude Code")
+    else:
+        print(f"  {Y}!{R} 'claude' CLI not found — remove kyp-mem MCP server manually")
+
+    if purge:
+        import shutil as sh
+        if CONFIG_DIR.exists():
+            sh.rmtree(CONFIG_DIR)
+            print(f"  {G}✓{R} Deleted {CONFIG_DIR} (vault, config, sessions)")
+        else:
+            print(f"  {D}  {CONFIG_DIR} does not exist{R}")
+
+    print()
+    print(f"  To finish, remove the npm package:")
+    print(f"    {Y}npm uninstall -g kyp-mem{R}")
+    print()
+    if not purge:
+        print(f"  {D}Your vault data at {CONFIG_DIR} was kept.{R}")
+        print(f"  {D}To delete it too: kyp-mem uninstall --purge{R}")
+        print()
+
+
+
     mcp_command, _ = _get_mcp_command()
 
     if global_config:

package/kyp_mem/config.py

@@ -34,4 +34,4 @@ def get_vault_path() -> str:
 
 def get_session_model() -> str:
     config = load_config()
-    return config.get("session_model", "claude-haiku-4-5-20251001")
+    return config.get("session_model", "claude-sonnet-4-6")

package/kyp_mem/hooks.py

@@ -9,7 +9,7 @@ from pathlib import Path
 SESSION_DIR = Path.home() / ".kyp-mem" / "sessions"
 CURRENT_SESSION = SESSION_DIR / "current.jsonl"
 
-MIN_ACTIONS = 3
+MIN_ACTIONS = 5
 CHARS_PER_TOKEN = 4
 
 COMMAND_OUTPUT_ESTIMATES = {
@@ -74,7 +74,7 @@ def _record_injection(project, chars):
 
 
 def handle_session_start():
-    """Inject project context into the conversation at session start."""
+    """Inject recent session memory into the conversation at session start."""
     sys.stdin.read()
 
     cwd = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
@@ -90,58 +90,31 @@ def handle_session_start():
         if not project_notes:
             return
 
-        parts = [f"# [kyp-mem] {project_name} — Project Context"]
-        parts.append(f"Vault: {get_vault_path()}")
-        parts.append("")
-
-        knowledge_path = f"{project_name}/Knowledge.md"
-        knowledge = vault.read(knowledge_path)
-        if knowledge:
-            parts.append("## Knowledge")
-            content = knowledge.content
-            timeline_idx = content.find("## Timeline")
-            if timeline_idx > 0:
-                content = content[:timeline_idx].strip()
-            if len(content) > 2000:
-                parts.append(content[:2000] + "\n...")
-            else:
-                parts.append(content)
-            parts.append("")
-
-        other_notes = sorted(
-            p for p in project_notes
-            if "/Sessions/" not in p and p != knowledge_path
-        )
-        if other_notes:
-            parts.append("## Project Notes")
-            for p in other_notes:
-                note = vault.index.notes.get(p)
-                title = note.title if note else p
-                tags = f" [{', '.join(note.tags)}]" if note and note.tags else ""
-                parts.append(f"- {title} ({p}){tags}")
-            parts.append("")
-
         sessions = sorted(
             (p for p in project_notes if "/Sessions/" in p),
             reverse=True,
         )[:3]
-        if sessions:
-            parts.append(f"## Recent Sessions (last {len(sessions)})")
-            for sp in sessions:
-                note = vault.read(sp)
-                if not note:
-                    continue
-                parts.append(f"### {note.title}")
-                content = note.content
-                timeline_idx = content.find("## Timeline")
-                if timeline_idx > 0:
-                    content = content[:timeline_idx].strip()
-                if len(content) > 300:
-                    content = content[:300] + "..."
-                parts.append(content)
-                parts.append("")
+        if not sessions:
+            return
 
-        parts.append("Use `kyp_project_context` for full details. Use `kyp_session_search` to search past sessions.")
+        parts = [f"# [kyp-mem] {project_name} — Recent Sessions"]
+        parts.append(f"Use `kyp_search` or `kyp_project_context` for architecture/project knowledge on demand.")
+        parts.append("")
+
+        parts.append(f"## Last {len(sessions)} Sessions")
+        for sp in sessions:
+            note = vault.read(sp)
+            if not note:
+                continue
+            parts.append(f"### {note.title}")
+            content = note.content
+            timeline_idx = content.find("## TIMELINE")
+            if timeline_idx < 0:
+                timeline_idx = content.find("## Timeline")
+            if timeline_idx > 0:
+                content = content[:timeline_idx].strip()
+            parts.append(content)
+            parts.append("")
 
         output = "\n".join(parts)
         try:
@@ -195,13 +168,25 @@ def handle_post_tool_use():
     cwd = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
     entry["cwd"] = cwd
 
-    # Measure response size for token economics
     tool_response = data.get("tool_response", "")
-    response_chars = len(str(tool_response)) if tool_response else 0
+    if isinstance(tool_response, str):
+        resp_str = tool_response
+    elif tool_response:
+        resp_str = json.dumps(tool_response)
+    else:
+        resp_str = ""
+    response_chars = len(resp_str)
+    resp_truncated = resp_str[:2000]
 
     if tool_name == "Edit":
         entry["action"] = "edit"
         entry["file"] = tool_input.get("file_path", "")
+        old_s = tool_input.get("old_string", "")
+        new_s = tool_input.get("new_string", "")
+        if old_s:
+            entry["old_string"] = old_s[:500]
+        if new_s:
+            entry["new_string"] = new_s[:500]
     elif tool_name == "Write":
         entry["action"] = "create"
         entry["file"] = tool_input.get("file_path", "")
@@ -214,10 +199,12 @@ def handle_post_tool_use():
             except OSError:
                 pass
         entry["response_chars"] = response_chars
+        entry["content"] = resp_truncated
     elif tool_name == "Bash":
         entry["action"] = "command"
         entry["command"] = tool_input.get("command", "")
         entry["response_chars"] = response_chars
+        entry["output"] = resp_truncated
     else:
         return
 
@@ -418,53 +405,62 @@ def _build_next_steps(files_edited, files_created, commands_classified):
 
 
 def _summarize_with_claude(raw_note, project_name):
-    """Use Claude to rewrite session sections in plain, human-readable language."""
+    """Use Claude CLI to rewrite session sections — uses existing Claude Code auth."""
     try:
-        from .config import get_session_model
-        import anthropic
+        import shutil
+        claude_bin = shutil.which("claude")
+        if not claude_bin:
+            return None
 
+        from .config import get_session_model
         model = get_session_model()
-        client = anthropic.Anthropic()
 
-        prompt = f"""Summarize this coding session for "{project_name}" in plain English. A future AI agent will read this to understand what happened — write for that audience.
+        prompt = f"""Rewrite this raw coding session into a structured summary. A future AI agent reads this to pick up where you left off — be precise and technical.
+
+You have: user prompts (the objectives), a timeline of file edits/reads/commands with their actual content and output. Synthesize into a dense, specific narrative.
 
-You have: user prompts (what was asked), a timeline of file edits/reads/commands (what happened), and raw section data. Synthesize these into a coherent narrative.
+## Format rules
 
-Rules:
-- Summary: 2-3 sentences. State the objective (from prompts), what was done, and the outcome. Be specific: "Fixed navigation bug where clicking sessions broke the back button" not "Modified files and ran commands."
-- INVESTIGATED: What was explored and WHY. "Examined the session hook pipeline to understand why summaries were empty" not "Searched for `session-view`". Max 4 bullets.
-- LEARNED: Insights or discoveries. "The config CLI command was defined but never wired to the dispatcher" not "Investigated and modified: `cli.py`". Max 4 bullets.
-- COMPLETED: Concrete deliverables. "Added AI-powered session summarization using Claude Haiku" not "Modified `hooks.py`". Max 5 bullets.
-- NEXT STEPS: What should happen next session. Infer from context — unfinished work, unfixed bugs, natural follow-ups. Max 3 bullets.
+- **Summary**: 1-2 sentences. State what was done and the outcome. Include error messages, feature names, or bug descriptions verbatim. Example: 'Debugged and fixed "Unknown hook type: session-start" error in kyp-mem; cleaned repository of session-specific files and prepared for release'
+- **INVESTIGATED**: One dense paragraph (not bullets). List specific files, paths, and systems examined with semicolons. Include full relative paths and module names. Example: 'Global and project-level Claude Code settings.json; kyp-mem Python CLI source (cli.py, hooks.py); installed Node.js wrapper at /opt/homebrew/lib/node_modules/kyp-mem/bin/cli.mjs; hook dispatcher implementation; git commit history'
+- **LEARNED**: One dense paragraph (not bullets). State technical insights with specifics — what was discovered, why it matters, root causes. Include version numbers, commit hashes, config values, error messages. Example: 'kyp-mem uses a Node.js wrapper with a "hook fast path" dispatcher that only handled 3 hook types (user-prompt, post-tool-use, stop); session-start was missing despite being implemented in Python backend'
+- **COMPLETED**: One dense paragraph (not bullets). List concrete deliverables with specifics — file names modified, features added, tests passed, counts, commit hashes. Use semicolons to separate items. Example: 'Fixed .gitignore to exclude session-specific files (CLAUDE.md, PLAN-ui-rewrite.md, templates/); removed 3 tracked files from git history; committed cleanup to main (commit f0b114e: 4 files changed, 626 deletions)'
+- **NEXT STEPS**: One dense paragraph (not bullets). Concrete actionable items for the next session. Example: 'Push commit f0b114e to GitHub; publish 0.5.1 release to npm with session-start hook support'
 
-NEVER include raw grep patterns, CSS class names, file paths, or command output. Write like you're telling a teammate what you did today.
+## Critical rules
+- ALWAYS include specific file names, paths, commit hashes, error messages, and counts
+- Write dense paragraphs with semicolons, NOT bullet lists
+- Never be vague: "Fixed 3 files" is bad, "Fixed .gitignore, cli.mjs, and hooks.py" is good
+- If a commit hash appears in the timeline, include it
+- Keep each section to one paragraph max
 
 Return ONLY this format (no preamble):
 
 ## Summary
-<text>
+<1-2 sentences>
 
 ## INVESTIGATED
-- <item>
+<one paragraph>
 
 ## LEARNED
-- <item>
+<one paragraph>
 
 ## COMPLETED
-- <item>
+<one paragraph>
 
 ## NEXT STEPS
-- <item>
+<one paragraph>
 
 Raw session data:
 {raw_note}"""
 
-        response = client.messages.create(
-            model=model,
-            max_tokens=1024,
-            messages=[{"role": "user", "content": prompt}],
+        result = subprocess.run(
+            [claude_bin, "-p", prompt, "--max-turns", "1", "--model", model],
+            capture_output=True, text=True, timeout=120,
         )
-        return response.content[0].text.strip()
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip()
+        return None
     except Exception:
         return None
 
@@ -503,7 +499,7 @@ def handle_stop():
     files_created = set()
     commands = []
     prompts = []
-    timeline = []
+    events = []
 
     for e in entries:
         ts_raw = e.get("ts", "")
@@ -512,69 +508,96 @@ def handle_stop():
 
         if action == "prompt":
             prompts.append({"ts": ts, "text": e.get("prompt", "")})
-            timeline.append(f"  {ts} — Prompt: {e.get('prompt', '')[:60]}...")
+            events.append({"ts": ts, "type": "prompt", "text": e.get("prompt", "")[:500]})
         elif action == "read":
             fp = e.get("file", "")
             files_read.add(fp)
-            timeline.append(f"  {ts} — Read `{Path(fp).name}`")
+            content = e.get("content", "")
+            events.append({"ts": ts, "type": "read", "file": fp, "content": content[:1000] if content else ""})
         elif action == "edit":
             fp = e.get("file", "")
             files_edited.add(fp)
-            timeline.append(f"  {ts} — Edit `{Path(fp).name}`")
+            events.append({
+                "ts": ts, "type": "edit", "file": fp,
+                "old": e.get("old_string", "")[:300],
+                "new": e.get("new_string", "")[:300],
+            })
         elif action == "create":
             fp = e.get("file", "")
             files_created.add(fp)
-            timeline.append(f"  {ts} — Write `{Path(fp).name}`")
+            events.append({"ts": ts, "type": "create", "file": fp})
         elif action == "command":
             cmd = e.get("command", "")
+            output = e.get("output", "")
             commands.append(cmd)
-            short = cmd[:80] + "..." if len(cmd) > 80 else cmd
-            timeline.append(f"  {ts} — `{short}`")
+            events.append({"ts": ts, "type": "command", "cmd": cmd[:300], "output": output[:1000] if output else ""})
 
     commands_classified = [_classify_command(cmd) for cmd in commands]
 
-    summary_items = []
-    if files_edited:
-        summary_items.append(f"Modified {len(files_edited)} file{'s' if len(files_edited) != 1 else ''}")
-    if files_created:
-        summary_items.append(f"Created {len(files_created)} file{'s' if len(files_created) != 1 else ''}")
-    if commands:
-        summary_items.append(f"Ran {len(commands)} command{'s' if len(commands) != 1 else ''}")
+    # Build rich context for Sonnet — actual content, not just filenames
+    raw_parts = []
 
-    investigated = _build_investigated(files_read, commands_classified, project_dir)
-    learned = _build_learned(files_read, files_edited, files_created, commands_classified, project_dir)
-    completed = _build_completed(files_edited, files_created, commands_classified, project_dir)
-    next_steps = _build_next_steps(files_edited, files_created, commands_classified)
+    if prompts:
+        raw_parts.append("## USER PROMPTS (the objectives)")
+        for p in prompts:
+            raw_parts.append(f"[{p['ts']}] {p['text'][:500]}")
+        raw_parts.append("")
+
+    raw_parts.append("## SESSION EVENTS (chronological, with content)")
+    for ev in events:
+        if ev["type"] == "prompt":
+            raw_parts.append(f"\n### [{ev['ts']}] User asked:")
+            raw_parts.append(ev["text"])
+        elif ev["type"] == "read":
+            raw_parts.append(f"\n### [{ev['ts']}] Read `{ev['file']}`")
+            if ev.get("content"):
+                raw_parts.append(f"```\n{ev['content']}\n```")
+        elif ev["type"] == "edit":
+            raw_parts.append(f"\n### [{ev['ts']}] Edited `{ev['file']}`")
+            if ev.get("old"):
+                raw_parts.append(f"Replaced:\n```\n{ev['old']}\n```")
+            if ev.get("new"):
+                raw_parts.append(f"With:\n```\n{ev['new']}\n```")
+        elif ev["type"] == "create":
+            raw_parts.append(f"\n### [{ev['ts']}] Created `{ev['file']}`")
+        elif ev["type"] == "command":
+            raw_parts.append(f"\n### [{ev['ts']}] Ran: `{ev['cmd']}`")
+            if ev.get("output"):
+                raw_parts.append(f"Output:\n```\n{ev['output']}\n```")
 
-    # Build raw note for Claude summarization
-    raw_parts = []
-    raw_parts.append("## Summary")
-    raw_parts.append(", ".join(summary_items) + f" in `{project_name}`." if summary_items else "")
-    raw_parts.append("")
-    raw_parts.append("## INVESTIGATED")
-    if investigated:
-        raw_parts.extend(investigated)
     raw_parts.append("")
-    raw_parts.append("## LEARNED")
-    if learned:
-        raw_parts.extend(learned)
+    raw_parts.append("## FILES MODIFIED")
+    for fp in sorted(files_edited):
+        raw_parts.append(f"- {_relative_path(fp, project_dir)}")
     raw_parts.append("")
-    raw_parts.append("## COMPLETED")
-    if completed:
-        raw_parts.extend(completed)
+    raw_parts.append("## FILES CREATED")
+    for fp in sorted(files_created):
+        raw_parts.append(f"- {_relative_path(fp, project_dir)}")
     raw_parts.append("")
-    raw_parts.append("## NEXT STEPS")
-    if next_steps:
-        raw_parts.extend(next_steps)
+    raw_parts.append("## FILES READ")
+    for fp in sorted(files_read):
+        raw_parts.append(f"- {_relative_path(fp, project_dir)}")
 
-    # Prompts go FIRST — they define the session's objective
-    if prompts:
-        raw_parts.insert(0, "## USER PROMPTS (what was asked)")
-        for i, p in enumerate(prompts):
-            raw_parts.insert(i + 1, f"- [{p['ts']}] {p['text'][:300]}")
-        raw_parts.insert(len(prompts) + 1, "")
+    # Keep timeline for backward compat in case summarization fails
+    timeline = []
+    for ev in events:
+        if ev["type"] == "prompt":
+            timeline.append(f"  {ev['ts']} — Prompt: {ev['text'][:60]}...")
+        elif ev["type"] == "read":
+            timeline.append(f"  {ev['ts']} — Read `{Path(ev['file']).name}`")
+        elif ev["type"] == "edit":
+            timeline.append(f"  {ev['ts']} — Edit `{Path(ev['file']).name}`")
+        elif ev["type"] == "create":
+            timeline.append(f"  {ev['ts']} — Write `{Path(ev['file']).name}`")
+        elif ev["type"] == "command":
+            short = ev["cmd"][:80] + "..." if len(ev["cmd"]) > 80 else ev["cmd"]
+            timeline.append(f"  {ev['ts']} — `{short}`")
+
+    investigated = _build_investigated(files_read, commands_classified, project_dir)
+    learned = _build_learned(files_read, files_edited, files_created, commands_classified, project_dir)
+    completed = _build_completed(files_edited, files_created, commands_classified, project_dir)
+    next_steps = _build_next_steps(files_edited, files_created, commands_classified)
 
-    # Full timeline gives Claude the narrative arc
     if timeline:
         raw_parts.append("")
         raw_parts.append("## TIMELINE (what happened, chronological)")
@@ -639,6 +662,13 @@ def handle_stop():
         parts.append("")
         parts.append(summarized)
     else:
+        summary_items = []
+        if files_edited:
+            summary_items.append(f"Modified {len(files_edited)} file{'s' if len(files_edited) != 1 else ''}")
+        if files_created:
+            summary_items.append(f"Created {len(files_created)} file{'s' if len(files_created) != 1 else ''}")
+        if commands:
+            summary_items.append(f"Ran {len(commands)} command{'s' if len(commands) != 1 else ''}")
         parts.append("## Summary")
         parts.append(", ".join(summary_items) + f" in `{project_name}`." if summary_items else "")
         parts.append("")

package/kyp_mem/static/index.html

@@ -475,8 +475,9 @@ body.resizing #resize-handle { pointer-events: auto !important; }
 .graph-header {
   display: flex; align-items: center; justify-content: space-between;
   padding: 10px 14px; border-bottom: 1px solid var(--line);
-  background: var(--bg-2); gap: 12px;
+  background: var(--bg-2); gap: 12px; position: relative; z-index: 10;
 }
+.graph-header .ghost-btn { cursor: pointer; }
 .graph-header-left { display: flex; align-items: center; gap: 10px; font-size: var(--fz-sm); white-space: nowrap; }
 .graph-header-right { display: flex; gap: 6px; flex-shrink: 0; }
 .tool-chip {
@@ -1428,6 +1429,8 @@ function renderSessionView(note) {
 }
 
 // ─── Graph View ──────────────────────────────────────────────────────────────
+let _graphMode = 'projects';
+
 function renderGraphView() {
   const area = $('content-area');
   area.innerHTML = `
@@ -1436,24 +1439,19 @@ function renderGraphView() {
         <div class="graph-header">
           <div class="graph-header-left">
             <span class="acc">▦</span>
-            <span style="font-weight:500">vault graph</span>
+            <button class="tool-chip graph-mode active" data-mode="projects">projects</button>
+            <button class="tool-chip graph-mode" data-mode="sessions">sessions</button>
             <span class="dim tab-nums" id="graph-stats"></span>
           </div>
           <div class="graph-header-right">
-            <button class="tool-chip active">force</button>
-            <button class="tool-chip">radial</button>
-            <button class="tool-chip">time</button>
+            <button class="tool-chip graph-layout active" data-layout="force">force</button>
+            <button class="tool-chip graph-layout" data-layout="radial">radial</button>
+            <button class="tool-chip graph-layout" data-layout="time">time</button>
             <button class="ghost-btn" id="graph-close">✕</button>
           </div>
         </div>
         <div class="graph-svg-wrap" id="graph-svg-wrap"></div>
-        <div class="graph-legend">
-          <div class="graph-legend-title">legend</div>
-          <div class="graph-legend-item"><i style="width:8px;height:8px;border-radius:999px;background:var(--accent)"></i>notes</div>
-          <div class="graph-legend-item"><i style="width:8px;height:8px;border-radius:999px;background:var(--panel-2);border:1px solid var(--muted)"></i>sessions</div>
-          <div class="graph-legend-item"><i style="width:12px;height:1px;background:var(--line-2)"></i>link</div>
-          <div class="graph-legend-item"><i style="width:12px;height:0;border-top:1px dashed var(--line-2)"></i>session ref</div>
-        </div>
+        <div class="graph-legend" id="graph-legend"></div>
       </section>
       <aside class="graph-rail" id="graph-rail">
         <div class="rail-card">
@@ -1470,36 +1468,88 @@ function renderGraphView() {
     </div>
   `;
 
-  $('graph-close').addEventListener('click', () => setView('note'));
+  updateGraphLegend();
+
+  const closeBtn = $('graph-close');
+  if (closeBtn) {
+    closeBtn.addEventListener('click', (e) => {
+      e.stopPropagation();
+      setView('note');
+      if (currentPath) loadNote(currentPath);
+      else $('content-area').innerHTML = '<div style="padding:40px;color:var(--muted)">Select a note from the sidebar</div>';
+    });
+  }
 
-  // Layout toggle buttons
-  const chips = document.querySelectorAll('.graph-header-right .tool-chip');
-  chips.forEach(chip => {
+  // Mode toggle (projects / sessions)
+  document.querySelectorAll('.graph-mode').forEach(btn => {
+    btn.addEventListener('click', () => {
+      document.querySelectorAll('.graph-mode').forEach(b => b.classList.remove('active'));
+      btn.classList.add('active');
+      _graphMode = btn.dataset.mode;
+      _graphData = null;
+      updateGraphLegend();
+      const activeLayout = document.querySelector('.graph-layout.active');
+      buildFullGraph(activeLayout ? activeLayout.dataset.layout : 'force');
+    });
+  });
+
+  // Layout toggle (force / radial / time)
+  document.querySelectorAll('.graph-layout').forEach(chip => {
     chip.addEventListener('click', () => {
-      chips.forEach(c => c.classList.remove('active'));
+      document.querySelectorAll('.graph-layout').forEach(c => c.classList.remove('active'));
       chip.classList.add('active');
-      buildFullGraph(chip.textContent.trim());
+      buildFullGraph(chip.dataset.layout);
     });
   });
 
   buildFullGraph('force');
 }
 
+function updateGraphLegend() {
+  const legend = $('graph-legend');
+  if (!legend) return;
+  if (_graphMode === 'sessions') {
+    legend.innerHTML = `
+      <div class="graph-legend-title">sessions</div>
+      <div class="graph-legend-item"><i style="width:8px;height:8px;border-radius:999px;background:var(--panel-2);border:1px solid var(--muted)"></i>session</div>
+      <div class="graph-legend-item"><i style="width:12px;height:0;border-top:1px dashed var(--line-2)"></i>temporal link</div>
+    `;
+  } else {
+    legend.innerHTML = `
+      <div class="graph-legend-title">projects</div>
+      <div class="graph-legend-item"><i style="width:8px;height:8px;border-radius:999px;background:var(--accent)"></i>notes</div>
+      <div class="graph-legend-item"><i style="width:12px;height:1px;background:var(--line-2)"></i>wikilink</div>
+    `;
+  }
+}
+
 async function buildFullGraph(layout) {
   const wrap = $('graph-svg-wrap');
   if (!wrap) return;
   wrap.innerHTML = '';
 
   if (!_graphData) {
-    _graphData = await fetchJSON('/api/graph');
+    _graphData = await fetchJSON(`/api/graph?kind=${_graphMode}`);
+  }
+
+  let nodes = _graphData.nodes.map(n => ({ ...n }));
+  let links = _graphData.edges.map(e => ({ ...e }));
+
+  // For sessions mode, create temporal links between consecutive sessions
+  if (_graphMode === 'sessions' && links.length === 0 && nodes.length > 1) {
+    const sorted = [...nodes].sort((a, b) => a.id.localeCompare(b.id));
+    for (let i = 1; i < sorted.length; i++) {
+      links.push({ source: sorted[i - 1].id, target: sorted[i].id });
+    }
   }
 
-  const nodes = _graphData.nodes.map(n => ({ ...n }));
-  const links = _graphData.edges.map(e => ({ ...e }));
   const nodeMap = new Map(nodes.map(n => [n.id, n]));
 
   $('graph-stats').textContent = `${nodes.length}n · ${links.length}e`;
-  if (nodes.length === 0) return;
+  if (nodes.length === 0) {
+    wrap.innerHTML = '<div style="display:flex;align-items:center;justify-content:center;height:100%;color:var(--muted);font-size:var(--fz-sm)">No nodes to display</div>';
+    return;
+  }
 
   const rect = wrap.getBoundingClientRect();
   const W = rect.width || 800;
@@ -1568,36 +1618,44 @@ async function buildFullGraph(layout) {
     const s = typeof l.source === 'object' ? l.source : nodeMap.get(l.source);
     const t = typeof l.target === 'object' ? l.target : nodeMap.get(l.target);
     if (!s || !t) return;
-    const isSession = s.kind === 'session' || t.kind === 'session';
+    const isTemporal = _graphMode === 'sessions';
     edgeGroup.append('line')
       .attr('x1', s.x).attr('y1', s.y).attr('x2', t.x).attr('y2', t.y)
-      .attr('stroke', 'var(--line-2)').attr('stroke-width', 1.2)
-      .attr('stroke-opacity', isSession ? 0.35 : 0.6)
-      .attr('stroke-dasharray', isSession ? '4 3' : '')
+      .attr('stroke', 'var(--line-2)').attr('stroke-width', isTemporal ? 1 : 1.2)
+      .attr('stroke-opacity', isTemporal ? 0.3 : 0.6)
+      .attr('stroke-dasharray', isTemporal ? '4 3' : '')
       .attr('stroke-linecap', 'round');
   });
 
   // Draw nodes
   const nodeGroup = g.append('g');
   nodes.forEach(n => {
-    const r = n.kind === 'session' ? 6 : 10;
+    const isPrimary = _graphMode === 'sessions' ? n.kind === 'session' : n.kind === 'note';
+    const r = isPrimary ? 10 : 6;
     const ng = nodeGroup.append('g').style('cursor', 'pointer');
 
-    if (n.kind === 'session') {
-      ng.append('circle').attr('cx', n.x).attr('cy', n.y).attr('r', r)
-        .attr('fill', 'var(--bg-2)').attr('stroke', 'var(--muted)').attr('stroke-width', 1.2);
-    } else {
+    if (isPrimary) {
       ng.append('circle').attr('cx', n.x).attr('cy', n.y).attr('r', r + 4)
         .attr('fill', 'var(--accent)').attr('fill-opacity', 0.12);
       ng.append('circle').attr('cx', n.x).attr('cy', n.y).attr('r', r)
         .attr('fill', 'var(--panel-2)').attr('stroke', 'var(--accent)').attr('stroke-width', 1.5);
+    } else {
+      ng.append('circle').attr('cx', n.x).attr('cy', n.y).attr('r', r)
+        .attr('fill', 'var(--bg-2)').attr('stroke', 'var(--muted)').attr('stroke-width', 1.2);
+    }
+
+    let label = n.title;
+    if (_graphMode === 'sessions' && n.kind === 'session') {
+      const m = n.id.match(/(\d{4}-\d{2}-\d{2})_(\d{2})(\d{2})/);
+      label = m ? `${m[1]} ${m[2]}:${m[3]}` : n.title;
     }
+    if (label.length > 22) label = label.substring(0, 20) + '…';
 
     ng.append('text').attr('x', n.x).attr('y', n.y + r + 14)
       .attr('text-anchor', 'middle').attr('font-size', 11)
-      .attr('fill', n.kind === 'session' ? 'var(--dim)' : 'var(--muted)').attr('opacity', 0.9)
+      .attr('fill', isPrimary ? 'var(--muted)' : 'var(--dim)').attr('opacity', 0.9)
       .style('font-family', 'JetBrains Mono, monospace')
-      .text(n.title.length > 20 ? n.title.substring(0, 18) + '…' : n.title);
+      .text(label);
 
     ng.on('click', () => {
       updateGraphRail(n, links, nodes);

package/kyp_mem/ui.py

@@ -30,13 +30,17 @@ def create_app(vault_path: str = None) -> FastAPI:
         return JSONResponse(vault.get_stats())
 
     @app.get("/api/graph")
-    def graph():
+    def graph(kind: str = "all"):
         nodes = []
         edges = []
         seen_edges = set()
         for path, note in vault.index.notes.items():
-            kind = "session" if "/Sessions/" in path else "note"
-            nodes.append({"id": path, "title": note.title, "kind": kind, "tags": note.tags})
+            node_kind = "session" if "/Sessions/" in path else "note"
+            if kind == "projects" and node_kind == "session":
+                continue
+            if kind == "sessions" and node_kind == "note":
+                continue
+            nodes.append({"id": path, "title": note.title, "kind": node_kind, "tags": note.tags})
             for link in (note.links or []):
                 target = None
                 link_lower = link.lower()
@@ -46,6 +50,11 @@ def create_app(vault_path: str = None) -> FastAPI:
                         target = p
                         break
                 if target and target != path:
+                    target_kind = "session" if "/Sessions/" in target else "note"
+                    if kind == "projects" and target_kind == "session":
+                        continue
+                    if kind == "sessions" and target_kind == "note":
+                        continue
                     key = tuple(sorted([path, target]))
                     if key not in seen_edges:
                         seen_edges.add(key)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kyp-mem",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Know Your Project — Persistent & Session level knowledge base for AI agents. MCP-powered with wikilinks, backlinks, auto-learning, and neon web UI.",
   "bin": {
     "kyp-mem": "bin/cli.mjs"