@atomicmemory/core 1.0.0

package/dist/services/composite-staleness.js

@@ -0,0 +1,50 @@
+/**
+ * Composite staleness filtering for retrieval.
+ *
+ * Phase 1 policy from the composite-vs-atomic retrieval contract:
+ * exclude composites from default retrieval if any covered member memory is no
+ * longer active. This catches superseded members (expired), invalidated or
+ * deleted members, and dangling member IDs left behind after deletes.
+ */
+export async function excludeStaleComposites(repo, userId, memories) {
+    const memberIds = collectCompositeMemberIds(memories);
+    if (memberIds.length === 0) {
+        return { filtered: memories, removedCompositeIds: [] };
+    }
+    const activeIds = await loadActiveMemberIds(repo, userId, memberIds);
+    const removedCompositeIds = [];
+    const filtered = memories.filter((memory) => {
+        if (!isComposite(memory))
+            return true;
+        if (!hasStaleMember(memory, activeIds))
+            return true;
+        removedCompositeIds.push(memory.id);
+        return false;
+    });
+    return { filtered, removedCompositeIds };
+}
+function collectCompositeMemberIds(memories) {
+    return [...new Set(memories
+            .filter(isComposite)
+            .flatMap((memory) => parseMemberIds(memory))
+            .filter((id) => typeof id === 'string'))];
+}
+async function loadActiveMemberIds(repo, userId, memberIds) {
+    const rows = await Promise.all(memberIds.map((id) => repo.getMemory(id, userId)));
+    return new Set(rows.filter((row) => row !== null).map((row) => row.id));
+}
+function hasStaleMember(memory, activeIds) {
+    const memberIds = parseMemberIds(memory);
+    if (memberIds.length === 0)
+        return false;
+    return memberIds.some((id) => !activeIds.has(id));
+}
+function isComposite(memory) {
+    return memory.memory_type === 'composite';
+}
+function parseMemberIds(memory) {
+    const candidate = memory.metadata?.memberMemoryIds;
+    if (!Array.isArray(candidate))
+        return [];
+    return candidate.filter((id) => typeof id === 'string');
+}

package/dist/services/conciseness-preference.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Conciseness preference for retrieval results.
+ *
+ * Penalizes over-broad composite memories when they compete with concise
+ * atomic facts for narrow queries. Without this, a composite that happens
+ * to contain the answer (among many irrelevant facts) can outrank a focused
+ * atomic fact because its centroid embedding is generically close to many
+ * query types.
+ *
+ * The penalty is proportional to how much longer a result is compared to the
+ * median result length. Results at or below median get no penalty.
+ */
+import type { SearchResult } from '../db/memory-repository.js';
+export declare function applyConcisenessPenalty(results: SearchResult[]): SearchResult[];

package/dist/services/conciseness-preference.js

@@ -0,0 +1,42 @@
+/**
+ * Conciseness preference for retrieval results.
+ *
+ * Penalizes over-broad composite memories when they compete with concise
+ * atomic facts for narrow queries. Without this, a composite that happens
+ * to contain the answer (among many irrelevant facts) can outrank a focused
+ * atomic fact because its centroid embedding is generically close to many
+ * query types.
+ *
+ * The penalty is proportional to how much longer a result is compared to the
+ * median result length. Results at or below median get no penalty.
+ */
+/**
+ * Maximum penalty applied to the longest result relative to median.
+ * A 0.15 penalty means a 5-point result becomes 4.25 at most.
+ * Tuned to demote broad composites without destroying their ranking
+ * when they genuinely contain the best answer.
+ */
+const MAX_PENALTY_FRACTION = 0.15;
+/**
+ * Results shorter than this get no penalty regardless of median.
+ * Prevents penalizing normal-length memories.
+ */
+const PENALTY_FREE_THRESHOLD_CHARS = 150;
+export function applyConcisenessPenalty(results) {
+    if (results.length < 2)
+        return results;
+    const lengths = results.map((r) => r.content.length).sort((a, b) => a - b);
+    const median = lengths[Math.floor(lengths.length / 2)];
+    if (median === 0)
+        return results;
+    return results.map((result) => {
+        const len = result.content.length;
+        if (len <= PENALTY_FREE_THRESHOLD_CHARS || len <= median) {
+            return result;
+        }
+        const excessRatio = (len - median) / median;
+        const penalty = Math.min(excessRatio * 0.1, MAX_PENALTY_FRACTION);
+        const penalizedScore = result.score * (1 - penalty);
+        return { ...result, score: penalizedScore };
+    }).sort((a, b) => b.score - a.score);
+}

