claude-memory-hub 0.9.5 → 0.10.0

package/CHANGELOG.md

@@ -5,6 +5,82 @@ Format follows [Keep a Changelog](https://keepachangelog.com/).
 
 ---
 
+## [0.10.0] - 2026-04-03
+
+Full conversation capture — memory-hub now remembers what you said AND what Claude said.
+
+### New Feature: Conversation Capture
+
+- **All user prompts saved** — every `UserPromptSubmit` hook now inserts the user's message into a new `messages` table (up to 2000 chars each). Previously only the first prompt was stored in `sessions.user_prompt` (500 chars)
+- **Transcript parsing at session-end** — when session ends, the Stop hook reads Claude Code's JSONL transcript file (`transcript_path`) and extracts all user + assistant text messages. Tool blocks (tool_use/tool_result) are skipped since they're already captured as entities. Streaming parser handles files up to 10MB safely
+- **`messages` table + FTS5 search** — new schema v5 migration adds `messages` table with full-text search index. Supports deduplication by UUID, conversation chain tracking via `parent_uuid`, and role-based filtering
+- **`memory_conversation` MCP tool** — new tool to retrieve or search conversation history for any session. Supports: get all messages, filter by role, full-text search across all conversations
+
+### Enriched Summaries
+
+- **Conversation digest in summaries** — session summarizer (both Tier 2 CLI and Tier 3 rule-based) now includes a digest of user requests from the `messages` table. Summaries now show "User requests (3): [1] fix login bug; [2] add dark mode; [3] deploy to prod" instead of just the first prompt
+- **Search across conversations** — `searchMessages()` provides FTS5 search across all stored messages with LIKE fallback
+
+### Data Flow
+
+```
+Session Start:
+  UserPromptSubmit → save user prompt to messages table (real-time)
+
+Mid-Session:
+  UserPromptSubmit → save each subsequent prompt (real-time)
+  PostToolUse → capture entities as before
+
+Session End (Stop hook):
+  1. Parse transcript_path JSONL → extract user + assistant messages
+  2. Bulk insert to messages table (dedup by UUID)
+  3. Summarize with conversation digest
+  4. Generate embeddings
+```
+
+### Database
+
+- **Schema v5** — new `messages` table, `fts_messages` FTS5 virtual table, auto-sync triggers
+- **Migration**: automatic on first use after upgrade
+
+### Before vs After
+
+```
+Before (0.9.x):
+  Stored: first user prompt (500 chars) + file/error/decision entities
+  Missing: subsequent prompts, ALL assistant responses
+  Summary: "Task: fix login. Files: auth.ts."
+
+After (0.10.0):
+  Stored: ALL user prompts + ALL assistant responses + entities
+  Summary: "User requests (3): fix login bug; add dark mode; deploy.
+           Files: auth.ts, theme.ts. Decisions: JWT refresh, CSS vars."
+  Searchable: "authentication login" → finds matching conversations
+```
+
+---
+
+## [0.9.6] - 2026-04-03
+
+Richer session capture — Agent results, higher limits, cleaner summaries.
+
+### Enhancements
+
+- **Agent/Skill result capture** — `tool_response` from Agent and Skill tools is now saved into entity `context` field (up to 800 chars). Previously only the prompt was captured, losing all agent output. This is the biggest data quality improvement — multi-agent workflows now produce meaningful summaries
+- **Higher summary limits** — `user_prompt` 200→500 chars, `decisions` 3→5 entries with context, `errors` 2→5 entries, `notes` 2→5 entries. CLI summarizer bumped to 6K prompt / 2K output (was 4K/1K). Decision entities now include agent/skill results in summary text
+- **IDE/system tag stripping in summarizer** — `<ide_opened_file>`, `<ide_selection>`, `<system-reminder>`, `<local-command-*>`, `<command-*>` tags are now stripped at both rule-based and CLI summarizer stages. Prevents tag noise from polluting L3 summaries
+- **PostCompact summary cap** — compact summaries exceeding 5,000 chars are truncated (was unbounded — seen 22K in production). Reduces DB bloat and improves search relevance
+- **Broader observation heuristics** — added patterns for: refactoring, dependency changes, test results, deployments, scaffolding, data risks, user task/feature requests. Captures more meaningful observations from tool output and user prompts
+
+### Before vs After
+
+```
+Before: "Task: <ide_opened_file>...</ide_opened_file>. Files (49): ..."  (1165 chars, noisy)
+After:  "Task: fix broken hooks in memory-hub. Files (15): ... Decisions: agent:debugger: investigated... → Found temp path issue..."  (richer, clean)
+```
+
+---
+
 ## [0.9.5] - 2026-04-03
 
 Stable install path — hooks no longer break after reboot or bunx cache cleanup.

package/README.md

@@ -26,10 +26,11 @@ Zero API key. Zero Python. Zero config. One install command.
 What makes it different? **The Compact Interceptor** — something no other memory tool has. When Claude Code auto-compacts at 200K tokens, memory-hub *tells the compact engine what matters*. PreCompact hook injects priority instructions. PostCompact hook saves the full summary. Result: 90% context salvage instead of vaporization.
 
 But it doesn't stop there:
+- **Full conversation capture** — every user prompt + assistant response saved via transcript parsing
 - **Cross-session memory** — past work auto-injected when you start a new session
 - **3-engine hybrid search** — FTS5 + TF-IDF + semantic embeddings (384-dim, offline)
 - **Proactive retrieval** — detects topic shifts mid-session, injects relevant context automatically
-- **91 unit tests**, batch queue (75ms→3ms), JSONL export/import, browser UI
+- **100+ unit tests**, batch queue (75ms→3ms), JSONL export/import, browser UI
 - **Multi-agent ready** — subagents share memory for free via MCP
 
 Built for developers who use Claude Code daily and are tired of repeating themselves.
@@ -61,13 +62,15 @@ Search:        Keyword-only, no semantic ranking
 | Problem | Claude Code built-in | claude-mem | memory-hub |
 |---------|:-------------------:|:----------:|:----------:|
 | Cross-session memory | -- | Yes | **Yes** |
+| Full conversation capture (user+assistant) | -- | -- | **Yes** |
+| Conversation search (FTS5) | -- | -- | **Yes** |
 | Influence what compact preserves | -- | -- | **Yes** |
 | Save compact output to L3 | -- | -- | **Yes** |
 | Hybrid search (FTS5 + TF-IDF + semantic) | -- | Partial | **Yes** |
 | 3-layer progressive search | -- | Yes | **Yes** |
 | Resource overhead analysis | -- | -- | **Yes** |
 | CLAUDE.md rule tracking | -- | -- | **Yes** |
-| Observation capture (14 patterns) | -- | Yes | **Yes** |
+| Observation capture (20+ patterns) | -- | Yes | **Yes** |
 | LLM summarization (3-tier) | -- | Yes (API) | **Yes (free)** |
 | Token-budget-aware tools (`max_tokens`) | -- | -- | **Yes** |
 | Proactive mid-session retrieval | -- | -- | **Yes** |
@@ -79,25 +82,29 @@ Search:        Keyword-only, no semantic ranking
 | Hook batching (3ms vs 75ms) | -- | -- | **Yes** |
 | Browser UI | -- | Yes | **Yes** |
 | Health monitoring + auto-cleanup | -- | -- | **Yes** |
-| Unit tests (91 tests) | N/A | -- | **Yes** |
+| Unit tests (100+) | N/A | -- | **Yes** |
 | No API key / Python / Chroma | N/A | Partial | **Yes** |
 
 ---
 
 ## How It Works
 
-### Layer 1 — Entity Capture (every tool call)
+### Layer 1 — Entity + Conversation Capture (every tool call + every prompt)
 
 ```
 Claude reads a file     → memory-hub records: which file, code patterns found
 Claude edits a file     → memory-hub records: what changed (old → new diff)
 Claude runs a command   → memory-hub records: command, exit code, stderr
 Claude makes a decision → memory-hub records: decision text + importance score
+Claude spawns an agent  → memory-hub records: agent type, prompt, result summary
+User sends a prompt     → memory-hub records: full prompt text to messages table
+Session ends            → memory-hub parses transcript: ALL user + assistant messages
 ```
 
 No XML. No special format. Extracted directly from hook JSON metadata.
 PostToolUse events are batched via write-through queue (~3ms per event vs ~75ms direct).
 Mid-session topic shifts auto-inject relevant past context (proactive retrieval).
+Full conversation (user + assistant) captured from Claude Code's JSONL transcript at session end.
 
 ### Layer 2 — Compact Interceptor (the key innovation)
 
@@ -127,7 +134,9 @@ Mid-session topic shifts auto-inject relevant past context (proactive retrieval)
 ### Layer 3 — Cross-Session Memory
 
 ```
-Session N ends  → 3-tier summarization: PostCompact > CLI claude > rule-based
+Session N ends  → Parse transcript: capture full conversation (user + assistant)
+                → 3-tier summarization: PostCompact > CLI claude > rule-based
+                → Summary enriched with conversation digest
                 → Summary saved to SQLite L3 with FTS5 indexing
 
 Session N+1     → UserPromptSubmit hook fires
@@ -173,9 +182,12 @@ Tool output contains "IMPORTANT: always pool DB connections"
 User prompt contains "remember that we use TypeScript strict"
   → observation entity (importance=3) saved to L2
 
-14 heuristic patterns: IMPORTANT, CRITICAL, SECURITY, DEPRECATED,
-  decision:, discovered, root cause, switched to, TODO:, FIXME:,
-  HACK:, performance:, bottleneck, OOM, don't, never, prefer, etc.
+20+ heuristic patterns:
+  Tool output: IMPORTANT, CRITICAL, SECURITY, DEPRECATED, migration failed,
+    decision:, discovered, root cause, switched to, refactored, installed,
+    TODO:, FIXME:, performance:, bottleneck, tests pass/fail, deployed, etc.
+  User prompt: IMPORTANT, MUST, remember that, don't/never/avoid,
+    fix/debug/investigate, implement/build/create, prefer/always use, etc.
 ```
 
 ---
@@ -193,10 +205,11 @@ User prompt contains "remember that we use TypeScript strict"
 │  └──────┬────────┘  │ priorities   │  └──────┬───────┘      │
 │         │           └──────┬───────┘         │              │
 │  ┌──────┴───────┐          │          ┌──────┴───────┐      │
-│  │UserPrompt    │          │          │ Stop         │      │
-│  │Submit: inject│          │          │ session end  │      │
-│  │past context  │          │          │ summarize    │      │
-│  └──────────────┘          │          └──────────────┘      │ 
+│  │UserPrompt    │          │          │ Stop           │    │
+│  │Submit: inject│          │          │ parse transcript│    │
+│  │past context +│          │          │ capture convo  │    │
+│  │save prompt   │          │          │ summarize      │    │
+│  └──────────────┘          │          └────────────────┘    │
 │                            │                                │
 │  MCP Server (stdio, long-lived)                             │
 │  ┌─────────────────────────────────────────────────────┐    │
@@ -204,7 +217,7 @@ User prompt contains "remember that we use TypeScript strict"
 │  │ memory_entities      memory_timeline (L2 context)   │    │
 │  │ memory_session_notes memory_fetch   (L3 full)       │    │
 │  │ memory_store         memory_context_budget          │    │
-│  │ memory_health                                       │    │
+│  │ memory_conversation  memory_health                  │    │
 │  │                                                     │    │
 │  │ L1 WorkingMemory: read-through cache over L2        │    │
 │  └─────────────────────────────────────────────────────┘    │
@@ -241,7 +254,8 @@ User prompt contains "remember that we use TypeScript strict"
 │  L2: SessionStore           SQLite                  │
 │  Entities + notes           <10ms access            │
 │  files, errors, decisions   Per-session scope       │
-│  observations (14 patterns) Importance scored 1-5   │
+│  messages (user+assistant)  Importance scored 1-5   │
+│  observations (20+ patterns)FTS5 on conversations   │
 ├─────────────────────────────────────────────────────┤
 │  L3: LongTermStore          SQLite + FTS5 + TF-IDF  │
 │  Cross-session summaries    <100ms access           │
@@ -318,6 +332,12 @@ Claude can call these tools directly during conversation:
 | `memory_timeline` | 2 (context) | ~200 | Then: see what happened before/after a result |
 | `memory_fetch` | 3 (full) | ~500 | Finally: get complete records for specific IDs |
 
+### Conversation
+
+| Tool | What it does | When to use |
+|------|-------------|-------------|
+| `memory_conversation` | Retrieve or search conversation messages | Reviewing what was discussed in a past session |
+
 ### Diagnostics
 
 | Tool | What it does |
@@ -416,6 +436,9 @@ Migration is idempotent — safe to run multiple times with zero duplicates.
 | **v0.8.0** | 91 unit tests (was 0%), L1 read-through cache, PostToolUse batch queue (75ms→3ms), JSONL export/import, data cleanup CLI, CI/CD auto-publish |
 | **v0.8.1** | Token-budget-aware MCP tools (`max_tokens`), proactive mid-session memory retrieval (topic-shift detection), session-end batch flush |
 | **v0.9.0** | Smart budget allocation (priority-based, memory never pushed out), CLAUDE.md adaptive compression (3 levels), overhead warning auto-injection, doubled injection limits |
+| **v0.9.5** | Stable install path — hooks no longer break after reboot or bunx cache cleanup |
+| **v0.9.6** | Agent/Skill result capture, higher summary limits, IDE tag stripping, PostCompact cap, broader observation patterns (20+) |
+| **v0.10.0** | **Full conversation capture** — all user prompts + assistant responses via transcript parsing, `messages` table with FTS5, `memory_conversation` MCP tool, conversation-enriched summaries |
 
 See [CHANGELOG.md](CHANGELOG.md) for full details.
 

package/dist/cli.js

@@ -240,6 +240,49 @@ function applyMigrations(db) {
     db.run("INSERT OR IGNORE INTO schema_versions(version, applied_at) VALUES (4, ?)", [Date.now()]);
     log.info("Migration v4 complete");
   }
+  if (currentVersion < 5) {
+    log.info("Applying migration v5: messages table for conversation capture");
+    db.run(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id    TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        project       TEXT NOT NULL,
+        role          TEXT NOT NULL CHECK(role IN ('user','assistant')),
+        content       TEXT NOT NULL,
+        prompt_number INTEGER NOT NULL DEFAULT 0,
+        timestamp     INTEGER NOT NULL,
+        uuid          TEXT,
+        parent_uuid   TEXT
+      )
+    `);
+    db.run(`CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, prompt_number)`);
+    db.run(`CREATE INDEX IF NOT EXISTS idx_messages_role    ON messages(session_id, role)`);
+    db.run(`CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_uuid ON messages(uuid) WHERE uuid IS NOT NULL`);
+    db.run(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS fts_messages USING fts5(
+        session_id UNINDEXED,
+        role,
+        content,
+        tokenize = 'porter unicode61'
+      )
+    `);
+    db.run(`
+      CREATE TRIGGER IF NOT EXISTS fts_messages_insert
+        AFTER INSERT ON messages BEGIN
+          INSERT INTO fts_messages(rowid, session_id, role, content)
+          VALUES (new.id, new.session_id, new.role, new.content);
+        END
+    `);
+    db.run(`
+      CREATE TRIGGER IF NOT EXISTS fts_messages_delete
+        AFTER DELETE ON messages BEGIN
+          INSERT INTO fts_messages(fts_messages, rowid, session_id, role, content)
+          VALUES ('delete', old.id, old.session_id, old.role, old.content);
+        END
+    `);
+    db.run("INSERT OR IGNORE INTO schema_versions(version, applied_at) VALUES (5, ?)", [Date.now()]);
+    log.info("Migration v5 complete");
+  }
 }
 function getDatabase() {
   if (!_db) {

package/dist/hooks/post-compact.js

@@ -337,6 +337,49 @@ function applyMigrations(db) {
     db.run("INSERT OR IGNORE INTO schema_versions(version, applied_at) VALUES (4, ?)", [Date.now()]);
     log.info("Migration v4 complete");
   }
+  if (currentVersion < 5) {
+    log.info("Applying migration v5: messages table for conversation capture");
+    db.run(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id    TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        project       TEXT NOT NULL,
+        role          TEXT NOT NULL CHECK(role IN ('user','assistant')),
+        content       TEXT NOT NULL,
+        prompt_number INTEGER NOT NULL DEFAULT 0,
+        timestamp     INTEGER NOT NULL,
+        uuid          TEXT,
+        parent_uuid   TEXT
+      )
+    `);
+    db.run(`CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, prompt_number)`);
+    db.run(`CREATE INDEX IF NOT EXISTS idx_messages_role    ON messages(session_id, role)`);
+    db.run(`CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_uuid ON messages(uuid) WHERE uuid IS NOT NULL`);
+    db.run(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS fts_messages USING fts5(
+        session_id UNINDEXED,
+        role,
+        content,
+        tokenize = 'porter unicode61'
+      )
+    `);
+    db.run(`
+      CREATE TRIGGER IF NOT EXISTS fts_messages_insert
+        AFTER INSERT ON messages BEGIN
+          INSERT INTO fts_messages(rowid, session_id, role, content)
+          VALUES (new.id, new.session_id, new.role, new.content);
+        END
+    `);
+    db.run(`
+      CREATE TRIGGER IF NOT EXISTS fts_messages_delete
+        AFTER DELETE ON messages BEGIN
+          INSERT INTO fts_messages(fts_messages, rowid, session_id, role, content)
+          VALUES ('delete', old.id, old.session_id, old.role, old.content);
+        END
+    `);
+    db.run("INSERT OR IGNORE INTO schema_versions(version, applied_at) VALUES (5, ?)", [Date.now()]);
+    log.info("Migration v5 complete");
+  }
 }
 var _db = null;
 function getDatabase() {
@@ -423,6 +466,68 @@ class SessionStore {
   getSessionNotes(session_id) {
     return this.db.query("SELECT * FROM session_notes WHERE session_id = ? ORDER BY created_at ASC").all(session_id);
   }
+  insertMessage(msg) {
+    if (msg.uuid) {
+      const existing = this.db.query("SELECT COUNT(*) as c FROM messages WHERE uuid = ?").get(msg.uuid);
+      if (existing && existing.c > 0)
+        return -1;
+    }
+    const result = this.db.run(`INSERT INTO messages(session_id, project, role, content, prompt_number, timestamp, uuid, parent_uuid)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+      msg.session_id,
+      msg.project,
+      msg.role,
+      msg.content,
+      msg.prompt_number,
+      msg.timestamp,
+      msg.uuid ?? null,
+      msg.parent_uuid ?? null
+    ]);
+    return Number(result.lastInsertRowid);
+  }
+  insertMessages(msgs) {
+    let count = 0;
+    const db = this.db;
+    db.transaction(() => {
+      for (const msg of msgs) {
+        const id = this.insertMessage(msg);
+        if (id !== -1)
+          count++;
+      }
+    })();
+    return count;
+  }
+  getSessionMessages(session_id, role) {
+    if (role) {
+      return this.db.query("SELECT * FROM messages WHERE session_id = ? AND role = ? ORDER BY prompt_number ASC, timestamp ASC").all(session_id, role);
+    }
+    return this.db.query("SELECT * FROM messages WHERE session_id = ? ORDER BY prompt_number ASC, timestamp ASC").all(session_id);
+  }
+  getMessageCount(session_id, role) {
+    if (role) {
+      const row2 = this.db.query("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND role = ?").get(session_id, role);
+      return row2?.c ?? 0;
+    }
+    const row = this.db.query("SELECT COUNT(*) as c FROM messages WHERE session_id = ?").get(session_id);
+    return row?.c ?? 0;
+  }
+  searchMessages(query, limit = 10) {
+    if (!query.trim())
+      return [];
+    const words = query.trim().split(/\s+/).filter((w) => w.length > 1).map((w) => `"${w.replace(/["*^()]/g, "")}"`);
+    if (words.length === 0)
+      return [];
+    const ftsQuery = words.join(" ");
+    try {
+      return this.db.query(`SELECT m.*, rank FROM fts_messages
+           JOIN messages m ON m.id = fts_messages.rowid
+           WHERE fts_messages MATCH ?
+           ORDER BY rank LIMIT ?`).all(ftsQuery, limit);
+    } catch {
+      const pattern = `%${query.replace(/[%_]/g, "\\$&")}%`;
+      return this.db.query("SELECT * FROM messages WHERE content LIKE ? ORDER BY timestamp DESC LIMIT ?").all(pattern, limit);
+    }
+  }
 }
 
 // src/db/long-term-store.ts
