@soleri/core 9.2.0 → 9.3.0

package/src/vault/vault-entries.ts

@@ -15,14 +15,33 @@ export interface AutoLinkConfig {
 }
 
 /** Updatable fields on an entry. */
-export type EntryUpdateFields = Partial<Pick<IntelligenceEntry,
-  'title' | 'description' | 'context' | 'example' | 'counterExample' | 'why' |
-  'tags' | 'appliesTo' | 'severity' | 'type' | 'domain' | 'validFrom' | 'validUntil'>>;
+export type EntryUpdateFields = Partial<
+  Pick<
+    IntelligenceEntry,
+    | 'title'
+    | 'description'
+    | 'context'
+    | 'example'
+    | 'counterExample'
+    | 'why'
+    | 'tags'
+    | 'appliesTo'
+    | 'severity'
+    | 'type'
+    | 'domain'
+    | 'validFrom'
+    | 'validUntil'
+  >
+>;
 
 /** Search/list filter options. */
 export interface EntryFilterOptions {
-  domain?: string; type?: string; severity?: string;
-  origin?: 'agent' | 'pack' | 'user'; limit?: number; includeExpired?: boolean;
+  domain?: string;
+  type?: string;
+  severity?: string;
+  origin?: 'agent' | 'pack' | 'user';
+  limit?: number;
+  includeExpired?: boolean;
 }
 
 export function autoLink(entryId: string, config: AutoLinkConfig): void {
@@ -32,10 +51,16 @@ export function autoLink(entryId: string, config: AutoLinkConfig): void {
     for (const s of suggestions) {
       config.linkManager.addLink(entryId, s.entryId, s.suggestedType, `auto: ${s.reason}`);
     }
-  } catch { /* best-effort */ }
+  } catch {
+    /* best-effort */
+  }
 }
 
