@soleri/forge 4.2.2 → 5.0.1

package/dist/templates/vault.js

@@ -0,0 +1,263 @@
+/**
+ * Generates the vault.ts source file for a new agent.
+ * The vault provides SQLite-backed knowledge storage with FTS5 search.
+ */
+export function generateVault() {
+    // 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');
+//# sourceMappingURL=vault.js.map

package/dist/templates/vault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault.js","sourceRoot":"","sources":["../../src/templates/vault.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,aAAa;IAC3B,2DAA2D;IAC3D,0DAA0D;IAC1D,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,MAAM,cAAc,GAAG;IACrB,wCAAwC;IACxC,sCAAsC;IACtC,sCAAsC;IACtC,oEAAoE;IACpE,EAAE;IACF,4EAA4E;IAC5E,6JAA6J;IAC7J,8HAA8H;IAC9H,yPAAyP;IACzP,oHAAoH;IACpH,EAAE;IACF,sBAAsB;IACtB,kCAAkC;IAClC,EAAE;IACF,8CAA8C;IAC9C,iFAAiF;IACjF,qCAAqC;IACrC,2CAA2C;IAC3C,0CAA0C;IAC1C,wBAAwB;IACxB,KAAK;IACL,EAAE;IACF,gCAAgC;IAChC,oBAAoB;IACpB,4CAA4C;IAC5C,8BAA8B;IAC9B,gFAAgF;IAChF,+BAA+B;IAC/B,8BAA8B;IAC9B,0FAA0F;IAC1F,oCAAoC;IACpC,qEAAqE;IACrE,0CAA0C;IAC1C,uCAAuC;IACvC,4DAA4D;IAC5D,2DAA2D;IAC3D,UAAU;IACV,kEAAkE;IAClE,gDAAgD;IAChD,+EAA+E;IAC/E,UAAU;IACV,6EAA6E;IAC7E,mJAAmJ;IACnJ,YAAY;IACZ,6EAA6E;IAC7E,wKAAwK;IACxK,YAAY;IACZ,6EAA6E;IAC7E,wKAAwK;IACxK,mJAAmJ;IACnJ,YAAY;IACZ,6CAA6C;IAC7C,gCAAgC;IAChC,6BAA6B;IAC7B,+DAA+D;IAC/D,8DAA8D;IAC9D,kDAAkD;IAClD,UAAU;IACV,6CAA6C;IAC7C,8BAA8B;IAC9B,qCAAqC;IACrC,gFAAgF;IAChF,gCAAgC;IAChC,gCAAgC;IAChC,4CAA4C;IAC5C,oDAAoD;IACpD,gDAAgD;IAChD,4DAA4D;IAC5D,6BAA6B;IAC7B,UAAU;IACV,mEAAmE;IACnE,uCAAuC;IACvC,gFAAgF;IAChF,UAAU;IACV,+EAA+E;IAC/E,gIAAgI;IAChI,YAAY;IACZ,+EAA+E;IAC/E,sJAAsJ;IACtJ,YAAY;IACZ,+EAA+E;IAC/E,sJAAsJ;IACtJ,gIAAgI;IAChI,YAAY;IACZ,qDAAqD;IACrD,gCAAgC;IAChC,4BAA4B;IAC5B,+CAA+C;IAC/C,2DAA2D;IAC3D,UAAU;IACV,mDAAmD;IACnD,+CAA+C;IAC/C,8BAA8B;IAC9B,iCAAiC;IACjC,0EAA0E;IAC1E,2DAA2D;IAC3D,UAAU;IACV,qFAAqF;IACrF,SAAS;IACT,KAAK;IACL,EAAE;IACF,gDAAgD;IAChD,sCAAsC;IACtC,2HAA2H;IAC3H,wHAAwH;IACxH,gIAAgI;IAChI,sIAAsI;IACtI,mGAAmG;IACnG,SAAS;IACT,sEAAsE;IACtE,sBAAsB;IACtB,oCAAoC;IACpC,gGAAgG;IAChG,qGAAqG;IACrG,yFAAyF;IACzF,0HAA0H;IAC1H,kBAAkB;IAClB,SAAS;IACT,qBAAqB;IACrB,SAAS;IACT,yBAAyB;IACzB,KAAK;IACL,EAAE;IACF,4HAA4H;IAC5H,yCAAyC;IACzC,0EAA0E;IAC1E,8FAA8F;IAC9F,oFAAoF;IACpF,wGAAwG;IACxG,0EAA0E;IAC1E,iMAAiM;IACjM,wEAAwE;IACxE,yCAAyC;IACzC,KAAK;IACL,EAAE;IACF,+CAA+C;IAC/C,uHAAuH;IACvH,0CAA0C;IAC1C,KAAK;IACL,EAAE;IACF,kJAAkJ;IAClJ,+EAA+E;IAC/E,gGAAgG;IAChG,sFAAsF;IACtF,0GAA0G;IAC1G,mLAAmL;IACnL,4EAA4E;IAC5E,8HAA8H;IAC9H,yHAAyH;IACzH,kCAAkC;IAClC,KAAK;IACL,EAAE;IACF,yBAAyB;IACzB,gHAAgH;IAChH,wIAAwI;IACxI,KAAK;IACL,EAAE;IACF,+DAA+D;IAC/D,mHAAmH;IACnH,EAAE;IACF,+DAA+D;IAC/D,gFAAgF;IAChF,6CAA6C;IAC7C,qBAAqB;IACrB,sIAAsI;IACtI,sCAAsC;IACtC,OAAO;IACP,gGAAgG;IAChG,oCAAoC;IACpC,KAAK;IACL,EAAE;IACF,kDAAkD;IAClD,4HAA4H;IAC5H,4BAA4B;IAC5B,kMAAkM;IAClM,KAAK;IACL,EAAE;IACF,mCAAmC;IACnC,gIAAgI;IAChI,uNAAuN;IACvN,KAAK;IACL,EAAE;IACF,oFAAoF;IACpF,+EAA+E;IAC/E,uNAAuN;IACvN,oQAAoQ;IACpQ,iCAAiC;IACjC,KAAK;IACL,EAAE;IACF,gHAAgH;IAChH,yCAAyC;IACzC,kGAAkG;IAClG,oFAAoF;IACpF,wHAAwH;IACxH,0EAA0E;IAC1E,8KAA8K;IAC9K,wEAAwE;IACxE,mCAAmC;IACnC,KAAK;IACL,EAAE;IACF,gHAAgH;IAChH,oGAAoG;IACpG,sFAAsF;IACtF,0HAA0H;IAC1H,kDAAkD;IAClD,uHAAuH;IACvH,yHAAyH;IACzH,mCAAmC;IACnC,KAAK;IACL,EAAE;IACF,gCAAgC;IAChC,2IAA2I;IAC3I,uLAAuL;IACvL,0MAA0M;IAC1M,uKAAuK;IACvK,KAAK;IACL,EAAE;IACF,0CAA0C;IAC1C,wHAAwH;IACxH,2CAA2C;IAC3C,KAAK;IACL,EAAE;IACF,kDAAkD;IAClD,EAAE;IACF,sCAAsC;IACtC,GAAG;IACH,EAAE;IACF,2EAA2E;IAC3E,mJAAmJ;IACnJ,iEAAiE;IACjE,GAAG;IACH,EAAE;IACF,wEAAwE;IACxE,kIAAkI;IAClI,kIAAkI;IAClI,mGAAmG;IACnG,0GAA0G;IAC1G,kHAAkH;IAClH,GAAG;IACH,EAAE;IACF,0EAA0E;IAC1E,kEAAkE;IAClE,GAAG;IACH,EAAE;IACF,8DAA8D;IAC9D,6GAA6G;IAC7G,qEAAqE;IACrE,4HAA4H;IAC5H,qGAAqG;IACrG,wDAAwD;IACxD,GAAG;CACJ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC"}

package/dist/types.d.ts

@@ -18,8 +18,8 @@ export declare const AgentConfigSchema: z.ZodObject<{
     /** Output directory (parent — agent dir will be created inside) */
     outputDir: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    id: string;
     name: string;
+    id: string;
     role: string;
     description: string;
     domains: string[];
@@ -27,8 +27,8 @@ export declare const AgentConfigSchema: z.ZodObject<{
     greeting: string;
     outputDir: string;
 }, {
-    id: string;
     name: string;
+    id: string;
     role: string;
     description: string;
     domains: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soleri/forge",
-  "version": "4.2.2",
+  "version": "5.0.1",
   "description": "Scaffold AI agents that learn, remember, and grow with you.",
   "keywords": [
     "agent",

package/src/__tests__/scaffolder.test.ts

@@ -42,23 +42,29 @@ describe('Scaffolder', () => {
       expect(preview.persona.name).toBe('Atlas');
       expect(preview.persona.role).toBe('Data Engineering Advisor');
       expect(preview.domains).toEqual(['data-pipelines', 'data-quality', 'etl']);
-      expect(preview.files.length).toBeGreaterThan(15);
+      expect(preview.files.length).toBeGreaterThan(10);
 
-      // Should include README, setup script, and LLM client (static modules now in @soleri/core)
       const paths = preview.files.map((f) => f.path);
       expect(paths).toContain('README.md');
       expect(paths).toContain('scripts/setup.sh');
-      expect(paths).toContain('src/llm/llm-client.ts');
+      expect(paths).toContain('src/index.ts');
       expect(paths).toContain('src/__tests__/facades.test.ts');
-      // Static modules should NOT be in preview (they live in @soleri/core now)
-      expect(paths).not.toContain('src/vault/vault.ts');
-      expect(paths).not.toContain('src/brain/brain.ts');
-      expect(paths).not.toContain('src/planning/planner.ts');
 
-      // Should have domain facades + core facade
+      // v5.0: These are no longer generated (live in @soleri/core)
+      expect(paths).not.toContain('src/llm/llm-client.ts');
+      expect(paths).not.toContain('src/facades/core.facade.ts');
+      expect(paths).not.toContain('src/facades/data-pipelines.facade.ts');
+
+      // Should have domain facades + core facade in preview
       expect(preview.facades).toHaveLength(4); // 3 domains + core
       expect(preview.facades[0].name).toBe('atlas_data_pipelines');
 
+      // Core facade should list all 31 ops
+      const coreFacade = preview.facades.find((f) => f.name === 'atlas_core')!;
+      expect(coreFacade.ops.length).toBe(31);
+      expect(coreFacade.ops).toContain('curator_status');
+      expect(coreFacade.ops).toContain('health');
+
       // Should NOT create any files
       expect(existsSync(join(tempDir, 'atlas'))).toBe(false);
     });
@@ -71,36 +77,33 @@ describe('Scaffolder', () => {
       expect(result.success).toBe(true);
       expect(result.agentDir).toBe(join(tempDir, 'atlas'));
       expect(result.domains).toEqual(['data-pipelines', 'data-quality', 'etl']);
-      expect(result.filesCreated.length).toBeGreaterThan(10);
+      expect(result.filesCreated.length).toBeGreaterThan(8);
     });
 
-    it('should create all expected directories', () => {
+    it('should create expected directories (no facades/ or llm/ dirs)', () => {
       scaffold(testConfig);
       const agentDir = join(tempDir, 'atlas');
 
-      expect(existsSync(join(agentDir, 'src', 'facades'))).toBe(true);
       expect(existsSync(join(agentDir, 'src', 'intelligence', 'data'))).toBe(true);
       expect(existsSync(join(agentDir, 'src', 'identity'))).toBe(true);
       expect(existsSync(join(agentDir, 'src', 'activation'))).toBe(true);
-      expect(existsSync(join(agentDir, 'src', 'llm'))).toBe(true);
-      // Static module directories should NOT exist (now in @soleri/core)
-      expect(existsSync(join(agentDir, 'src', 'vault'))).toBe(false);
-      expect(existsSync(join(agentDir, 'src', 'planning'))).toBe(false);
-      expect(existsSync(join(agentDir, 'src', 'brain'))).toBe(false);
+      // v5.0: facades/ and llm/ dirs are no longer generated
+      expect(existsSync(join(agentDir, 'src', 'facades'))).toBe(false);
+      expect(existsSync(join(agentDir, 'src', 'llm'))).toBe(false);
     });
 
-    it('should create valid package.json', () => {
+    it('should create valid package.json with @soleri/core ^2.0.0', () => {
       scaffold(testConfig);
       const pkg = JSON.parse(readFileSync(join(tempDir, 'atlas', 'package.json'), 'utf-8'));
 
       expect(pkg.name).toBe('atlas-mcp');
       expect(pkg.type).toBe('module');
       expect(pkg.dependencies['@modelcontextprotocol/sdk']).toBeDefined();
-      expect(pkg.dependencies['@soleri/core']).toBeDefined();
+      expect(pkg.dependencies['@soleri/core']).toBe('^2.0.0');
       expect(pkg.dependencies['zod']).toBeDefined();
-      expect(pkg.dependencies['@anthropic-ai/sdk']).toBeDefined();
-      // better-sqlite3 is now transitive via @soleri/core
-      expect(pkg.dependencies['better-sqlite3']).toBeUndefined();
+      // Anthropic SDK is now optional (LLMClient in core handles dynamic import)
+      expect(pkg.dependencies['@anthropic-ai/sdk']).toBeUndefined();
+      expect(pkg.optionalDependencies['@anthropic-ai/sdk']).toBeDefined();
     });
 
     it('should create persona with correct config', () => {
@@ -115,20 +118,6 @@ describe('Scaffolder', () => {
       expect(persona).toContain('Data quality is non-negotiable');
     });
 
-    it('should create domain facades', () => {
-      scaffold(testConfig);
-      const facadesDir = join(tempDir, 'atlas', 'src', 'facades');
-      const files = readdirSync(facadesDir);
-
-      expect(files).toContain('data-pipelines.facade.ts');
-      expect(files).toContain('data-quality.facade.ts');
-      expect(files).toContain('etl.facade.ts');
-      expect(files).toContain('core.facade.ts');
-      // facade-factory.ts and types.ts are now in @soleri/core
-      expect(files).not.toContain('facade-factory.ts');
-      expect(files).not.toContain('types.ts');
-    });
-
     it('should create empty intelligence data files', () => {
       scaffold(testConfig);
       const dataDir = join(tempDir, 'atlas', 'src', 'intelligence', 'data');
@@ -138,29 +127,30 @@ describe('Scaffolder', () => {
       expect(files).toContain('data-quality.json');
       expect(files).toContain('etl.json');
 
-      // Each file should have empty entries array
       const bundle = JSON.parse(readFileSync(join(dataDir, 'data-pipelines.json'), 'utf-8'));
       expect(bundle.domain).toBe('data-pipelines');
       expect(bundle.entries).toEqual([]);
     });
 
-    it('should create entry point importing from @soleri/core', () => {
+    it('should create entry point using runtime factories from @soleri/core', () => {
       scaffold(testConfig);
       const entry = readFileSync(join(tempDir, 'atlas', 'src', 'index.ts'), 'utf-8');
 
-      expect(entry).toContain('createDataPipelinesFacade');
-      expect(entry).toContain('createDataQualityFacade');
-      expect(entry).toContain('createEtlFacade');
-      expect(entry).toContain('createCoreFacade');
+      // v5.0 runtime factory pattern
+      expect(entry).toContain('createAgentRuntime');
+      expect(entry).toContain('createCoreOps');
+      expect(entry).toContain('createDomainFacades');
+      expect(entry).toContain("from '@soleri/core'");
+      expect(entry).toContain("agentId: 'atlas'");
       expect(entry).toContain("name: 'atlas-mcp'");
-      expect(entry).toContain('Brain');
-      expect(entry).toContain('LLMClient');
-      expect(entry).toContain('KeyPool');
-      expect(entry).toContain('loadKeyPoolConfig');
       expect(entry).toContain('Hello');
-      // Should import shared modules from @soleri/core
-      expect(entry).toContain("from '@soleri/core'");
-      expect(entry).toContain("loadKeyPoolConfig('atlas')");
+      // Agent-specific ops still reference persona/activation
+      expect(entry).toContain('PERSONA');
+      expect(entry).toContain('activateAgent');
+      // Domain list is embedded
+      expect(entry).toContain('data-pipelines');
+      expect(entry).toContain('data-quality');
+      expect(entry).toContain('etl');
     });
 
     it('should create .mcp.json for client config', () => {
@@ -206,99 +196,52 @@ describe('Scaffolder', () => {
       expect(readme).toContain('# Atlas');
       expect(readme).toContain('Data Engineering Advisor');
       expect(readme).toContain('Hello, Atlas!');
-      expect(readme).toContain('Goodbye, Atlas!');
       expect(readme).toContain('data-pipelines');
-      expect(readme).toContain('data-quality');
-      expect(readme).toContain('etl');
-      expect(readme).toContain('Data quality is non-negotiable');
-      expect(readme).toContain('./scripts/setup.sh');
     });
 
-    it('should create executable setup.sh with agent-specific content', () => {
+    it('should create executable setup.sh', () => {
       scaffold(testConfig);
       const setupPath = join(tempDir, 'atlas', 'scripts', 'setup.sh');
       const setup = readFileSync(setupPath, 'utf-8');
 
-      // Content checks
       expect(setup).toContain('AGENT_NAME="atlas"');
-      expect(setup).toContain('=== Atlas Setup ===');
-      expect(setup).toContain('Building Atlas...');
-      expect(setup).toContain('Hello, Atlas!');
       expect(setup).toContain('#!/usr/bin/env bash');
-      expect(setup).toContain('claude mcp add');
 
-      // Executable permission check
       const stats = statSync(setupPath);
       const isExecutable = (stats.mode & 0o111) !== 0;
       expect(isExecutable).toBe(true);
     });
 
-    it('should create LLM client file importing from @soleri/core', () => {
-      scaffold(testConfig);
-      const llmDir = join(tempDir, 'atlas', 'src', 'llm');
-      // Only llm-client.ts should exist (types, utils, key-pool are in @soleri/core)
-      expect(existsSync(join(llmDir, 'llm-client.ts'))).toBe(true);
-      expect(existsSync(join(llmDir, 'types.ts'))).toBe(false);
-      expect(existsSync(join(llmDir, 'utils.ts'))).toBe(false);
-      expect(existsSync(join(llmDir, 'key-pool.ts'))).toBe(false);
-
-      const client = readFileSync(join(llmDir, 'llm-client.ts'), 'utf-8');
-      expect(client).toContain('class LLMClient');
-      expect(client).toContain('class ModelRouter');
-      expect(client).toContain('.atlas');
-      expect(client).toContain("from '@soleri/core'");
-    });
-
-    it('should only create facades test file (static tests in @soleri/core)', () => {
-      scaffold(testConfig);
-      const testsDir = join(tempDir, 'atlas', 'src', '__tests__');
-      const files = readdirSync(testsDir);
-
-      expect(files).toContain('facades.test.ts');
-      // Static module tests are now in @soleri/core
-      expect(files).not.toContain('vault.test.ts');
-      expect(files).not.toContain('loader.test.ts');
-      expect(files).not.toContain('planner.test.ts');
-      expect(files).not.toContain('brain.test.ts');
-      expect(files).not.toContain('llm.test.ts');
-    });
-
-    it('should generate facade tests referencing all domains', () => {
+    it('should generate facade tests using runtime factories', () => {
       scaffold(testConfig);
       const facadesTest = readFileSync(
         join(tempDir, 'atlas', 'src', '__tests__', 'facades.test.ts'),
         'utf-8',
       );
 
+      // Should use runtime factories from @soleri/core
+      expect(facadesTest).toContain('createAgentRuntime');
+      expect(facadesTest).toContain('createCoreOps');
+      expect(facadesTest).toContain('createDomainFacade');
+      expect(facadesTest).toContain("from '@soleri/core'");
+
+      // Domain facades
       expect(facadesTest).toContain('atlas_data_pipelines');
       expect(facadesTest).toContain('atlas_data_quality');
       expect(facadesTest).toContain('atlas_etl');
       expect(facadesTest).toContain('atlas_core');
-      expect(facadesTest).toContain('createDataPipelinesFacade');
-      // Should import shared modules from @soleri/core
-      expect(facadesTest).toContain("from '@soleri/core'");
-      // Activation ops should be tested
+
+      // Agent-specific ops tested
       expect(facadesTest).toContain('activate');
       expect(facadesTest).toContain('inject_claude_md');
       expect(facadesTest).toContain('setup');
-      // Memory + planning ops should be tested
-      expect(facadesTest).toContain('memory_capture');
-      expect(facadesTest).toContain('memory_search');
-      expect(facadesTest).toContain('create_plan');
-      expect(facadesTest).toContain('complete_plan');
-      // Brain ops should be tested
-      expect(facadesTest).toContain('record_feedback');
-      expect(facadesTest).toContain('rebuild_vocabulary');
-      expect(facadesTest).toContain('brain_stats');
-      // LLM ops should be tested
-      expect(facadesTest).toContain('llm_status');
-      expect(facadesTest).toContain('LLMClient');
-      expect(facadesTest).toContain('KeyPool');
+      expect(facadesTest).toContain('health');
+      expect(facadesTest).toContain('identity');
     });
 
     it('should fail if directory already exists', () => {
       scaffold(testConfig);
-      const result = scaffold(testConfig); // second time
+      const result = scaffold(testConfig);
 
       expect(result.success).toBe(false);
       expect(result.summary).toContain('already exists');