kyp-mem 0.5.1 → 0.6.0

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":
@@ -267,7 +271,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

@@ -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 = [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("Use `kyp_project_context` for full details. Use `kyp_session_search` to search past sessions.")
+        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
 
@@ -426,35 +413,41 @@ def _summarize_with_claude(raw_note, project_name):
         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 (what was asked), a timeline of file edits/reads/commands (what happened), and raw section data. Synthesize these into a coherent narrative.
+You have: user prompts (the objectives), a timeline of file edits/reads/commands, and raw section data. Synthesize into a dense, specific narrative.
 
-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.
+## Format rules
 
-NEVER include raw grep patterns, CSS class names, file paths, or command output. Write like you're telling a teammate what you did today.
+- **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'
+
+## 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}"""
@@ -503,7 +496,7 @@ def handle_stop():
     files_created = set()
     commands = []
     prompts = []
-    timeline = []
+    events = []
 
     for e in entries:
         ts_raw = e.get("ts", "")
@@ -512,69 +505,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 +659,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kyp-mem",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "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"