pi-hermes-memory 0.3.2 → 0.4.0

package/README.md

@@ -19,56 +19,15 @@ Your Pi agent normally forgets everything when you close a session. This extensi
 | **Memory Aging** | Entries carry timestamps — consolidation knows which facts are stale and which are fresh |
 | **Project Memory** | Per-project memory (`~/.pi/agent/<project>/MEMORY.md`) alongside your global memory |
 | **Secret Detection** | API keys, tokens, SSH keys, and credential assignments are blocked from being persisted to memory |
+| **Session History Search** | Search across all past conversations via SQLite FTS5 — "what did we discuss about auth?" |
+| **Extended Memory Store** | Unlimited searchable memories beyond the core 5,000-char limit |
+| **Learn Memory Tool** | `/learn-memory-tool` — a skill that teaches users how to use the memory system |
 
 ## How It Works
 
 ### Session Lifecycle
 
-```mermaid
-sequenceDiagram
-    participant User
-    participant Pi
-    participant Extension
-    participant Disk as ~/.pi/agent/memory/
-
-    Note over Pi,Disk: ── Session Start ──
-    Pi->>Extension: session_start event
-    Extension->>Disk: loadFromDisk() — read MEMORY.md + USER.md + skills/
-    Extension-->>Extension: Capture frozen snapshot (memory + skill index)
-
-    Note over Pi,Disk: ── System Prompt Injection ──
-    Pi->>Extension: before_agent_start event
-    Extension-->>Pi: systemPrompt + frozen memory block + skill index
-    Note right of Pi: Agent now "remembers"<br/>facts AND procedures<br/>from past sessions
-
-    Note over Pi,Disk: ── Agent Loop ──
-    User->>Pi: "Remember I prefer vim"
-    Pi->>Extension: tool_call (memory, add)
-    Extension->>Extension: scanContent() — security check
-    Extension->>Disk: Atomic write to USER.md
-    Extension-->>Pi: { success: true, usage: "3% — 41/1375" }
-
-    Note over Pi,Disk: ── User Correction ──
-    User->>Pi: "No, don't use npm — use pnpm"
-    Extension->>Extension: isCorrection() = true
-    Extension->>Pi: pi.exec("pi -p", correctionPrompt)
-    Note right of Pi: Immediate save<br/>no waiting for nudge
-
-    Note over Pi,Disk: ── Complex Task (8+ tool calls) ──
-    Pi->>Extension: turn_end (8 tool calls, 3 tool types)
-    Extension->>Pi: pi.exec("pi -p", skillExtractionPrompt)
-    Note right of Pi: Extract reusable<br/>procedure as skill
-
-    Note over Pi,Disk: ── Background Review (10 turns or 15 tool calls) ──
-    Pi->>Extension: turn_end event
-    Extension->>Pi: pi.exec("pi -p", reviewPrompt)
-    Note right of Pi: Reviews conversation<br/>saves memories AND skills
-
-    Note over Pi,Disk: ── Session End ──
-    Pi->>Extension: session_shutdown event
-    Extension->>Pi: pi.exec("pi -p", flushPrompt)
-    Note right of Pi: One last turn to flush<br/>anything worth saving
-```
+![Session Lifecycle](docs/images/session-lifecycle.svg)
 
 ### Memory + Skills Architecture
 
