kyp-mem 0.5.0 → 0.6.0

package/README.md

@@ -1,288 +1,137 @@
-# KYP-MEM — Know Your Project Memory
+# KYP-MEM
 
-**Persistent memory for AI coding agents.** Your AI agent forgets everything between sessions. KYP-MEM fixes that.
 
-KYP-MEM is an MCP server that gives your AI agent a knowledge base and session memory. It remembers your architecture, past bugs, decisions, and what happened last session — so you never repeat yourself.
+> Claude that remembers your conversations AND understands your project.
 
----
+KYP-MEM gives AI coding agents two-layer memory:
 
-## How It Works
-
-KYP-MEM gives your agent two types of memory:
-
-### Knowledge Base — long-term project memory
-
-Structured markdown notes organized by project. Architecture docs, API references, known bugs, key decisions, setup guides. The agent reads these before doing any work and updates them as it learns.
-
-```
-MyProject/
-├── Knowledge.md      # Architecture, bugs, decisions, notes
-├── API.md            # Endpoints and contracts
-├── Setup.md          # Environment setup guide
-└── Sessions/
-```
-
-### Session Memory — what happened each session
-
-Every coding session is automatically captured — files changed, commands run, prompts used. These notes are embedded into a vector database for semantic search, so the agent can find past work by meaning, not just keywords.
+- **Session Memory (Episodic)** → remembers what happened across coding sessions
 
-```
-MyProject/Sessions/
-├── 2026-05-12_143022.md  # "Fixed auth bug, found rate limiter issue"
-├── 2026-05-12_091544.md  # "Investigated flaky tests — race condition"
-└── 2026-05-11_162301.md  # "Set up CI, decided on GitHub Actions"
-```
+- **Project Intelligence** → understands architecture, decisions, docs, and relationships
 
-### The Loop
+Your AI agent stops starting from zero every day.
 
-```
-Session Start
-  → Agent loads project knowledge + recent sessions
-  → Agent is grounded: knows architecture, past bugs, last session's next steps
+## Example
 
-During Work
-  → Agent hits a bug → searches session memory → finds it was already investigated
-  → Agent makes a decision → updates Knowledge.md so future sessions know
+User:
 
-Session End
-  → Hooks auto-capture everything into a structured session note
-  → Note is embedded into the vector store for future semantic search
-```
+> "Why did we move from REST to Kafka?"
 
----
+Claude:
 
-## Install
+> "In the May 12 session, we found the REST pipeline couldn't handle peak trading volume.
+> We decided to migrate to Kafka for async processing.
+> See [[Architecture Decisions]] and [[Event Pipeline]]."
 
-```bash
-pip install kyp-mem
-```
-
-## Setup
+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.
 
-```bash
-kyp-mem init              # Choose where to store your vault
-kyp-mem setup-claude      # Register MCP server with Claude Code
-kyp-mem install-hooks     # Enable automatic session capture
-```
+## How It Works
 
-Restart Claude Code. KYP-MEM runs automatically with 14 tools available to the agent.
+KYP-MEM operates as a Model Context Protocol (MCP) server that runs silently in the background, integrating directly with Claude Code.
 
-### Quick Setup (one command)
+### 1. Episodic Memory (Sessions)
 
-```bash
-claude mcp add -s user -e KYP_VAULT="$HOME/.kyp-mem/vault" kyp-mem -- kyp-mem serve
-```
+Every coding session is automatically captured with full context:
 
-### Enable for All Projects
+- User prompts (what was asked)
+- File reads with content (what was found)
+- File edits with diffs (what changed and why)
+- Command outputs (what happened)
 
-```bash
-kyp-mem setup-claude --global
-kyp-mem install-hooks --global
-```
+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.
 
----
+### 2. Project Intelligence (Vault)
 
-## What the Agent Does Automatically
+KYP-MEM maintains structured project knowledge as Markdown files with `[[wikilinks]]`:
 
-KYP-MEM embeds behavioral instructions directly into tool descriptions. The agent follows these rules without any user action:
+- Architecture docs, API references, setup guides
+- Known issues, decision history, linked concepts
 
-1. **Session start** — loads project knowledge + recent session history
-2. **Before investigating bugs** — searches session memory first to avoid duplicate work
-3. **Before making decisions** — checks if a prior session already decided this
-4. **After fixing or learning something** — updates Knowledge.md for future sessions
-5. **Never hallucinates** — if it's not in the knowledge base, it says so
+The agent searches this on-demand via `kyp_search` when it needs project context.
 
-No prompting needed. The agent reads the tool descriptions and follows the protocol.
+### How It All Connects
 
----
+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.
 
-## Automatic Session Capture
+## Installation
 
 ```bash
-kyp-mem install-hooks
+npm install -g kyp-mem
 ```
 