@@ -500,37 +605,46 @@ function sanitizeFtsQuery(query) {
 }
 
 // src/summarizer/summarizer-prompts.ts
+function stripNoiseTags(text) {
+  return text.replace(/<ide_opened_file>[\s\S]*?<\/ide_opened_file>\s*/g, "").replace(/<ide_selection>[\s\S]*?<\/ide_selection>\s*/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>\s*/g, "").replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>\s*/g, "").replace(/<command-name>[\s\S]*?<\/command-name>\s*/g, "").replace(/<command-message>[\s\S]*?<\/command-message>\s*/g, "").replace(/<command-args>[\s\S]*?<\/command-args>\s*/g, "").replace(/<local-command-stdout>[\s\S]*?<\/local-command-stdout>\s*/g, "").trim();
+}
 function buildRuleBasedSummary(session, files, errors, decisions, notes = []) {
   const parts = [];
   if (session.user_prompt) {
-    parts.push(`Task: ${session.user_prompt.slice(0, 200)}.`);
+    const cleanPrompt = stripNoiseTags(session.user_prompt);
+    if (cleanPrompt) {
+      parts.push(`Task: ${cleanPrompt.slice(0, 500)}.`);
+    }
   }
   if (files.length > 0) {
-    const listed = files.slice(0, 10).join(", ");
-    parts.push(`Files (${files.length}): ${listed}${files.length > 10 ? ` (+${files.length - 10} more)` : ""}.`);
+    const listed = files.slice(0, 15).join(", ");
+    parts.push(`Files (${files.length}): ${listed}${files.length > 15 ? ` (+${files.length - 15} more)` : ""}.`);
   }
   if (decisions.length > 0) {
-    const listed = decisions.slice(0, 3).map((d) => d.entity_value.slice(0, 100)).join("; ");
+    const listed = decisions.slice(0, 5).map((d) => {
+      const base = d.entity_value.slice(0, 150);
+      const ctx = d.context ? ` \u2192 ${d.context.slice(0, 200)}` : "";
+      return base + ctx;
+    }).join("; ");
     parts.push(`Decisions: ${listed}.`);
   }
   if (errors.length > 0) {
-    const first = errors[0];
-    const ctx = first.context ? ` (${first.context.slice(0, 60)})` : "";
-    parts.push(`Errors (${errors.length}): ${first.entity_value.slice(0, 100)}${ctx}.`);
-    if (errors.length > 1) {
-      parts.push(`Also: ${errors[1].entity_value.slice(0, 80)}.`);
-    }
+    const errorLines = errors.slice(0, 5).map((e) => {
+      const ctx = e.context ? ` (${e.context.slice(0, 100)})` : "";
+      return `${e.entity_value.slice(0, 150)}${ctx}`;
+    });
+    parts.push(`Errors (${errors.length}): ${errorLines.join("; ")}.`);
   }
   if (notes.length > 0) {
-    parts.push(`Notes: ${notes.slice(-2).join("; ").slice(0, 200)}.`);
+    parts.push(`Notes: ${notes.slice(-5).join("; ").slice(0, 500)}.`);
   }
   return parts.join(" ") || `Session in project ${session.project}.`;
 }
 
 // src/summarizer/cli-summarizer.ts
 var log2 = createLogger("cli-summarizer");