@@ -80,63 +39,13 @@ The extension manages three types of knowledge:
 | **User Profile** (USER.md) | Who you are — name, preferences, communication style | 1,375 chars max | Fixed per session |
 | **Skills** (skills/*.md) | Procedures — *how* to do something, reusable across sessions | Unlimited | ~3K for index, full on demand |
 
-```mermaid
-graph TB
-    subgraph "Persistent Storage"
-        MEM["MEMORY.md<br/><i>Agent's notes</i>"]
-        USR["USER.md<br/><i>User profile</i>"]
-        SKL["skills/<br/><i>Procedural memory</i><br/>debug-ts.md<br/>deploy-checklist.md"]
-    end
-
-    subgraph "System Prompt (frozen snapshot)"
-        SMEM["Memory block<br/>Full content"]
-        SUSR["User block<br/>Full content"]
-        SSKL["Skill index<br/>Names + descriptions only"]
-    end
-
-    subgraph "On Demand (via skill tool)"
-        FULL["Full skill content<br/>Loaded when needed"]
-    end
-
-    MEM --> SMEM
-    USR --> SUSR
-    SKL --> SSKL
-    SSKL -.->|"skill view"| FULL
-
-    style SMEM fill:#1a1a2e,stroke:#e94560,color:#fff
-    style SUSR fill:#1a1a2e,stroke:#e94560,color:#fff
-    style SSKL fill:#16213e,stroke:#0f3460,color:#fff
-    style FULL fill:#0a1128,stroke:#1282a2,color:#fff
-```
+![Memory + Skills Architecture](docs/images/memory-architecture.svg)
 
 ### Security: Content Scanning
 
 Every write — memory and skills — passes through a scanner before being accepted. This prevents the LLM from being tricked into storing malicious content that would later be injected into the system prompt.
 
-```mermaid
-flowchart LR
-    A["LLM calls<br/>memory or skill"] --> B{scanContent}
-    B -->|Blocked| C["❌ Return error"]
-    B -->|Safe| D{Char limit<br/>check}
-    D -->|Exceeds| E{autoConsolidate?}
-    E -->|Yes| G["🔄 Merge & prune<br/>then retry"]
-    E -->|No| F["❌ Return budget error"]
-    D -->|Within limit| H["✅ Write to disk"]
-
-    subgraph "Blocked Patterns"
-        P1["'ignore previous instructions'"]
-        P2["'curl ${API_KEY}'"]
-        P3["Zero-width chars"]
-    end
-
-    B -.- P1
-    B -.- P2
-    B -.- P3
-
-    style C fill:#3d0000,stroke:#ff4444,color:#fff
-    style G fill:#003d3d,stroke:#00cccc,color:#fff
-    style H fill:#003d00,stroke:#44ff44,color:#fff
-```
+![Security: Content Scanning](docs/images/security-flow.svg)
 
 ## Installation
 
@@ -251,9 +160,34 @@ Run `tsc --noEmit` and confirm zero errors.
 
 | Store | File | What goes here | Limit |
 |---|---|---|---|
-| **memory** | `MEMORY.md` | Agent's notes — env facts, project conventions, tool quirks, lessons learned | 2,200 chars |
-| **user** | `USER.md` | User profile — name, preferences, communication style, habits | 1,375 chars |
+| **memory** | `MEMORY.md` | Agent's notes — env facts, project conventions, tool quirks, lessons learned | 5,000 chars |
+| **user** | `USER.md` | User profile — name, preferences, communication style, habits | 5,000 chars |
 | **skills** | `skills/*.md` | Procedures — *how* to debug, deploy, test, or fix something | Unlimited |
+| **extended** | `sessions.db` | Searchable memories beyond the core limit | Unlimited |
+| **sessions** | `sessions.db` | Past conversation history (searchable via FTS5) | Unlimited |
+
+### Session History Search
+
+The extension indexes your Pi session history into a SQLite database with FTS5 full-text search. The agent can search across all past conversations using the `session_search` tool:
+
+| Tool | What it does |
+|---|---|---|
+| `session_search` | Search past conversations — "what did we discuss about auth?" |
+| `memory_search` | Search extended memory store — unlimited capacity, keyword-based |
+
+Session history is indexed automatically on session shutdown. To bulk-import existing sessions:
+
+```
+/memory-index-sessions
+```
+
+### Extended Memory Store
+
+When the core memory (5,000 chars) isn't enough, the agent can store additional memories in the SQLite-backed extended store. These are searchable via `memory_search` but not automatically injected into the system prompt.
+
+This is the **hybrid memory architecture**:
+- **Core memory** (MEMORY.md/USER.md): Always injected, 5,000 chars each, human-readable
+- **Extended memory** (SQLite): Unlimited, searchable on demand, agent-driven
 
 ### Correction Detection
 
@@ -305,6 +239,8 @@ This means skills build up naturally over time without you having to ask.
 | `/memory-consolidate` | Manually trigger memory consolidation to free space |
 | `/memory-interview` | Answer a few questions to pre-fill your user profile |
 | `/memory-switch-project` | List all project memories and their entry counts |
+| `/memory-index-sessions` | Import past Pi sessions into the search database |
+| `/learn-memory-tool` | Skill that teaches users how to use the memory system |
 
 ### `/memory-insights` Output
 
@@ -348,9 +284,9 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 
 ```json
 {
-  "memoryCharLimit": 2200,
-  "userCharLimit": 1375,
-  "projectCharLimit": 2200,
+  "memoryCharLimit": 5000,
+  "userCharLimit": 5000,
+  "projectCharLimit": 5000,
   "memoryDir": "~/.pi/agent/memory",
   "nudgeInterval": 10,
   "nudgeToolCalls": 15,
@@ -365,9 +301,9 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 
 | Setting | Default | Description |
 |---|---|---|
-| `memoryCharLimit` | `2200` | Max characters in MEMORY.md |
-| `userCharLimit` | `1375` | Max characters in USER.md |
-| `projectCharLimit` | `2200` | Max characters in project-scoped MEMORY.md |
+| `memoryCharLimit` | `5000` | Max characters in MEMORY.md |
+| `userCharLimit` | `5000` | Max characters in USER.md |
+| `projectCharLimit` | `5000` | Max characters in project-scoped MEMORY.md |
 | `memoryDir` | `~/.pi/agent/memory` | Custom directory for memory files |
 | `nudgeInterval` | `10` | Turns between auto-reviews |
 | `nudgeToolCalls` | `15` | Tool calls between auto-reviews (OR with turns) |
@@ -384,6 +320,7 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 ~/.pi/agent/memory/
 ├── MEMORY.md          ← Agent's personal notes (env facts, patterns, lessons)
 ├── USER.md            ← User profile (name, preferences, habits)
+├── sessions.db        ← SQLite database (session history + extended memory)
 └── skills/
     ├── debug-typescript-errors.md
     └── deploy-checklist.md
@@ -391,60 +328,19 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 
 These are plain markdown files. You can read and edit them directly if you want to curate what the agent remembers. Memory entries are separated by `§` (section sign). Skills use standard SKILL.md format with frontmatter.
 
+The `sessions.db` SQLite database stores session history and extended memory entries. It's searchable via FTS5 full-text search.
+
 ## Known Limitations
 
 - **`§` delimiter**: Memory entries are separated by `§` (section sign). If an entry naturally contains `§`, it will be split incorrectly on reload. This is rare in English text but possible. [Hermes uses the same delimiter.]
 - **Background review cost**: Each review cycle costs one full LLM API call via a child `pi -p` process. Correction detection and skill auto-extraction add occasional extra calls.
-- **No search/indexing**: At the 2,200-char limit, the LLM can scan the entire block. Full-text search across sessions is planned for v0.3.
+- **Session search requires indexing**: Past sessions must be indexed before they're searchable. Run `/memory-index-sessions` to bulk-import, or let the extension auto-index on session shutdown.
 - **System prompts are invisible**: Pi's TUI does not display the system prompt. Memory injection works but you won't see it in the interface — verify by asking the agent a question that relies on stored memory.
 - **Skills are agent-generated**: Skills are created by the agent based on its experience. They may not always be perfectly structured. You can edit or delete them in `~/.pi/agent/memory/skills/`.
 
 ## Architecture
 
-```mermaid
-graph LR
-    subgraph "pi-hermes-memory/src/"
-        IDX["index.ts<br/><i>Entry point</i>"]
-        MS["memory-store.ts<br/><i>Memory CRUD</i>"]
-        SS["skill-store.ts<br/><i>Skill CRUD</i>"]
-        MT["memory-tool.ts<br/><i>Memory LLM tool</i>"]
-        ST["skill-tool.ts<br/><i>Skill LLM tool</i>"]
-        CS["content-scanner.ts<br/><i>Security</i>"]
-        BR["background-review.ts<br/><i>Learning loop</i>"]
-        AC["auto-consolidate.ts<br/><i>Memory merge</i>"]
-        CD["correction-detector.ts<br/><i>Instant save</i>"]
-        SA["skill-auto-trigger.ts<br/><i>Skill extraction</i>"]
-        SF["session-flush.ts<br/><i>Pre-compaction flush</i>"]
-        IN["insights.ts<br/><i>/memory-insights</i>"]
-        SC["skills-command.ts<br/><i>/memory-skills</i>"]
-    end
-
-    IDX --> MS
-    IDX --> SS
-    IDX --> MT
-    IDX --> ST
-    IDX --> BR
-    IDX --> AC
-    IDX --> CD
-    IDX --> SA
-    IDX --> SF
-    IDX --> IN
-    IDX --> SC
-    MT --> MS
-    ST --> SS
-    MS --> CS
-    SS --> CS
-    BR --> MS
-    AC --> MS
-    CD --> MS
-    SA --> MS
-    SA --> SS
-
-    style IDX fill:#e94560,stroke:#fff,color:#fff
-    style MS fill:#0f3460,stroke:#fff,color:#fff
-    style SS fill:#0f3460,stroke:#fff,color:#fff
-    style CS fill:#ff6600,stroke:#fff,color:#fff
-```
+![Source Architecture](docs/images/source-architecture.svg)
 
 ## Credits
 

package/docs/0.4/PLAN.md

@@ -0,0 +1,160 @@
+# v0.4 Plan: SQLite FTS5 Session Search + Hybrid Memory
+
+## Problem
+
+The current memory architecture has two scaling bottlenecks:
+
+1. **Memory capacity**: MEMORY.md is capped at 2,200 chars. Power users accumulate knowledge faster than consolidation can manage. Important facts get pruned.
+2. **No session history search**: Past conversations are stored as JSONL files in `~/.pi/agent/sessions/<project>/`, but there's no way to search them. When the agent needs context from a previous session, it's gone forever.
+
+## Solution: Hybrid Memory Architecture
+
+### Core memory (always injected, unchanged)
+- `MEMORY.md` — 5,000 chars (up from 2,200)
+- `USER.md` — 5,000 chars (up from 1,375)
+- Still injected into every session via `<memory-context>` tags
+- Still human-readable, still editable
+
+### Extended memory (SQLite, searchable on demand)
+- `~/.pi/agent/memory/sessions.db`
+- `memories` table — unlimited entries, searchable via FTS5
+- Agent uses `memory_search` tool to query when it needs context
+- Not automatically injected — agent must explicitly search
+
+### Session history (SQLite, searchable on demand)
+- Same `sessions.db` file
+- `sessions` + `messages` tables — all past conversations indexed
+- `session_fts` FTS5 index — full-text search across all sessions
+- Agent uses `session_search` tool to find relevant past context
+
+## Architecture
+
+```
+Session starts
+    ↓
+┌─────────────────────────────────────────────────┐
+│ System Prompt (always injected)                 │
+│ ┌─────────────────────────────────────────────┐ │
+│ │ <memory-context>                            │ │
+│ │ MEMORY (your personal notes) [5,000 chars]  │ │
+│ │ ═══ END MEMORY ═══                         │ │
+│ │ </memory-context>                           │ │
+│ │ <memory-context>                            │ │
+│ │ USER PROFILE [5,000 chars]                  │ │
+│ │ ═══ END MEMORY ═══                         │ │
+│ │ </memory-context>                           │ │
+│ │ <memory-context>                            │ │
+│ │ PROJECT MEMORY [5,000 chars]                │ │
+│ │ ═══ END MEMORY ═══                         │ │
+│ │ </memory-context>                           │ │
+│ └─────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────┘
+
+Agent has access to tools:
+    memory_search("prisma migration")
+        → Searches memories table (global + project)
+        → Returns top-10 relevant entries
+
+    session_search("how we fixed the test hang")
+        → Searches session history via FTS5
+        → Returns relevant conversation snippets
+```
+
+## Data Model
+
+```sql
+-- Session metadata
+CREATE TABLE sessions (
+  id TEXT PRIMARY KEY,           -- UUID from JSONL
+  project TEXT NOT NULL,         -- decoded cwd path
+  started_at TEXT NOT NULL,      -- ISO timestamp
+  ended_at TEXT,                 -- ISO timestamp (null if still running)
+  message_count INTEGER DEFAULT 0
+);
+
+-- All messages from all sessions
+CREATE TABLE messages (
+  id TEXT PRIMARY KEY,           -- message ID from JSONL
+  session_id TEXT NOT NULL REFERENCES sessions(id),
+  role TEXT NOT NULL,            -- 'user', 'assistant', 'system'
+  content TEXT NOT NULL,         -- extracted text content
+  timestamp TEXT NOT NULL,       -- ISO timestamp
+  tool_calls TEXT                -- JSON array of tool call names (for assistant messages)
+);
+
+-- FTS5 index for full-text search across messages
+CREATE VIRTUAL TABLE message_fts USING fts5(
+  content,
+  content='messages',
+  content_rowid='rowid'
+);
+
+-- Extended memory entries (beyond MEMORY.md limit)
+CREATE TABLE memories (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project TEXT,                  -- NULL for global, project name for project-specific
+  target TEXT NOT NULL,          -- 'memory' or 'user'
+  content TEXT NOT NULL,
+  created DATE NOT NULL,
+  last_referenced DATE NOT NULL
+);
+
+-- FTS5 index for memory search
+CREATE VIRTUAL TABLE memory_fts USING fts5(
+  content,
+  content='memories',
+  content_rowid='id'
+);
+```
+
+## Key Design Decisions
+
+### 1. Session indexing is lazy (on session end)
+- Don't parse JSONL files on every startup
+- Index a session when `session_shutdown` fires
+- Bulk import existing sessions via `/memory-index-sessions` command
+
+### 2. FTS5 for both memories and sessions
+- Keyword search is sufficient for v0.4
+- Embeddings deferred to v0.5+ if search quality isn't enough
+- `better-sqlite3` includes FTS5 by default
+
+### 3. Single DB file
+- `~/.pi/agent/memory/sessions.db` stores everything
+- Memories + sessions + FTS indices in one file
+- Simple backup (copy one file), simple cleanup
+
+### 4. Agent-driven search
+- `memory_search` and `session_search` are LLM tools
+- Agent decides when to search (not automatic)
+- Avoids injecting irrelevant context into every session
+
+### 5. Char limit increase to 5,000
+- MEMORY.md: 2,200 → 5,000 chars
+- USER.md: 1,375 → 5,000 chars
+- Project MEMORY.md: 2,200 → 5,000 chars
+- More room for core memories before consolidation kicks in
+
+## Dependencies
+
+| Package | Purpose | Size |
+|---|---|---|
+| `better-sqlite3` | SQLite with FTS5 | ~1MB native addon |
+
+## Risks
+
+| Risk | Mitigation |
+|---|---|
+| `better-sqlite3` is a native C++ addon | Standard for dev tools; CI has build tools |
+| FTS5 search quality | Start with keyword search, add embeddings later if needed |
+| Session JSONL format changes | Parse defensively, skip unknown message types |
+| Large session history (1000+ sessions) | FTS5 handles this well; add pagination to results |
+| DB corruption | Atomic writes, WAL mode, backup before migrations |
+
+## Success Criteria
+
+1. `session_search("prisma migration")` returns relevant conversation snippets from past sessions
+2. `memory_search("auth setup")` returns relevant entries from extended memory store
+3. MEMORY.md limit raised to 5,000 chars without breaking existing functionality
+4. Existing session files indexed without data loss
+5. All tests pass, zero regressions

package/docs/0.4/TASKS.md

@@ -0,0 +1,146 @@
+# v0.4 Tasks: SQLite FTS5 Session Search + Hybrid Memory
+
+## Status Legend
+- `[ ]` Not started
+- `[~]` In progress
+- `[x]` Done
+
+---
+
+## Epic 1: SQLite Foundation
+
+### Task 1.1: Install better-sqlite3 and create DB module
+- [ ] Install `better-sqlite3` + `@types/better-sqlite3`
+- [ ] Create `src/store/db.ts` — DatabaseManager class
+  - Lazy initialization (create/open DB on first use)
+  - WAL mode for concurrent reads
+  - Auto-create tables if they don't exist
+  - `close()` method for cleanup
+- [ ] Create `tests/store/db.test.ts` — tests for DB initialization, table creation, close/reopen
+
+### Task 1.2: Create schema and migrations
+- [ ] Define schema in `src/store/schema.ts` — all CREATE TABLE statements
+  - `sessions` table
+  - `messages` table
+  - `message_fts` FTS5 virtual table
+  - `memories` table
+  - `memory_fts` FTS5 virtual table
+- [ ] Add triggers to keep FTS index in sync (INSERT/UPDATE/DELETE)
+- [ ] Test: schema creates cleanly on fresh DB, idempotent on existing DB
+
+---
+
+## Epic 2: Session History Indexing
+
+### Task 2.1: JSONL parser
+- [ ] Create `src/store/session-parser.ts`
+  - `parseSessionFile(path)` — read JSONL, extract session metadata + messages
+  - Handle all message types: user, assistant, system, tool_result
+  - Extract text content from `content` array (handle text, thinking, tool_use types)
+  - Skip unknown types gracefully
+  - Return structured `SessionData` with `messages: ParsedMessage[]`
+- [ ] Create `tests/store/session-parser.test.ts` — test with real JSONL fixtures
+
+### Task 2.2: Session indexer
+- [ ] Create `src/store/session-indexer.ts`
+  - `indexSession(db, sessionData)` — INSERT into sessions + messages tables
+  - `indexAllSessions(db, projectPath?)` — bulk index all sessions for a project (or all projects)
+  - Skip already-indexed sessions (by session ID)
+  - `getSessionStats(db)` — count of sessions, messages, indexed projects
+- [ ] Create `tests/store/session-indexer.test.ts` — test indexing, deduplication, stats
+
+### Task 2.3: /memory-index-sessions command
+- [ ] Create `src/handlers/index-sessions.ts`
+  - `/memory-index-sessions` — bulk import existing JSONL sessions
+  - Show progress: "Indexing 36 sessions..."
+  - Show result: "Indexed 36 sessions, 1,247 messages"
+  - Handle errors gracefully (corrupt JSONL, missing files)
+- [ ] Wire into `src/index.ts`
+- [ ] Create `tests/handlers/index-sessions.test.ts`
+
+---
+
+## Epic 3: Session Search
+
+### Task 3.1: Session search store
+- [ ] Add to `src/store/session-indexer.ts` (or separate `session-search.ts`)
+  - `searchSessions(db, query, options?)` — FTS5 search across messages
+  - Options: `limit`, `project`, `role` filter, `since` date filter
+  - Returns: `SearchResult[]` with `{sessionId, role, content, timestamp, snippet, project}`
+  - `snippet` — highlighted match context from FTS5 `snippet()` function
+- [ ] Create `tests/store/session-search.test.ts` — test search, filters, relevance
+
+### Task 3.2: session_search tool
+- [ ] Create `src/tools/session-search-tool.ts`
+  - LLM tool definition: `session_search(query, project?, limit?)`
+  - Returns formatted results for the agent
+  - Includes session date, project, and content snippet
+- [ ] Register in `src/index.ts`
+- [ ] Create `tests/tools/session-search-tool.test.ts`
+
+---
+
+## Epic 4: Extended Memory Store
+
+### Task 4.1: SQLite memory store
+- [ ] Create `src/store/sqlite-memory-store.ts`
+  - `addMemory(db, content, project?, target?)` — INSERT into memories + memory_fts
+  - `searchMemories(db, query, options?)` — FTS5 search across memories
+  - `getMemories(db, project?, target?)` — list all memories (optionally filtered)
+  - `removeMemory(db, id)` — DELETE by ID
+  - `getMemoryStats(db)` — count by project/target
+- [ ] Create `tests/store/sqlite-memory-store.test.ts`
+
+### Task 4.2: memory_search tool
+- [ ] Create `src/tools/memory-search-tool.ts`
+  - LLM tool definition: `memory_search(query, project?, limit?)`
+  - Searches both global and project-specific memories
+  - Returns formatted results for the agent
+- [ ] Register in `src/index.ts`
+- [ ] Create `tests/tools/memory-search-tool.test.ts`
+
+---
+
+## Epic 5: Char Limit Increase
+
+### Task 5.1: Update defaults
+- [ ] Update `src/config.ts` — change defaults:
+  - `memoryCharLimit`: 2200 → 5000
+  - `userCharLimit`: 1375 → 5000
+  - `projectCharLimit`: 2200 → 5000
+- [ ] Update `src/constants.ts` — change constants if any
+- [ ] Update README configuration table
+
+### Task 5.2: Update tests
+- [ ] Update all tests that depend on char limits
+- [ ] Verify consolidation still works at new limits
+- [ ] Verify interview still works at new limits
+
+---
+
+## Epic 6: Integration & Polish
+
+### Task 6.1: Wire everything into index.ts
+- [ ] Initialize DatabaseManager on extension load
+- [ ] Register `session_search` and `memory_search` tools
+- [ ] Register `/memory-index-sessions` command
+- [ ] Auto-index session on `session_shutdown` event
+- [ ] Close DB on extension unload
+
+### Task 6.2: Add session indexing to background review
+- [ ] In `session-flush.ts` — also index the session to SQLite before flushing memories
+- [ ] Ensure session is indexed even if shutdown event is missed
+
+### Task 6.3: Update README
+- [ ] Add "Hybrid Memory Architecture" section
+- [ ] Document `session_search` and `memory_search` tools
+- [ ] Document `/memory-index-sessions` command
+- [ ] Update char limit documentation
+- [ ] Update configuration table
+
+### Task 6.4: Version bump & release
+- [ ] Bump version to `0.4.0`
+- [ ] Update CHANGELOG.md
+- [ ] Run full test suite
+- [ ] Publish to npm
+- [ ] Create GitHub release