package/dist/services/conflict-policy.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Conflict policy helpers for AUDN clarification and candidate expansion.
+ */
+import type { AUDNDecision } from './extraction.js';
+export interface CandidateMemory {
+    id: string;
+    content: string;
+    similarity: number;
+    importance: number;
+    agent_id?: string;
+}
+export declare function applyClarificationOverrides(decision: AUDNDecision, factText: string, candidates: CandidateMemory[], factKeywords?: string[], factType?: string | null): AUDNDecision;
+export declare function extractConflictKeywords(text: string): string[];
+export declare function mergeCandidates(primary: CandidateMemory[], secondary: CandidateMemory[]): CandidateMemory[];
+/** Trust context for multi-agent conflict resolution. */
+export interface TrustContext {
+    callerAgentId: string;
+    callerTrustLevel: number;
+    candidateTrustLevels: Map<string, number>;
+}

package/dist/services/conflict-policy.js

@@ -0,0 +1,335 @@
+/**
+ * Conflict policy helpers for AUDN clarification and candidate expansion.
+ */
+import { config } from '../config.js';
+const UNCERTAIN_MARKERS = ['maybe', 'might', 'not sure', 'i think', 'perhaps', 'tomorrow'];
+const UNCERTAIN_PATTERNS = [
+    /\b(?:need|needs|needed|will|should)\s+to\s+check\b/i,
+    /\bcheck\s+(?:later|tomorrow|again|back)\b/i,
+];
+const GENERIC_CONFLICT_MARKERS = [
+    'user',
+    'users',
+    'january',
+    'february',
+    'march',
+    'april',
+    'june',
+    'july',
+    'august',
+    'september',
+    'october',
+    'november',
+    'december',
+];
+const SAFETY_RISK_MARKERS = ['allergic', 'life-threatening', 'anaphyl', 'avoid', 'cannot eat', "can't eat", 'severe'];
+const SAFETY_CLEARANCE_MARKERS = ['ate', 'eat', 'eating', 'cookie', 'meal', 'dish', 'okay', 'fine', 'safe'];
+const SAFE_REUSE_MIN_SIMILARITY = config.audnSafeReuseMinSimilarity;
+const SAFE_REUSE_MIN_SHARED_KEYWORDS = 2;
+const TRANSITION_MARKERS = ['switched away from', 'switched from', 'migrated from', 'moved from', 'previously used'];
+const POLICIES = [
+    resolveExplicitReplacementOnClarify,
+    preserveLowConfidenceClarify,
+    detectUncertainConflict,
+    resolveCriticalConflict,
+    preserveRecommendationAttribution,
+    separateStateTransition,
+    supersedeInsteadOfUpdate,
+];
+export function applyClarificationOverrides(decision, factText, candidates, factKeywords = [], factType = null) {
+    const ctx = { decision, factText, candidates, factKeywords, factType };
+    for (const policy of POLICIES) {
+        const result = policy(ctx);
+        if (result !== null)
+            return result;
+    }
+    return preserveAtomicFacts(decision, factText, candidates, factKeywords, factType);
+}
+/**
+ * AUDN returned CLARIFY but the new fact carries an explicit replacement
+ * signal ("replacing X", "no longer Y", "instead of Z", "correction: ..."):
+ *   - With a target that's present in the candidate set: upgrade to
+ *     SUPERSEDE so the stale memory is expired.
+ *   - Without a target, or with a stale/invalid target ID that doesn't
+ *     resolve to any candidate: keep the CLARIFY hold. memory-audn would
+ *     reject a SUPERSEDE against a missing target and fall back to
+ *     canonical storage, which leaves the old memory active — same bug
+ *     as routing through promoteToAdd.
+ */
+function resolveExplicitReplacementOnClarify(ctx) {
+    if (ctx.decision.action !== 'CLARIFY')
+        return null;
+    if (!containsExplicitReplacementSignal(ctx.factText))
+        return null;
+    const targetId = ctx.decision.targetMemoryId;
+    const targetInCandidates = targetId !== null && targetId !== undefined
+        && ctx.candidates.some((candidate) => candidate.id === targetId);
+    return targetInCandidates ? supersede(ctx.decision) : ctx.decision;
+}
+function preserveLowConfidenceClarify(ctx) {
+    if (!shouldClarifyConflict(ctx.decision))
+        return null;
+    if (containsExplicitReplacementSignal(ctx.factText))
+        return null;
+    return ctx.decision;
+}
+function detectUncertainConflict(ctx) {
+    if (!isUncertainConflict(ctx.factText, ctx.candidates))
+        return null;
+    return clarify(ctx.decision, 'Uncertain contradiction detected in new fact');
+}
+/**
+ * If the new fact contradicts a high-importance memory, require clarification
+ * unless an explicit replacement signal is present (and the action is
+ * already destructive). Otherwise promote to ADD so a non-contradictory
+ * specialization doesn't overwrite the original.
+ */
+function resolveCriticalConflict(ctx) {
+    if (!isCriticalConflict(ctx.decision, ctx.factText, ctx.candidates))
+        return null;
+    const target = resolveDecisionTarget(ctx.decision, ctx.candidates);
+    if (target && containsContradictionSignal(ctx.factText, target.content)) {
+        if (canApplyExplicitReplacement(ctx.decision, ctx.factText)) {
+            return ctx.decision.action === 'UPDATE' ? supersede(ctx.decision) : ctx.decision;
+        }
+        return clarify(ctx.decision, 'Critical existing memory requires clarification before replacement');
+    }
+    return promoteToAdd(ctx.decision);
+}
+function preserveRecommendationAttribution(ctx) {
+    if (!shouldPreserveRecommendationAttribution(ctx.decision, ctx.factText, ctx.candidates))
+        return null;
+    return promoteToAdd(ctx.decision);
+}
+function separateStateTransition(ctx) {
+    if (!shouldSeparateStateTransition(ctx.decision, ctx.factText))
+        return null;
+    return promoteToAdd(ctx.decision);
+}
+function supersedeInsteadOfUpdate(ctx) {
+    if (!shouldSupersedeInsteadOfUpdate(ctx.decision, ctx.factText, ctx.candidates))
+        return null;
+    return supersede(ctx.decision);
+}
+export function extractConflictKeywords(text) {
+    const words = text.toLowerCase().match(/[a-z]{4,}/g) ?? [];
+    return [...new Set(words.filter((word) => !UNCERTAIN_MARKERS.includes(word) && !GENERIC_CONFLICT_MARKERS.includes(word)))];
+}
+export function mergeCandidates(primary, secondary) {
+    const merged = new Map();
+    for (const candidate of [...primary, ...secondary]) {
+        const existing = merged.get(candidate.id);
+        if (!existing || candidate.similarity > existing.similarity) {
+            merged.set(candidate.id, candidate);
+        }
+    }
+    return [...merged.values()].sort((left, right) => right.similarity - left.similarity);
+}
+function shouldClarifyConflict(decision) {
+    if (decision.action === 'CLARIFY')
+        return true;
+    if (decision.action !== 'SUPERSEDE' && decision.action !== 'DELETE')
+        return false;
+    if (decision.contradictionConfidence === null)
+        return false;
+    // DELETE is more destructive than SUPERSEDE — require higher confidence
+    const threshold = decision.action === 'DELETE'
+        ? Math.min(config.clarificationConflictThreshold + 0.1, 1.0)
+        : config.clarificationConflictThreshold;
+    return decision.contradictionConfidence < threshold;
+}
+function isUncertainConflict(factText, candidates) {
+    if (candidates.length === 0)
+        return false;
+    const lower = factText.toLowerCase();
+    return UNCERTAIN_MARKERS.some((marker) => lower.includes(marker))
+        || UNCERTAIN_PATTERNS.some((pattern) => pattern.test(factText));
+}
+function isCriticalConflict(decision, factText, candidates) {
+    // Only apply critical-conflict protection to destructive actions (SUPERSEDE/DELETE).
+    // ADD is not a conflict — it stores new info alongside existing memories.
+    if (decision.action === 'ADD' || decision.action === 'NOOP')
+        return false;
+    const criticalCandidate = candidates.find((candidate) => candidate.importance >= 0.9 && hasSharedKeyword(factText, candidate.content));
+    if (!criticalCandidate)
+        return false;
+    if (decision.action === 'UPDATE')
+        return hasSafetyConflictSignal(factText, criticalCandidate.content);
+    return true;
+}
+function hasSafetyConflictSignal(factText, candidateText) {
+    return containsAny(candidateText, SAFETY_RISK_MARKERS) && containsAny(factText, SAFETY_CLEARANCE_MARKERS);
+}
+function containsAny(text, markers) {
+    const lower = text.toLowerCase();
+    return markers.some((marker) => lower.includes(marker));
+}
+function hasSharedKeyword(left, right) {
+    const leftWords = new Set(extractConflictKeywords(left));
+    return extractConflictKeywords(right).some((word) => leftWords.has(word));
+}
+function supersede(decision) {
+    return {
+        ...decision,
+        action: 'SUPERSEDE',
+        updatedContent: null,
+    };
+}
+function shouldSupersedeInsteadOfUpdate(decision, factText, candidates) {
+    if (decision.action !== 'UPDATE')
+        return false;
+    if (!decision.targetMemoryId || !decision.updatedContent)
+        return false;
+    const target = candidates.find((c) => c.id === decision.targetMemoryId);
+    if (!target)
+        return false;
+    return containsContradictionSignal(factText, target.content);
+}
+const SWITCH_MARKERS = ['switched', 'changed', 'moved to', 'replaced', 'replacing', 'no longer', 'instead of', 'now using', 'now use', 'corrected from', 'correction:', 'correction '];
+const EXPLICIT_REPLACEMENT_PATTERNS = [
+    /\breplac(?:e|ed|ing)\b/i,
+    /\bno longer\b/i,
+    /\binstead of\b/i,
+    /\bcorrect(?:ed|ion)\b/i,
+];
+function containsExplicitReplacementSignal(factText) {
+    return EXPLICIT_REPLACEMENT_PATTERNS.some((pattern) => pattern.test(factText));
+}
+function canApplyExplicitReplacement(decision, factText) {
+    if (decision.action !== 'SUPERSEDE' && decision.action !== 'UPDATE')
+        return false;
+    return containsExplicitReplacementSignal(factText);
+}
+function containsContradictionSignal(factText, candidateText) {
+    if (containsExplicitReplacementSignal(factText))
+        return true;
+    const candidateKeywords = extractConflictKeywords(candidateText);
+    const negationPattern = candidateKeywords.some((kw) => {
+        const negated = new RegExp(`(not|no longer|stopped|quit|don'?t)\\s+\\w*\\s*${kw}`, 'i');
+        return negated.test(factText);
+    });
+    return negationPattern;
+}
+function shouldPreserveRecommendationAttribution(decision, factText, candidates) {
+    if (decision.action !== 'SUPERSEDE' && decision.action !== 'DELETE')
+        return false;
+    if (!/\b(recommended|suggested)\b/i.test(factText))
+        return false;
+    const target = resolveDecisionTarget(decision, candidates);
+    if (!target)
+        return false;
+    return !containsContradictionSignal(factText, target.content);
+}
+function clarify(decision, note) {
+    return {
+        ...decision,
+        action: 'CLARIFY',
+        clarificationNote: decision.clarificationNote ?? note,
+        contradictionConfidence: decision.contradictionConfidence ?? 0.35,
+    };
+}
+function preserveAtomicFacts(decision, factText, candidates, factKeywords, factType) {
+    if (!shouldPreserveAtomicBoundary(factText, factType))
+        return decision;
+    if (decision.action !== 'UPDATE' && decision.action !== 'NOOP')
+        return decision;
+    if (isStateTransitionFact(factText))
+        return promoteToAdd(decision);
+    const target = resolveDecisionTarget(decision, candidates);
+    if (!target)
+        return promoteToAdd(decision);
+    if (decision.action === 'UPDATE' && isContentGrowthExcessive(decision.updatedContent, target.content)) {
+        return promoteToAdd(decision);
+    }
+    if (isSafeReuse(target, factText, factKeywords))
+        return decision;
+    return promoteToAdd(decision);
+}
+const MAX_UPDATE_GROWTH_RATIO = 1.5;
+/** Reject UPDATE if merged content would grow more than 50% vs original. */
+function isContentGrowthExcessive(updatedContent, originalContent) {
+    if (!updatedContent)
+        return false;
+    return updatedContent.length > originalContent.length * MAX_UPDATE_GROWTH_RATIO;
+}
+function resolveDecisionTarget(decision, candidates) {
+    if (decision.targetMemoryId) {
+        return candidates.find((candidate) => candidate.id === decision.targetMemoryId) ?? null;
+    }
+    return candidates[0] ?? null;
+}
+function isSafeReuse(candidate, factText, factKeywords) {
+    if (candidate.similarity < SAFE_REUSE_MIN_SIMILARITY)
+        return false;
+    const sharedFactKeywords = countSharedFactKeywords(factKeywords, candidate.content);
+    if (sharedFactKeywords >= SAFE_REUSE_MIN_SHARED_KEYWORDS)
+        return true;
+    return sharedFactKeywords === 1
+        && candidate.similarity >= 0.95
+        && countSharedKeywords(factText, candidate.content) >= SAFE_REUSE_MIN_SHARED_KEYWORDS;
+}
+function countSharedKeywords(left, right) {
+    const leftWords = new Set(extractConflictKeywords(left));
+    return extractConflictKeywords(right).filter((word) => leftWords.has(word)).length;
+}
+function countSharedFactKeywords(keywords, content) {
+    const lowerContent = content.toLowerCase();
+    return keywords
+        .map((keyword) => keyword.trim().toLowerCase())
+        .filter((keyword) => keyword.length > 0)
+        .filter((keyword) => lowerContent.includes(keyword))
+        .length;
+}
+function isStateTransitionFact(text) {
+    const lower = text.toLowerCase();
+    return TRANSITION_MARKERS.some((marker) => lower.includes(marker));
+}
+function shouldSeparateStateTransition(decision, factText) {
+    if (!isStateTransitionFact(factText))
+        return false;
+    return decision.action === 'UPDATE' || decision.action === 'NOOP' || decision.action === 'SUPERSEDE';
+}
+function shouldPreserveAtomicBoundary(_factText, _factType) {
+    // Apply atomic boundary protection to ALL fact types.
+    // Previously gated to factType==='project' and recommendation facts only,
+    // which allowed non-project facts to be merged via UPDATE/NOOP without
+    // the similarity+keyword safety check. This caused 21-vs-51 memory count
+    // swings across runs (AUDN non-determinism in merge decisions).
+    return true;
+}
+function promoteToAdd(decision) {
+    return {
+        ...decision,
+        action: 'ADD',
+        targetMemoryId: null,
+        updatedContent: null,
+    };
+}
+/**
+ * Applies trust-based overrides to AUDN decisions when the caller agent has
+ * lower trust than the target memory's agent. Forces CLARIFY instead of
+ * SUPERSEDE/DELETE/UPDATE to prevent low-trust agents from silently overwriting
+ * high-trust memories.
+ */
+function applyTrustOverrides(decision, candidates, trustContext) {
+    if (!trustContext)
+        return decision;
+    if (!isDestructiveAction(decision))
+        return decision;
+    if (!decision.targetMemoryId)
+        return decision;
+    const targetCandidate = candidates.find((c) => c.id === decision.targetMemoryId);
+    if (!targetCandidate?.agent_id)
+        return decision;
+    const targetAgentId = targetCandidate.agent_id;
+    if (targetAgentId === trustContext.callerAgentId)
+        return decision;
+    const targetTrust = trustContext.candidateTrustLevels.get(targetAgentId) ?? 0.5;
+    if (trustContext.callerTrustLevel >= targetTrust)
+        return decision;
+    return clarify(decision, `Low-trust agent (${trustContext.callerTrustLevel.toFixed(2)}) cannot ${decision.action.toLowerCase()} ` +
+        `memory from higher-trust agent (${targetTrust.toFixed(2)})`);
+}
+function isDestructiveAction(decision) {
+    return decision.action === 'SUPERSEDE' || decision.action === 'DELETE' || decision.action === 'UPDATE';
+}