-var MAX_PROMPT_CHARS = 4000;
-var MAX_OUTPUT_CHARS = 1000;
+var MAX_PROMPT_CHARS = 6000;
+var MAX_OUTPUT_CHARS = 2000;
 var DEFAULT_TIMEOUT_MS = 30000;
 var _cliAvailable;
 var _cliCheckedAt = 0;
@@ -550,27 +664,30 @@ function isClaudeCliAvailable() {
   _cliCheckedAt = Date.now();
   return _cliAvailable;
 }
+function stripNoise(text) {
+  return text.replace(/<ide_opened_file>[\s\S]*?<\/ide_opened_file>\s*/g, "").replace(/<ide_selection>[\s\S]*?<\/ide_selection>\s*/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>\s*/g, "").replace(/<local-command-[\w-]+>[\s\S]*?<\/local-command-[\w-]+>\s*/g, "").replace(/<command-[\w-]+>[\s\S]*?<\/command-[\w-]+>\s*/g, "").trim();
+}
 function buildCliPrompt(ctx) {
   const sections = [
-    "Summarize this coding session in 2-3 plain sentences. No markdown, no headers, no code blocks.",
-    "Focus on: what was accomplished, key decisions, important findings.",
+    "Summarize this coding session in 3-5 plain sentences. No markdown, no headers, no code blocks.",
+    "Focus on: what was accomplished, key decisions, important findings, tools/agents used.",
     "",
     `Project: ${ctx.project}`
   ];
   if (ctx.files.length > 0) {
-    sections.push(`Files modified: ${ctx.files.slice(0, 10).join(", ")}`);
+    sections.push(`Files modified: ${ctx.files.slice(0, 15).join(", ")}`);
   }
   if (ctx.errors.length > 0) {
-    sections.push(`Errors resolved: ${ctx.errors.slice(0, 5).join("; ")}`);
+    sections.push(`Errors resolved: ${ctx.errors.slice(0, 5).map(stripNoise).join("; ")}`);
   }
   if (ctx.decisions.length > 0) {
-    sections.push(`Decisions: ${ctx.decisions.slice(0, 5).join("; ")}`);
+    sections.push(`Decisions: ${ctx.decisions.slice(0, 8).map(stripNoise).join("; ")}`);
   }
   if (ctx.notes.length > 0) {
-    sections.push(`Notes: ${ctx.notes.slice(0, 3).join("; ")}`);
+    sections.push(`Notes: ${ctx.notes.slice(0, 5).map(stripNoise).join("; ")}`);
   }
   if (ctx.observations.length > 0) {
-    sections.push(`Key observations: ${ctx.observations.slice(0, 3).join("; ")}`);
+    sections.push(`Key observations: ${ctx.observations.slice(0, 5).map(stripNoise).join("; ")}`);
   }
   let prompt = sections.join(`
 `);
@@ -666,24 +783,34 @@ class SessionSummarizer {
     const decisions = this.sessionStore.getSessionDecisions(session_id);
     const observations = this.sessionStore.getSessionObservations(session_id);
     const notes = this.sessionStore.getSessionNotes(session_id).map((n) => n.content);
-    if (files.length === 0 && errors.length === 0 && notes.length === 0)
+    const messages = this.sessionStore.getSessionMessages(session_id);
+    if (files.length === 0 && errors.length === 0 && notes.length === 0 && messages.length === 0)
       return;
     const hasModified = this.sessionStore.hasModifiedFiles(session_id);
-    if (!hasModified && errors.length === 0 && decisions.length === 0 && notes.length === 0 && observations.length === 0)
+    if (!hasModified && errors.length === 0 && decisions.length === 0 && notes.length === 0 && observations.length === 0 && messages.length === 0)
       return;
-    const obsValues = observations.slice(0, 5).map((o) => o.entity_value);
+    const userPrompts = messages.filter((m) => m.role === "user").slice(0, 10).map((m, i) => `[${i + 1}] ${m.content.slice(0, 150)}`);
+    const conversationDigest = userPrompts.length > 0 ? `User requests (${userPrompts.length}): ${userPrompts.join("; ")}` : "";
+    const obsValues = observations.slice(0, 8).map((o) => o.entity_value);
     let summaryText;
     let tier = "rule-based";
     const llmMode = process.env["CLAUDE_MEMORY_HUB_LLM"] ?? "auto";
     if (llmMode !== "rule-based") {
+      const decisionDetails = decisions.slice(0, 8).map((d) => {
+        const ctx2 = d.context ? ` \u2192 ${d.context.slice(0, 200)}` : "";
+        return d.entity_value.slice(0, 150) + ctx2;
+      });
+      const allNotes = [...notes.slice(0, 5)];
+      if (conversationDigest)
+        allNotes.push(conversationDigest);
       const ctx = {
         sessionId: session_id,
         project,
         files,
-        errors: errors.slice(0, 5).map((e) => e.entity_value.slice(0, 100)),
-        decisions: decisions.slice(0, 5).map((d) => d.entity_value.slice(0, 100)),
-        notes: notes.slice(0, 3),
-        observations: obsValues.slice(0, 3)
+        errors: errors.slice(0, 5).map((e) => e.entity_value.slice(0, 150)),
+        decisions: decisionDetails,
+        notes: allNotes,
+        observations: obsValues.slice(0, 5)
       };
       summaryText = await tryCliSummary(ctx);
       if (summaryText)
@@ -691,6 +818,8 @@ class SessionSummarizer {
     }
     if (!summaryText) {
       const allNotes = [...notes, ...obsValues];
+      if (conversationDigest)
+        allNotes.push(conversationDigest);
       summaryText = buildRuleBasedSummary(session, files, errors, decisions, allNotes);
     }
     log3.info("Summary generated", { session_id, tier, length: summaryText.length });
@@ -774,10 +903,14 @@ async function handlePostCompact(hook, project) {
   const files = store.getSessionFiles(hook.session_id);
   const decisions = store.getSessionDecisions(hook.session_id);
   const errors = store.getSessionErrors(hook.session_id);
+  const MAX_COMPACT_SUMMARY = 5000;
+  const summary = hook.compact_summary.length > MAX_COMPACT_SUMMARY ? hook.compact_summary.slice(0, MAX_COMPACT_SUMMARY - 20) + `
+
+[truncated]` : hook.compact_summary;
   ltStore.upsertSummary({
     session_id: hook.session_id,
     project,
-    summary: hook.compact_summary,
+    summary,
     files_touched: JSON.stringify(files.slice(0, 50)),
     decisions: JSON.stringify(decisions.slice(0, 20).map((d) => d.entity_value)),
     errors_fixed: JSON.stringify(errors.slice(0, 10).map((e) => e.entity_value.slice(0, 100))),
@@ -898,18 +1031,26 @@ function extractCodePatterns(content) {
 var TOOL_OUTPUT_HEURISTICS = [
   { pattern: /\b(IMPORTANT|CRITICAL|WARNING|BREAKING)\b/i, importance: 4, label: "important" },
   { pattern: /\b(DEPRECATED|SECURITY|VULNERABILITY)\b/i, importance: 4, label: "security" },
+  { pattern: /\b(migration failed|data loss|corrupt)/i, importance: 4, label: "data-risk" },
   { pattern: /\b(decision:|decided to|NOTE:|conclusion:)/i, importance: 3, label: "decision-note" },
   { pattern: /\b(discovered|found that|learned|realized|root cause)\b/i, importance: 3, label: "discovery" },
   { pattern: /\b(workaround:|alternative:|instead of|switched to)/i, importance: 3, label: "approach-change" },
+  { pattern: /\b(refactored?|migrated?|upgraded?|replaced)\b/i, importance: 3, label: "refactor" },
+  { pattern: /\b(installed|added dependency|npm install|bun add)\b/i, importance: 2, label: "dependency" },
   { pattern: /\b(TODO:|FIXME:|HACK:|WORKAROUND:)/i, importance: 2, label: "todo-note" },
   { pattern: /\b(performance:|bottleneck|slow|timeout|OOM)/i, importance: 2, label: "performance" },
+  { pattern: /\b(created|scaffolded|initialized|bootstrapped)\b/i, importance: 2, label: "creation" },
+  { pattern: /\b(tests? (?:pass|fail)|coverage|assertion)/i, importance: 2, label: "test-result" },
+  { pattern: /\b(deployed|published|released|pushed to)\b/i, importance: 2, label: "deployment" },
   { pattern: /^>\s+.{10,}/m, importance: 2, label: "quoted" }
 ];
 var PROMPT_HEURISTICS = [
   { pattern: /\b(IMPORTANT|CRITICAL|MUST)\b/i, importance: 4, label: "user-important" },
   { pattern: /\b(remember that|note that|I decided|we should|keep in mind)\b/i, importance: 3, label: "user-note" },
   { pattern: /\b(don't|do not|never|avoid|stop)\b/i, importance: 3, label: "user-constraint" },
-  { pattern: /\b(prefer|always use|convention is|pattern is)\b/i, importance: 2, label: "user-preference" }
+  { pattern: /\b(fix|debug|investigate|analyze|resolve)\b/i, importance: 2, label: "user-task" },
+  { pattern: /\b(prefer|always use|convention is|pattern is)\b/i, importance: 2, label: "user-preference" },
+  { pattern: /\b(implement|build|create|add feature|integrate)\b/i, importance: 2, label: "user-feature" }
 ];
 var MAX_VALUE_LENGTH = 500;
 var MIN_INPUT_LENGTH = 20;
@@ -1018,13 +1159,15 @@ function extractEntities(hook, promptNumber = 0) {
     case "Agent": {
       const subagentType = stringField2(tool_input, "subagent_type") ?? "general-purpose";
       const prompt = stringField2(tool_input, "prompt") ?? "";
-      raw.push(makeEntity(session_id, project, tool_name, "decision", `agent:${subagentType}: ${prompt.slice(0, 100)}`, 3, now, promptNumber));
+      const agentResult = extractAgentResult(tool_response);
+      raw.push(makeEntity(session_id, project, tool_name, "decision", `agent:${subagentType}: ${prompt.slice(0, 200)}`, 3, now, promptNumber, agentResult || undefined));
       break;
     }
     case "Skill": {
       const skillName = stringField2(tool_input, "skill") ?? "unknown";
       const args = stringField2(tool_input, "args") ?? "";
-      raw.push(makeEntity(session_id, project, tool_name, "decision", `skill:${skillName} ${args.slice(0, 80)}`.trim(), 2, now, promptNumber));
+      const skillResult = extractAgentResult(tool_response);
+      raw.push(makeEntity(session_id, project, tool_name, "decision", `skill:${skillName} ${args.slice(0, 120)}`.trim(), 2, now, promptNumber, skillResult || undefined));
       break;
     }
     default:
@@ -1055,6 +1198,15 @@ function stringField2(obj, key) {
 function deriveProject(hook) {
   return "unknown";
 }
+function extractAgentResult(response) {
+  if (!response)
+    return;
+  const r = response;
+  const text = typeof r === "string" ? r : stringField2(r, "result") ?? stringField2(r, "output") ?? stringField2(r, "content") ?? stringField2(r, "text");
+  if (!text)
+    return;
+  return text.length > 800 ? text.slice(0, 797) + "..." : text;
+}
 function extractFileFromBashCmd(cmd) {
   const patterns = [
     /(?:cp|mv)\s+\S+\s+(\S+\.[\w]+)/,
@@ -1971,6 +2123,18 @@ async function handleUserPromptSubmit(hook, project) {
     user_prompt: cleanPrompt.slice(0, 500) || hook.prompt.slice(0, 500),
     status: "active"
   });
+  const promptText = cleanPrompt || hook.prompt;
+  if (promptText.length > 5) {
+    const promptNum = store.getMessageCount(hook.session_id, "user");
+    store.insertMessage({
+      session_id: hook.session_id,
+      project,
+      role: "user",
+      content: promptText.slice(0, 2000),
+      prompt_number: promptNum,
+      timestamp: Date.now()
+    });
+  }
   const promptObs = extractObservationFromPrompt(cleanPrompt || hook.prompt, hook.session_id, project, 0);
   if (promptObs)
     store.insertEntity({ ...promptObs, project });