-Installs three Claude Code hooks:
-
-- **UserPromptSubmit** — captures every prompt you send to the agent
-- **PostToolUse** — captures file edits, writes, and shell commands in real-time
-- **Stop** — when the session ends, compiles all activity into a structured note
-
-Each session note looks like this:
-
-```markdown
-# Session 2026-05-12_143022
-
-**Project:** MyProject
-**Actions:** 15 total, 12 substantive
+That's it. The postinstall script automatically:
 
-## Summary
-Fixed auth bug, refactored token refresh logic.
+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
 
-## PROMPTS
-### 1. [14:25:01]
-> fix the token refresh bug in auth.py
+Restart Claude Code and you're ready to go.
 
-### 2. [14:30:22]
-> also add retry logic for expired tokens
+### Requirements
 
-## INVESTIGATED
-- grep for "token expired" across auth module
-- read OAuth provider docs
+- Node.js 18+
+- Python 3.10+
+- Claude Code CLI
+- Anthropic API key (for session summarization with Sonnet)
 
-## LEARNED
-- Refresh tokens expire after 30 days, not 90
+### Custom Vault Path
 
-## COMPLETED
-- Fixed token refresh in auth.py
-- Added retry logic for expired tokens
+If you want to store your vault somewhere other than `~/.kyp-mem/vault`:
 
-## NEXT STEPS
-- Add integration test for token refresh flow
+```bash
+kyp-mem init    # Interactive prompt to choose vault location
 ```
 
-Sessions with fewer than 3 substantive actions are automatically skipped.
-
----
-
-## Semantic Search
-
-Session notes are embedded into a vector database (ChromaDB). This enables search by meaning:
+## The Agent's Workflow
 
-- Searching **"authentication failing"** finds sessions about "login bug" and "OAuth token expiry"
-- Searching **"deploy process"** finds sessions about "CI pipeline setup" and "release workflow"
+KYP-MEM embeds behavioral instructions directly into its tools. Without any prompting from you, the agent will automatically:
 
-The agent doesn't need exact keywords — it finds semantically related past work.
-
----
+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
 
+Browse your knowledge graph, view session timelines, and see semantic relationships visually.
+
 ```bash
 kyp-mem ui
 ```
-
-Opens at `localhost:3333` with two panels:
-
-**Session Memory** — semantic search across all sessions, grouped by project with timestamps
-
-**Knowledge Base** — file tree with folders, notes, tags. Full-text search, tag filtering, quick switcher (`Cmd+O`)
-
-**Editor** — rendered markdown with `[[wikilink]]` navigation, inline editing
-
-**Graph** — knowledge graph showing connections between notes, backlinks, and related content
-
----
-
-## MCP Tools (14 total)
-
-### Agent Behavior
-
-| Tool | Purpose |
-|------|---------|
-| `____kyp_instructions` | Embeds behavioral rules the agent follows automatically |
-| `kyp_project_context` | Loads project knowledge + recent sessions at session start |
-
-### Knowledge Base
-
-| Tool | Purpose |
-|------|---------|
-| `kyp_list` | Browse folders and notes |
-| `kyp_read` | Read a note (summary by default, `full=True` for complete) |
-| `kyp_write` | Create or update a note with tags and `[[wikilinks]]` |
-| `kyp_delete` | Delete a note |
-| `kyp_search` | Full-text search with optional tag filter |
-| `kyp_tags` | List all tags or filter notes by tag |
-| `kyp_related` | Find related notes by links, tags, proximity |
-| `kyp_recent` | Recently modified notes |
-| `kyp_stats` | Vault statistics |
-
-### Session Memory
-
-| Tool | Purpose |
-|------|---------|
-| `kyp_session_search` | Semantic search across all session logs |
-| `kyp_session_create` | Manually create a session note |
-| `kyp_sessions` | List sessions by project |
-
----
-
-## Adding to Your Project
-
-Add a `CLAUDE.md` to any project root:
-
-```markdown
-# Project Memory
-
-## Session Start (MANDATORY)
-Call `kyp_project_context("PROJECT_NAME")` at the start of every session to load:
-- Project knowledge base (architecture, bugs, decisions)
-- Recent session history (what was done, what's next)
-
-## During Work
-- Before investigating bugs: `kyp_session_search("error or symptom")`
-- Before making decisions: `kyp_session_search("topic")`
-- After fixing bugs: update Knowledge.md via `kyp_write`
-- After decisions: add to Key Decisions in Knowledge.md
-
-## Rules
-- Never hallucinate project details — check the knowledge base first.
-- Use [[wikilinks]] to connect related notes.
-- Sessions are captured automatically — no manual logging needed.
-```
-
-A template is available at `templates/CLAUDE.md.template`.
-
----
-
-## Vault Structure
-
-```
-~/.kyp-mem/
-├── config.json           # Vault path configuration
-├── chroma/               # Vector database for semantic search
-└── vault/
-    ├── ProjectA/
-    │   ├── Knowledge.md  # Ground truth: architecture, bugs, decisions
-    │   ├── API.md
-    │   └── Sessions/
-    │       ├── 2026-05-12_143022.md
-    │       └── 2026-05-11_091544.md
-    ├── ProjectB/
-    │   ├── Knowledge.md
-    │   └── Sessions/
-    └── ...
-```
-
-Notes use YAML frontmatter for tags and `[[wikilinks]]` for cross-references:
-
-```markdown
----
-tags: [trading, config]
-created: 2026-05-12
----
-# Configuration
-Settings are in `HedgeConfig`. See [[Risk Management]] for limits.
-```
-
----
+*Opens at `localhost:3333`.*
 
 ## CLI Commands
 
-| Command | What it does |
+| 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 setup-claude --global` | Register globally (all projects) |
 | `kyp-mem install-hooks` | Enable automatic session capture |
-| `kyp-mem install-hooks --remove` | Remove session capture hooks |
 | `kyp-mem serve` | Start MCP server (stdio, used by the agent) |
-| `kyp-mem ui` | Open web UI at localhost:3333 |
+| `kyp-mem ui` | Open the local web UI |
 | `kyp-mem stats` | Print vault statistics |
-| `kyp-mem tree` | Print vault tree |
-| `kyp-mem doctor` | Check installation health |
+| `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.0",
+  "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"