-export function seed(provider: PersistenceProvider, entries: IntelligenceEntry[], alc: AutoLinkConfig): number {
+export function seed(
+  provider: PersistenceProvider,
+  entries: IntelligenceEntry[],
+  alc: AutoLinkConfig,
+): number {
   const sql = `
     INSERT INTO entries (id,type,domain,title,severity,description,context,example,counter_example,why,tags,applies_to,valid_from,valid_until,content_hash,tier,origin)
     VALUES (@id,@type,@domain,@title,@severity,@description,@context,@example,@counterExample,@why,@tags,@appliesTo,@validFrom,@validUntil,@contentHash,@tier,@origin)
@@ -48,13 +73,23 @@ export function seed(provider: PersistenceProvider, entries: IntelligenceEntry[]
     let count = 0;
     for (const entry of entries) {
       provider.run(sql, {
-        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 ?? []),
-        validFrom: entry.validFrom ?? null, validUntil: entry.validUntil ?? null,
-        contentHash: computeContentHash(entry), tier: entry.tier ?? 'agent', origin: entry.origin ?? 'agent',
+        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 ?? []),
+        validFrom: entry.validFrom ?? null,
+        validUntil: entry.validUntil ?? null,
+        contentHash: computeContentHash(entry),
+        tier: entry.tier ?? 'agent',
+        origin: entry.origin ?? 'agent',
       });
       count++;
     }
@@ -67,10 +102,13 @@ export function seed(provider: PersistenceProvider, entries: IntelligenceEntry[]
 }
 
 export function seedDedup(
-  provider: PersistenceProvider, entries: IntelligenceEntry[], alc: AutoLinkConfig,
+  provider: PersistenceProvider,
+  entries: IntelligenceEntry[],
+  alc: AutoLinkConfig,
 ): Array<{ id: string; action: 'inserted' | 'duplicate'; existingId?: string }> {
   return provider.transaction(() => {
-    const results: Array<{ id: string; action: 'inserted' | 'duplicate'; existingId?: string }> = [];
+    const results: Array<{ id: string; action: 'inserted' | 'duplicate'; existingId?: string }> =
+      [];
     for (const entry of entries) {
       const hash = computeContentHash(entry);
       const existing = findByContentHash(provider, hash);
@@ -86,24 +124,44 @@ export function seedDedup(
 }
 
 export function installPack(
-  provider: PersistenceProvider, entries: IntelligenceEntry[], alc: AutoLinkConfig,
+  provider: PersistenceProvider,
+  entries: IntelligenceEntry[],
+  alc: AutoLinkConfig,
 ): { installed: number; skipped: number } {
-  let installed = 0, skipped = 0;
+  let installed = 0,
+    skipped = 0;
   const tagged = entries.map((e) => ({ ...e, origin: 'pack' as const }));
   for (const r of seedDedup(provider, tagged, alc)) {
-    if (r.action === 'inserted') installed++; else skipped++;
+    if (r.action === 'inserted') installed++;
+    else skipped++;
   }
   return { installed, skipped };
 }
 
-export function search(provider: PersistenceProvider, query: string, options?: EntryFilterOptions): SearchResult[] {
+export function search(
+  provider: PersistenceProvider,
+  query: string,
+  options?: EntryFilterOptions,
+): SearchResult[] {
   const limit = options?.limit ?? 10;
   const filters: string[] = [];
   const fp: Record<string, unknown> = {};
-  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; }
-  if (options?.origin) { filters.push('e.origin = @origin'); fp.origin = options.origin; }
+  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;
+  }
+  if (options?.origin) {
+    filters.push('e.origin = @origin');
+    fp.origin = options.origin;
+  }
   if (!options?.includeExpired) {
     const now = Math.floor(Date.now() / 1000);
     filters.push('(e.valid_until IS NULL OR e.valid_until > @now)');
@@ -125,7 +183,9 @@ export function search(provider: PersistenceProvider, query: string, options?: E
         { query, limit, ...fp },
       );
       return rows.map(rowToSearchResult);
-    } catch { return []; }
+    } catch {
+      return [];
+    }
   }
 }
 
@@ -140,12 +200,27 @@ export function list(
 ): 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?.origin) { filters.push('origin = @origin'); params.origin = options.origin; }
+  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?.origin) {
+    filters.push('origin = @origin');
+    params.origin = options.origin;
+  }
   if (options?.tags?.length) {
-    const c = options.tags.map((t, i) => { params[`tag${i}`] = `%"${t}"%`; return `tags LIKE @tag${i}`; });
+    const c = options.tags.map((t, i) => {
+      params[`tag${i}`] = `%"${t}"%`;
+      return `tags LIKE @tag${i}`;
+    });
     filters.push(`(${c.join(' OR ')})`);
   }
   if (!options?.includeExpired) {
@@ -164,10 +239,19 @@ export function list(
 
 export function stats(provider: PersistenceProvider): VaultStats {
   const total = provider.get<{ count: number }>('SELECT COUNT(*) as count FROM entries')!.count;
-  return { totalEntries: total, byType: gc(provider, 'type'), byDomain: gc(provider, 'domain'), bySeverity: gc(provider, 'severity') };
+  return {
+    totalEntries: total,
+    byType: gc(provider, 'type'),
+    byDomain: gc(provider, 'domain'),
+    bySeverity: gc(provider, 'severity'),
+  };
 }
 
-export function add(provider: PersistenceProvider, entry: IntelligenceEntry, alc: AutoLinkConfig): void {
+export function add(
+  provider: PersistenceProvider,
+  entry: IntelligenceEntry,
+  alc: AutoLinkConfig,
+): void {
   seed(provider, [entry], alc);
 }
 
@@ -175,38 +259,64 @@ export function remove(provider: PersistenceProvider, id: string): boolean {
   return provider.run('DELETE FROM entries WHERE id = ?', [id]).changes > 0;
 }
 
-export function update(provider: PersistenceProvider, id: string, fields: EntryUpdateFields, alc: AutoLinkConfig): IntelligenceEntry | null {
+export function update(
+  provider: PersistenceProvider,
+  id: string,
+  fields: EntryUpdateFields,
+  alc: AutoLinkConfig,
+): IntelligenceEntry | null {
   const existing = get(provider, id);
   if (!existing) return null;
   seed(provider, [{ ...existing, ...fields }], alc);
   return get(provider, id);
 }
 
-export function setTemporal(provider: PersistenceProvider, id: string, validFrom?: number, validUntil?: number): boolean {
+export function setTemporal(
+  provider: PersistenceProvider,
+  id: string,
+  validFrom?: number,
+  validUntil?: number,
+): boolean {
   const sets: string[] = [];
   const params: Record<string, unknown> = { id };
-  if (validFrom !== undefined) { sets.push('valid_from = @validFrom'); params.validFrom = validFrom; }
-  if (validUntil !== undefined) { sets.push('valid_until = @validUntil'); params.validUntil = validUntil; }
+  if (validFrom !== undefined) {
+    sets.push('valid_from = @validFrom');
+    params.validFrom = validFrom;
+  }
+  if (validUntil !== undefined) {
+    sets.push('valid_until = @validUntil');
+    params.validUntil = validUntil;
+  }
   if (sets.length === 0) return false;
   sets.push('updated_at = unixepoch()');
   return provider.run(`UPDATE entries SET ${sets.join(', ')} WHERE id = @id`, params).changes > 0;
 }
 
-export function findExpiring(provider: PersistenceProvider, withinDays: number): IntelligenceEntry[] {
+export function findExpiring(
+  provider: PersistenceProvider,
+  withinDays: number,
+): IntelligenceEntry[] {
   const now = Math.floor(Date.now() / 1000);
   const cutoff = now + withinDays * 86400;
-  return provider.all<Record<string, unknown>>(
-    'SELECT * FROM entries WHERE valid_until IS NOT NULL AND valid_until > @now AND valid_until <= @cutoff ORDER BY valid_until ASC',
-    { now, cutoff },
-  ).map(rowToEntry);
+  return provider
+    .all<Record<string, unknown>>(
+      'SELECT * FROM entries WHERE valid_until IS NOT NULL AND valid_until > @now AND valid_until <= @cutoff ORDER BY valid_until ASC',
+      { now, cutoff },
+    )
+    .map(rowToEntry);
 }
 
-export function findExpired(provider: PersistenceProvider, limit: number = 50): IntelligenceEntry[] {
+export function findExpired(
+  provider: PersistenceProvider,
+  limit: number = 50,
+): IntelligenceEntry[] {
   const now = Math.floor(Date.now() / 1000);
-  return provider.all<Record<string, unknown>>(
-    'SELECT * FROM entries WHERE valid_until IS NOT NULL AND valid_until <= @now ORDER BY valid_until DESC LIMIT @limit',
-    { now, limit },
-  ).map(rowToEntry);
+  return provider
+    .all<Record<string, unknown>>(
+      'SELECT * FROM entries WHERE valid_until IS NOT NULL AND valid_until <= @now ORDER BY valid_until DESC LIMIT @limit',
+      { now, limit },
+    )
+    .map(rowToEntry);
 }
 
 export function bulkRemove(provider: PersistenceProvider, ids: string[]): number {
@@ -225,45 +335,75 @@ export function getTags(provider: PersistenceProvider): Array<{ tag: string; cou
       counts.set(tag, (counts.get(tag) ?? 0) + 1);
     }
   }
-  return Array.from(counts.entries()).map(([tag, count]) => ({ tag, count })).sort((a, b) => b.count - a.count);
+  return Array.from(counts.entries())
+    .map(([tag, count]) => ({ tag, count }))
+    .sort((a, b) => b.count - a.count);
 }
 
-export function getDomains(provider: PersistenceProvider): Array<{ domain: string; count: number }> {
-  return provider.all('SELECT domain, COUNT(*) as count FROM entries GROUP BY domain ORDER BY count DESC');
+export function getDomains(
+  provider: PersistenceProvider,
+): Array<{ domain: string; count: number }> {
+  return provider.all(
+    'SELECT domain, COUNT(*) as count FROM entries GROUP BY domain ORDER BY count DESC',
+  );
 }
 
 export function getRecent(provider: PersistenceProvider, limit: number = 20): IntelligenceEntry[] {
-  return provider.all<Record<string, unknown>>('SELECT * FROM entries ORDER BY updated_at DESC LIMIT ?', [limit]).map(rowToEntry);
+  return provider
+    .all<Record<string, unknown>>('SELECT * FROM entries ORDER BY updated_at DESC LIMIT ?', [limit])
+    .map(rowToEntry);
 }
 
 export function findByContentHash(provider: PersistenceProvider, hash: string): string | null {
-  return provider.get<{ id: string }>('SELECT id FROM entries WHERE content_hash = @hash', { hash })?.id ?? null;
+  return (
+    provider.get<{ id: string }>('SELECT id FROM entries WHERE content_hash = @hash', { hash })
+      ?.id ?? null
+  );
 }
 
-export function contentHashStats(provider: PersistenceProvider): { total: number; hashed: number; uniqueHashes: number } {
+export function contentHashStats(provider: PersistenceProvider): {
+  total: number;
+  hashed: number;
+  uniqueHashes: number;
+} {
   const total = provider.get<{ c: number }>('SELECT COUNT(*) as c FROM entries')?.c ?? 0;
-  const hashed = provider.get<{ c: number }>('SELECT COUNT(*) as c FROM entries WHERE content_hash IS NOT NULL')?.c ?? 0;
-  const uniqueHashes = provider.get<{ c: number }>('SELECT COUNT(DISTINCT content_hash) as c FROM entries WHERE content_hash IS NOT NULL')?.c ?? 0;
+  const hashed =
+    provider.get<{ c: number }>('SELECT COUNT(*) as c FROM entries WHERE content_hash IS NOT NULL')
+      ?.c ?? 0;
+  const uniqueHashes =
+    provider.get<{ c: number }>(
+      'SELECT COUNT(DISTINCT content_hash) as c FROM entries WHERE content_hash IS NOT NULL',
+    )?.c ?? 0;
   return { total, hashed, uniqueHashes };
 }
 
 // ── Helpers ──────────────────────────────────────────────────────────────
 
 function gc(provider: PersistenceProvider, col: string): Record<string, number> {
-  const rows = provider.all<{ key: string; count: number }>(`SELECT ${col} as key, COUNT(*) as count FROM entries GROUP BY ${col}`);
+  const rows = provider.all<{ key: string; count: number }>(
+    `SELECT ${col} as key, COUNT(*) as count FROM entries GROUP BY ${col}`,
+  );
   return Object.fromEntries(rows.map((r) => [r.key, r.count]));
 }
 
 export 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) || '[]'),
-    tier: (row.tier as IntelligenceEntry['tier']) ?? undefined, origin: (row.origin as IntelligenceEntry['origin']) ?? undefined,
-    validFrom: (row.valid_from as number) ?? undefined, validUntil: (row.valid_until as number) ?? undefined,
+    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) || '[]'),
+    tier: (row.tier as IntelligenceEntry['tier']) ?? undefined,
+    origin: (row.origin as IntelligenceEntry['origin']) ?? undefined,
+    validFrom: (row.valid_from as number) ?? undefined,
+    validUntil: (row.valid_until as number) ?? undefined,
   };
 }
 
@@ -274,8 +414,12 @@ export function rowToSearchResult(row: Record<string, unknown>): SearchResult {
 
 /** Build FTS5 query from natural language: terms joined with OR for broad matching. */
 export function buildFtsQuery(query: string): string {
-  const terms = query.toLowerCase().split(/\s+/)
-    .filter((t) => t.length >= 2).map((t) => t.replace(/[^a-z0-9]/g, '')).filter(Boolean);
+  const terms = query
+    .toLowerCase()
+    .split(/\s+/)
+    .filter((t) => t.length >= 2)
+    .map((t) => t.replace(/[^a-z0-9]/g, ''))
+    .filter(Boolean);
   if (terms.length === 0) return query;
   if (terms.length === 1) return terms[0];
   return terms.join(' OR ');

package/src/vault/vault-maintenance.ts

@@ -111,10 +111,9 @@ export function archive(
   const reason = options.reason ?? `Archived: older than ${options.olderThanDays} days`;
 
   return provider.transaction(() => {
-    const candidates = provider.all<{ id: string }>(
-      'SELECT id FROM entries WHERE updated_at < ?',
-      [cutoff],
-    );
+    const candidates = provider.all<{ id: string }>('SELECT id FROM entries WHERE updated_at < ?', [
+      cutoff,
+    ]);
 
     if (candidates.length === 0) return { archived: 0 };
 
@@ -173,14 +172,10 @@ export function registerProject(
   return getProject(provider, path)!;
 }
 
-export function getProject(
-  provider: PersistenceProvider,
-  path: string,
-): ProjectInfo | null {
-  const row = provider.get<Record<string, unknown>>(
-    'SELECT * FROM projects WHERE path = ?',
-    [path],
-  );
+export function getProject(provider: PersistenceProvider, path: string): ProjectInfo | null {
+  const row = provider.get<Record<string, unknown>>('SELECT * FROM projects WHERE path = ?', [
+    path,
+  ]);
   if (!row) return null;
   return {
     path: row.path as string,

package/src/vault/vault-manager.test.ts

@@ -7,13 +7,17 @@ vi.mock('./vault.js', () => {
   const MockVault = function (this: Record<string, unknown>, path: string) {
     this._path = path;
     this.search = vi.fn().mockReturnValue([]);
-    this.stats = vi.fn().mockReturnValue({ totalEntries: 0, byType: {}, byDomain: {}, bySeverity: {} });
+    this.stats = vi
+      .fn()
+      .mockReturnValue({ totalEntries: 0, byType: {}, byDomain: {}, bySeverity: {} });
     this.close = vi.fn();
-  } as unknown as typeof import('./vault.js')['Vault'];
+  } as unknown as (typeof import('./vault.js'))['Vault'];
   return { Vault: MockVault };
 });
 
-function makeManager(weights?: Partial<Record<'agent' | 'project' | 'team', number>>): VaultManager {
+function makeManager(
+  weights?: Partial<Record<'agent' | 'project' | 'team', number>>,
+): VaultManager {
   return new VaultManager({ agentId: 'test-agent', weights });
 }
 
@@ -74,7 +78,7 @@ describe('VaultManager', () => {
 
   it('throws when connecting duplicate named vault', () => {
     mgr.connect('shared', '/tmp/shared.db');
-    expect(() => mgr.connect('shared', '/tmp/other.db')).toThrow("already connected");
+    expect(() => mgr.connect('shared', '/tmp/other.db')).toThrow('already connected');
   });
 
   it('disconnects a named vault', () => {
@@ -122,14 +126,10 @@ describe('VaultManager', () => {
   it('deduplicates entries keeping highest weighted score', () => {
     const entry = { id: 'e1', title: 'Shared' };
     const agentVault = mgr.open('agent', '/tmp/a.db');
-    (agentVault.search as ReturnType<typeof vi.fn>).mockReturnValue([
-      { entry, score: 0.5 },
-    ]);
+    (agentVault.search as ReturnType<typeof vi.fn>).mockReturnValue([{ entry, score: 0.5 }]);
 
     const teamVault = mgr.open('team', '/tmp/t.db');
-    (teamVault.search as ReturnType<typeof vi.fn>).mockReturnValue([
-      { entry, score: 0.8 },
-    ]);
+    (teamVault.search as ReturnType<typeof vi.fn>).mockReturnValue([{ entry, score: 0.8 }]);
 
     const results = mgr.search('test');
     // Agent: 0.5 * 1.0 = 0.5, Team: 0.8 * 0.6 = 0.48 → agent wins

package/src/vault/vault-markdown-sync.ts

@@ -105,7 +105,10 @@ export async function syncAllToMarkdown(
   for (const entry of entries) {
     const domain = entry.domain || '_general';
     const slug = titleToSlug(entry.title);
-    if (!slug) { skipped++; continue; }
+    if (!slug) {
+      skipped++;
+      continue;
+    }
 
     const filePath = join(knowledgeDir, 'vault', domain, `${slug}.md`);
     if (existsSync(filePath)) {

package/src/vault/vault-memories.ts

@@ -228,16 +228,16 @@ export function pruneMemories(
   olderThanDays: number,
 ): { pruned: number } {
   const cutoff = Math.floor(Date.now() / 1000) - olderThanDays * 86400;
-  const result = provider.run(
-    'DELETE FROM memories WHERE created_at < ? AND archived_at IS NULL',
-    [cutoff],
-  );
+  const result = provider.run('DELETE FROM memories WHERE created_at < ? AND archived_at IS NULL', [
+    cutoff,
+  ]);
   return { pruned: result.changes };
 }
 
-export function deduplicateMemories(
-  provider: PersistenceProvider,
-): { removed: number; groups: Array<{ kept: string; removed: string[] }> } {
+export function deduplicateMemories(provider: PersistenceProvider): {
+  removed: number;
+  groups: Array<{ kept: string; removed: string[] }>;
+} {
   const dupeRows = provider.all<{ id1: string; id2: string }>(`
       SELECT m1.id as id1, m2.id as id2
       FROM memories m1

package/src/vault/vault-schema.ts

@@ -87,7 +87,9 @@ function createCoreTables(provider: PersistenceProvider): void {
     );`);
 
   // Add memory columns if missing
-  const memCols = provider.all<{ name: string }>('PRAGMA table_info(memories)').map((r: { name: string }) => r.name);
+  const memCols = provider
+    .all<{ name: string }>('PRAGMA table_info(memories)')
+    .map((r: { name: string }) => r.name);
   if (!memCols.includes('intent')) {
     provider.execSql(`
       ALTER TABLE memories ADD COLUMN intent TEXT;
@@ -134,8 +136,12 @@ function migrateBrainSchema(provider: PersistenceProvider): void {
   const hasSource = columns.some((c: { name: string }) => c.name === 'source');
   if (!hasSource && columns.length > 0) {
     provider.transaction(() => {
-      provider.run(`CREATE TABLE brain_feedback_new (id INTEGER PRIMARY KEY AUTOINCREMENT, query TEXT NOT NULL, entry_id TEXT NOT NULL, action TEXT NOT NULL CHECK(action IN ('accepted', 'dismissed', 'modified', 'failed')), source TEXT NOT NULL DEFAULT 'search', confidence REAL NOT NULL DEFAULT 0.6, duration INTEGER, context TEXT NOT NULL DEFAULT '{}', reason TEXT, created_at INTEGER NOT NULL DEFAULT (unixepoch()))`);
-      provider.run(`INSERT INTO brain_feedback_new (id, query, entry_id, action, created_at) SELECT id, query, entry_id, action, created_at FROM brain_feedback`);
+      provider.run(
+        `CREATE TABLE brain_feedback_new (id INTEGER PRIMARY KEY AUTOINCREMENT, query TEXT NOT NULL, entry_id TEXT NOT NULL, action TEXT NOT NULL CHECK(action IN ('accepted', 'dismissed', 'modified', 'failed')), source TEXT NOT NULL DEFAULT 'search', confidence REAL NOT NULL DEFAULT 0.6, duration INTEGER, context TEXT NOT NULL DEFAULT '{}', reason TEXT, created_at INTEGER NOT NULL DEFAULT (unixepoch()))`,
+      );
+      provider.run(
+        `INSERT INTO brain_feedback_new (id, query, entry_id, action, created_at) SELECT id, query, entry_id, action, created_at FROM brain_feedback`,
+      );
       provider.run('DROP TABLE brain_feedback');
       provider.run('ALTER TABLE brain_feedback_new RENAME TO brain_feedback');
       provider.run('CREATE INDEX IF NOT EXISTS idx_brain_feedback_query ON brain_feedback(query)');
@@ -143,39 +149,90 @@ function migrateBrainSchema(provider: PersistenceProvider): void {
   }
   try {
     const sessionCols = provider.all<{ name: string }>('PRAGMA table_info(brain_sessions)');
-    if (sessionCols.length > 0 && !sessionCols.some((c: { name: string }) => c.name === 'extracted_at')) {
+    if (
+      sessionCols.length > 0 &&
+      !sessionCols.some((c: { name: string }) => c.name === 'extracted_at')
+    ) {
       provider.run('ALTER TABLE brain_sessions ADD COLUMN extracted_at TEXT');
     }
-  } catch { /* brain_sessions doesn't exist yet */ }
+  } catch {
+    /* brain_sessions doesn't exist yet */
+  }
 }
 
 function migrateTemporalSchema(provider: PersistenceProvider): void {
-  try { provider.run('ALTER TABLE entries ADD COLUMN valid_from INTEGER'); } catch { /* exists */ }
-  try { provider.run('ALTER TABLE entries ADD COLUMN valid_until INTEGER'); } catch { /* exists */ }
+  try {
+    provider.run('ALTER TABLE entries ADD COLUMN valid_from INTEGER');
+  } catch {
+    /* exists */
+  }
+  try {
+    provider.run('ALTER TABLE entries ADD COLUMN valid_until INTEGER');
+  } catch {
+    /* exists */
+  }
 }
 
 function migrateOriginColumn(provider: PersistenceProvider): void {
-  try { provider.run("ALTER TABLE entries ADD COLUMN origin TEXT NOT NULL DEFAULT 'user' CHECK(origin IN ('agent', 'pack', 'user'))"); } catch { /* exists */ }
+  try {
+    provider.run(
+      "ALTER TABLE entries ADD COLUMN origin TEXT NOT NULL DEFAULT 'user' CHECK(origin IN ('agent', 'pack', 'user'))",
+    );
+  } catch {
+    /* exists */
+  }
   provider.execSql('CREATE INDEX IF NOT EXISTS idx_entries_origin ON entries(origin)');
 }
 
 function migrateContentHash(provider: PersistenceProvider): void {
-  try { provider.run('ALTER TABLE entries ADD COLUMN content_hash TEXT'); } catch { /* exists */ }
-  provider.execSql('CREATE INDEX IF NOT EXISTS idx_entries_content_hash ON entries(content_hash) WHERE content_hash IS NOT NULL');
-  const unhashed = provider.all<{ id: string; type: string; domain: string; title: string; description: string; tags: string; example: string | null; counter_example: string | null }>(
+  try {
+    provider.run('ALTER TABLE entries ADD COLUMN content_hash TEXT');
+  } catch {
+    /* exists */
+  }
+  provider.execSql(
+    'CREATE INDEX IF NOT EXISTS idx_entries_content_hash ON entries(content_hash) WHERE content_hash IS NOT NULL',
+  );
+  const unhashed = provider.all<{
+    id: string;
+    type: string;
+    domain: string;
+    title: string;
+    description: string;
+    tags: string;
+    example: string | null;
+    counter_example: string | null;
+  }>(
     'SELECT id, type, domain, title, description, tags, example, counter_example FROM entries WHERE content_hash IS NULL',
   );
   if (unhashed.length > 0) {
     provider.transaction(() => {
       for (const row of unhashed) {
-        const hash = computeContentHash({ type: row.type, domain: row.domain, title: row.title, description: row.description, tags: JSON.parse(row.tags), example: row.example ?? undefined, counterExample: row.counter_example ?? undefined });
-        provider.run('UPDATE entries SET content_hash = @hash WHERE id = @id', { hash, id: row.id });
+        const hash = computeContentHash({
+          type: row.type,
+          domain: row.domain,
+          title: row.title,
+          description: row.description,
+          tags: JSON.parse(row.tags),
+          example: row.example ?? undefined,
+          counterExample: row.counter_example ?? undefined,
+        });
+        provider.run('UPDATE entries SET content_hash = @hash WHERE id = @id', {
+          hash,
+          id: row.id,
+        });
       }
     });
   }
 }
 
 function migrateTierColumn(provider: PersistenceProvider): void {
-  try { provider.run("ALTER TABLE entries ADD COLUMN tier TEXT DEFAULT 'agent'"); } catch { /* exists */ }
-  provider.execSql('CREATE INDEX IF NOT EXISTS idx_entries_tier ON entries(tier) WHERE tier IS NOT NULL');
+  try {
+    provider.run("ALTER TABLE entries ADD COLUMN tier TEXT DEFAULT 'agent'");
+  } catch {
+    /* exists */
+  }
+  provider.execSql(
+    'CREATE INDEX IF NOT EXISTS idx_entries_tier ON entries(tier) WHERE tier IS NOT NULL',
+  );
 }