audrey 0.17.0 → 0.20.0

package/src/embedding.js

@@ -1,260 +0,0 @@
-import { createHash } from 'node:crypto';
-import { describeHttpError, requireApiKey } from './utils.js';
-
-/**
- * @typedef {Object} EmbeddingProvider
- * @property {number} dimensions
- * @property {string} modelName
- * @property {string} modelVersion
- * @property {(text: string) => Promise<number[]>} embed
- * @property {(texts: string[]) => Promise<number[][]>} embedBatch
- * @property {(vector: number[]) => Buffer} vectorToBuffer
- * @property {(buffer: Buffer) => number[]} bufferToVector
- */
-
-/** @implements {EmbeddingProvider} */
-export class MockEmbeddingProvider {
-  constructor({ dimensions = 64 } = {}) {
-    this.dimensions = dimensions;
-    this.modelName = 'mock-embedding';
-    this.modelVersion = '1.0.0';
-  }
-
-  async embed(text) {
-    const hash = createHash('sha256').update(text).digest();
-    const vector = new Array(this.dimensions);
-    for (let i = 0; i < this.dimensions; i++) {
-      vector[i] = (hash[i % hash.length] / 255) * 2 - 1;
-    }
-    const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
-    return vector.map(v => v / magnitude);
-  }
-
-  async embedBatch(texts) {
-    return Promise.all(texts.map(t => this.embed(t)));
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-/** @implements {EmbeddingProvider} */
-export class OpenAIEmbeddingProvider {
-  constructor({ apiKey, model = 'text-embedding-3-small', dimensions = 1536, timeout = 30000 } = {}) {
-    this.apiKey = apiKey || process.env.OPENAI_API_KEY;
-    this.model = model;
-    this.dimensions = dimensions;
-    this.timeout = timeout;
-    this.modelName = model;
-    this.modelVersion = 'latest';
-  }
-
-  async embed(text) {
-    requireApiKey(this.apiKey, 'OpenAI embedding', 'OPENAI_API_KEY');
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch('https://api.openai.com/v1/embeddings', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ input: text, model: this.model, dimensions: this.dimensions }),
-        signal: controller.signal,
-      });
-      if (!response.ok) throw new Error(`OpenAI embedding failed: ${await describeHttpError(response)}`);
-      const data = await response.json();
-      return data.data[0].embedding;
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  async embedBatch(texts) {
-    requireApiKey(this.apiKey, 'OpenAI embedding', 'OPENAI_API_KEY');
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch('https://api.openai.com/v1/embeddings', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ input: texts, model: this.model, dimensions: this.dimensions }),
-        signal: controller.signal,
-      });
-      if (!response.ok) throw new Error(`OpenAI embedding failed: ${await describeHttpError(response)}`);
-      const data = await response.json();
-      return data.data.map(d => d.embedding);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-/** @implements {EmbeddingProvider} */
-export class LocalEmbeddingProvider {
-  constructor({ model = 'Xenova/all-MiniLM-L6-v2', device = 'gpu', batchSize = 64, pipelineFactory = null } = {}) {
-    this.model = model;
-    this.dimensions = 384;
-    this.modelName = model;
-    this.modelVersion = '1.0.0';
-    this.device = device;
-    this.batchSize = batchSize;
-    this.pipelineFactory = pipelineFactory;
-    this._pipeline = null;
-    this._readyPromise = null;
-    this._actualDevice = null;
-  }
-
-  ready() {
-    if (!this._readyPromise) {
-      this._readyPromise = (async () => {
-        const pipeline = this.pipelineFactory || (await import('@huggingface/transformers')).pipeline;
-        try {
-          this._pipeline = await pipeline('feature-extraction', this.model, {
-            dtype: 'fp32', device: this.device,
-          });
-          this._actualDevice = this.device;
-        } catch {
-          this._pipeline = await pipeline('feature-extraction', this.model, {
-            dtype: 'fp32', device: 'cpu',
-          });
-          this._actualDevice = 'cpu';
-        }
-      })();
-    }
-    return this._readyPromise;
-  }
-
-  async embed(text) {
-    await this.ready();
-    const output = await this._pipeline(text, { pooling: 'mean', normalize: true });
-    return Array.from(output.data);
-  }
-
-  async embedBatch(texts) {
-    if (texts.length === 0) return [];
-    await this.ready();
-    const results = [];
-    for (let i = 0; i < texts.length; i += this.batchSize) {
-      const chunk = texts.slice(i, i + this.batchSize);
-      const output = await this._pipeline(chunk, { pooling: 'mean', normalize: true });
-      results.push(...output.tolist());
-    }
-    return results;
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-/** @implements {EmbeddingProvider} */
-export class GeminiEmbeddingProvider {
-  constructor({ apiKey, model = 'gemini-embedding-001', timeout = 30000 } = {}) {
-    this.apiKey = apiKey || process.env.GOOGLE_API_KEY;
-    this.model = model;
-    this.dimensions = 3072;
-    this.timeout = timeout;
-    this.modelName = model;
-    this.modelVersion = 'latest';
-  }
-
-  async embed(text) {
-    requireApiKey(this.apiKey, 'Gemini embedding', 'GOOGLE_API_KEY');
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:embedContent`,
-        {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json', 'x-goog-api-key': this.apiKey },
-          body: JSON.stringify({ model: `models/${this.model}`, content: { parts: [{ text }] } }),
-          signal: controller.signal,
-        }
-      );
-      if (!response.ok) throw new Error(`Gemini embedding failed: ${await describeHttpError(response)}`);
-      const data = await response.json();
-      return data.embedding.values;
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  async embedBatch(texts) {
-    if (texts.length === 0) return [];
-    requireApiKey(this.apiKey, 'Gemini embedding', 'GOOGLE_API_KEY');
-    const results = [];
-    for (let i = 0; i < texts.length; i += 100) {
-      const chunk = texts.slice(i, i + 100);
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), this.timeout);
-      try {
-        const response = await fetch(
-          `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:batchEmbedContents`,
-          {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'x-goog-api-key': this.apiKey },
-            body: JSON.stringify({
-              requests: chunk.map(text => ({
-                model: `models/${this.model}`,
-                content: { parts: [{ text }] },
-              })),
-            }),
-            signal: controller.signal,
-          }
-        );
-        if (!response.ok) throw new Error(`Gemini batch embedding failed: ${await describeHttpError(response)}`);
-        const data = await response.json();
-        results.push(...data.embeddings.map(e => e.values));
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-    return results;
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-export function createEmbeddingProvider(config) {
-  switch (config.provider) {
-    case 'mock':
-      return new MockEmbeddingProvider(config);
-    case 'openai':
-      return new OpenAIEmbeddingProvider(config);
-    case 'local':
-      return new LocalEmbeddingProvider(config);
-    case 'gemini':
-      return new GeminiEmbeddingProvider(config);
-    default:
-      throw new Error(`Unknown embedding provider: ${config.provider}. Valid: mock, openai, local, gemini`);
-  }
-}

package/src/encode.js

@@ -1,69 +0,0 @@
-import { generateId } from './ulid.js';
-import { sourceReliability } from './confidence.js';
-import { arousalSalienceBoost } from './affect.js';
-import { hasFTSTables, insertFTSEpisode } from './fts.js';
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {import('./embedding.js').EmbeddingProvider} embeddingProvider
- * @param {{ content: string, source: string, salience?: number, causal?: { trigger?: string, consequence?: string }, tags?: string[], supersedes?: string, context?: object, affect?: object, arousalWeight?: number, private?: boolean }} params
- * @returns {Promise<string>}
- */
-export async function encodeEpisode(db, embeddingProvider, {
-  content,
-  source,
-  salience = 0.5,
-  causal,
-  tags,
-  supersedes,
-  context = {},
-  affect = {},
-  arousalWeight = 0.3,
-  private: isPrivate = false,
-  agent = 'default',
-}) {
-  if (!content || typeof content !== 'string') throw new Error('content must be a non-empty string');
-  if (salience < 0 || salience > 1) throw new Error('salience must be between 0 and 1');
-  if (tags && !Array.isArray(tags)) throw new Error('tags must be an array');
-
-  const reliability = sourceReliability(source);
-  const vector = await embeddingProvider.embed(content);
-  const embeddingBuffer = embeddingProvider.vectorToBuffer(vector);
-  const id = generateId();
-  const now = new Date().toISOString();
-
-  const boost = arousalSalienceBoost(affect.arousal);
-  const effectiveSalience = Math.min(1.0, salience + (boost * arousalWeight));
-
-  const insertAndLink = db.transaction(() => {
-    db.prepare(`
-      INSERT INTO episodes (
-        id, content, embedding, source, source_reliability, salience, context, affect,
-        tags, causal_trigger, causal_consequence, created_at,
-        embedding_model, embedding_version, supersedes, "private", agent
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      id, content, embeddingBuffer, source, reliability, effectiveSalience,
-      JSON.stringify(context),
-      JSON.stringify(affect),
-      tags ? JSON.stringify(tags) : null,
-      causal?.trigger || null, causal?.consequence || null,
-      now, embeddingProvider.modelName, embeddingProvider.modelVersion,
-      supersedes || null,
-      isPrivate ? 1 : 0,
-      agent,
-    );
-    db.prepare(
-      'INSERT INTO vec_episodes(id, embedding, source, consolidated) VALUES (?, ?, ?, ?)'
-    ).run(id, embeddingBuffer, source, BigInt(0));
-    if (supersedes) {
-      db.prepare('UPDATE episodes SET superseded_by = ? WHERE id = ?').run(id, supersedes);
-    }
-    if (hasFTSTables(db)) {
-      insertFTSEpisode(db, id, content, tags);
-    }
-  });
-
-  insertAndLink();
-  return id;
-}

package/src/export.js

@@ -1,67 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { join, dirname } from 'node:path';
-import { safeJsonParse } from './utils.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
-
-export function exportMemories(db) {
-  const episodes = db.prepare(
-    'SELECT id, content, source, source_reliability, salience, context, affect, tags, causal_trigger, causal_consequence, created_at, embedding_model, embedding_version, supersedes, superseded_by, consolidated, "private" FROM episodes'
-  ).all().map(ep => ({
-    ...ep,
-    tags: safeJsonParse(ep.tags, null),
-    context: safeJsonParse(ep.context, null),
-    affect: safeJsonParse(ep.affect, null),
-  }));
-
-  const semantics = db.prepare(
-    'SELECT id, content, state, conditions, evidence_episode_ids, evidence_count, supporting_count, contradicting_count, source_type_diversity, consolidation_checkpoint, embedding_model, embedding_version, consolidation_model, consolidation_prompt_hash, created_at, last_reinforced_at, retrieval_count, challenge_count, interference_count, salience FROM semantics'
-  ).all().map(sem => ({
-    ...sem,
-    evidence_episode_ids: safeJsonParse(sem.evidence_episode_ids, []),
-  }));
-
-  const procedures = db.prepare(
-    'SELECT id, content, state, trigger_conditions, evidence_episode_ids, success_count, failure_count, embedding_model, embedding_version, created_at, last_reinforced_at, retrieval_count, interference_count, salience FROM procedures'
-  ).all().map(proc => ({
-    ...proc,
-    evidence_episode_ids: safeJsonParse(proc.evidence_episode_ids, []),
-  }));
-
-  const causalLinks = db.prepare('SELECT * FROM causal_links').all();
-
-  const contradictions = db.prepare(
-    'SELECT id, claim_a_id, claim_a_type, claim_b_id, claim_b_type, state, resolution, resolved_at, reopened_at, reopen_evidence_id, created_at FROM contradictions'
-  ).all();
-
-  const consolidationRuns = db.prepare(
-    'SELECT id, checkpoint_cursor, input_episode_ids, output_memory_ids, confidence_deltas, consolidation_model, consolidation_prompt_hash, started_at, completed_at, status FROM consolidation_runs'
-  ).all().map(run => ({
-    ...run,
-    confidence_deltas: safeJsonParse(run.confidence_deltas, null),
-    input_episode_ids: safeJsonParse(run.input_episode_ids, []),
-    output_memory_ids: safeJsonParse(run.output_memory_ids, []),
-  }));
-
-  const consolidationMetrics = db.prepare(
-    'SELECT id, run_id, min_cluster_size, similarity_threshold, episodes_evaluated, clusters_found, principles_extracted, created_at FROM consolidation_metrics'
-  ).all();
-
-  const configRows = db.prepare('SELECT key, value FROM audrey_config').all();
-  const config = Object.fromEntries(configRows.map(r => [r.key, r.value]));
-
-  return {
-    version: pkg.version,
-    exportedAt: new Date().toISOString(),
-    episodes,
-    semantics,
-    procedures,
-    causalLinks,
-    contradictions,
-    consolidationRuns,
-    consolidationMetrics,
-    config,
-  };
-}

package/src/forget.js

@@ -1,111 +0,0 @@
-export function forgetMemory(db, id, { purge = false } = {}) {
-  const episode = db.prepare('SELECT id FROM episodes WHERE id = ?').get(id);
-  if (episode) {
-    if (purge) {
-      db.prepare('DELETE FROM vec_episodes WHERE id = ?').run(id);
-      db.prepare('DELETE FROM episodes WHERE id = ?').run(id);
-    } else {
-      db.prepare("UPDATE episodes SET superseded_by = 'forgotten' WHERE id = ?").run(id);
-      db.prepare('DELETE FROM vec_episodes WHERE id = ?').run(id);
-    }
-    return { id, type: 'episodic', purged: purge };
-  }
-
-  const semantic = db.prepare('SELECT id FROM semantics WHERE id = ?').get(id);
-  if (semantic) {
-    if (purge) {
-      db.prepare('DELETE FROM vec_semantics WHERE id = ?').run(id);
-      db.prepare('DELETE FROM semantics WHERE id = ?').run(id);
-    } else {
-      db.prepare("UPDATE semantics SET state = 'superseded' WHERE id = ?").run(id);
-      db.prepare('DELETE FROM vec_semantics WHERE id = ?').run(id);
-    }
-    return { id, type: 'semantic', purged: purge };
-  }
-
-  const procedure = db.prepare('SELECT id FROM procedures WHERE id = ?').get(id);
-  if (procedure) {
-    if (purge) {
-      db.prepare('DELETE FROM vec_procedures WHERE id = ?').run(id);
-      db.prepare('DELETE FROM procedures WHERE id = ?').run(id);
-    } else {
-      db.prepare("UPDATE procedures SET state = 'superseded' WHERE id = ?").run(id);
-      db.prepare('DELETE FROM vec_procedures WHERE id = ?').run(id);
-    }
-    return { id, type: 'procedural', purged: purge };
-  }
-
-  throw new Error(`Memory not found: ${id}`);
-}
-
-export function purgeMemories(db) {
-  const deadEpisodes = db.prepare(
-    'SELECT id FROM episodes WHERE superseded_by IS NOT NULL'
-  ).all();
-  const deadSemantics = db.prepare(
-    "SELECT id FROM semantics WHERE state IN ('superseded', 'dormant', 'rolled_back')"
-  ).all();
-  const deadProcedures = db.prepare(
-    "SELECT id FROM procedures WHERE state IN ('superseded', 'dormant', 'rolled_back')"
-  ).all();
-
-  const purgeAll = db.transaction(() => {
-    for (const row of deadEpisodes) {
-      db.prepare('DELETE FROM vec_episodes WHERE id = ?').run(row.id);
-      db.prepare('DELETE FROM episodes WHERE id = ?').run(row.id);
-    }
-    for (const row of deadSemantics) {
-      db.prepare('DELETE FROM vec_semantics WHERE id = ?').run(row.id);
-      db.prepare('DELETE FROM semantics WHERE id = ?').run(row.id);
-    }
-    for (const row of deadProcedures) {
-      db.prepare('DELETE FROM vec_procedures WHERE id = ?').run(row.id);
-      db.prepare('DELETE FROM procedures WHERE id = ?').run(row.id);
-    }
-  });
-
-  purgeAll();
-
-  return {
-    episodes: deadEpisodes.length,
-    semantics: deadSemantics.length,
-    procedures: deadProcedures.length,
-  };
-}
-
-export async function forgetByQuery(db, embeddingProvider, query, { minSimilarity = 0.9, purge = false } = {}) {
-  const queryVector = await embeddingProvider.embed(query);
-  const queryBuffer = embeddingProvider.vectorToBuffer(queryVector);
-
-  const candidates = [];
-
-  const epMatch = db.prepare(`
-    SELECT e.id, (1.0 - v.distance) AS similarity, 'episodic' AS type
-    FROM vec_episodes v JOIN episodes e ON e.id = v.id
-    WHERE v.embedding MATCH ? AND k = 1 AND e.superseded_by IS NULL
-  `).get(queryBuffer);
-  if (epMatch) candidates.push(epMatch);
-
-  const semMatch = db.prepare(`
-    SELECT s.id, (1.0 - v.distance) AS similarity, 'semantic' AS type
-    FROM vec_semantics v JOIN semantics s ON s.id = v.id
-    WHERE v.embedding MATCH ? AND k = 1 AND (v.state = 'active' OR v.state = 'context_dependent')
-  `).get(queryBuffer);
-  if (semMatch) candidates.push(semMatch);
-
-  const procMatch = db.prepare(`
-    SELECT p.id, (1.0 - v.distance) AS similarity, 'procedural' AS type
-    FROM vec_procedures v JOIN procedures p ON p.id = v.id
-    WHERE v.embedding MATCH ? AND k = 1 AND (v.state = 'active' OR v.state = 'context_dependent')
-  `).get(queryBuffer);
-  if (procMatch) candidates.push(procMatch);
-
-  if (candidates.length === 0) return null;
-
-  candidates.sort((a, b) => b.similarity - a.similarity);
-  const best = candidates[0];
-
-  if (best.similarity < minSimilarity) return null;
-
-  return forgetMemory(db, best.id, { purge });
-}

package/src/fts.js

@@ -1,134 +0,0 @@
-/**
- * FTS5 full-text search for Audrey memories.
- * Creates virtual tables alongside vec0 tables for hybrid retrieval.
- */
-
-export function createFTSTables(db) {
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS fts_episodes
-      USING fts5(id UNINDEXED, content, tags, tokenize='porter unicode61');
-    CREATE VIRTUAL TABLE IF NOT EXISTS fts_semantics
-      USING fts5(id UNINDEXED, content, tokenize='porter unicode61');
-    CREATE VIRTUAL TABLE IF NOT EXISTS fts_procedures
-      USING fts5(id UNINDEXED, content, tokenize='porter unicode61');
-  `);
-}
-
-export function hasFTSTables(db) {
-  const row = db.prepare(
-    "SELECT COUNT(*) AS c FROM sqlite_master WHERE type='table' AND name='fts_episodes'"
-  ).get();
-  return row.c > 0;
-}
-
-export function insertFTSEpisode(db, id, content, tags) {
-  db.prepare('INSERT OR REPLACE INTO fts_episodes(id, content, tags) VALUES (?, ?, ?)').run(
-    id, content, tags ? (Array.isArray(tags) ? tags.join(' ') : tags) : ''
-  );
-}
-
-export function insertFTSSemantic(db, id, content) {
-  db.prepare('INSERT OR REPLACE INTO fts_semantics(id, content) VALUES (?, ?)').run(id, content);
-}
-
-export function insertFTSProcedure(db, id, content) {
-  db.prepare('INSERT OR REPLACE INTO fts_procedures(id, content) VALUES (?, ?)').run(id, content);
-}
-
-export function deleteFTSEpisode(db, id) {
-  db.prepare('DELETE FROM fts_episodes WHERE id = ?').run(id);
-}
-
-export function deleteFTSSemantic(db, id) {
-  db.prepare('DELETE FROM fts_semantics WHERE id = ?').run(id);
-}
-
-export function deleteFTSProcedure(db, id) {
-  db.prepare('DELETE FROM fts_procedures WHERE id = ?').run(id);
-}
-
-/**
- * Search episodes via FTS5 BM25.
- * Returns [{ id, content, rank }] sorted by relevance.
- */
-export function searchFTSEpisodes(db, query, limit = 30, agentFilter = null) {
-  const agentClause = agentFilter ? 'AND e.agent = ?' : '';
-  const params = agentFilter ? [query, agentFilter, limit] : [query, limit];
-  return db.prepare(`
-    SELECT f.id, f.content, e.agent, bm25(fts_episodes) AS rank
-    FROM fts_episodes f
-    JOIN episodes e ON e.id = f.id
-    WHERE fts_episodes MATCH ?
-      AND e.superseded_by IS NULL
-      ${agentClause}
-    ORDER BY rank
-    LIMIT ?
-  `).all(...params);
-}
-
-export function searchFTSSemantics(db, query, limit = 30, agentFilter = null) {
-  const agentClause = agentFilter ? 'AND s.agent = ?' : '';
-  const params = agentFilter ? [query, agentFilter, limit] : [query, limit];
-  return db.prepare(`
-    SELECT f.id, f.content, s.agent, bm25(fts_semantics) AS rank
-    FROM fts_semantics f
-    JOIN semantics s ON s.id = f.id
-    WHERE fts_semantics MATCH ?
-      AND s.state = 'active'
-      ${agentClause}
-    ORDER BY rank
-    LIMIT ?
-  `).all(...params);
-}
-
-export function searchFTSProcedures(db, query, limit = 30, agentFilter = null) {
-  const agentClause = agentFilter ? 'AND p.agent = ?' : '';
-  const params = agentFilter ? [query, agentFilter, limit] : [query, limit];
-  return db.prepare(`
-    SELECT f.id, f.content, p.agent, bm25(fts_procedures) AS rank
-    FROM fts_procedures f
-    JOIN procedures p ON p.id = f.id
-    WHERE fts_procedures MATCH ?
-      AND p.state = 'active'
-      ${agentClause}
-    ORDER BY rank
-    LIMIT ?
-  `).all(...params);
-}
-
-/**
- * Backfill FTS tables from existing data.
- */
-export function backfillFTS(db) {
-  const episodes = db.prepare('SELECT id, content, tags FROM episodes').all();
-  const insert = db.prepare('INSERT OR IGNORE INTO fts_episodes(id, content, tags) VALUES (?, ?, ?)');
-  for (const ep of episodes) {
-    const tags = ep.tags ? (typeof ep.tags === 'string' ? JSON.parse(ep.tags) : ep.tags) : [];
-    insert.run(ep.id, ep.content, Array.isArray(tags) ? tags.join(' ') : '');
-  }
-
-  const semantics = db.prepare('SELECT id, content FROM semantics').all();
-  const insertSem = db.prepare('INSERT OR IGNORE INTO fts_semantics(id, content) VALUES (?, ?)');
-  for (const sem of semantics) {
-    insertSem.run(sem.id, sem.content);
-  }
-
-  const procedures = db.prepare('SELECT id, content FROM procedures').all();
-  const insertProc = db.prepare('INSERT OR IGNORE INTO fts_procedures(id, content) VALUES (?, ?)');
-  for (const proc of procedures) {
-    insertProc.run(proc.id, proc.content);
-  }
-}
-
-/**
- * Sanitize FTS5 query — escape special characters.
- */
-export function sanitizeFTSQuery(query) {
-  return query
-    .replace(/[*"(){}[\]^~\\:]/g, ' ')
-    .replace(/\bAND\b|\bOR\b|\bNOT\b|\bNEAR\b/gi, ' ')
-    .trim()
-    .split(/\s+/)
-    .filter(Boolean)
-    .join(' ');
-}