pi-hermes-memory 0.3.3 → 0.4.0

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,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

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.0",
   "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,61 @@
+import path from 'node:path';
+import os from 'node:os';
+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(ctx: {
+  registerCommand: (name: string, handler: (args: string, ctx: unknown) => Promise<void>) => void;
+  sendUserMessage: (msg: string) => void;
+}) {
+  ctx.registerCommand('memory-index-sessions', async (_args: string, cmdCtx: unknown) => {
+    const sendUserMessage = (cmdCtx as { sendUserMessage?: (msg: string) => void }).sendUserMessage
+      ?? ctx.sendUserMessage;
+
+    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)}`);
+    }
+  });
+}