package/dist/services/consensus-extraction.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Consensus extraction — stabilizes LLM fact extraction by running
+ * extractFacts() multiple times and keeping only facts that appear
+ * consistently across runs.
+ *
+ * For each run, facts are compared by semantic similarity. A fact is
+ * "stable" if it appears (with similarity >= threshold) in at least
+ * ceil(N/2) of N runs. Unstable facts are discarded.
+ *
+ * This reduces variance from LLM non-determinism at the cost of
+ * N× extraction API calls.
+ */
+import { type ExtractedFact } from './extraction.js';
+/**
+ * Config subset consumed by consensusExtractFacts. Kept narrow so callers
+ * only need to thread through the fields the function actually reads —
+ * a `Pick<IngestRuntimeConfig, ...>` of the deps.config bundle.
+ */
+export interface ConsensusExtractionConfig {
+    consensusExtractionEnabled: boolean;
+    consensusExtractionRuns: number;
+    chunkedExtractionEnabled: boolean;
+    chunkedExtractionFallbackEnabled: boolean;
+    chunkSizeTurns: number;
+    chunkOverlapTurns: number;
+    extractionCacheEnabled: boolean;
+    observationDateExtractionEnabled: boolean;
+    quotedEntityExtractionEnabled: boolean;
+}
+/**
+ * Run extraction N times and return facts based on mode:
+ * - "consensus" (default): Keep only facts that appear in majority of runs.
+ * - "union": Keep all unique facts found across all runs (improves recall).
+ * Falls back to single extraction when consensus is disabled.
+ *
+ * Config is passed explicitly — consumers thread their `deps.config`
+ * through. This module no longer reads the module-level config singleton.
+ */
+export declare function consensusExtractFacts(conversationText: string, config: ConsensusExtractionConfig): Promise<ExtractedFact[]>;

