pi-hermes-memory 0.3.3 → 0.4.1

package/README.md

@@ -19,6 +19,9 @@ 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
 
@@ -157,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
 
@@ -211,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
 
@@ -254,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,
@@ -271,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) |
@@ -290,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
@@ -297,11 +328,13 @@ 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/`.
 

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,113 @@
+# 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
+- [x] Install `better-sqlite3` + `@types/better-sqlite3`
+- [x] Create `src/store/db.ts` — DatabaseManager class
+- [x] Create `tests/store/db.test.ts` — 14 tests passing
+
+### Task 1.2: Create schema and migrations
+- [x] Define schema in `src/store/schema.ts`
+- [x] Add triggers to keep FTS index in sync
+- [x] Test: schema creates cleanly on fresh DB, idempotent on existing DB
+
+---
+
+## Epic 2: Session History Indexing ✅
+
+### Task 2.1: JSONL parser
+- [x] Create `src/store/session-parser.ts`
+- [x] Create `tests/store/session-parser.test.ts` — 14 tests passing
+
+### Task 2.2: Session indexer
+- [x] Create `src/store/session-indexer.ts`
+- [x] Create `tests/store/session-indexer.test.ts` — 12 tests passing
+
+### Task 2.3: /memory-index-sessions command
+- [x] Create `src/handlers/index-sessions.ts`
+- [x] Wire into `src/index.ts`
+
+---
+
+## Epic 3: Session Search ✅
+
+### Task 3.1: Session search store
+- [x] Create `src/store/session-search.ts` — FTS5 search
+- [x] Create `tests/store/session-search.test.ts` — 11 tests passing
+
+### Task 3.2: session_search tool
+- [x] Create `src/tools/session-search-tool.ts`
+- [x] Register in `src/index.ts`
+
+---
+
+## Epic 4: Extended Memory Store ✅
+
+### Task 4.1: SQLite memory store
+- [x] Create `src/store/sqlite-memory-store.ts`
+- [x] Create `tests/store/sqlite-memory-store.test.ts` — 19 tests passing
+
+### Task 4.2: memory_search tool
+- [x] Create `src/tools/memory-search-tool.ts`
+- [x] Register in `src/index.ts`
+
+---
+
+## Epic 5: Char Limit Increase ✅
+
+### Task 5.1: Update defaults
+- [x] Update `src/constants.ts` — 5000 defaults
+- [x] Update `src/types.ts` — updated comments
+- [x] Update README configuration table
+
+### Task 5.2: Update tests
+- [x] Updated all tests that depend on char limits
+- [x] Verified consolidation still works at new limits
+
+---
+
+## Epic 6: Integration & Polish ✅
+
+### Task 6.1: Wire everything into index.ts
+- [x] Initialize DatabaseManager on extension load
+- [x] Register `session_search` and `memory_search` tools
+- [x] Register `/memory-index-sessions` command
+- [x] Auto-index session on `session_shutdown` event
+
+### Task 6.2: Add session indexing to background review
+- [x] Auto-index on session_shutdown (indexes most recent session)
+
+### Task 6.3: Update README
+- [x] Added session history search and extended memory sections
+- [x] Updated char limits: 2200/1375 → 5000
+- [x] Updated configuration table and JSON example
+- [x] Updated Where Data Lives with sessions.db
+- [x] Updated Known Limitations
+
+### Task 6.4: Version bump & release
+- [x] Bump version to `0.4.0`
+- [x] Run full test suite — 272 tests passing
+- [x] Publish to npm
+- [x] Create GitHub release
+
+---
+
+## Summary
+
+| Epic | Files Created | Tests |
+|---|---|---|
+| 1. SQLite Foundation | db.ts, schema.ts | 14 |
+| 2. Session Indexing | session-parser.ts, session-indexer.ts, index-sessions.ts | 26 |
+| 3. Session Search | session-search.ts, session-search-tool.ts | 11 |
+| 4. Extended Memory | sqlite-memory-store.ts, memory-search-tool.ts | 19 |
+| 5. Char Limits | constants.ts, types.ts | — |
+| 6. Integration | index.ts, README.md, learn-memory-tool skill | — |
+| **Total** | **12 new files** | **272 tests** |

package/docs/ROADMAP.md

@@ -242,50 +242,68 @@ Project-scoped memory (`~/.pi/agent/<project>/MEMORY.md`) was added in the featu
 
 ---
 
-## v0.4.0 — Structured Storage + Session Search
+## v0.4.0 — SQLite FTS5 Session Search + Hybrid Memory
 
-**Goal**: SQLite backend with FTS5 full-text search over all past conversations. MemoryBackend interface for pluggable storage. Keep the same tool interface.
+**Goal**: SQLite backend with FTS5 full-text search over all past conversations. Extended memory store with unlimited capacity. Increased core memory limits.
 
-### Core Abstraction
+**Why now**: Power users hit the 2,200-char limit and lose important knowledge. Past sessions are rich with context but unreachable. Hybrid memory solves both — core memories always injected, deep knowledge searchable on demand.
 
-```typescript
-interface MemoryBackend {
-  // Write
-  add(target: "memory" | "user", entry: MemoryEntry): Promise<MemoryResult>;
-  replace(target: "memory" | "user", query: string, entry: MemoryEntry): Promise<MemoryResult>;
-  remove(target: "memory" | "user", query: string): Promise<MemoryResult>;
+**Full plan**: `docs/0.4/PLAN.md` · **Tasks**: `docs/0.4/TASKS.md`
 
-  // Read
-  getAll(target: "memory" | "user"): Promise<MemoryEntry[]>;
-  search(query: string, limit?: number): Promise<MemoryEntry[]>;
+### Architecture
 
-  // Lifecycle
-  formatForSystemPrompt(cwd?: string, prompt?: string): Promise<string>;
-  close(): Promise<void>;
-}
 ```
+Session starts
+    ↓
+┌─────────────────────────────────────────────────┐
+│ System Prompt (always injected)                 │
+│ • MEMORY.md — 5,000 chars (up from 2,200)      │
+│ • USER.md — 5,000 chars (up from 1,375)        │
+│ • Project MEMORY.md — 5,000 chars              │
+│ • Skills index                                 │
+└─────────────────────────────────────────────────┘
+
+Agent has access to tools:
+    memory_search("prisma migration")
+        → Searches SQLite 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
 
-Current `MemoryStore` becomes `MarkdownBackend` — the default, zero-dependency implementation. New `SQLiteBackend` adds structure + FTS5 search.
+- `~/.pi/agent/memory/sessions.db` — single SQLite file
+- `sessions` + `messages` tables — all past conversations indexed
+- `message_fts` FTS5 virtual table — full-text search across messages
+- `memories` table — extended memory entries (unlimited, searchable)
+- `memory_fts` FTS5 virtual table — full-text search across memories
 
 ### Deliverables
 
-- [ ] `MemoryBackend` interface in `src/types.ts`
-- [ ] `MarkdownBackend` — wraps current `MemoryStore` (backwards compatible)
-- [ ] `SQLiteBackend` — FTS5 search, key-value entries, confidence scores, dedup by key
-- [ ] Session indexer — index past and current session conversations for full-text search
-- [ ] `session_search` tool — agent can query past conversations on demand
-- [ ] Summarization via `pi.exec()` — summarize relevant session fragments to keep token cost manageable
-- [ ] Config: `"backend": "markdown" | "sqlite"` (defaults to `markdown` for zero-dep install)
+- [ ] `better-sqlite3` dependency — SQLite with FTS5
+- [ ] `src/store/db.ts` — DatabaseManager (lazy init, WAL mode, auto-create tables)
+- [ ] `src/store/session-parser.ts` — JSONL parser for Pi session files
+- [ ] `src/store/session-indexer.ts` — index sessions + messages into SQLite
+- [ ] `src/store/session-search.ts` — FTS5 search across session history
+- [ ] `src/store/sqlite-memory-store.ts` — extended memory store (unlimited, searchable)
+- [ ] `session_search` tool — agent queries past conversations
+- [ ] `memory_search` tool — agent queries extended memories
+- [ ] `/memory-index-sessions` command — bulk import existing sessions
+- [ ] Auto-index session on shutdown
+- [ ] Char limits: MEMORY.md 2,200 → 5,000, USER.md 1,375 → 5,000, project 2,200 → 5,000
 - [ ] Config: `sessionSearchEnabled: boolean` (default: true)
 - [ ] Config: `sessionRetentionDays: number` (default: 90)
-- [ ] Migration tool: markdown → sqlite one-time import
 
 ### What Does NOT Change
 
-- Content scanner (guards all backends)
-- Tool interface (`memory` tool name and actions)
+- Content scanner (guards all writes)
+- Memory tool interface (add/replace/remove actions)
 - System prompt injection (frozen snapshot pattern)
-- Config file location and format (just adds new fields)
+- Skills system (unchanged)
+- Background review, correction detection, auto-consolidation (unchanged)
 
 ---
 
@@ -387,7 +405,7 @@ gantt
     Project memory polish                            :v03d, after v03c, 2d
 
     section v0.4.0
-    MemoryBackend interface + SQLite + session search:v04a, after v03d, 10d
+    SQLite FTS5 + session search + hybrid memory    :v04a, after v03d, 10d
 
     section v0.5.0
     ExternalSync + Mem0 / Honcho                     :v05a, after v04b, 10d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "Your Pi agent remembers everything across sessions — your preferences, your stack, your corrections, and even how it solved problems. Zero-config install, works immediately. Persistent memory + procedural skills + auto-correction detection + security-first content scanning.",
   "type": "module",
   "main": "src/index.ts",
@@ -43,8 +43,12 @@
   "devDependencies": {
     "@mariozechner/pi-ai": "^0.70.0",
     "@mariozechner/pi-coding-agent": "^0.70.0",
+    "@types/better-sqlite3": "^7.6.13",
     "tsx": "^4.21.0",
     "typebox": "^1.1.33",
     "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.9.0"
   }
 }

package/src/constants.ts

@@ -8,11 +8,11 @@
 export const ENTRY_DELIMITER = "\n§\n";
 
 // ─── Character limits (not tokens — model-independent) ───
-export const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
-export const DEFAULT_USER_CHAR_LIMIT = 1375;
+export const DEFAULT_MEMORY_CHAR_LIMIT = 5000;
+export const DEFAULT_USER_CHAR_LIMIT = 5000;
 
 // ─── Learning loop defaults ───
-export const DEFAULT_PROJECT_CHAR_LIMIT = 2200;
+export const DEFAULT_PROJECT_CHAR_LIMIT = 5000;
 
 export const DEFAULT_NUDGE_INTERVAL = 10;
 export const DEFAULT_FLUSH_MIN_TURNS = 6;

package/src/handlers/index-sessions.ts

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import os from 'node:os';
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { DatabaseManager } from '../store/db.js';
+import { indexAllSessions, getSessionStats } from '../store/session-indexer.js';
+
+const SESSIONS_DIR = path.join(os.homedir(), '.pi', 'agent', 'sessions');
+
+export function registerIndexSessionsCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("memory-index-sessions", {
+    description: "Import past Pi sessions into the search database",
+    handler: async (_args, ctx) => {
+      const sendUserMessage = (msg: string) => {
+        if (ctx && typeof ctx === 'object' && 'sendUserMessage' in ctx) {
+          (ctx as { sendUserMessage: (msg: string) => void }).sendUserMessage(msg);
+        }
+      };
+
+      sendUserMessage('🔍 Indexing session history...');
+
+      try {
+        const memoryDir = path.join(os.homedir(), '.pi', 'agent', 'memory');
+        const dbManager = new DatabaseManager(memoryDir);
+
+        try {
+          const result = indexAllSessions(dbManager, SESSIONS_DIR);
+          const stats = getSessionStats(dbManager);
+
+          let output = `\n✅ Session indexing complete!\n\n`;
+          output += `📊 Results:\n`;
+          output += `• Sessions processed: ${result.sessionsProcessed}\n`;
+          output += `• Sessions indexed: ${result.sessionsIndexed}\n`;
+          output += `• Sessions skipped (already indexed): ${result.sessionsSkipped}\n`;
+          output += `• Messages indexed: ${result.messagesIndexed}\n`;
+
+          if (stats.projects.length > 0) {
+            output += `\n📁 Projects:\n`;
+            for (const p of stats.projects) {
+              output += `• ${p.project}: ${p.sessions} sessions, ${p.messages} messages\n`;
+            }
+          }
+
+          if (result.errors.length > 0) {
+            output += `\n⚠️ Errors (${result.errors.length}):\n`;
+            for (const err of result.errors.slice(0, 5)) {
+              output += `• ${err}\n`;
+            }
+            if (result.errors.length > 5) {
+              output += `• ... and ${result.errors.length - 5} more\n`;
+            }
+          }
+
+          output += `\n💡 Use the \`session_search\` tool to search across indexed sessions.`;
+
+          sendUserMessage(output);
+        } finally {
+          dbManager.close();
+        }
+      } catch (err) {
+        sendUserMessage(`❌ Session indexing failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  });
+}

package/src/index.ts

@@ -27,8 +27,13 @@ import * as os from "node:os";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { MemoryStore } from "./store/memory-store.js";
 import { SkillStore } from "./store/skill-store.js";
+import { DatabaseManager } from "./store/db.js";
+import { indexSession } from "./store/session-indexer.js";
+import { parseSessionFile } from "./store/session-parser.js";
 import { registerMemoryTool } from "./tools/memory-tool.js";
 import { registerSkillTool } from "./tools/skill-tool.js";
+import { registerSessionSearchTool } from "./tools/session-search-tool.js";
+import { registerMemorySearchTool } from "./tools/memory-search-tool.js";
 import { setupBackgroundReview } from "./handlers/background-review.js";
 import { setupSessionFlush } from "./handlers/session-flush.js";
 import { registerInsightsCommand } from "./handlers/insights.js";
@@ -38,6 +43,7 @@ import { setupSkillAutoTrigger } from "./handlers/skill-auto-trigger.js";
 import { registerSkillsCommand } from "./handlers/skills-command.js";
 import { registerInterviewCommand } from "./handlers/interview.js";
 import { registerSwitchProjectCommand } from "./handlers/switch-project.js";
+import { registerIndexSessionsCommand } from "./handlers/index-sessions.js";
 import { loadConfig } from "./config.js";
 import { detectProject } from "./project.js";
 
@@ -47,6 +53,7 @@ export default function (pi: ExtensionAPI) {
   const globalDir = config.memoryDir ?? path.join(os.homedir(), ".pi", "agent", "memory");
   const store = new MemoryStore(config);
   const skillStore = new SkillStore(path.join(globalDir, "skills"));
+  const dbManager = new DatabaseManager(globalDir);
 
   // Detect project from cwd using shared helper
   const project = detectProject();
@@ -111,4 +118,36 @@ export default function (pi: ExtensionAPI) {
   registerSkillsCommand(pi, skillStore);
   registerInterviewCommand(pi, store);
   registerSwitchProjectCommand(pi);
+
+  // ── 11. SQLite session search + extended memory ──
+  registerSessionSearchTool(pi, dbManager);
+  registerMemorySearchTool(pi, dbManager);
+  registerIndexSessionsCommand(pi);
+
+  // ── 12. Auto-index session on shutdown ──
+  pi.on("session_shutdown", async (_event, _ctx) => {
+    try {
+      const fs = require("node:fs");
+      const sessionsDir = path.join(os.homedir(), ".pi", "agent", "sessions");
+      const cwd = process.cwd();
+      const encodedCwd = cwd.replace(/\//g, "-");
+      const sessionDir = path.join(sessionsDir, encodedCwd);
+
+      if (fs.existsSync(sessionDir)) {
+        // Find the most recent JSONL file (the one we just finished)
+        const files = fs.readdirSync(sessionDir)
+          .filter((f: string) => f.endsWith(".jsonl"))
+          .sort()
+          .reverse();
+        if (files.length > 0) {
+          const sessionData = parseSessionFile(path.join(sessionDir, files[0]));
+          if (sessionData) {
+            indexSession(dbManager, sessionData);
+          }
+        }
+      }
+    } catch {
+      // Silent fail — don't block shutdown
+    }
+  });
 }