@soleri/forge 3.0.0 → 4.1.0

package/src/templates/test-vault.ts

@@ -1,380 +0,0 @@
-/**
- * Generates vault test file for a new agent.
- * Tests cover: constructor, seed, search (FTS5), get, list, stats, add, remove.
- */
-export function generateVaultTest(): string {
-  return VAULT_TEST_TEMPLATE;
-}
-
-const VAULT_TEST_TEMPLATE = [
-  "import { describe, it, expect, beforeEach, afterEach } from 'vitest';",
-  "import { Vault } from '../vault/vault.js';",
-  "import type { IntelligenceEntry } from '../intelligence/types.js';",
-  '',
-  'function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {',
-  '  return {',
-  "    id: overrides.id ?? 'test-entry-1',",
-  "    type: overrides.type ?? 'pattern',",
-  "    domain: overrides.domain ?? 'testing',",
-  "    title: overrides.title ?? 'Test Pattern',",
-  "    severity: overrides.severity ?? 'warning',",
-  "    description: overrides.description ?? 'A test pattern for unit tests.',",
-  "    context: overrides.context ?? 'Use in test suites.',",
-  "    example: overrides.example ?? 'expect(result).toBe(true);',",
-  "    counterExample: overrides.counterExample ?? 'assert(result);',",
-  "    why: overrides.why ?? 'Tests should be explicit about expectations.',",
-  "    tags: overrides.tags ?? ['testing', 'assertions'],",
-  "    appliesTo: overrides.appliesTo ?? ['*.test.ts'],",
-  '  };',
-  '}',
-  '',
-  "describe('Vault', () => {",
-  '  let vault: Vault;',
-  '',
-  '  beforeEach(() => {',
-  "    vault = new Vault(':memory:');",
-  '  });',
-  '',
-  '  afterEach(() => {',
-  '    vault.close();',
-  '  });',
-  '',
-  "  describe('constructor', () => {",
-  "    it('should create an in-memory vault', () => {",
-  '      const stats = vault.stats();',
-  '      expect(stats.totalEntries).toBe(0);',
-  '    });',
-  '',
-  "    it('should expose db via getDb()', () => {",
-  '      const db = vault.getDb();',
-  '      expect(db).toBeDefined();',
-  "      const row = db.prepare('SELECT COUNT(*) as count FROM brain_vocabulary').get() as { count: number };",
-  '      expect(row.count).toBe(0);',
-  '    });',
-  '  });',
-  '',
-  "  describe('seed', () => {",
-  "    it('should seed entries and return count', () => {",
-  "      const entries = [makeEntry({ id: 'e1' }), makeEntry({ id: 'e2' })];",
-  '      const count = vault.seed(entries);',
-  '      expect(count).toBe(2);',
-  '      expect(vault.stats().totalEntries).toBe(2);',
-  '    });',
-  '',
-  "    it('should upsert on duplicate id', () => {",
-  "      vault.seed([makeEntry({ id: 'e1', title: 'Original' })]);",
-  "      vault.seed([makeEntry({ id: 'e1', title: 'Updated' })]);",
-  '      expect(vault.stats().totalEntries).toBe(1);',
-  "      const entry = vault.get('e1');",
-  "      expect(entry?.title).toBe('Updated');",
-  '    });',
-  '',
-  "    it('should handle empty array', () => {",
-  '      const count = vault.seed([]);',
-  '      expect(count).toBe(0);',
-  '    });',
-  '  });',
-  '',
-  "  describe('search', () => {",
-  '    beforeEach(() => {',
-  '      vault.seed([',
-  "        makeEntry({ id: 'search-1', title: 'Input validation pattern', description: 'Always validate user input at boundaries.', domain: 'security', tags: ['validation'] }),",
-  "        makeEntry({ id: 'search-2', title: 'Caching strategy', description: 'Use cache-aside for read-heavy workloads.', domain: 'performance', tags: ['caching'] }),",
-  "        makeEntry({ id: 'search-3', title: 'Error handling pattern', description: 'Use typed errors with context for debugging.', domain: 'clean-code', tags: ['errors'] }),",
-  '      ]);',
-  '    });',
-  '',
-  "    it('should find entries matching query', () => {",
-  "      const results = vault.search('validation input');",
-  '      expect(results.length).toBeGreaterThan(0);',
-  "      expect(results[0].entry.id).toBe('search-1');",
-  '    });',
-  '',
-  "    it('should return scores with results', () => {",
-  "      const results = vault.search('caching');",
-  '      expect(results[0].score).toBeGreaterThan(0);',
-  '    });',
-  '',
-  "    it('should filter by domain', () => {",
-  "      const results = vault.search('pattern', { domain: 'security' });",
-  "      expect(results.every((r) => r.entry.domain === 'security')).toBe(true);",
-  '    });',
-  '',
-  "    it('should respect limit', () => {",
-  "      const results = vault.search('pattern', { limit: 1 });",
-  '      expect(results.length).toBeLessThanOrEqual(1);',
-  '    });',
-  '',
-  "    it('should return empty for no matches', () => {",
-  "      const results = vault.search('xyznonexistent');",
-  '      expect(results).toEqual([]);',
-  '    });',
-  '  });',
-  '',
-  "  describe('get', () => {",
-  "    it('should return entry by id', () => {",
-  "      vault.seed([makeEntry({ id: 'get-1', title: 'Get Test' })]);",
-  "      const entry = vault.get('get-1');",
-  '      expect(entry).not.toBeNull();',
-  "      expect(entry!.title).toBe('Get Test');",
-  '    });',
-  '',
-  "    it('should return null for missing id', () => {",
-  "      expect(vault.get('nonexistent')).toBeNull();",
-  '    });',
-  '',
-  "    it('should preserve all fields', () => {",
-  "      const original = makeEntry({ id: 'full-1' });",
-  '      vault.seed([original]);',
-  "      const entry = vault.get('full-1')!;",
-  '      expect(entry.id).toBe(original.id);',
-  '      expect(entry.type).toBe(original.type);',
-  '      expect(entry.domain).toBe(original.domain);',
-  '      expect(entry.tags).toEqual(original.tags);',
-  '    });',
-  '  });',
-  '',
-  "  describe('list', () => {",
-  '    beforeEach(() => {',
-  '      vault.seed([',
-  "        makeEntry({ id: 'l1', domain: 'api', type: 'pattern', severity: 'critical' }),",
-  "        makeEntry({ id: 'l2', domain: 'api', type: 'anti-pattern', severity: 'warning' }),",
-  "        makeEntry({ id: 'l3', domain: 'db', type: 'rule', severity: 'suggestion' }),",
-  "        makeEntry({ id: 'l4', domain: 'db', type: 'pattern', severity: 'critical', tags: ['indexing', 'query'] }),",
-  '      ]);',
-  '    });',
-  '',
-  "    it('should list all entries', () => {",
-  '      const entries = vault.list();',
-  '      expect(entries).toHaveLength(4);',
-  '    });',
-  '',
-  "    it('should filter by domain', () => {",
-  "      const entries = vault.list({ domain: 'api' });",
-  '      expect(entries).toHaveLength(2);',
-  "      expect(entries.every((e) => e.domain === 'api')).toBe(true);",
-  '    });',
-  '',
-  "    it('should filter by type', () => {",
-  "      const entries = vault.list({ type: 'pattern' });",
-  '      expect(entries).toHaveLength(2);',
-  '    });',
-  '',
-  "    it('should filter by severity', () => {",
-  "      const entries = vault.list({ severity: 'critical' });",
-  '      expect(entries).toHaveLength(2);',
-  '    });',
-  '',
-  "    it('should filter by tags', () => {",
-  "      const entries = vault.list({ tags: ['indexing'] });",
-  '      expect(entries).toHaveLength(1);',
-  "      expect(entries[0].id).toBe('l4');",
-  '    });',
-  '',
-  "    it('should support limit and offset', () => {",
-  '      const page1 = vault.list({ limit: 2, offset: 0 });',
-  '      const page2 = vault.list({ limit: 2, offset: 2 });',
-  '      expect(page1).toHaveLength(2);',
-  '      expect(page2).toHaveLength(2);',
-  '      expect(page1[0].id).not.toBe(page2[0].id);',
-  '    });',
-  '  });',
-  '',
-  "  describe('stats', () => {",
-  "    it('should return zero counts for empty vault', () => {",
-  '      const stats = vault.stats();',
-  '      expect(stats.totalEntries).toBe(0);',
-  '      expect(stats.byType).toEqual({});',
-  '      expect(stats.byDomain).toEqual({});',
-  '      expect(stats.bySeverity).toEqual({});',
-  '    });',
-  '',
-  "    it('should return correct breakdowns', () => {",
-  '      vault.seed([',
-  "        makeEntry({ id: 's1', domain: 'api', type: 'pattern', severity: 'critical' }),",
-  "        makeEntry({ id: 's2', domain: 'api', type: 'rule', severity: 'warning' }),",
-  "        makeEntry({ id: 's3', domain: 'db', type: 'pattern', severity: 'critical' }),",
-  '      ]);',
-  '      const stats = vault.stats();',
-  '      expect(stats.totalEntries).toBe(3);',
-  '      expect(stats.byDomain).toEqual({ api: 2, db: 1 });',
-  '      expect(stats.byType).toEqual({ pattern: 2, rule: 1 });',
-  '      expect(stats.bySeverity).toEqual({ critical: 2, warning: 1 });',
-  '    });',
-  '  });',
-  '',
-  "  describe('add', () => {",
-  "    it('should add a single entry', () => {",
-  "      vault.add(makeEntry({ id: 'add-1' }));",
-  '      expect(vault.stats().totalEntries).toBe(1);',
-  "      expect(vault.get('add-1')).not.toBeNull();",
-  '    });',
-  '  });',
-  '',
-  "  describe('remove', () => {",
-  "    it('should remove an existing entry', () => {",
-  "      vault.seed([makeEntry({ id: 'rm-1' })]);",
-  "      const removed = vault.remove('rm-1');",
-  '      expect(removed).toBe(true);',
-  "      expect(vault.get('rm-1')).toBeNull();",
-  '      expect(vault.stats().totalEntries).toBe(0);',
-  '    });',
-  '',
-  "    it('should return false for nonexistent id', () => {",
-  "      expect(vault.remove('nonexistent')).toBe(false);",
-  '    });',
-  '  });',
-  '',
-  "  describe('registerProject', () => {",
-  "    it('should register a new project', () => {",
-  "      const project = vault.registerProject('/home/user/my-project', 'my-project');",
-  "      expect(project.path).toBe('/home/user/my-project');",
-  "      expect(project.name).toBe('my-project');",
-  '      expect(project.sessionCount).toBe(1);',
-  '    });',
-  '',
-  "    it('should derive name from path when not provided', () => {",
-  "      const project = vault.registerProject('/home/user/cool-app');",
-  "      expect(project.name).toBe('cool-app');",
-  '    });',
-  '',
-  "    it('should increment session count on re-registration', () => {",
-  "      vault.registerProject('/home/user/app');",
-  "      const second = vault.registerProject('/home/user/app');",
-  '      expect(second.sessionCount).toBe(2);',
-  "      const third = vault.registerProject('/home/user/app');",
-  '      expect(third.sessionCount).toBe(3);',
-  '    });',
-  '',
-  "    it('should update last_seen_at on re-registration', () => {",
-  "      const first = vault.registerProject('/home/user/app');",
-  "      const second = vault.registerProject('/home/user/app');",
-  '      expect(second.lastSeenAt).toBeGreaterThanOrEqual(first.lastSeenAt);',
-  '    });',
-  '  });',
-  '',
-  "  describe('getProject', () => {",
-  "    it('should return null for unregistered project', () => {",
-  "      expect(vault.getProject('/nonexistent')).toBeNull();",
-  '    });',
-  '',
-  "    it('should return registered project', () => {",
-  "      vault.registerProject('/home/user/app', 'app');",
-  "      const project = vault.getProject('/home/user/app');",
-  '      expect(project).not.toBeNull();',
-  "      expect(project!.name).toBe('app');",
-  '    });',
-  '  });',
-  '',
-  "  describe('listProjects', () => {",
-  "    it('should return empty array when no projects', () => {",
-  '      expect(vault.listProjects()).toEqual([]);',
-  '    });',
-  '',
-  "    it('should list all registered projects', () => {",
-  "      vault.registerProject('/home/user/app-a', 'app-a');",
-  "      vault.registerProject('/home/user/app-b', 'app-b');",
-  '      const projects = vault.listProjects();',
-  '      expect(projects).toHaveLength(2);',
-  '    });',
-  '  });',
-  '',
-  "  describe('captureMemory', () => {",
-  "    it('should capture a memory and return it', () => {",
-  "      const memory = vault.captureMemory({ projectPath: '/test', type: 'lesson', context: 'Debugging session', summary: 'Learned about FTS5 tokenizers', topics: ['sqlite', 'fts5'], filesModified: ['vault.ts'], toolsUsed: ['Bash'] });",
-  '      expect(memory.id).toMatch(/^mem-/);',
-  "      expect(memory.type).toBe('lesson');",
-  "      expect(memory.summary).toBe('Learned about FTS5 tokenizers');",
-  "      expect(memory.topics).toEqual(['sqlite', 'fts5']);",
-  '      expect(memory.archivedAt).toBeNull();',
-  '    });',
-  '',
-  "    it('should capture session memories', () => {",
-  "      const memory = vault.captureMemory({ projectPath: '/test', type: 'session', context: 'refactoring vault module', summary: 'Refactored vault to use FTS5', topics: ['vault'], filesModified: [], toolsUsed: [] });",
-  "      expect(memory.type).toBe('session');",
-  '      expect(memory.createdAt).toBeGreaterThan(0);',
-  '    });',
-  '',
-  "    it('should capture preference memories', () => {",
-  "      const memory = vault.captureMemory({ projectPath: '/test', type: 'preference', context: 'user prefers bun over npm', summary: 'Use bun for package management', topics: ['tooling'], filesModified: [], toolsUsed: [] });",
-  "      expect(memory.type).toBe('preference');",
-  '    });',
-  '  });',
-  '',
-  "  describe('searchMemories', () => {",
-  '    beforeEach(() => {',
-  "      vault.captureMemory({ projectPath: '/test', type: 'lesson', context: 'Debugging SQL queries', summary: 'Always use parameterized queries to prevent injection', topics: ['sql', 'security'], filesModified: [], toolsUsed: [] });",
-  "      vault.captureMemory({ projectPath: '/test', type: 'session', context: 'Working on API design', summary: 'Implemented REST endpoints with pagination', topics: ['api', 'rest'], filesModified: ['routes.ts'], toolsUsed: ['Edit'] });",
-  "      vault.captureMemory({ projectPath: '/other', type: 'preference', context: 'User likes TypeScript strict mode', summary: 'Always enable strict mode in tsconfig', topics: ['typescript'], filesModified: [], toolsUsed: [] });",
-  '    });',
-  '',
-  "    it('should find memories matching query', () => {",
-  "      const results = vault.searchMemories('parameterized queries');",
-  '      expect(results.length).toBeGreaterThan(0);',
-  "      expect(results[0].summary).toContain('parameterized');",
-  '    });',
-  '',
-  "    it('should filter by type', () => {",
-  "      const results = vault.searchMemories('queries OR endpoints OR strict', { type: 'lesson' });",
-  "      expect(results.every((m) => m.type === 'lesson')).toBe(true);",
-  '    });',
-  '',
-  "    it('should filter by project path', () => {",
-  "      const results = vault.searchMemories('queries OR endpoints OR strict', { projectPath: '/other' });",
-  "      expect(results.every((m) => m.projectPath === '/other')).toBe(true);",
-  '    });',
-  '',
-  "    it('should respect limit', () => {",
-  "      const results = vault.searchMemories('queries OR endpoints OR strict', { limit: 1 });",
-  '      expect(results.length).toBeLessThanOrEqual(1);',
-  '    });',
-  '',
-  "    it('should return empty for no matches', () => {",
-  "      const results = vault.searchMemories('xyznonexistent');",
-  '      expect(results).toEqual([]);',
-  '    });',
-  '  });',
-  '',
-  "  describe('listMemories', () => {",
-  '    beforeEach(() => {',
-  "      vault.captureMemory({ projectPath: '/proj-a', type: 'lesson', context: 'ctx', summary: 'lesson one', topics: [], filesModified: [], toolsUsed: [] });",
-  "      vault.captureMemory({ projectPath: '/proj-a', type: 'session', context: 'ctx', summary: 'session one', topics: [], filesModified: [], toolsUsed: [] });",
-  "      vault.captureMemory({ projectPath: '/proj-b', type: 'preference', context: 'ctx', summary: 'pref one', topics: [], filesModified: [], toolsUsed: [] });",
-  '    });',
-  '',
-  "    it('should list all memories', () => {",
-  '      const memories = vault.listMemories();',
-  '      expect(memories).toHaveLength(3);',
-  '    });',
-  '',
-  "    it('should filter by type', () => {",
-  "      const memories = vault.listMemories({ type: 'lesson' });",
-  '      expect(memories).toHaveLength(1);',
-  "      expect(memories[0].type).toBe('lesson');",
-  '    });',
-  '',
-  "    it('should filter by project path', () => {",
-  "      const memories = vault.listMemories({ projectPath: '/proj-a' });",
-  '      expect(memories).toHaveLength(2);',
-  '    });',
-  '  });',
-  '',
-  "  describe('memoryStats', () => {",
-  "    it('should return zero counts for empty memories', () => {",
-  '      const stats = vault.memoryStats();',
-  '      expect(stats.total).toBe(0);',
-  '      expect(stats.byType).toEqual({});',
-  '    });',
-  '',
-  "    it('should return correct breakdown', () => {",
-  "      vault.captureMemory({ projectPath: '/a', type: 'lesson', context: 'ctx', summary: 's', topics: [], filesModified: [], toolsUsed: [] });",
-  "      vault.captureMemory({ projectPath: '/a', type: 'lesson', context: 'ctx', summary: 's', topics: [], filesModified: [], toolsUsed: [] });",
-  "      vault.captureMemory({ projectPath: '/b', type: 'session', context: 'ctx', summary: 's', topics: [], filesModified: [], toolsUsed: [] });",
-  '      const stats = vault.memoryStats();',
-  '      expect(stats.total).toBe(3);',
-  '      expect(stats.byType).toEqual({ lesson: 2, session: 1 });',
-  "      expect(stats.byProject).toEqual({ '/a': 2, '/b': 1 });",
-  '    });',
-  '  });',
-  '});',
-].join('\n');

