ai-memory-layer 2.0.1 → 3.0.0

package/dist/core/orchestrator.js

@@ -1,10 +1,13 @@
 import { normalizeScope } from '../contracts/identity.js';
+import { ResourceNotFoundError, ScopeMismatchError, ValidationError, } from '../contracts/errors.js';
 import { DEFAULT_EXTRACTION_POLICY } from '../contracts/policy.js';
+import { UniqueConstraintError } from '../contracts/storage.js';
 import { assertCompactionTrigger, assertFactConfidence, assertFactType, assertFactType as assertExtractedFactType, assertNonEmpty, assertStringArray, assertMaxEntries, nowSeconds, } from './validation.js';
 import { classifyFactRelation, createRegexExtractor, normalizeFactText, normalizeExtractedFact, normalizeKnowledgeMemory, } from './extractor.js';
 import { emitMemoryEvent } from './telemetry.js';
 import { assessCandidateTrust, buildKnowledgeConflict } from './trust.js';
 import { getNativeSyncAdapter } from '../adapters/sync-to-async.js';
+import { autoDetectAssociations } from './associations.js';
 function resolveExtractionPolicy(policy) {
     return {
         ...DEFAULT_EXTRACTION_POLICY,
@@ -89,6 +92,185 @@ function mergeRecoveredFacts(extracted, recovered, maxFactsPerExtraction) {
     }
     return merged;
 }
+function resolveCreatedKnowledgeClass(knowledgeClass, knowledgeState, evidence) {
+    const supportEvidence = evidence.filter((item) => item.support_polarity === 'supports');
+    const outcomeFailures = supportEvidence.filter((item) => item.outcome === 'failure').length;
+    const outcomeSuccesses = supportEvidence.filter((item) => item.outcome === 'success').length;
+    if (outcomeFailures > outcomeSuccesses && ['strategy', 'procedure'].includes(knowledgeClass)) {
+        return 'anti_pattern';
+    }
+    if (knowledgeState === 'trusted' && knowledgeClass === 'procedure' && outcomeSuccesses > 0) {
+        return 'strategy';
+    }
+    return knowledgeClass;
+}
+function shouldSupersedeExistingKnowledge(relation, relatedKnowledge, decision, conflictStrategy) {
+    return Boolean(relatedKnowledge &&
+        (decision === 'supersede_existing' ||
+            relation === 'update' ||
+            (relation === 'conflict' && conflictStrategy === 'supersede')));
+}
+function buildPromotionAuditPayload(input) {
+    return {
+        ...input.normalizedScope,
+        working_memory_id: input.workingMemoryId,
+        fact: input.fact.fact,
+        fact_type: input.fact.factType,
+        fact_subject: input.fact.subject,
+        fact_attribute: input.fact.attribute,
+        fact_value: input.fact.value,
+        normalized_fact: input.fact.normalizedFact,
+        slot_key: input.fact.slotKey,
+        is_negated: input.fact.isNegated,
+        confidence: input.confidence,
+        confidence_score: input.confidenceScore,
+        verification_status: input.verificationStatus,
+        source_text: input.sourceText,
+        decision: input.relation === 'update'
+            ? 'updated'
+            : input.relation === 'conflict'
+                ? 'conflict'
+                : input.relation === 'compatible'
+                    ? 'compatible'
+                    : 'created',
+        created_knowledge_id: input.createdKnowledgeId,
+        related_knowledge_id: input.relatedKnowledgeId,
+        detail: input.relation === 'conflict'
+            ? input.verificationNotes ?? `Conflict strategy '${input.conflictStrategy}'`
+            : input.relation === 'update'
+                ? input.verificationNotes ?? 'Superseded prior related knowledge'
+                : input.relation === 'compatible'
+                    ? input.verificationNotes ?? 'Created alongside compatible related knowledge'
+                    : input.verificationNotes ?? 'Created new knowledge memory',
+    };
+}
+function bindCandidateEvidenceToCandidate(candidateEvidenceInputs, candidateId) {
+    return candidateEvidenceInputs.map((item) => ({
+        ...item,
+        knowledge_candidate_id: candidateId,
+    }));
+}
+function bindCandidateEvidenceToKnowledge(candidateEvidence, knowledgeId) {
+    return candidateEvidence.map(({ id: _id, ...item }) => ({
+        ...item,
+        knowledge_candidate_id: null,
+        knowledge_memory_id: knowledgeId,
+    }));
+}
+function isPromiseLike(value) {
+    return typeof value === 'object' && value !== null && 'then' in value;
+}
+function chainMaybe(value, next) {
+    return isPromiseLike(value) ? value.then(next) : next(value);
+}
+function attemptMaybe(work, onError) {
+    try {
+        const result = work();
+        return isPromiseLike(result) ? result.catch(onError) : result;
+    }
+    catch (error) {
+        return onError(error);
+    }
+}
+function assertSyncResult(value) {
+    if (isPromiseLike(value)) {
+        throw new Error('Expected synchronous persistence result');
+    }
+    return value;
+}
+function ignoreUniqueConstraint(error) {
+    if (!(error instanceof UniqueConstraintError)) {
+        throw error;
+    }
+}
+function buildPromotionPersistencePlan(input) {
+    const promotedState = input.trustAssessment.state === 'trusted' ? 'trusted' : 'provisional';
+    const createdKnowledgeClass = resolveCreatedKnowledgeClass(input.grounded.candidate.knowledge_class, promotedState, input.candidateEvidenceInputs);
+    const promotedKnowledgeInput = buildKnowledgeInput(input.normalizedScope, input.workingMemoryId, input.fact, {
+        confidence: input.resolvedConfidence,
+        confidenceScore: input.resolvedConfidenceScore,
+        trustScore: input.trustAssessment.trust_score,
+        knowledgeState: promotedState,
+        knowledgeClass: createdKnowledgeClass,
+        verificationStatus: input.resolvedVerificationStatus,
+        verificationNotes: input.verificationNotes ??
+            (input.trustAssessment.reasons.length > 0
+                ? input.trustAssessment.reasons.join(', ')
+                : null),
+        contradictionScore: input.conflict?.severity === 'high' ? 1 : 0,
+        sourceTurnIds: input.grounded.supportedTurnIds,
+    });
+    const auditInput = buildPromotionAuditPayload({
+        normalizedScope: input.normalizedScope,
+        workingMemoryId: input.workingMemoryId,
+        fact: input.fact,
+        confidence: input.resolvedConfidence,
+        confidenceScore: input.trustAssessment.trust_score,
+        verificationStatus: input.resolvedVerificationStatus,
+        sourceText: input.fact.sourceText ?? input.fact.fact,
+        relation: input.strongestRelation.relation,
+        createdKnowledgeId: 0,
+        relatedKnowledgeId: input.strongestRelation.related?.id ?? null,
+        verificationNotes: input.verificationNotes,
+        conflictStrategy: input.policy.conflictStrategy,
+    });
+    return {
+        candidateInput: input.candidateInput,
+        candidateEvidenceInputs: input.candidateEvidenceInputs,
+        promotedKnowledgeInput,
+        auditInput,
+        supersededKnowledgeId: shouldSupersedeExistingKnowledge(input.strongestRelation.relation, input.strongestRelation.related, input.trustAssessment.decision, input.policy.conflictStrategy)
+            ? input.strongestRelation.related.id
+            : null,
+    };
+}
+function persistRejectedKnowledgeCandidateCore(adapter, candidateInput, candidateEvidenceInputs) {
+    return chainMaybe(adapter.insertKnowledgeCandidate(candidateInput), (rejectedCandidate) => {
+        if (candidateEvidenceInputs.length === 0) {
+            return undefined;
+        }
+        return chainMaybe(adapter.insertKnowledgeEvidenceBatch(bindCandidateEvidenceToCandidate(candidateEvidenceInputs, rejectedCandidate.id)), () => undefined);
+    });
+}
+async function persistRejectedKnowledgeCandidateAsync(adapter, candidateInput, candidateEvidenceInputs) {
+    await Promise.resolve(persistRejectedKnowledgeCandidateCore(adapter, candidateInput, candidateEvidenceInputs));
+}
+function persistRejectedKnowledgeCandidateSync(adapter, candidateInput, candidateEvidenceInputs) {
+    assertSyncResult(persistRejectedKnowledgeCandidateCore(adapter, candidateInput, candidateEvidenceInputs));
+}
+function persistPromotedKnowledgeCore(adapter, normalizedScope, plan) {
+    return chainMaybe(adapter.insertKnowledgeCandidate(plan.candidateInput), (candidate) => {
+        const candidateEvidenceResult = plan.candidateEvidenceInputs.length > 0
+            ? adapter.insertKnowledgeEvidenceBatch(bindCandidateEvidenceToCandidate(plan.candidateEvidenceInputs, candidate.id))
+            : [];
+        return chainMaybe(candidateEvidenceResult, (candidateEvidence) => chainMaybe(adapter.promoteKnowledgeCandidate(candidate.id, plan.promotedKnowledgeInput), (knowledge) => chainMaybe(candidateEvidence.length > 0
+            ? adapter.insertKnowledgeEvidenceBatch(bindCandidateEvidenceToKnowledge(candidateEvidence, knowledge.id))
+            : undefined, () => chainMaybe(plan.supersededKnowledgeId != null
+            ? chainMaybe(adapter.supersedeKnowledgeMemory(plan.supersededKnowledgeId, knowledge.id), () => attemptMaybe(() => adapter.insertAssociation({
+                ...normalizedScope,
+                source_kind: 'knowledge',
+                source_id: knowledge.id,
+                target_kind: 'knowledge',
+                target_id: plan.supersededKnowledgeId,
+                association_type: 'supersedes',
+                confidence: 1,
+                auto_generated: true,
+            }), (error) => {
+                ignoreUniqueConstraint(error);
+                return undefined;
+            }))
+            : undefined, () => chainMaybe(adapter.insertKnowledgeMemoryAudit({
+            ...plan.auditInput,
+            created_knowledge_id: knowledge.id,
+        }), () => knowledge)))));
+    });
+}
+async function persistPromotedKnowledgeAsync(adapter, normalizedScope, plan) {
+    return Promise.resolve(persistPromotedKnowledgeCore(adapter, normalizedScope, plan));
+}
+function persistPromotedKnowledgeSync(adapter, normalizedScope, plan) {
+    return assertSyncResult(persistPromotedKnowledgeCore(adapter, normalizedScope, plan));
+}
 function evidenceSourceTypeForTurn(turn) {
     if (turn.role === 'assistant')
         return 'assistant_turn';
@@ -195,14 +377,14 @@ function assertTurnsMatchScope(turns, scope, sessionId) {
     const normalized = normalizeScope(scope);
     for (const turn of turns) {
         if (turn.session_id !== sessionId) {
-            throw new Error(`Memory validation: turn ${turn.id} session_id '${turn.session_id}' does not match '${sessionId}'`);
+            throw new ValidationError(`Memory validation: turn ${turn.id} session_id '${turn.session_id}' does not match '${sessionId}'`);
         }
         if (turn.tenant_id !== normalized.tenant_id ||
             turn.system_id !== normalized.system_id ||
             turn.workspace_id !== normalized.workspace_id ||
             turn.collaboration_id !== normalized.collaboration_id ||
             turn.scope_id !== normalized.scope_id) {
-            throw new Error(`Memory validation: turn ${turn.id} does not belong to the requested scope`);
+            throw new ScopeMismatchError(`Memory validation: turn ${turn.id} does not belong to the requested scope`);
         }
     }
 }
@@ -216,7 +398,7 @@ export async function commitCompaction(adapter, input) {
     assertMaxEntries(input.topicTags, 'topicTags', 5);
     const turnsToArchive = sortTurnsAscending(input.turnsToArchive);
     if (turnsToArchive.length === 0) {
-        throw new Error("Memory validation: 'turnsToArchive' must not be empty");
+        throw new ValidationError("Memory validation: 'turnsToArchive' must not be empty");
     }
     assertTurnsMatchScope(turnsToArchive, normalizedScope, input.sessionId);
     const turnIdStart = turnsToArchive[0].id;
@@ -306,13 +488,13 @@ export async function commitCompaction(adapter, input) {
 export async function compactTurns(adapter, scope, sessionId, turnsToCompact, summarize, trigger, retainedTurnCount, telemetry) {
     assertCompactionTrigger(trigger, 'trigger');
     if (!Number.isInteger(retainedTurnCount) || retainedTurnCount < 0) {
-        throw new Error(`Memory validation: 'retainedTurnCount' must be a non-negative integer, got '${retainedTurnCount}'`);
+        throw new ValidationError(`Memory validation: 'retainedTurnCount' must be a non-negative integer, got '${retainedTurnCount}'`);
     }
     const orderedTurns = sortTurnsAscending(turnsToCompact);
     assertTurnsMatchScope(orderedTurns, scope, sessionId);
     const turnsToArchive = orderedTurns.slice(0, Math.max(0, orderedTurns.length - retainedTurnCount));
     if (turnsToArchive.length === 0) {
-        throw new Error('Memory validation: no turns are eligible for compaction');
+        throw new ValidationError('Memory validation: no turns are eligible for compaction');
     }
     const startedAtMs = Date.now();
     const summary = await summarize(turnsToArchive);
@@ -339,14 +521,14 @@ export async function promoteToKnowledge(adapter, workingMemoryId, input) {
     const normalizedScope = normalizeScope(input.scope);
     const workingMemory = await adapter.getWorkingMemoryById(workingMemoryId);
     if (!workingMemory) {
-        throw new Error(`Memory validation: working memory ${workingMemoryId} was not found`);
+        throw new ResourceNotFoundError(`Memory validation: working memory ${workingMemoryId} was not found`);
     }
     if (workingMemory.tenant_id !== normalizedScope.tenant_id ||
         workingMemory.system_id !== normalizedScope.system_id ||
         workingMemory.workspace_id !== normalizedScope.workspace_id ||
         workingMemory.collaboration_id !== normalizedScope.collaboration_id ||
         workingMemory.scope_id !== normalizedScope.scope_id) {
-        throw new Error(`Memory validation: working memory ${workingMemoryId} does not belong to the requested scope`);
+        throw new ScopeMismatchError(`Memory validation: working memory ${workingMemoryId} does not belong to the requested scope`);
     }
     return runAtomicStorage(adapter, async () => {
         const knowledgeMemory = await adapter.insertKnowledgeMemory({
@@ -391,14 +573,14 @@ export async function extractKnowledge(adapter, workingMemoryId, scope, extracto
     const policy = resolveExtractionPolicy(options?.policy);
     const workingMemory = await adapter.getWorkingMemoryById(workingMemoryId);
     if (!workingMemory) {
-        throw new Error(`Memory validation: working memory ${workingMemoryId} was not found`);
+        throw new ResourceNotFoundError(`Memory validation: working memory ${workingMemoryId} was not found`);
     }
     if (workingMemory.tenant_id !== normalizedScope.tenant_id ||
         workingMemory.system_id !== normalizedScope.system_id ||
         workingMemory.workspace_id !== normalizedScope.workspace_id ||
         workingMemory.collaboration_id !== normalizedScope.collaboration_id ||
         workingMemory.scope_id !== normalizedScope.scope_id) {
-        throw new Error(`Memory validation: working memory ${workingMemoryId} does not belong to the requested scope`);
+        throw new ScopeMismatchError(`Memory validation: working memory ${workingMemoryId} does not belong to the requested scope`);
     }
     const extracted = (await extractor(workingMemory.summary, workingMemory.key_entities, workingMemory.topic_tags))
         .slice(0, policy.maxFactsPerExtraction)
@@ -652,23 +834,7 @@ export async function extractKnowledge(adapter, workingMemoryId, scope, extracto
             continue;
         }
         if (trustAssessment.decision === 'reject_candidate') {
-            await runAtomicStorage(adapter, async () => {
-                const rejectedCandidate = await adapter.insertKnowledgeCandidate(candidateInput);
-                if (candidateEvidenceInputs.length > 0) {
-                    await adapter.insertKnowledgeEvidenceBatch(candidateEvidenceInputs.map((item) => ({
-                        ...item,
-                        knowledge_candidate_id: rejectedCandidate.id,
-                    })));
-                }
-            }, (syncAdapter) => {
-                const rejectedCandidate = syncAdapter.insertKnowledgeCandidate(candidateInput);
-                if (candidateEvidenceInputs.length > 0) {
-                    syncAdapter.insertKnowledgeEvidenceBatch(candidateEvidenceInputs.map((item) => ({
-                        ...item,
-                        knowledge_candidate_id: rejectedCandidate.id,
-                    })));
-                }
-            });
+            await runAtomicStorage(adapter, () => persistRejectedKnowledgeCandidateAsync(adapter, candidateInput, candidateEvidenceInputs), (syncAdapter) => persistRejectedKnowledgeCandidateSync(syncAdapter, candidateInput, candidateEvidenceInputs));
             await adapter.insertKnowledgeMemoryAudit({
                 ...normalizedScope,
                 working_memory_id: workingMemoryId,
@@ -746,165 +912,31 @@ export async function extractKnowledge(adapter, workingMemoryId, scope, extracto
             });
             continue;
         }
-        const createdFact = await runAtomicStorage(adapter, async () => {
-            const candidate = await adapter.insertKnowledgeCandidate(candidateInput);
-            const candidateEvidence = candidateEvidenceInputs.length > 0
-                ? await adapter.insertKnowledgeEvidenceBatch(candidateEvidenceInputs.map((item) => ({
-                    ...item,
-                    knowledge_candidate_id: candidate.id,
-                })))
-                : [];
-            const supportEvidence = candidateEvidence.filter((item) => item.support_polarity === 'supports');
-            const outcomeFailures = supportEvidence.filter((item) => item.outcome === 'failure').length;
-            const outcomeSuccesses = supportEvidence.filter((item) => item.outcome === 'success').length;
-            const createdKnowledgeClass = outcomeFailures > outcomeSuccesses &&
-                ['strategy', 'procedure'].includes(grounded.candidate.knowledge_class)
-                ? 'anti_pattern'
-                : trustAssessment.state === 'trusted' &&
-                    grounded.candidate.knowledge_class === 'procedure' &&
-                    outcomeSuccesses > 0
-                    ? 'strategy'
-                    : grounded.candidate.knowledge_class;
-            const knowledge = await adapter.promoteKnowledgeCandidate(candidate.id, buildKnowledgeInput(normalizedScope, workingMemoryId, fact, {
-                confidence: resolvedConfidence,
-                confidenceScore: resolvedConfidenceScore,
-                trustScore: trustAssessment.trust_score,
-                knowledgeState: trustAssessment.state === 'trusted' ? 'trusted' : 'provisional',
-                knowledgeClass: createdKnowledgeClass,
-                verificationStatus: resolvedVerificationStatus,
-                verificationNotes: verificationNotes ?? (trustAssessment.reasons.length > 0 ? trustAssessment.reasons.join(', ') : null),
-                contradictionScore: conflict?.severity === 'high' ? 1 : 0,
-                sourceTurnIds: grounded.supportedTurnIds,
-            }));
-            if (candidateEvidence.length > 0) {
-                await adapter.insertKnowledgeEvidenceBatch(candidateEvidence.map(({ id: _id, ...item }) => ({
-                    ...item,
-                    knowledge_candidate_id: null,
-                    knowledge_memory_id: knowledge.id,
-                })));
-            }
-            if (strongestRelation.related &&
-                (trustAssessment.decision === 'supersede_existing' ||
-                    strongestRelation.relation === 'update' ||
-                    (strongestRelation.relation === 'conflict' && policy.conflictStrategy === 'supersede'))) {
-                await adapter.supersedeKnowledgeMemory(strongestRelation.related.id, knowledge.id);
-            }
-            await adapter.insertKnowledgeMemoryAudit({
-                ...normalizedScope,
-                working_memory_id: workingMemoryId,
-                fact: fact.fact,
-                fact_type: fact.factType,
-                fact_subject: fact.subject,
-                fact_attribute: fact.attribute,
-                fact_value: fact.value,
-                normalized_fact: fact.normalizedFact,
-                slot_key: fact.slotKey,
-                is_negated: fact.isNegated,
-                confidence: resolvedConfidence,
-                confidence_score: trustAssessment.trust_score,
-                verification_status: resolvedVerificationStatus,
-                source_text: fact.sourceText ?? fact.fact,
-                decision: strongestRelation.relation === 'update'
-                    ? 'updated'
-                    : strongestRelation.relation === 'conflict'
-                        ? 'conflict'
-                        : strongestRelation.relation === 'compatible'
-                            ? 'compatible'
-                            : 'created',
-                created_knowledge_id: knowledge.id,
-                related_knowledge_id: strongestRelation.related?.id ?? null,
-                detail: strongestRelation.relation === 'conflict'
-                    ? verificationNotes ?? `Conflict strategy '${policy.conflictStrategy}'`
-                    : strongestRelation.relation === 'update'
-                        ? verificationNotes ?? 'Superseded prior related knowledge'
-                        : strongestRelation.relation === 'compatible'
-                            ? verificationNotes ?? 'Created alongside compatible related knowledge'
-                            : verificationNotes ?? 'Created new knowledge memory',
-            });
-            return knowledge;
-        }, (syncAdapter) => {
-            const candidate = syncAdapter.insertKnowledgeCandidate(candidateInput);
-            const candidateEvidence = candidateEvidenceInputs.length > 0
-                ? syncAdapter.insertKnowledgeEvidenceBatch(candidateEvidenceInputs.map((item) => ({
-                    ...item,
-                    knowledge_candidate_id: candidate.id,
-                })))
-                : [];
-            const supportEvidence = candidateEvidence.filter((item) => item.support_polarity === 'supports');
-            const outcomeFailures = supportEvidence.filter((item) => item.outcome === 'failure').length;
-            const outcomeSuccesses = supportEvidence.filter((item) => item.outcome === 'success').length;
-            const createdKnowledgeClass = outcomeFailures > outcomeSuccesses &&
-                ['strategy', 'procedure'].includes(grounded.candidate.knowledge_class)
-                ? 'anti_pattern'
-                : trustAssessment.state === 'trusted' &&
-                    grounded.candidate.knowledge_class === 'procedure' &&
-                    outcomeSuccesses > 0
-                    ? 'strategy'
-                    : grounded.candidate.knowledge_class;
-            const knowledge = syncAdapter.promoteKnowledgeCandidate(candidate.id, buildKnowledgeInput(normalizedScope, workingMemoryId, fact, {
-                confidence: resolvedConfidence,
-                confidenceScore: resolvedConfidenceScore,
-                trustScore: trustAssessment.trust_score,
-                knowledgeState: trustAssessment.state === 'trusted' ? 'trusted' : 'provisional',
-                knowledgeClass: createdKnowledgeClass,
-                verificationStatus: resolvedVerificationStatus,
-                verificationNotes: verificationNotes ?? (trustAssessment.reasons.length > 0 ? trustAssessment.reasons.join(', ') : null),
-                contradictionScore: conflict?.severity === 'high' ? 1 : 0,
-                sourceTurnIds: grounded.supportedTurnIds,
-            }));
-            if (candidateEvidence.length > 0) {
-                syncAdapter.insertKnowledgeEvidenceBatch(candidateEvidence.map(({ id: _id, ...item }) => ({
-                    ...item,
-                    knowledge_candidate_id: null,
-                    knowledge_memory_id: knowledge.id,
-                })));
-            }
-            if (strongestRelation.related &&
-                (trustAssessment.decision === 'supersede_existing' ||
-                    strongestRelation.relation === 'update' ||
-                    (strongestRelation.relation === 'conflict' && policy.conflictStrategy === 'supersede'))) {
-                syncAdapter.supersedeKnowledgeMemory(strongestRelation.related.id, knowledge.id);
-            }
-            syncAdapter.insertKnowledgeMemoryAudit({
-                ...normalizedScope,
-                working_memory_id: workingMemoryId,
-                fact: fact.fact,
-                fact_type: fact.factType,
-                fact_subject: fact.subject,
-                fact_attribute: fact.attribute,
-                fact_value: fact.value,
-                normalized_fact: fact.normalizedFact,
-                slot_key: fact.slotKey,
-                is_negated: fact.isNegated,
-                confidence: resolvedConfidence,
-                confidence_score: trustAssessment.trust_score,
-                verification_status: resolvedVerificationStatus,
-                source_text: fact.sourceText ?? fact.fact,
-                decision: strongestRelation.relation === 'update'
-                    ? 'updated'
-                    : strongestRelation.relation === 'conflict'
-                        ? 'conflict'
-                        : strongestRelation.relation === 'compatible'
-                            ? 'compatible'
-                            : 'created',
-                created_knowledge_id: knowledge.id,
-                related_knowledge_id: strongestRelation.related?.id ?? null,
-                detail: strongestRelation.relation === 'conflict'
-                    ? verificationNotes ?? `Conflict strategy '${policy.conflictStrategy}'`
-                    : strongestRelation.relation === 'update'
-                        ? verificationNotes ?? 'Superseded prior related knowledge'
-                        : strongestRelation.relation === 'compatible'
-                            ? verificationNotes ?? 'Created alongside compatible related knowledge'
-                            : verificationNotes ?? 'Created new knowledge memory',
-            });
-            return knowledge;
+        const promotionPlan = buildPromotionPersistencePlan({
+            normalizedScope,
+            workingMemoryId,
+            fact,
+            candidateInput,
+            candidateEvidenceInputs,
+            grounded,
+            trustAssessment,
+            strongestRelation,
+            resolvedConfidence,
+            resolvedConfidenceScore,
+            resolvedVerificationStatus,
+            verificationNotes,
+            conflict,
+            policy,
         });
+        const createdFact = await runAtomicStorage(adapter, () => persistPromotedKnowledgeAsync(adapter, normalizedScope, promotionPlan), (syncAdapter) => persistPromotedKnowledgeSync(syncAdapter, normalizedScope, promotionPlan));
         duplicateLookup.set(normalizedFact, createdFact);
         normalizedKnowledge.push({
             memory: createdFact,
             normalized: normalizeKnowledgeMemory(createdFact),
         });
         created.push(createdFact);
+        // Auto-detect associations between the new fact and all known knowledge (including batch-created)
+        await autoDetectAssociations(adapter, normalizedScope, createdFact, [...activeKnowledge, ...created.slice(0, -1)]);
     }
     emitMemoryEvent('extraction', normalizedScope, options, Date.now() - startedAt, {
         workingMemoryId,