package/dist/services/consensus-extraction.js

@@ -0,0 +1,147 @@
+/**
+ * Consensus extraction — stabilizes LLM fact extraction by running
+ * extractFacts() multiple times and keeping only facts that appear
+ * consistently across runs.
+ *
+ * For each run, facts are compared by semantic similarity. A fact is
+ * "stable" if it appears (with similarity >= threshold) in at least
+ * ceil(N/2) of N runs. Unstable facts are discarded.
+ *
+ * This reduces variance from LLM non-determinism at the cost of
+ * N× extraction API calls.
+ */
+import { extractFacts } from './extraction.js';
+import { cachedExtractFacts } from './extraction-cache.js';
+import { chunkedExtractFacts } from './chunked-extraction.js';
+import { cosineSimilarity, embedText } from './embedding.js';
+import { classifyNetwork } from './memory-network.js';
+import { mergeQuotedEntityFacts } from './quoted-entity-extraction.js';
+const SIMILARITY_THRESHOLD = 0.90;
+/**
+ * Run extraction N times and return facts based on mode:
+ * - "consensus" (default): Keep only facts that appear in majority of runs.
+ * - "union": Keep all unique facts found across all runs (improves recall).
+ * Falls back to single extraction when consensus is disabled.
+ *
+ * Config is passed explicitly — consumers thread their `deps.config`
+ * through. This module no longer reads the module-level config singleton.
+ */
+export async function consensusExtractFacts(conversationText, config) {
+    if (!config.consensusExtractionEnabled) {
+        const options = buildExtractionOptions(config);
+        const facts = await extractOnce(conversationText, options, config);
+        return applyOptionalQuotedEntityExtraction(facts, conversationText, config);
+    }
+    const allRunFacts = await runMultipleExtractions(conversationText, config);
+    const mode = (process.env.CONSENSUS_MODE || 'consensus').toLowerCase();
+    if (mode === 'union') {
+        const unique = await deduplicateFacts(allRunFacts.flat());
+        return applyNetworkClassification(applyOptionalQuotedEntityExtraction(unique, conversationText, config));
+    }
+    const stableFacts = await filterByMajorityVote(allRunFacts);
+    return applyNetworkClassification(applyOptionalQuotedEntityExtraction(stableFacts, conversationText, config));
+}
+function applyOptionalQuotedEntityExtraction(facts, conversationText, config) {
+    return config.quotedEntityExtractionEnabled
+        ? mergeQuotedEntityFacts(facts, conversationText)
+        : facts;
+}
+/** Run extractFacts() N times to get independent LLM samples. */
+async function runMultipleExtractions(conversationText, config) {
+    const allRunFacts = [];
+    const options = buildExtractionOptions(config);
+    for (let i = 0; i < config.consensusExtractionRuns; i++) {
+        allRunFacts.push(await extractFacts(conversationText, options));
+    }
+    return allRunFacts;
+}
+function buildExtractionOptions(config) {
+    return {
+        observationDateExtractionEnabled: config.observationDateExtractionEnabled,
+    };
+}
+function buildChunkingConfig(config) {
+    return {
+        chunkSizeTurns: config.chunkSizeTurns,
+        chunkOverlapTurns: config.chunkOverlapTurns,
+        extractionCacheEnabled: config.extractionCacheEnabled,
+    };
+}
+async function extractOnce(conversationText, options, config) {
+    if (config.chunkedExtractionEnabled) {
+        return chunkedExtractFacts(conversationText, options, buildChunkingConfig(config));
+    }
+    // Branch on the per-request runtime config rather than the singleton.
+    // cachedExtractFacts internally checks the singleton; if a benchmark sets
+    // config_override.extractionCacheEnabled=false but the singleton is true,
+    // routing through cachedExtractFacts would silently cache anyway.
+    const facts = config.extractionCacheEnabled
+        ? await cachedExtractFacts(conversationText, options)
+        : await extractFacts(conversationText, options);
+    if (!shouldUseChunkedFallback(conversationText, facts, config))
+        return facts;
+    return chunkedExtractFacts(conversationText, options, buildChunkingConfig(config));
+}
+function shouldUseChunkedFallback(conversationText, facts, config) {
+    return config.chunkedExtractionFallbackEnabled
+        && facts.length === 0
+        && countConversationTurns(conversationText) > config.chunkSizeTurns;
+}
+function countConversationTurns(conversationText) {
+    return conversationText
+        .split('\n')
+        .filter((line) => /^\w[\w\s]*:/.test(line.trim()))
+        .length;
+}
+/** Keep only facts from run[0] that appear in a majority of all runs. */
+async function filterByMajorityVote(allRunFacts) {
+    const referenceFacts = allRunFacts[0];
+    if (referenceFacts.length === 0)
+        return [];
+    const majority = Math.ceil(allRunFacts.length / 2);
+    const refWithEmbeddings = await embedFacts(referenceFacts);
+    const otherRunEmbeddings = await Promise.all(allRunFacts.slice(1).map((facts) => embedFacts(facts)));
+    return refWithEmbeddings
+        .filter((ref) => countMatches(ref, otherRunEmbeddings) + 1 >= majority)
+        .map((ref) => ref.fact);
+}
+/** Embed all facts in a batch. */
+async function embedFacts(facts) {
+    return Promise.all(facts.map(async (fact) => ({ fact, embedding: await embedText(fact.fact) })));
+}
+/** Count how many other runs contain a similar fact. */
+function countMatches(ref, otherRuns) {
+    let count = 0;
+    for (const run of otherRuns) {
+        const hasMatch = run.some((other) => cosineSimilarity(ref.embedding, other.embedding) >= SIMILARITY_THRESHOLD);
+        if (hasMatch)
+            count++;
+    }
+    return count;
+}
+/** Deduplicate facts using embedding similarity. */
+async function deduplicateFacts(facts) {
+    if (facts.length <= 1)
+        return facts;
+    const withEmb = await Promise.all(facts.map(async (f) => ({ fact: f, embedding: await embedText(f.fact) })));
+    const kept = new Array(facts.length).fill(true);
+    for (let i = 0; i < withEmb.length; i++) {
+        if (!kept[i])
+            continue;
+        for (let j = i + 1; j < withEmb.length; j++) {
+            if (!kept[j])
+                continue;
+            if (cosineSimilarity(withEmb[i].embedding, withEmb[j].embedding) >= SIMILARITY_THRESHOLD) {
+                kept[j] = false;
+            }
+        }
+    }
+    return withEmb.filter((_, i) => kept[i]).map((e) => e.fact);
+}
+/** Classify each fact into its memory network (world/experience/opinion). */
+function applyNetworkClassification(facts) {
+    return facts.map((fact) => {
+        const { network, opinionConfidence } = classifyNetwork(fact);
+        return { ...fact, network, opinionConfidence };
+    });
+}