audrey 0.16.1 → 0.20.0

package/src/llm.js

@@ -1,246 +0,0 @@
-/**
- * @typedef {Object} ChatMessage
- * @property {'system' | 'user' | 'assistant'} role
- * @property {string} content
- */
-
-function extractJSON(text) {
-  const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
-  return fenced ? fenced[1].trim() : text.trim();
-}
-
-/**
- * @typedef {Object} LLMCompletionResult
- * @property {string} content
- */
-
-/**
- * @typedef {Object} LLMCompletionOptions
- * @property {number} [maxTokens]
- */
-
-/**
- * @typedef {Object} LLMProvider
- * @property {string} modelName
- * @property {string} modelVersion
- * @property {(messages: ChatMessage[], options?: LLMCompletionOptions) => Promise<LLMCompletionResult>} complete
- * @property {(messages: ChatMessage[], options?: LLMCompletionOptions) => Promise<Object>} json
- */
-
-/**
- * @typedef {Object} MockLLMConfig
- * @property {'mock'} provider
- * @property {Record<string, Object>} [responses={}]
- */
-
-/**
- * @typedef {Object} AnthropicLLMConfig
- * @property {'anthropic'} provider
- * @property {string} [apiKey]
- * @property {string} [model='claude-sonnet-4-6']
- * @property {number} [maxTokens=1024]
- */
-
-/**
- * @typedef {Object} OpenAILLMConfig
- * @property {'openai'} provider
- * @property {string} [apiKey]
- * @property {string} [model='gpt-4o']
- * @property {number} [maxTokens=1024]
- */
-
-const PROMPT_TYPE_KEYS = [
-  'principleExtraction',
-  'contradictionDetection',
-  'causalArticulation',
-  'contextResolution',
-];
-
-/** @implements {LLMProvider} */
-export class MockLLMProvider {
-  /** @param {Partial<MockLLMConfig>} [config={}] */
-  constructor({ responses = {} } = {}) {
-    this.responses = responses;
-    this.modelName = 'mock-llm';
-    this.modelVersion = '1.0.0';
-  }
-
-  _matchPromptType(messages) {
-    const systemMsg = messages.find(m => m.role === 'system')?.content || '';
-    for (const key of PROMPT_TYPE_KEYS) {
-      if (systemMsg.includes(key)) return key;
-    }
-    return null;
-  }
-
-  /**
-   * @param {ChatMessage[]} messages
-   * @returns {Promise<LLMCompletionResult>}
-   */
-  async complete(messages) {
-    const promptType = this._matchPromptType(messages);
-    const cannedResponse = promptType ? this.responses[promptType] : undefined;
-    return { content: cannedResponse !== undefined ? JSON.stringify(cannedResponse) : '{}' };
-  }
-
-  /**
-   * @param {ChatMessage[]} messages
-   * @returns {Promise<Object>}
-   */
-  async json(messages) {
-    const promptType = this._matchPromptType(messages);
-    const cannedResponse = promptType ? this.responses[promptType] : undefined;
-    return cannedResponse !== undefined ? cannedResponse : {};
-  }
-}
-
-/** @implements {LLMProvider} */
-export class AnthropicLLMProvider {
-  /** @param {Partial<AnthropicLLMConfig>} [config={}] */
-  constructor({ apiKey, model = 'claude-sonnet-4-6', maxTokens = 1024, timeout = 30000 } = {}) {
-    this.apiKey = apiKey || process.env.ANTHROPIC_API_KEY;
-    this.model = model;
-    this.maxTokens = maxTokens;
-    this.timeout = timeout;
-    this.modelName = model;
-    this.modelVersion = 'latest';
-  }
-
-  /**
-   * @param {ChatMessage[]} messages
-   * @param {LLMCompletionOptions} [options={}]
-   * @returns {Promise<LLMCompletionResult>}
-   */
-  async complete(messages, options = {}) {
-    const systemMsg = messages.find(m => m.role === 'system')?.content;
-    const nonSystemMsgs = messages.filter(m => m.role !== 'system');
-
-    const body = {
-      model: this.model,
-      max_tokens: options.maxTokens || this.maxTokens,
-      messages: nonSystemMsgs,
-    };
-    if (systemMsg) body.system = systemMsg;
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch('https://api.anthropic.com/v1/messages', {
-        method: 'POST',
-        headers: {
-          'x-api-key': this.apiKey,
-          'anthropic-version': '2023-06-01',
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        const errorBody = await response.text().catch(() => '');
-        throw new Error(`Anthropic API error: ${response.status} ${errorBody}`);
-      }
-
-      const data = await response.json();
-      const text = data.content?.[0]?.text || '';
-      return { content: text };
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  /**
-   * @param {ChatMessage[]} messages
-   * @param {LLMCompletionOptions} [options={}]
-   * @returns {Promise<Object>}
-   */
-  async json(messages, options = {}) {
-    const result = await this.complete(messages, options);
-    try {
-      return JSON.parse(extractJSON(result.content));
-    } catch {
-      throw new Error(`Failed to parse LLM response as JSON: ${result.content.slice(0, 200)}`);
-    }
-  }
-}
-
-/** @implements {LLMProvider} */
-export class OpenAILLMProvider {
-  /** @param {Partial<OpenAILLMConfig>} [config={}] */
-  constructor({ apiKey, model = 'gpt-4o', maxTokens = 1024, timeout = 30000 } = {}) {
-    this.apiKey = apiKey || process.env.OPENAI_API_KEY;
-    this.model = model;
-    this.maxTokens = maxTokens;
-    this.timeout = timeout;
-    this.modelName = model;
-    this.modelVersion = 'latest';
-  }
-
-  /**
-   * @param {ChatMessage[]} messages
-   * @param {LLMCompletionOptions} [options={}]
-   * @returns {Promise<LLMCompletionResult>}
-   */
-  async complete(messages, options = {}) {
-    const body = {
-      model: this.model,
-      max_tokens: options.maxTokens || this.maxTokens,
-      messages,
-    };
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch('https://api.openai.com/v1/chat/completions', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        throw new Error(`OpenAI API error: ${response.status}`);
-      }
-
-      const data = await response.json();
-      const text = data.choices?.[0]?.message?.content || '';
-      return { content: text };
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  /**
-   * @param {ChatMessage[]} messages
-   * @param {LLMCompletionOptions} [options={}]
-   * @returns {Promise<Object>}
-   */
-  async json(messages, options = {}) {
-    const result = await this.complete(messages, options);
-    try {
-      return JSON.parse(extractJSON(result.content));
-    } catch {
-      throw new Error(`Failed to parse LLM response as JSON: ${result.content.slice(0, 200)}`);
-    }
-  }
-}
-
-/**
- * @param {MockLLMConfig | AnthropicLLMConfig | OpenAILLMConfig} config
- * @returns {MockLLMProvider | AnthropicLLMProvider | OpenAILLMProvider}
- */
-export function createLLMProvider(config) {
-  switch (config.provider) {
-    case 'mock':
-      return new MockLLMProvider(config);
-    case 'anthropic':
-      return new AnthropicLLMProvider(config);
-    case 'openai':
-      return new OpenAILLMProvider(config);
-    default:
-      throw new Error(`Unknown LLM provider: ${config.provider}. Valid: mock, anthropic, openai`);
-  }
-}

package/src/migrate.js

@@ -1,58 +0,0 @@
-import { dropVec0Tables, createVec0Tables } from './db.js';
-
-export async function reembedAll(db, embeddingProvider, { dropAndRecreate = false } = {}) {
-  if (dropAndRecreate) {
-    dropVec0Tables(db);
-    createVec0Tables(db, embeddingProvider.dimensions);
-  }
-
-  const episodes = db.prepare('SELECT id, content, source FROM episodes').all();
-  const semantics = db.prepare('SELECT id, content, state FROM semantics').all();
-  const procedures = db.prepare('SELECT id, content, state FROM procedures').all();
-
-  const episodeVectors = episodes.length > 0
-    ? await embeddingProvider.embedBatch(episodes.map(ep => ep.content))
-    : [];
-  const semanticVectors = semantics.length > 0
-    ? await embeddingProvider.embedBatch(semantics.map(s => s.content))
-    : [];
-  const procedureVectors = procedures.length > 0
-    ? await embeddingProvider.embedBatch(procedures.map(p => p.content))
-    : [];
-
-  const updateEpLegacy = db.prepare('UPDATE episodes SET embedding = ? WHERE id = ?');
-  const deleteVecEp = db.prepare('DELETE FROM vec_episodes WHERE id = ?');
-  const insertVecEp = db.prepare('INSERT INTO vec_episodes(id, embedding, source, consolidated) VALUES (?, ?, ?, ?)');
-
-  const updateSemLegacy = db.prepare('UPDATE semantics SET embedding = ? WHERE id = ?');
-  const deleteVecSem = db.prepare('DELETE FROM vec_semantics WHERE id = ?');
-  const insertVecSem = db.prepare('INSERT INTO vec_semantics(id, embedding, state) VALUES (?, ?, ?)');
-
-  const updateProcLegacy = db.prepare('UPDATE procedures SET embedding = ? WHERE id = ?');
-  const deleteVecProc = db.prepare('DELETE FROM vec_procedures WHERE id = ?');
-  const insertVecProc = db.prepare('INSERT INTO vec_procedures(id, embedding, state) VALUES (?, ?, ?)');
-
-  const writeTx = db.transaction(() => {
-    for (let i = 0; i < episodes.length; i++) {
-      const buf = embeddingProvider.vectorToBuffer(episodeVectors[i]);
-      updateEpLegacy.run(buf, episodes[i].id);
-      deleteVecEp.run(episodes[i].id);
-      insertVecEp.run(episodes[i].id, buf, episodes[i].source, BigInt(0));
-    }
-    for (let i = 0; i < semantics.length; i++) {
-      const buf = embeddingProvider.vectorToBuffer(semanticVectors[i]);
-      updateSemLegacy.run(buf, semantics[i].id);
-      deleteVecSem.run(semantics[i].id);
-      insertVecSem.run(semantics[i].id, buf, semantics[i].state);
-    }
-    for (let i = 0; i < procedures.length; i++) {
-      const buf = embeddingProvider.vectorToBuffer(procedureVectors[i]);
-      updateProcLegacy.run(buf, procedures[i].id);
-      deleteVecProc.run(procedures[i].id);
-      insertVecProc.run(procedures[i].id, buf, procedures[i].state);
-    }
-  });
-  writeTx();
-
-  return { episodes: episodes.length, semantics: semantics.length, procedures: procedures.length };
-}

package/src/recall.js

@@ -1,352 +0,0 @@
-import { computeConfidence, DEFAULT_HALF_LIVES, salienceModifier } from './confidence.js';
-import { interferenceModifier } from './interference.js';
-import { contextMatchRatio, contextModifier } from './context.js';
-import { moodCongruenceModifier, affectSimilarity } from './affect.js';
-import { daysBetween, safeJsonParse } from './utils.js';
-
-function computeEpisodicConfidence(ep, now, confidenceConfig = {}) {
-  const ageDays = daysBetween(ep.created_at, now);
-  const halfLives = confidenceConfig.halfLives || DEFAULT_HALF_LIVES;
-  let confidence = computeConfidence({
-    sourceType: ep.source,
-    supportingCount: 1,
-    contradictingCount: 0,
-    ageDays,
-    halfLifeDays: halfLives.episodic ?? DEFAULT_HALF_LIVES.episodic,
-    retrievalCount: 0,
-    daysSinceRetrieval: ageDays,
-    weights: confidenceConfig.weights,
-    customSourceReliability: confidenceConfig.sourceReliability,
-  });
-  confidence *= salienceModifier(ep.salience);
-  return Math.max(0, Math.min(1, confidence));
-}
-
-function computeSemanticConfidence(sem, now, confidenceConfig = {}) {
-  const ageDays = daysBetween(sem.created_at, now);
-  const daysSinceRetrieval = sem.last_reinforced_at
-    ? daysBetween(sem.last_reinforced_at, now)
-    : ageDays;
-  const halfLives = confidenceConfig.halfLives || DEFAULT_HALF_LIVES;
-  let confidence = computeConfidence({
-    sourceType: 'tool-result',
-    supportingCount: sem.supporting_count || 0,
-    contradictingCount: sem.contradicting_count || 0,
-    ageDays,
-    halfLifeDays: halfLives.semantic ?? DEFAULT_HALF_LIVES.semantic,
-    retrievalCount: sem.retrieval_count || 0,
-    daysSinceRetrieval,
-    weights: confidenceConfig.weights,
-    customSourceReliability: confidenceConfig.sourceReliability,
-  });
-  confidence *= interferenceModifier(sem.interference_count || 0, confidenceConfig.interferenceWeight);
-  confidence *= salienceModifier(sem.salience);
-  return Math.max(0, Math.min(1, confidence));
-}
-
-function computeProceduralConfidence(proc, now, confidenceConfig = {}) {
-  const ageDays = daysBetween(proc.created_at, now);
-  const daysSinceRetrieval = proc.last_reinforced_at
-    ? daysBetween(proc.last_reinforced_at, now)
-    : ageDays;
-  const halfLives = confidenceConfig.halfLives || DEFAULT_HALF_LIVES;
-  let confidence = computeConfidence({
-    sourceType: 'tool-result',
-    supportingCount: proc.success_count || 0,
-    contradictingCount: proc.failure_count || 0,
-    ageDays,
-    halfLifeDays: halfLives.procedural ?? DEFAULT_HALF_LIVES.procedural,
-    retrievalCount: proc.retrieval_count || 0,
-    daysSinceRetrieval,
-    weights: confidenceConfig.weights,
-    customSourceReliability: confidenceConfig.sourceReliability,
-  });
-  confidence *= interferenceModifier(proc.interference_count || 0, confidenceConfig.interferenceWeight);
-  confidence *= salienceModifier(proc.salience);
-  return Math.max(0, Math.min(1, confidence));
-}
-
-function buildEpisodicEntry(ep, confidence, score, includeProvenance, contextMatch, moodCongruence) {
-  const entry = {
-    id: ep.id,
-    content: ep.content,
-    type: 'episodic',
-    confidence,
-    score,
-    source: ep.source,
-    createdAt: ep.created_at,
-  };
-  if (contextMatch !== undefined) {
-    entry.contextMatch = contextMatch;
-  }
-  if (moodCongruence !== undefined) {
-    entry.moodCongruence = moodCongruence;
-  }
-  if (includeProvenance) {
-    entry.provenance = {
-      source: ep.source,
-      sourceReliability: ep.source_reliability,
-      createdAt: ep.created_at,
-      supersedes: ep.supersedes || null,
-    };
-  }
-  return entry;
-}
-
-function buildSemanticEntry(sem, confidence, score, includeProvenance) {
-  const entry = {
-    id: sem.id,
-    content: sem.content,
-    type: 'semantic',
-    confidence,
-    score,
-    source: 'consolidation',
-    state: sem.state,
-    createdAt: sem.created_at,
-  };
-  if (includeProvenance) {
-    entry.provenance = {
-      evidenceEpisodeIds: safeJsonParse(sem.evidence_episode_ids, []),
-      evidenceCount: sem.evidence_count || 0,
-      supportingCount: sem.supporting_count || 0,
-      contradictingCount: sem.contradicting_count || 0,
-      consolidationCheckpoint: sem.consolidation_checkpoint || null,
-    };
-  }
-  return entry;
-}
-
-function buildProceduralEntry(proc, confidence, score, includeProvenance) {
-  const entry = {
-    id: proc.id,
-    content: proc.content,
-    type: 'procedural',
-    confidence,
-    score,
-    source: 'consolidation',
-    state: proc.state,
-    createdAt: proc.created_at,
-  };
-  if (includeProvenance) {
-    entry.provenance = {
-      evidenceEpisodeIds: safeJsonParse(proc.evidence_episode_ids, []),
-      successCount: proc.success_count || 0,
-      failureCount: proc.failure_count || 0,
-      triggerConditions: proc.trigger_conditions || null,
-    };
-  }
-  return entry;
-}
-
-function stateClause(includeDormant) {
-  return includeDormant
-    ? "AND (v.state = 'active' OR v.state = 'context_dependent' OR v.state = 'dormant')"
-    : "AND (v.state = 'active' OR v.state = 'context_dependent')";
-}
-
-function matchesDateFilters(createdAt, filters) {
-  if (filters.after && createdAt <= filters.after) return false;
-  if (filters.before && createdAt >= filters.before) return false;
-  return true;
-}
-
-function safeKForTable(db, table, candidateK) {
-  const rowCount = db.prepare(`SELECT COUNT(*) AS c FROM ${table}`).get().c;
-  return rowCount > 0 ? Math.min(candidateK, rowCount) : 0;
-}
-
-function knnEpisodic(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, confidenceConfig, filters = {}, includePrivate = false) {
-  const safeK = safeKForTable(db, 'vec_episodes', candidateK);
-  if (safeK === 0) return [];
-  const privateClause = includePrivate ? '' : 'AND e."private" = 0';
-  const rows = db.prepare(`
-    SELECT e.*, (1.0 - v.distance) AS similarity
-    FROM vec_episodes v
-    JOIN episodes e ON e.id = v.id
-    WHERE v.embedding MATCH ?
-      AND k = ?
-      AND e.superseded_by IS NULL
-      ${privateClause}
-  `).all(queryBuffer, safeK);
-
-  const results = [];
-  for (const row of rows) {
-    if (!matchesDateFilters(row.created_at, filters)) continue;
-    if (filters.tags?.length) {
-      const rowTags = safeJsonParse(row.tags, []);
-      if (!filters.tags.some(t => rowTags.includes(t))) continue;
-    }
-    if (filters.sources?.length && !filters.sources.includes(row.source)) continue;
-    let confidence = computeEpisodicConfidence(row, now, confidenceConfig);
-
-    let ctxMatch;
-    if (confidenceConfig?.retrievalContext) {
-      const encodingCtx = safeJsonParse(row.context, {});
-      ctxMatch = contextMatchRatio(encodingCtx, confidenceConfig.retrievalContext);
-      confidence *= contextModifier(encodingCtx, confidenceConfig.retrievalContext, confidenceConfig.contextWeight);
-      confidence = Math.max(0, Math.min(1, confidence));
-    }
-
-    let moodMatch;
-    if (confidenceConfig?.retrievalMood) {
-      const encodingAffect = safeJsonParse(row.affect, {});
-      moodMatch = affectSimilarity(encodingAffect, confidenceConfig.retrievalMood);
-      confidence *= moodCongruenceModifier(encodingAffect, confidenceConfig.retrievalMood, confidenceConfig.affectWeight);
-      confidence = Math.max(0, Math.min(1, confidence));
-    }
-
-    if (confidence < minConfidence) continue;
-    const score = row.similarity * confidence;
-    results.push(buildEpisodicEntry(row, confidence, score, includeProvenance, ctxMatch, moodMatch));
-  }
-  return results;
-}
-
-function knnSemantic(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, includeDormant, confidenceConfig, filters = {}) {
-  const safeK = safeKForTable(db, 'vec_semantics', candidateK);
-  if (safeK === 0) return { results: [], matchedIds: [] };
-  const rows = db.prepare(`
-    SELECT s.*, (1.0 - v.distance) AS similarity
-    FROM vec_semantics v
-    JOIN semantics s ON s.id = v.id
-    WHERE v.embedding MATCH ?
-      AND k = ?
-      ${stateClause(includeDormant)}
-  `).all(queryBuffer, safeK);
-
-  const results = [];
-  const matchedIds = [];
-  for (const row of rows) {
-    if (!matchesDateFilters(row.created_at, filters)) continue;
-    const confidence = computeSemanticConfidence(row, now, confidenceConfig);
-    if (confidence < minConfidence) continue;
-    const score = row.similarity * confidence;
-    matchedIds.push(row.id);
-    results.push(buildSemanticEntry(row, confidence, score, includeProvenance));
-  }
-  return { results, matchedIds };
-}
-
-function knnProcedural(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, includeDormant, confidenceConfig, filters = {}) {
-  const safeK = safeKForTable(db, 'vec_procedures', candidateK);
-  if (safeK === 0) return { results: [], matchedIds: [] };
-  const rows = db.prepare(`
-    SELECT p.*, (1.0 - v.distance) AS similarity
-    FROM vec_procedures v
-    JOIN procedures p ON p.id = v.id
-    WHERE v.embedding MATCH ?
-      AND k = ?
-      ${stateClause(includeDormant)}
-  `).all(queryBuffer, safeK);
-
-  const results = [];
-  const matchedIds = [];
-  for (const row of rows) {
-    if (!matchesDateFilters(row.created_at, filters)) continue;
-    const confidence = computeProceduralConfidence(row, now, confidenceConfig);
-    if (confidence < minConfidence) continue;
-    const score = row.similarity * confidence;
-    matchedIds.push(row.id);
-    results.push(buildProceduralEntry(row, confidence, score, includeProvenance));
-  }
-  return { results, matchedIds };
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {import('./embedding.js').EmbeddingProvider} embeddingProvider
- * @param {string} query
- * @param {{ minConfidence?: number, types?: string[], limit?: number, includeProvenance?: boolean, includeDormant?: boolean, tags?: string[], sources?: string[], after?: string, before?: string }} [options]
- * @returns {AsyncGenerator<{ id: string, content: string, type: string, confidence: number, score: number, source: string, createdAt: string }>}
- */
-export async function* recallStream(db, embeddingProvider, query, options = {}) {
-  const {
-    minConfidence = 0,
-    types,
-    limit = 10,
-    includeProvenance = false,
-    includeDormant = false,
-    confidenceConfig,
-    tags,
-    sources,
-    after,
-    before,
-    includePrivate = false,
-  } = options;
-
-  const queryVector = await embeddingProvider.embed(query);
-  const queryBuffer = embeddingProvider.vectorToBuffer(queryVector);
-  const searchTypes = types || ['episodic', 'semantic', 'procedural'];
-  const now = new Date();
-  const hasFilters = tags?.length || sources?.length || after || before;
-  const candidateK = hasFilters ? limit * 5 : limit * 3;
-  const filters = { tags, sources, after, before };
-
-  const allResults = [];
-
-  if (searchTypes.includes('episodic')) {
-    try {
-      const episodic = knnEpisodic(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, confidenceConfig, filters, includePrivate);
-      allResults.push(...episodic);
-    } catch {
-      // A broken episodic index should not block semantic/procedural recall.
-    }
-  }
-
-  if (searchTypes.includes('semantic')) {
-    try {
-      const { results: semResults, matchedIds: semIds } =
-        knnSemantic(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, includeDormant, confidenceConfig, filters);
-      allResults.push(...semResults);
-
-      if (semIds.length > 0) {
-        const nowISO = now.toISOString();
-        const placeholders = semIds.map(() => '?').join(',');
-        db.prepare(
-          `UPDATE semantics SET retrieval_count = retrieval_count + 1, last_reinforced_at = ? WHERE id IN (${placeholders})`
-        ).run(nowISO, ...semIds);
-      }
-    } catch {
-      // A broken semantic index should not block other memory types.
-    }
-  }
-
-  if (searchTypes.includes('procedural')) {
-    try {
-      const { results: procResults, matchedIds: procIds } =
-        knnProcedural(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, includeDormant, confidenceConfig, filters);
-      allResults.push(...procResults);
-
-      if (procIds.length > 0) {
-        const nowISO = now.toISOString();
-        const placeholders = procIds.map(() => '?').join(',');
-        db.prepare(
-          `UPDATE procedures SET retrieval_count = retrieval_count + 1, last_reinforced_at = ? WHERE id IN (${placeholders})`
-        ).run(nowISO, ...procIds);
-      }
-    } catch {
-      // A broken procedural index should not block other memory types.
-    }
-  }
-
-  allResults.sort((a, b) => b.score - a.score);
-  const top = allResults.slice(0, limit);
-  for (const entry of top) {
-    yield entry;
-  }
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {import('./embedding.js').EmbeddingProvider} embeddingProvider
- * @param {string} query
- * @param {{ minConfidence?: number, types?: string[], limit?: number, includeProvenance?: boolean, includeDormant?: boolean, tags?: string[], sources?: string[], after?: string, before?: string }} [options]
- * @returns {Promise<Array<{ id: string, content: string, type: string, confidence: number, score: number, source: string, createdAt: string }>>}
- */
-export async function recall(db, embeddingProvider, query, options = {}) {
-  const results = [];
-  for await (const entry of recallStream(db, embeddingProvider, query, options)) {
-    results.push(entry);
-  }
-  return results;
-}

package/src/rollback.js

@@ -1,42 +0,0 @@
-import { safeJsonParse } from './utils.js';
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @returns {Array<{ id: string, checkpoint_cursor: string|null, input_episode_ids: string, output_memory_ids: string, started_at: string, completed_at: string|null, status: string }>}
- */
-export function getConsolidationHistory(db) {
-  return db.prepare(`
-    SELECT id, checkpoint_cursor, input_episode_ids, output_memory_ids,
-           started_at, completed_at, status
-    FROM consolidation_runs ORDER BY started_at DESC
-  `).all();
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {string} runId
- * @returns {{ rolledBackMemories: number, restoredEpisodes: number }}
- */
-export function rollbackConsolidation(db, runId) {
-  const run = db.prepare('SELECT * FROM consolidation_runs WHERE id = ?').get(runId);
-  if (!run) throw new Error(`Consolidation run not found: ${runId}`);
-  if (run.status === 'rolled_back') throw new Error(`Run already rolled back: ${runId}`);
-
-  const outputIds = safeJsonParse(run.output_memory_ids, []);
-  const inputIds = safeJsonParse(run.input_episode_ids, []);
-
-  const doRollback = db.transaction(() => {
-    const markSemantics = db.prepare('UPDATE semantics SET state = ? WHERE id = ?');
-    const markProcedures = db.prepare('UPDATE procedures SET state = ? WHERE id = ?');
-    for (const id of outputIds) {
-      markSemantics.run('rolled_back', id);
-      markProcedures.run('rolled_back', id);
-    }
-    const unmark = db.prepare('UPDATE episodes SET consolidated = 0 WHERE id = ?');
-    for (const id of inputIds) { unmark.run(id); }
-    db.prepare('UPDATE consolidation_runs SET status = ? WHERE id = ?').run('rolled_back', runId);
-  });
-
-  doRollback();
-  return { rolledBackMemories: outputIds.length, restoredEpisodes: inputIds.length };
-}