audrey 0.17.0 → 0.20.0

package/src/recall.js

@@ -1,573 +0,0 @@
-import { computeConfidence, DEFAULT_HALF_LIVES, salienceModifier, sourceReliability } 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';
-import { hasFTSTables, searchFTSEpisodes, searchFTSSemantics, searchFTSProcedures, sanitizeFTSQuery } from './fts.js';
-
-const STOPWORDS = new Set([
-  'a', 'an', 'and', 'are', 'at', 'be', 'by', 'did', 'do', 'does', 'for', 'from', 'had', 'has', 'have',
-  'how', 'i', 'in', 'is', 'it', 'me', 'my', 'now', 'of', 'on', 'or', 'our', 's', 'sam', 'she', 'that',
-  'the', 'their', 'them', 'there', 'they', 'this', 'to', 'was', 'we', 'were', 'what', 'when', 'where',
-  'which', 'who', 'why', 'with', 'would', 'you', 'your',
-]);
-
-const IDENTIFIER_TERMS = new Set(['account', 'api', 'credential', 'id', 'identifier', 'key', 'number', 'password', 'secret', 'ssn', 'token']);
-
-function tokenize(text) {
-  return String(text || '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim()
-    .split(/\s+/)
-    .filter(Boolean);
-}
-
-function significantTokens(text) {
-  return tokenize(text).filter(token => !STOPWORDS.has(token));
-}
-
-function lexicalCoverage(query, content) {
-  const queryTokens = significantTokens(query);
-  if (queryTokens.length === 0) return 1;
-  const contentTokens = new Set(significantTokens(content));
-  let matched = 0;
-  for (const token of queryTokens) {
-    if (contentTokens.has(token)) matched++;
-  }
-  return matched / queryTokens.length;
-}
-
-function hasIdentifierIntent(query) {
-  const normalized = String(query || '').toLowerCase();
-  const asksForValue = /\b(find|give|lookup|show|tell|what|which)\b/.test(normalized);
-  const mentionsIdentifier = /\b(account number|api key|credential|id|identifier|key|number|passport number|password|secret|ssn|token)\b/.test(normalized);
-  return asksForValue && mentionsIdentifier;
-}
-
-function hasIdentifierEvidence(content) {
-  const tokens = significantTokens(content);
-  if (tokens.some(token => IDENTIFIER_TERMS.has(token))) {
-    return true;
-  }
-  return /(?:\b\d{4,}\b|sk-[a-z0-9_-]+)/i.test(content);
-}
-
-function adjustedScore(query, entry) {
-  const coverage = lexicalCoverage(query, entry.content);
-  let score = entry.score;
-
-  if (hasIdentifierIntent(query) && !hasIdentifierEvidence(entry.content)) {
-    score *= 0.02;
-  }
-
-  return { score, coverage };
-}
-
-function overlapRatio(contentA, contentB) {
-  const tokensA = significantTokens(contentA);
-  const tokensB = significantTokens(contentB);
-  if (tokensA.length === 0 || tokensB.length === 0) return 0;
-  const setB = new Set(tokensB);
-  let matched = 0;
-  for (const token of tokensA) {
-    if (setB.has(token)) matched++;
-  }
-  return matched / Math.min(tokensA.length, tokensB.length);
-}
-
-function reliabilityForRecallSource(source) {
-  if (source === 'consolidation') {
-    return sourceReliability('tool-result');
-  }
-  return sourceReliability(source);
-}
-
-function shouldSuppressDuplicate(existing, candidate) {
-  const overlap = overlapRatio(existing.content, candidate.content);
-  if (overlap < 0.5) return false;
-  if (existing.type !== candidate.type) return false;
-  const existingReliability = reliabilityForRecallSource(existing.source);
-  const candidateReliability = reliabilityForRecallSource(candidate.source);
-  if (existingReliability < candidateReliability) return false;
-  if (existingReliability - candidateReliability < 0.2) return false;
-  return existing.score >= candidate.score * 0.95;
-}
-
-function applyResultGuards(query, results, limit) {
-  const identifierIntent = hasIdentifierIntent(query);
-  const rescored = results
-    .map(entry => {
-      const { score, coverage } = adjustedScore(query, entry);
-      return { ...entry, score, lexicalCoverage: coverage };
-    })
-    .filter(entry => !identifierIntent || entry.score > 0.05)
-    .sort((a, b) => b.score - a.score);
-
-  const accepted = [];
-  for (const candidate of rescored) {
-    if (accepted.some(existing => shouldSuppressDuplicate(existing, candidate))) {
-      continue;
-    }
-    accepted.push(candidate);
-    if (accepted.length >= limit) break;
-  }
-
-  return accepted;
-}
-
-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,
-    agent: ep.agent || 'default',
-  };
-  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,
-    agent: sem.agent || 'default',
-  };
-  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,
-    agent: proc.agent || 'default',
-  };
-  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, agentFilter = null) {
-  const safeK = safeKForTable(db, 'vec_episodes', candidateK);
-  if (safeK === 0) return [];
-  const privateClause = includePrivate ? '' : 'AND e."private" = 0';
-  const agentClause = agentFilter ? 'AND e.agent = ?' : '';
-  const params = agentFilter ? [queryBuffer, safeK, agentFilter] : [queryBuffer, safeK];
-  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}
-      ${agentClause}
-  `).all(...params);
-
-  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 = {}, agentFilter = null) {
-  const safeK = safeKForTable(db, 'vec_semantics', candidateK);
-  if (safeK === 0) return { results: [], matchedIds: [] };
-  const agentClause = agentFilter ? 'AND s.agent = ?' : '';
-  const params = agentFilter ? [queryBuffer, safeK, agentFilter] : [queryBuffer, safeK];
-  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)}
-      ${agentClause}
-  `).all(...params);
-
-  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 = {}, agentFilter = null) {
-  const safeK = safeKForTable(db, 'vec_procedures', candidateK);
-  if (safeK === 0) return { results: [], matchedIds: [] };
-  const agentClause = agentFilter ? 'AND p.agent = ?' : '';
-  const params = agentFilter ? [queryBuffer, safeK, agentFilter] : [queryBuffer, safeK];
-  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)}
-      ${agentClause}
-  `).all(...params);
-
-  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 };
-}
-
-async function runRecallQuery(db, embeddingProvider, query, options = {}) {
-  const {
-    minConfidence = 0,
-    types,
-    limit = 10,
-    includeProvenance = false,
-    includeDormant = false,
-    confidenceConfig,
-    tags,
-    sources,
-    after,
-    before,
-    includePrivate = false,
-    scope = 'shared',
-    agent,
-    retrieval = 'hybrid',
-  } = options;
-
-  const searchTypes = types || ['episodic', 'semantic', 'procedural'];
-  const now = new Date();
-  const agentFilter = scope === 'agent' && agent ? agent : null;
-
-  // Keyword-only mode: FTS5 search without vector embeddings
-  if (retrieval === 'keyword') {
-    const ftsAvailable = hasFTSTables(db);
-    if (!ftsAvailable) {
-      return { top: [], errors: [] };
-    }
-    const sanitized = sanitizeFTSQuery(query);
-    if (!sanitized) return { top: [], errors: [] };
-
-    const keywordResults = [];
-    try {
-      if (searchTypes.includes('episodic')) {
-        for (const row of searchFTSEpisodes(db, sanitized, limit * 3, agentFilter)) {
-          keywordResults.push({ id: row.id, content: row.content, type: 'episodic', score: -row.rank, agent: row.agent || 'default' });
-        }
-      }
-      if (searchTypes.includes('semantic')) {
-        for (const row of searchFTSSemantics(db, sanitized, limit * 3, agentFilter)) {
-          keywordResults.push({ id: row.id, content: row.content, type: 'semantic', score: -row.rank, agent: row.agent || 'default' });
-        }
-      }
-      if (searchTypes.includes('procedural')) {
-        for (const row of searchFTSProcedures(db, sanitized, limit * 3, agentFilter)) {
-          keywordResults.push({ id: row.id, content: row.content, type: 'procedural', score: -row.rank, agent: row.agent || 'default' });
-        }
-      }
-    } catch {
-      // FTS query syntax error — fall through with whatever we have
-    }
-    keywordResults.sort((a, b) => b.score - a.score);
-    const top = keywordResults.slice(0, limit).map(entry => ({
-      ...entry,
-      confidence: 1,
-      source: 'keyword',
-      createdAt: now.toISOString(),
-    }));
-    return { top, errors: [] };
-  }
-
-  const queryVector = await embeddingProvider.embed(query);
-  const queryBuffer = embeddingProvider.vectorToBuffer(queryVector);
-  const hasFilters = tags?.length || sources?.length || after || before;
-  const candidateK = hasFilters ? limit * 5 : limit * 3;
-  const filters = { tags, sources, after, before };
-
-  const allResults = [];
-  const errors = [];
-
-  if (searchTypes.includes('episodic')) {
-    try {
-      const episodic = knnEpisodic(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, confidenceConfig, filters, includePrivate, agentFilter);
-      allResults.push(...episodic);
-    } catch (err) {
-      errors.push({ type: 'episodic', message: err.message });
-    }
-  }
-
-  if (searchTypes.includes('semantic')) {
-    try {
-      const { results: semResults, matchedIds: semIds } =
-        knnSemantic(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, includeDormant, confidenceConfig, filters, agentFilter);
-      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 (err) {
-      errors.push({ type: 'semantic', message: err.message });
-    }
-  }
-
-  if (searchTypes.includes('procedural')) {
-    try {
-      const { results: procResults, matchedIds: procIds } =
-        knnProcedural(db, queryBuffer, candidateK, now, minConfidence, includeProvenance, includeDormant, confidenceConfig, filters, agentFilter);
-      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 (err) {
-      errors.push({ type: 'procedural', message: err.message });
-    }
-  }
-
-  // Hybrid mode: merge vector results with FTS5 keyword results via RRF
-  if (retrieval === 'hybrid' && hasFTSTables(db)) {
-    const sanitized = sanitizeFTSQuery(query);
-    if (sanitized) {
-      const keywordHits = new Map();
-      try {
-        if (searchTypes.includes('episodic')) {
-          for (const row of searchFTSEpisodes(db, sanitized, limit * 3, agentFilter)) {
-            keywordHits.set(row.id, (keywordHits.get(row.id) || 0) + 1);
-          }
-        }
-        if (searchTypes.includes('semantic')) {
-          for (const row of searchFTSSemantics(db, sanitized, limit * 3, agentFilter)) {
-            keywordHits.set(row.id, (keywordHits.get(row.id) || 0) + 1);
-          }
-        }
-        if (searchTypes.includes('procedural')) {
-          for (const row of searchFTSProcedures(db, sanitized, limit * 3, agentFilter)) {
-            keywordHits.set(row.id, (keywordHits.get(row.id) || 0) + 1);
-          }
-        }
-      } catch {
-        // FTS query error — continue with vector-only results
-      }
-
-      // RRF boost: memories found by both vector AND keyword get a score bonus
-      const RRF_K = 60;
-      if (keywordHits.size > 0) {
-        // Rank keyword results by their BM25 order
-        const keywordRanks = new Map();
-        let rank = 1;
-        for (const id of keywordHits.keys()) {
-          keywordRanks.set(id, rank++);
-        }
-
-        for (const result of allResults) {
-          if (keywordRanks.has(result.id)) {
-            // Boost score for results found by both vector AND keyword search
-            const kRank = keywordRanks.get(result.id);
-            const rrfBoost = 1 / (RRF_K + kRank);
-            result.score = result.score + rrfBoost;
-          }
-        }
-      }
-    }
-  }
-
-  const top = applyResultGuards(query, allResults, limit);
-  return { top, errors };
-}
-
-/**
- * @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 { top, errors } = await runRecallQuery(db, embeddingProvider, query, options);
-  for (const entry of top) {
-    if (errors.length > 0) entry._recallErrors = errors;
-    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 { top, errors } = await runRecallQuery(db, embeddingProvider, query, options);
-  const results = [...top];
-  results.partialFailure = errors.length > 0;
-  results.errors = errors;
-  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 };
-}

package/src/ulid.js

@@ -1,18 +0,0 @@
-import { monotonicFactory } from 'ulid';
-import { createHash } from 'node:crypto';
-
-const monotonic = monotonicFactory();
-
-/** @returns {string} */
-export function generateId() {
-  return monotonic();
-}
-
-/**
- * @param {...*} parts
- * @returns {string}
- */
-export function generateDeterministicId(...parts) {
-  const input = JSON.stringify(parts);
-  return createHash('sha256').update(input).digest('hex').slice(0, 26);
-}

package/src/utils.js

@@ -1,63 +0,0 @@
-/**
- * @param {Buffer} bufA
- * @param {Buffer} bufB
- * @param {import('./embedding.js').EmbeddingProvider} provider
- * @returns {number}
- */
-export function cosineSimilarity(bufA, bufB, provider) {
-  const a = provider.bufferToVector(bufA);
-  const b = provider.bufferToVector(bufB);
-  let dot = 0, magA = 0, magB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
-  }
-  const mag = Math.sqrt(magA) * Math.sqrt(magB);
-  return mag === 0 ? 0 : dot / mag;
-}
-
-/**
- * @param {string} dateStr
- * @param {Date} now
- * @returns {number}
- */
-export function daysBetween(dateStr, now) {
-  return Math.max(0, (now.getTime() - new Date(dateStr).getTime()) / (1000 * 60 * 60 * 24));
-}
-
-/**
- * @param {string | null | undefined} str
- * @param {*} [fallback=null]
- * @returns {*}
- */
-export function safeJsonParse(str, fallback = null) {
-  if (!str) return fallback;
-  try { return JSON.parse(str); }
-  catch { return fallback; }
-}
-
-/**
- * @param {string | undefined | null} apiKey
- * @param {string} operation
- * @param {string} envVar
- * @returns {void}
- */
-export function requireApiKey(apiKey, operation, envVar) {
-  if (typeof apiKey !== 'string' || apiKey.trim() === '') {
-    throw new Error(`${operation} requires ${envVar}`);
-  }
-}
-
-/**
- * @param {{ status: number, text: () => Promise<string> }} response
- * @returns {Promise<string>}
- */
-export async function describeHttpError(response) {
-  if (typeof response.text !== 'function') {
-    return `${response.status}`;
-  }
-  const body = await response.text().catch(() => '');
-  const normalized = body.replace(/\s+/g, ' ').trim().slice(0, 300);
-  return normalized ? `${response.status} ${normalized}` : `${response.status}`;
-}