package/src/templates/vault.ts

@@ -1,263 +0,0 @@
-/**
- * Generates the vault.ts source file for a new agent.
- * The vault provides SQLite-backed knowledge storage with FTS5 search.
- */
-export function generateVault(): string {
-  // The vault template is stored as a static string to avoid
-  // template literal escaping issues with nested backticks.
-  return VAULT_TEMPLATE;
-}
-
-const VAULT_TEMPLATE = [
-  "import Database from 'better-sqlite3';",
-  "import { mkdirSync } from 'node:fs';",
-  "import { dirname } from 'node:path';",
-  "import type { IntelligenceEntry } from '../intelligence/types.js';",
-  '',
-  'export interface SearchResult { entry: IntelligenceEntry; score: number; }',
-  'export interface VaultStats { totalEntries: number; byType: Record<string, number>; byDomain: Record<string, number>; bySeverity: Record<string, number>; }',
-  'export interface ProjectInfo { path: string; name: string; registeredAt: number; lastSeenAt: number; sessionCount: number; }',
-  "export interface Memory { id: string; projectPath: string; type: 'session' | 'lesson' | 'preference'; context: string; summary: string; topics: string[]; filesModified: string[]; toolsUsed: string[]; createdAt: number; archivedAt: number | null; }",
-  'export interface MemoryStats { total: number; byType: Record<string, number>; byProject: Record<string, number>; }',
-  '',
-  'export class Vault {',
-  '  private db: Database.Database;',
-  '',
-  "  constructor(dbPath: string = ':memory:') {",
-  "    if (dbPath !== ':memory:') mkdirSync(dirname(dbPath), { recursive: true });",
-  '    this.db = new Database(dbPath);',
-  "    this.db.pragma('journal_mode = WAL');",
-  "    this.db.pragma('foreign_keys = ON');",
-  '    this.initialize();',
-  '  }',
-  '',
-  '  private initialize(): void {',
-  '    this.db.exec(`',
-  '      CREATE TABLE IF NOT EXISTS entries (',
-  '        id TEXT PRIMARY KEY,',
-  "        type TEXT NOT NULL CHECK(type IN ('pattern', 'anti-pattern', 'rule')),",
-  '        domain TEXT NOT NULL,',
-  '        title TEXT NOT NULL,',
-  "        severity TEXT NOT NULL CHECK(severity IN ('critical', 'warning', 'suggestion')),",
-  '        description TEXT NOT NULL,',
-  '        context TEXT, example TEXT, counter_example TEXT, why TEXT,',
-  "        tags TEXT NOT NULL DEFAULT '[]',",
-  "        applies_to TEXT DEFAULT '[]',",
-  '        created_at INTEGER NOT NULL DEFAULT (unixepoch()),',
-  '        updated_at INTEGER NOT NULL DEFAULT (unixepoch())',
-  '      );',
-  '      CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(',
-  '        id, title, description, context, tags,',
-  "        content='entries', content_rowid='rowid', tokenize='porter unicode61'",
-  '      );',
-  '      CREATE TRIGGER IF NOT EXISTS entries_ai AFTER INSERT ON entries BEGIN',
-  '        INSERT INTO entries_fts(rowid,id,title,description,context,tags) VALUES(new.rowid,new.id,new.title,new.description,new.context,new.tags);',
-  '      END;',
-  '      CREATE TRIGGER IF NOT EXISTS entries_ad AFTER DELETE ON entries BEGIN',
-  "        INSERT INTO entries_fts(entries_fts,rowid,id,title,description,context,tags) VALUES('delete',old.rowid,old.id,old.title,old.description,old.context,old.tags);",
-  '      END;',
-  '      CREATE TRIGGER IF NOT EXISTS entries_au AFTER UPDATE ON entries BEGIN',
-  "        INSERT INTO entries_fts(entries_fts,rowid,id,title,description,context,tags) VALUES('delete',old.rowid,old.id,old.title,old.description,old.context,old.tags);",
-  '        INSERT INTO entries_fts(rowid,id,title,description,context,tags) VALUES(new.rowid,new.id,new.title,new.description,new.context,new.tags);',
-  '      END;',
-  '      CREATE TABLE IF NOT EXISTS projects (',
-  '        path TEXT PRIMARY KEY,',
-  '        name TEXT NOT NULL,',
-  '        registered_at INTEGER NOT NULL DEFAULT (unixepoch()),',
-  '        last_seen_at INTEGER NOT NULL DEFAULT (unixepoch()),',
-  '        session_count INTEGER NOT NULL DEFAULT 1',
-  '      );',
-  '      CREATE TABLE IF NOT EXISTS memories (',
-  '        id TEXT PRIMARY KEY,',
-  '        project_path TEXT NOT NULL,',
-  "        type TEXT NOT NULL CHECK(type IN ('session', 'lesson', 'preference')),",
-  '        context TEXT NOT NULL,',
-  '        summary TEXT NOT NULL,',
-  "        topics TEXT NOT NULL DEFAULT '[]',",
-  "        files_modified TEXT NOT NULL DEFAULT '[]',",
-  "        tools_used TEXT NOT NULL DEFAULT '[]',",
-  '        created_at INTEGER NOT NULL DEFAULT (unixepoch()),',
-  '        archived_at INTEGER',
-  '      );',
-  '      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(',
-  '        id, context, summary, topics,',
-  "        content='memories', content_rowid='rowid', tokenize='porter unicode61'",
-  '      );',
-  '      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN',
-  '        INSERT INTO memories_fts(rowid,id,context,summary,topics) VALUES(new.rowid,new.id,new.context,new.summary,new.topics);',
-  '      END;',
-  '      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN',
-  "        INSERT INTO memories_fts(memories_fts,rowid,id,context,summary,topics) VALUES('delete',old.rowid,old.id,old.context,old.summary,old.topics);",
-  '      END;',
-  '      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN',
-  "        INSERT INTO memories_fts(memories_fts,rowid,id,context,summary,topics) VALUES('delete',old.rowid,old.id,old.context,old.summary,old.topics);",
-  '        INSERT INTO memories_fts(rowid,id,context,summary,topics) VALUES(new.rowid,new.id,new.context,new.summary,new.topics);',
-  '      END;',
-  '      CREATE TABLE IF NOT EXISTS brain_vocabulary (',
-  '        term TEXT PRIMARY KEY,',
-  '        idf REAL NOT NULL,',
-  '        doc_count INTEGER NOT NULL DEFAULT 1,',
-  '        updated_at INTEGER NOT NULL DEFAULT (unixepoch())',
-  '      );',
-  '      CREATE TABLE IF NOT EXISTS brain_feedback (',
-  '        id INTEGER PRIMARY KEY AUTOINCREMENT,',
-  '        query TEXT NOT NULL,',
-  '        entry_id TEXT NOT NULL,',
-  "        action TEXT NOT NULL CHECK(action IN ('accepted', 'dismissed')),",
-  '        created_at INTEGER NOT NULL DEFAULT (unixepoch())',
-  '      );',
-  '      CREATE INDEX IF NOT EXISTS idx_brain_feedback_query ON brain_feedback(query);',
-  '    `);',
-  '  }',
-  '',
-  '  seed(entries: IntelligenceEntry[]): number {',
-  '    const upsert = this.db.prepare(`',
-  '      INSERT INTO entries (id,type,domain,title,severity,description,context,example,counter_example,why,tags,applies_to)',
-  '      VALUES (@id,@type,@domain,@title,@severity,@description,@context,@example,@counterExample,@why,@tags,@appliesTo)',
-  '      ON CONFLICT(id) DO UPDATE SET type=excluded.type,domain=excluded.domain,title=excluded.title,severity=excluded.severity,',
-  '        description=excluded.description,context=excluded.context,example=excluded.example,counter_example=excluded.counter_example,',
-  '        why=excluded.why,tags=excluded.tags,applies_to=excluded.applies_to,updated_at=unixepoch()',
-  '    `);',
-  '    const tx = this.db.transaction((items: IntelligenceEntry[]) => {',
-  '      let count = 0;',
-  '      for (const entry of items) {',
-  '        upsert.run({ id: entry.id, type: entry.type, domain: entry.domain, title: entry.title,',
-  '          severity: entry.severity, description: entry.description, context: entry.context ?? null,',
-  '          example: entry.example ?? null, counterExample: entry.counterExample ?? null,',
-  '          why: entry.why ?? null, tags: JSON.stringify(entry.tags), appliesTo: JSON.stringify(entry.appliesTo ?? []) });',
-  '        count++;',
-  '      }',
-  '      return count;',
-  '    });',
-  '    return tx(entries);',
-  '  }',
-  '',
-  '  search(query: string, options?: { domain?: string; type?: string; severity?: string; limit?: number }): SearchResult[] {',
-  '    const limit = options?.limit ?? 10;',
-  '    const filters: string[] = []; const fp: Record<string, string> = {};',
-  "    if (options?.domain) { filters.push('e.domain = @domain'); fp.domain = options.domain; }",
-  "    if (options?.type) { filters.push('e.type = @type'); fp.type = options.type; }",
-  "    if (options?.severity) { filters.push('e.severity = @severity'); fp.severity = options.severity; }",
-  "    const wc = filters.length > 0 ? `AND ${filters.join(' AND ')}` : '';",
-  '    const rows = this.db.prepare(`SELECT e.*, -rank as score FROM entries_fts fts JOIN entries e ON e.rowid = fts.rowid WHERE entries_fts MATCH @query ${wc} ORDER BY score DESC LIMIT @limit`)',
-  '      .all({ query, limit, ...fp }) as Array<Record<string, unknown>>;',
-  '    return rows.map(rowToSearchResult);',
-  '  }',
-  '',
-  '  get(id: string): IntelligenceEntry | null {',
-  "    const row = this.db.prepare('SELECT * FROM entries WHERE id = ?').get(id) as Record<string, unknown> | undefined;",
-  '    return row ? rowToEntry(row) : null;',
-  '  }',
-  '',
-  '  list(options?: { domain?: string; type?: string; severity?: string; tags?: string[]; limit?: number; offset?: number }): IntelligenceEntry[] {',
-  '    const filters: string[] = []; const params: Record<string, unknown> = {};',
-  "    if (options?.domain) { filters.push('domain = @domain'); params.domain = options.domain; }",
-  "    if (options?.type) { filters.push('type = @type'); params.type = options.type; }",
-  "    if (options?.severity) { filters.push('severity = @severity'); params.severity = options.severity; }",
-  '    if (options?.tags?.length) { const c = options.tags.map((t, i) => { params[`tag${i}`] = `%"${t}"%`; return `tags LIKE @tag${i}`; }); filters.push(`(${c.join(\' OR \')})`); }',
-  "    const wc = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : '';",
-  '    const rows = this.db.prepare(`SELECT * FROM entries ${wc} ORDER BY severity, domain, title LIMIT @limit OFFSET @offset`)',
-  '      .all({ ...params, limit: options?.limit ?? 50, offset: options?.offset ?? 0 }) as Array<Record<string, unknown>>;',
-  '    return rows.map(rowToEntry);',
-  '  }',
-  '',
-  '  stats(): VaultStats {',
-  "    const total = (this.db.prepare('SELECT COUNT(*) as count FROM entries').get() as { count: number }).count;",
-  "    return { totalEntries: total, byType: gc(this.db, 'type'), byDomain: gc(this.db, 'domain'), bySeverity: gc(this.db, 'severity') };",
-  '  }',
-  '',
-  '  add(entry: IntelligenceEntry): void { this.seed([entry]); }',
-  "  remove(id: string): boolean { return this.db.prepare('DELETE FROM entries WHERE id = ?').run(id).changes > 0; }",
-  '',
-  '  registerProject(path: string, name?: string): ProjectInfo {',
-  "    const projectName = name ?? path.split('/').filter(Boolean).pop() ?? path;",
-  '    const existing = this.getProject(path);',
-  '    if (existing) {',
-  "      this.db.prepare('UPDATE projects SET last_seen_at = unixepoch(), session_count = session_count + 1 WHERE path = ?').run(path);",
-  '      return this.getProject(path)!;',
-  '    }',
-  "    this.db.prepare('INSERT INTO projects (path, name) VALUES (?, ?)').run(path, projectName);",
-  '    return this.getProject(path)!;',
-  '  }',
-  '',
-  '  getProject(path: string): ProjectInfo | null {',
-  "    const row = this.db.prepare('SELECT * FROM projects WHERE path = ?').get(path) as Record<string, unknown> | undefined;",
-  '    if (!row) return null;',
-  '    return { path: row.path as string, name: row.name as string, registeredAt: row.registered_at as number, lastSeenAt: row.last_seen_at as number, sessionCount: row.session_count as number };',
-  '  }',
-  '',
-  '  listProjects(): ProjectInfo[] {',
-  "    const rows = this.db.prepare('SELECT * FROM projects ORDER BY last_seen_at DESC').all() as Array<Record<string, unknown>>;",
-  '    return rows.map((row) => ({ path: row.path as string, name: row.name as string, registeredAt: row.registered_at as number, lastSeenAt: row.last_seen_at as number, sessionCount: row.session_count as number }));',
-  '  }',
-  '',
-  "  captureMemory(memory: Omit<Memory, 'id' | 'createdAt' | 'archivedAt'>): Memory {",
-  '    const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;',
-  '    this.db.prepare(`INSERT INTO memories (id, project_path, type, context, summary, topics, files_modified, tools_used) VALUES (@id, @projectPath, @type, @context, @summary, @topics, @filesModified, @toolsUsed)`)',
-  '      .run({ id, projectPath: memory.projectPath, type: memory.type, context: memory.context, summary: memory.summary, topics: JSON.stringify(memory.topics), filesModified: JSON.stringify(memory.filesModified), toolsUsed: JSON.stringify(memory.toolsUsed) });',
-  '    return this.getMemory(id)!;',
-  '  }',
-  '',
-  '  searchMemories(query: string, options?: { type?: string; projectPath?: string; limit?: number }): Memory[] {',
-  '    const limit = options?.limit ?? 10;',
-  "    const filters: string[] = ['m.archived_at IS NULL']; const fp: Record<string, unknown> = {};",
-  "    if (options?.type) { filters.push('m.type = @type'); fp.type = options.type; }",
-  "    if (options?.projectPath) { filters.push('m.project_path = @projectPath'); fp.projectPath = options.projectPath; }",
-  "    const wc = filters.length > 0 ? `AND ${filters.join(' AND ')}` : '';",
-  '    const rows = this.db.prepare(`SELECT m.* FROM memories_fts fts JOIN memories m ON m.rowid = fts.rowid WHERE memories_fts MATCH @query ${wc} ORDER BY rank LIMIT @limit`)',
-  '      .all({ query, limit, ...fp }) as Array<Record<string, unknown>>;',
-  '    return rows.map(rowToMemory);',
-  '  }',
-  '',
-  '  listMemories(options?: { type?: string; projectPath?: string; limit?: number; offset?: number }): Memory[] {',
-  "    const filters: string[] = ['archived_at IS NULL']; const params: Record<string, unknown> = {};",
-  "    if (options?.type) { filters.push('type = @type'); params.type = options.type; }",
-  "    if (options?.projectPath) { filters.push('project_path = @projectPath'); params.projectPath = options.projectPath; }",
-  "    const wc = `WHERE ${filters.join(' AND ')}`;",
-  '    const rows = this.db.prepare(`SELECT * FROM memories ${wc} ORDER BY created_at DESC LIMIT @limit OFFSET @offset`)',
-  '      .all({ ...params, limit: options?.limit ?? 50, offset: options?.offset ?? 0 }) as Array<Record<string, unknown>>;',
-  '    return rows.map(rowToMemory);',
-  '  }',
-  '',
-  '  memoryStats(): MemoryStats {',
-  "    const total = (this.db.prepare('SELECT COUNT(*) as count FROM memories WHERE archived_at IS NULL').get() as { count: number }).count;",
-  "    const byTypeRows = this.db.prepare('SELECT type as key, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY type').all() as Array<{ key: string; count: number }>;",
-  "    const byProjectRows = this.db.prepare('SELECT project_path as key, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY project_path').all() as Array<{ key: string; count: number }>;",
-  '    return { total, byType: Object.fromEntries(byTypeRows.map((r) => [r.key, r.count])), byProject: Object.fromEntries(byProjectRows.map((r) => [r.key, r.count])) };',
-  '  }',
-  '',
-  '  getMemory(id: string): Memory | null {',
-  "    const row = this.db.prepare('SELECT * FROM memories WHERE id = ?').get(id) as Record<string, unknown> | undefined;",
-  '    return row ? rowToMemory(row) : null;',
-  '  }',
-  '',
-  '  getDb(): Database.Database { return this.db; }',
-  '',
-  '  close(): void { this.db.close(); }',
-  '}',
-  '',
-  'function gc(db: Database.Database, col: string): Record<string, number> {',
-  '  const rows = db.prepare(`SELECT ${col} as key, COUNT(*) as count FROM entries GROUP BY ${col}`).all() as Array<{ key: string; count: number }>;',
-  '  return Object.fromEntries(rows.map((r) => [r.key, r.count]));',
-  '}',
-  '',
-  'function rowToEntry(row: Record<string, unknown>): IntelligenceEntry {',
-  "  return { id: row.id as string, type: row.type as IntelligenceEntry['type'], domain: row.domain as IntelligenceEntry['domain'],",
-  "    title: row.title as string, severity: row.severity as IntelligenceEntry['severity'], description: row.description as string,",
-  '    context: (row.context as string) ?? undefined, example: (row.example as string) ?? undefined,',
-  '    counterExample: (row.counter_example as string) ?? undefined, why: (row.why as string) ?? undefined,',
-  "    tags: JSON.parse((row.tags as string) || '[]'), appliesTo: JSON.parse((row.applies_to as string) || '[]') };",
-  '}',
-  '',
-  'function rowToSearchResult(row: Record<string, unknown>): SearchResult {',
-  '  return { entry: rowToEntry(row), score: row.score as number };',
-  '}',
-  '',
-  'function rowToMemory(row: Record<string, unknown>): Memory {',
-  "  return { id: row.id as string, projectPath: row.project_path as string, type: row.type as Memory['type'],",
-  '    context: row.context as string, summary: row.summary as string,',
-  "    topics: JSON.parse((row.topics as string) || '[]'), filesModified: JSON.parse((row.files_modified as string) || '[]'),",
-  "    toolsUsed: JSON.parse((row.tools_used as string) || '[]'), createdAt: row.created_at as number,",
-  '    archivedAt: (row.archived_at as number) ?? null };',
-  '}',
-].join('\n');