@devflow-tools/memory-engine 0.17.8 → 0.18.0

package/dist/memory-engine.js

@@ -8,12 +8,13 @@ import { GraphStore } from './graph-store.js';
 import { extractRuleMemories } from './rule-extractor.js';
 import { isObservationType } from './observation-types.js';
 import { classifyFailureCategory, evaluateStoredObservationQuality, observationClusterKey, } from './observation-quality.js';
-import { buildPreferenceConflictDiagnostics, normalizeExplicitPreferenceContent, } from './preference-conflicts.js';
+import { buildPreferenceConflictDiagnostics, } from './preference-conflicts.js';
 import { enrichExplicitMemory, } from './explicit-memory-enricher.js';
-import { evaluateBootstrapMemory, MEMORY_SELECTION_THRESHOLD, normalizeMemoryEntities, } from './memory-relevance.js';
+import { evaluateBootstrapMemory, MEMORY_SELECTION_THRESHOLD, } from './memory-relevance.js';
 import { resolveCapabilityRollout } from '@devflow-tools/sdk/capability-rollout';
-import { compileSemanticMemory } from './semantic-memory-compiler.js';
+import { authorizeMemoryMutation, compileRetrievalScope, stripMutableIdentityMetadata } from '@devflow-tools/sdk';
 import { emitSemanticControlLog } from '@devflow-tools/telemetry';
+import { MemoryCommandService } from './memory-command-service.js';
 function estimateMemoryTokens(text) {
     const cjkCharacters = text.match(/[\u3400-\u9fff\uf900-\ufaff]/g)?.length ?? 0;
     return Math.max(1, cjkCharacters + Math.ceil((text.length - cjkCharacters) / 4));
@@ -57,25 +58,21 @@ export class MemoryEngine {
     searcher;
     graph;
     rootPath;
-    constructor(rootPath, embedder) {
+    projectIdentity;
+    commands;
+    constructor(rootPath, embedder, projectIdentity) {
         this.rootPath = rootPath;
-        this.store = new MemoryStore(rootPath);
+        this.projectIdentity = projectIdentity;
         this.embedder = embedder ?? new EmbeddingProvider();
+        this.store = new MemoryStore(rootPath, this.embedder.getCapability('memory_retrieval').profile, projectIdentity);
         this.searcher = new HybridSearch(this.store, this.embedder, this);
         this.graph = new GraphStore(this.store);
-        this.reconcileHistoricalExplicitPreferences();
+        this.commands = new MemoryCommandService(rootPath, this.store, projectIdentity);
     }
     _initPromise = null;
     _embedderAvailable = true;
-    _explicitPreferencesReconciled = false;
-    reconcileHistoricalExplicitPreferences() {
-        if (this._explicitPreferencesReconciled)
-            return;
-        this.store.reconcileExplicitPreferenceConflicts(this.rootPath);
-        this._explicitPreferencesReconciled = true;
-    }
     getExplicitPreferenceConflictState() {
-        const conflicts = buildPreferenceConflictDiagnostics(this.store.listCurrentExplicitPreferences(this.rootPath));
+        const conflicts = buildPreferenceConflictDiagnostics(this.store.listCurrentExplicitPreferences(this.projectIdentity.memoryNamespace));
         return {
             conflicts,
             withheldIds: new Set(conflicts.flatMap(conflict => conflict.memoryIds)),
@@ -91,8 +88,25 @@ export class MemoryEngine {
     async ensureInit() {
         if (!this._initPromise) {
             this._initPromise = (async () => {
-                this.reconcileHistoricalExplicitPreferences();
+                const before = this.embedder.getCapability('memory_retrieval');
                 this._embedderAvailable = await this.embedder.warmup();
+                const after = this.embedder.getCapability('memory_retrieval');
+                if (before.status !== after.status) {
+                    emitSemanticControlLog({
+                        event: 'embedding.capability.transitioned',
+                        identity: { projectRoot: this.rootPath },
+                        level: after.status === 'ready' ? 'info' : 'warn',
+                        timestamp: Date.now(),
+                        data: {
+                            purpose: 'memory_retrieval',
+                            profileHash: after.profile.profileHash,
+                            generation: after.profile.generation,
+                            from: before.status,
+                            to: after.status,
+                            failure: after.failure,
+                        },
+                    });
+                }
             })();
         }
         return this._initPromise;
@@ -275,6 +289,7 @@ export class MemoryEngine {
                 executionId: normalized.executionId,
                 action: normalized.action,
                 requiredPolicyFacets: normalized.requiredPolicyFacets,
+                semanticTask: normalized.semanticTask,
                 scope: normalized.scopes?.length === 1 ? normalized.scopes[0] : undefined,
             });
             const results = searchOutcome.results;
@@ -487,7 +502,6 @@ export class MemoryEngine {
                     executionId: normalized.executionId,
                 };
                 this.store.recordRetrievalAccess({ ...access, accessType: 'selected' });
-                this.store.recordRetrievalAccess({ ...access, accessType: 'exposed' });
             }
             catch { /* access reinforcement is non-critical */ }
         }
@@ -510,72 +524,49 @@ export class MemoryEngine {
             relevant: [],
         };
     }
-    async saveExplicitMemoryIntent(content, sessionId, sourceEventId) {
-        const normalizedContent = normalizeExplicitPreferenceContent(content);
-        if (!normalizedContent)
-            throw new Error('Explicit memory content must be nonblank');
-        const observationSessionId = sessionId ?? `explicit:${Date.now()}`;
-        const compilation = compileSemanticMemory({
-            projectRoot: this.rootPath,
-            narrative: normalizedContent,
+    async saveExplicitMemoryIntent(content, provenance, sourceEventId) {
+        const observationSessionId = provenance.sessionId;
+        const event = sourceEventId ? this.store.getEvent(sourceEventId) : null;
+        const turnId = eventTurnId(event, sourceEventId ?? `turn:${observationSessionId}`);
+        const result = await this.commands.commitExplicitEpisode({
+            content, actorId: provenance.actorId, sessionId: observationSessionId, turnId,
+            sourceMessageId: sourceEventId ?? `explicit-message:${turnId}`,
             sourceEventIds: sourceEventId ? [sourceEventId] : [],
-            existing: this.store.listObservations().map(observation => ({
-                id: observation.id,
-                semanticKey: observation.semantic_key,
-                facetKey: observation.facet_key,
-                resolutionState: observation.resolution_state,
-            })),
+            createdAt: event?.created_at,
+            supersedesEpisodeId: provenance.supersedesEpisodeId,
         });
-        if (compilation.facts.length === 0) {
-            throw new Error(`Explicit memory semantic compilation failed: ${compilation.status}`);
-        }
-        const existingIds = sourceEventId
-            ? new Set(this.store.listObservations().map(observation => observation.id))
-            : null;
-        const rows = compilation.facts.map(fact => this.store.acceptExplicitPreference({
-            sessionId: observationSessionId,
-            project: this.rootPath,
-            title: fact.enrichment.title,
-            content: fact.enrichment.narrative,
-            sourceEventId,
-            enrichment: fact.enrichment,
-        }));
-        const row = rows[0];
-        for (let index = 1; index < rows.length; index++) {
-            this.store.addSemanticObservationRelation(row.id, rows[index].id, compilation.facts[index]?.relationToPrimary ?? 'related_to');
-        }
-        if (sourceEventId) {
-            const event = this.store.getEvent(sourceEventId);
-            if (!event) {
-                return {
-                    id: row.id, type: row.type, title: row.title, content: row.narrative,
-                    source: row.source, scope: row.project, confidence: row.confidence,
-                    importance: row.importance, score: 1, createdAt: observationEffectiveTimestamp(row),
-                    indexStatus: row.embedding ? 'indexed' : 'pending',
-                    durable: true,
-                    lexicallyReady: row.quality_status === 'accepted',
-                    policyReady: row.quality_status === 'accepted' && compilation.facts[0].enrichment.facet !== 'generic',
-                    vectorStatus: row.embedding ? 'ready' : 'pending',
-                    relatedMemoryIds: rows.slice(1).map(item => item.id),
-                    semanticDecision: {
-                        status: compilation.status,
-                        operations: compilation.facts.map(fact => fact.operation),
-                        rejectedCount: compilation.rejected.length,
-                    },
-                };
-            }
+        const rows = result.factIds.flatMap(id => {
+            const row = this.store.getObservation(id);
+            return row ? [row] : [];
+        });
+        if (sourceEventId && event) {
             for (const saved of rows) {
                 this.store.recordPendingTurnObservation({
                     turnEventId: sourceEventId,
-                    turnId: eventTurnId(event, sourceEventId),
+                    turnId,
                     sessionId: observationSessionId,
-                    project: this.rootPath,
+                    project: this.projectIdentity.memoryNamespace,
                     observationId: saved.id,
-                    createdByTurn: !existingIds.has(saved.id),
+                    createdByTurn: result.decisions.some(decision => decision.candidateId && decision.operation === 'add'),
                     createdAt: event.created_at,
                 });
             }
         }
+        const row = rows[0];
+        if (!row) {
+            return {
+                id: result.episode.episodeId, type: 'cold_episode',
+                title: result.episode.content.slice(0, 160), content: result.episode.content,
+                source: 'explicit_intent', scope: this.projectIdentity.memoryNamespace, confidence: 1, importance: 10,
+                score: 1, createdAt: result.episode.createdAt, indexStatus: 'pending', durable: true,
+                lexicallyReady: true, policyReady: false, vectorStatus: 'pending', relatedMemoryIds: [],
+                semanticDecision: {
+                    status: result.status === 'held' ? 'semantic_rejected' : 'semantic_unavailable',
+                    operations: result.decisions.map(decision => decision.operation),
+                    rejectedCount: result.status === 'held' ? result.decisions.length : 0,
+                },
+            };
+        }
         return {
             id: row.id, type: row.type, title: row.title, content: row.narrative,
             source: row.source, scope: row.project, confidence: row.confidence,
@@ -583,37 +574,40 @@ export class MemoryEngine {
             indexStatus: row.embedding ? 'indexed' : 'pending',
             durable: true,
             lexicallyReady: row.quality_status === 'accepted',
-            policyReady: row.quality_status === 'accepted' && compilation.facts[0].enrichment.facet !== 'generic',
+            policyReady: row.quality_status === 'accepted' && row.facet_key !== null,
             vectorStatus: row.embedding ? 'ready' : 'pending',
             relatedMemoryIds: rows.slice(1).map(item => item.id),
             semanticDecision: {
-                status: compilation.status,
-                operations: compilation.facts.map(fact => fact.operation),
-                rejectedCount: compilation.rejected.length,
+                status: 'semantic_ready',
+                operations: result.decisions.map(decision => decision.operation),
+                rejectedCount: result.decisions.filter(decision => decision.operation === 'hold').length,
             },
         };
     }
     enrichExplicitMemoryObservation(observationId) {
         const observation = this.store.getObservation(observationId);
-        if (!observation)
-            throw new Error(`Observation ${observationId} not found`);
+        if (!observation) {
+            const episode = this.commands.getEpisode(observationId);
+            if (!episode)
+                throw new Error(`Observation ${observationId} not found`);
+            return enrichExplicitMemory({
+                projectRoot: this.rootPath,
+                content: episode.content,
+                sourceEventIds: episode.sourceEventIds,
+            });
+        }
         const enrichment = enrichExplicitMemory({
             projectRoot: this.rootPath,
             content: observation.narrative,
             sourceEventIds: parseStringArray(observation.source_event_ids),
         });
-        this.store.applyExplicitMemoryEnrichment(observationId, enrichment);
         return enrichment;
     }
     attributeRetrievalBenefits(options) {
         const selectedRows = this.store.listRetrievalAccessForAttribution(options.sessionId, options.executionId);
         const unique = new Map(selectedRows.map(row => [row.source_id, row]));
-        const answerEntities = normalizeMemoryEntities(options.finalAnswer ?? '');
-        const normalizedAnswer = (options.finalAnswer ?? '').normalize('NFKC').toLocaleLowerCase('en-US');
-        const authoritativeAdoptedIds = options.adoptedSourceIds
-            ? new Set(options.adoptedSourceIds)
-            : null;
-        let adopted = 0;
+        const consumedSourceIds = new Set(options.consumedSourceIds);
+        let consumed = 0;
         let positive = 0;
         let negative = 0;
         const rollout = resolveCapabilityRollout(this.rootPath).config.outcomeAttribution;
@@ -622,23 +616,12 @@ export class MemoryEngine {
             const observation = row.source_type === 'observation' ? this.store.getObservation(row.source_id) : null;
             if (!memory && !observation)
                 continue;
-            const title = memory?.title ?? observation.title;
-            const content = memory?.content ?? observation.narrative;
-            const concepts = observation ? parseStringArray(observation.concepts) : [];
-            const sourceEntities = normalizeMemoryEntities(`${title}\n${content}\n${concepts.join(' ')}`);
-            const entityAdopted = [...sourceEntities].some(entity => answerEntities.has(entity));
-            const factAdopted = parseStringArray(observation?.facts ?? '[]').some(fact => {
-                const normalizedFact = fact.normalize('NFKC').toLocaleLowerCase('en-US').trim();
-                return normalizedFact.length >= 12 && normalizedAnswer.includes(normalizedFact);
-            });
-            if (authoritativeAdoptedIds
-                ? !authoritativeAdoptedIds.has(row.source_id)
-                : !entityAdopted && !factAdopted)
+            if (!consumedSourceIds.has(row.source_id))
                 continue;
             this.store.recordRetrievalAccess({
                 sourceType: row.source_type,
                 sourceId: row.source_id,
-                accessType: 'adopted',
+                accessType: 'consumed',
                 sessionId: row.session_id ?? options.sessionId,
                 requestId: row.request_id ?? undefined,
                 executionId: row.execution_id ?? options.executionId,
@@ -646,10 +629,27 @@ export class MemoryEngine {
                 purpose: row.purpose ?? 'session_final_answer',
                 rank: row.rank ?? undefined,
                 score: row.score ?? undefined,
-                idempotencyKey: `memory-adopted:${options.sessionId}:${options.executionId ?? ''}:${row.source_type}:${row.source_id}`,
+                idempotencyKey: `memory-consumed:${options.sessionId}:${options.executionId ?? ''}:${row.source_type}:${row.source_id}`,
             });
-            adopted += 1;
-            if (rollout !== 'off' && options.outcome && options.outcome !== 'unknown') {
+            consumed += 1;
+            if (options.verificationReceipt) {
+                this.store.recordRetrievalAccess({
+                    sourceType: row.source_type,
+                    sourceId: row.source_id,
+                    accessType: 'verified',
+                    sessionId: row.session_id ?? options.sessionId,
+                    requestId: row.request_id ?? undefined,
+                    executionId: row.execution_id ?? options.executionId,
+                    query: row.query ?? undefined,
+                    purpose: 'same_task_verification',
+                    rank: row.rank ?? undefined,
+                    score: row.score ?? undefined,
+                    verificationReceipt: options.verificationReceipt,
+                    idempotencyKey: `memory-verified:${options.sessionId}:${options.executionId ?? ''}:${row.source_type}:${row.source_id}`,
+                });
+            }
+            if (rollout !== 'off' && options.verificationReceipt
+                && options.outcome && options.outcome !== 'unknown') {
                 const accessType = options.outcome === 'positive' ? 'positive_outcome' : 'negative_outcome';
                 this.store.recordRetrievalAccess({
                     sourceType: row.source_type,
@@ -675,7 +675,7 @@ export class MemoryEngine {
                     negative += 1;
             }
         }
-        return { selected: unique.size, adopted, positive, negative, unknown: Math.max(0, unique.size - adopted) };
+        return { selected: unique.size, consumed, positive, negative, unknown: Math.max(0, unique.size - consumed) };
     }
     recordContextEnvelopeSelection(options) {
         const entries = [...new Map(options.entries.map(entry => [entry.id, entry])).values()];
@@ -684,21 +684,19 @@ export class MemoryEngine {
             const sourceType = this.store.getObservation(id) ? 'observation' : this.store.get(id) ? 'memory' : null;
             if (!sourceType)
                 continue;
-            for (const accessType of ['selected', 'exposed']) {
-                this.store.recordRetrievalAccess({
-                    sourceType,
-                    sourceId: id,
-                    accessType,
-                    sessionId: options.sessionId,
-                    executionId: options.executionId,
-                    requestId: options.requestId,
-                    query: options.query,
-                    purpose: 'task_context_envelope',
-                    rank: index + 1,
-                    score: entry.score,
-                    contextReceipt: options.contextReceipt,
-                });
-            }
+            this.store.recordRetrievalAccess({
+                sourceType,
+                sourceId: id,
+                accessType: 'selected',
+                sessionId: options.sessionId,
+                executionId: options.executionId,
+                requestId: options.requestId,
+                query: options.query,
+                purpose: 'task_context_envelope',
+                rank: index + 1,
+                score: entry.score,
+                contextReceipt: options.contextReceipt,
+            });
         }
     }
     listObservationMemories(source) {
@@ -729,18 +727,24 @@ export class MemoryEngine {
             source: m.source,
         }));
     }
-    async approveCandidate(id) {
-        this.store.update(id, { status: 'approved' });
+    async approveCandidate(id, provenance) {
+        await this.updateMemory(id, { status: 'approved' }, provenance);
     }
-    async rejectCandidate(id) {
-        this.store.delete(id);
+    async rejectCandidate(id, provenance) {
+        await this.deleteMemory(id, provenance);
     }
     // --- New API methods ---
     async search(query, options) {
+        return (await this.searchWithDiagnostics(query, options)).results;
+    }
+    async searchWithDiagnostics(query, options) {
         await this.ensureInit();
         const { withheldIds } = this.getExplicitPreferenceConflictState();
-        const results = await this.searcher.search(query, { ...options, excludedIds: withheldIds });
-        return results.filter(result => this.isSearchResultVisible(result, withheldIds));
+        const outcome = await this.searcher.searchWithDiagnostics(query, { ...options, excludedIds: withheldIds });
+        return {
+            ...outcome,
+            results: outcome.results.filter(result => this.isSearchResultVisible(result, withheldIds)),
+        };
     }
     getRetrievalRevision() {
         return this.store.getRetrievalRevision();
@@ -754,14 +758,12 @@ export class MemoryEngine {
         });
         return rows.map(r => this._rowToRecord(r));
     }
-    async addMemory(entry) {
-        return this.addMemoryWithStatus(entry);
+    async addMemory(entry, provenance) {
+        return this.addMemoryWithStatus(entry, provenance);
     }
-    async addMemoryWithStatus(entry, requestedStatus, options = {}) {
+    async addMemoryWithStatus(entry, provenance, requestedStatus, options = {}) {
         await this.ensureInit();
-        if (entry.sessionId) {
-            await this.ensureSession(entry.sessionId, this.rootPath);
-        }
+        await this.ensureSession(provenance.sessionId, this.projectIdentity.memoryNamespace);
         // 1. SHA-256 content hash exact dedup
         const normalizedContent = entry.content
             .replace(/\/Users\/[^/\s]+(\/\S+)?/g, '{PROJECT_ROOT}$1')
@@ -813,21 +815,21 @@ export class MemoryEngine {
                 if (bestSim > 0.85 && bestMatch) {
                     if (entry.content.length > bestMatch.content.length) {
                         const newRow = this.store.add({
+                            actorId: provenance.actorId,
                             type: bestMatch.type,
-                            category: entry.category,
                             content: entry.content,
                             originalText: entry.originalText,
                             source: entry.source,
                             status: requestedStatus ?? bestMatch.status,
                             confidence: entry.confidence ?? bestMatch.confidence,
                             scope: entry.scope ?? bestMatch.scope,
-                            sessionId: entry.sessionId,
+                            sessionId: provenance.sessionId,
                         });
-                        this.store.update(newRow.id, {
+                        this.updateStoredRow(newRow, {
                             version: (bestMatch.version || 1) + 1,
                             supersedes: bestMatch.id,
                         });
-                        this.store.update(bestMatch.id, {
+                        this.updateStoredRow(bestMatch, {
                             status: 'superseded',
                             superseded_by: newRow.id,
                         });
@@ -840,7 +842,7 @@ export class MemoryEngine {
                             reason: `superseded_by:${newRow.id}`,
                         });
                         emitSemanticControlLog({
-                            event: 'memory.write.completed', identity: { projectRoot: this.rootPath, sessionId: entry.sessionId }, level: 'info', timestamp: Date.now(),
+                            event: 'memory.write.completed', identity: { projectRoot: this.rootPath, sessionId: provenance.sessionId }, level: 'info', timestamp: Date.now(),
                             data: { stage: 'version', oldMemoryId: bestMatch.id, newMemoryId: newRow.id, version: (bestMatch.version || 1) + 1 },
                         });
                         return this._rowToRecord(newRow);
@@ -861,14 +863,17 @@ export class MemoryEngine {
                 const arbitration = await this.detectAndArbitrateContradiction(entry.content, newEmb);
                 if (arbitration.decision === 'skip') {
                     emitSemanticControlLog({
-                        event: 'memory.write.completed', identity: { projectRoot: this.rootPath, sessionId: entry.sessionId }, level: 'info', timestamp: Date.now(),
+                        event: 'memory.write.completed', identity: { projectRoot: this.rootPath, sessionId: provenance.sessionId }, level: 'info', timestamp: Date.now(),
                         data: { stage: 'contradiction_arbitration', operation: 'hold', reason: arbitration.reason },
                     });
                     return null;
                 }
                 if (arbitration.decision === 'merge' && arbitration.conflictingId) {
                     const mergedContent = arbitration.mergedContent || `${entry.content}`;
-                    this.store.update(arbitration.conflictingId, { content: mergedContent });
+                    const conflicting = this.store.get(arbitration.conflictingId);
+                    if (!conflicting)
+                        throw new Error('MEMORY_ID_NOT_FOUND');
+                    this.updateStoredRow(conflicting, { content: mergedContent });
                     this.store.incrementAccess(arbitration.conflictingId);
                     this.store.recordHistory({
                         memoryId: arbitration.conflictingId,
@@ -877,7 +882,7 @@ export class MemoryEngine {
                         reason: `contradiction_merged: ${arbitration.reason ?? 'unknown'}`,
                     });
                     emitSemanticControlLog({
-                        event: 'memory.write.completed', identity: { projectRoot: this.rootPath, sessionId: entry.sessionId }, level: 'info', timestamp: Date.now(),
+                        event: 'memory.write.completed', identity: { projectRoot: this.rootPath, sessionId: provenance.sessionId }, level: 'info', timestamp: Date.now(),
                         data: { stage: 'contradiction_arbitration', operation: 'merge', conflictingMemoryId: arbitration.conflictingId, reason: arbitration.reason },
                     });
                     const mergedRow = this.store.get(arbitration.conflictingId);
@@ -888,20 +893,21 @@ export class MemoryEngine {
             }
             catch (err) {
                 emitSemanticControlLog({
-                    event: 'memory.write.degraded', identity: { projectRoot: this.rootPath, sessionId: entry.sessionId }, level: 'warn', timestamp: Date.now(),
+                    event: 'memory.write.degraded', identity: { projectRoot: this.rootPath, sessionId: provenance.sessionId }, level: 'warn', timestamp: Date.now(),
                     data: { stage: 'contradiction_detection', reason: memoryEngineErrorReason(err), fallback: 'write_without_arbitration' },
                 });
             }
         }
         const row = this.store.add({
-            category: entry.category,
+            actorId: provenance.actorId,
+            type: entry.category,
             content: entry.content,
             originalText: entry.originalText,
             source: entry.source,
             status: insertStatus,
             confidence: entry.confidence,
             scope: entry.scope,
-            sessionId: entry.sessionId,
+            sessionId: provenance.sessionId,
         });
         // 4. Audit: record ADD event
         this.store.recordHistory({
@@ -927,10 +933,42 @@ export class MemoryEngine {
     }
     reconcileRuleStatus(row, requestedStatus) {
         if (requestedStatus && row.source === 'rule_engine' && row.status !== requestedStatus) {
-            this.store.update(row.id, { status: requestedStatus });
+            this.updateStoredRow(row, { status: requestedStatus });
             row.status = requestedStatus;
         }
     }
+    authorizeMutation(row, provenance) {
+        const requestScope = compileRetrievalScope({
+            channel: 'memory', operation: 'write',
+            ...this.projectIdentity, ...provenance,
+        });
+        const authorized = authorizeMemoryMutation({
+            id: row.id,
+            requestScope,
+            storedScope: {
+                projectId: row.project_id,
+                memoryNamespace: row.memory_namespace,
+                actorId: row.actor_id,
+                sessionId: row.session_id ?? '',
+            },
+        });
+        return {
+            id: authorized.id,
+            projectId: authorized.scope.projectId,
+            memoryNamespace: authorized.scope.memoryNamespace,
+            actorId: authorized.scope.actorId,
+            sessionId: authorized.scope.sessionId,
+        };
+    }
+    updateStoredRow(row, updates) {
+        this.store.updateScoped({
+            id: row.id,
+            projectId: row.project_id,
+            memoryNamespace: row.memory_namespace,
+            actorId: row.actor_id,
+            sessionId: row.session_id ?? '',
+        }, updates);
+    }
     /** Map internal MemoryRow → SDK MemoryEntryRecord */
     _rowToRecord(row) {
         const sdkStatus = row.status === 'active' ? 'approved' :
@@ -938,6 +976,9 @@ export class MemoryEngine {
                 row.status;
         return {
             id: row.id,
+            projectId: row.project_id,
+            memoryNamespace: row.memory_namespace,
+            actorId: row.actor_id,
             category: row.type,
             content: row.content,
             originalText: row.original_text ?? undefined,
@@ -950,9 +991,12 @@ export class MemoryEngine {
             approvedAt: (row.status === 'active' || row.status === 'approved') ? row.updated_at : undefined,
         };
     }
-    async updateMemory(id, updates) {
+    async updateMemory(id, updates, provenance) {
         const old = this.store.get(id);
-        this.store.update(id, updates);
+        if (!old)
+            throw new Error('MEMORY_ID_NOT_FOUND');
+        const scope = this.authorizeMutation(old, provenance);
+        this.store.updateScoped(scope, stripMutableIdentityMetadata(updates));
         if (old) {
             this.store.recordHistory({
                 memoryId: id,
@@ -965,31 +1009,32 @@ export class MemoryEngine {
             });
         }
     }
-    async deleteMemory(id) {
+    async deleteMemory(id, provenance) {
         const old = this.store.get(id);
-        if (old) {
-            this.store.recordHistory({
-                memoryId: id,
-                event: 'DELETE',
-                oldContent: old.content,
-                reason: 'manual_delete',
-            });
-        }
-        this.store.delete(id);
+        if (!old)
+            throw new Error('MEMORY_ID_NOT_FOUND');
+        const scope = this.authorizeMutation(old, provenance);
+        this.store.recordHistory({
+            memoryId: id,
+            event: 'DELETE',
+            oldContent: old.content,
+            reason: 'manual_delete',
+        });
+        this.store.deleteScoped(scope);
     }
     async getPendingMemories() {
         return this.listMemories({ status: 'pending' });
     }
-    async approveMemory(id) {
-        this.store.update(id, { status: 'approved' });
+    async approveMemory(id, provenance) {
+        await this.updateMemory(id, { status: 'approved' }, provenance);
         this.store.recordHistory({
             memoryId: id,
             event: 'REINFORCE',
             reason: 'user_approved',
         });
     }
-    async rejectMemory(id) {
-        this.store.delete(id);
+    async rejectMemory(id, provenance) {
+        await this.deleteMemory(id, provenance);
     }
     // --- Session Consolidation & Contradiction Detection ---
     async consolidateSession(sessionId) {
@@ -1014,7 +1059,7 @@ export class MemoryEngine {
             source: 'auto',
             confidence: 0.5,
             scope: sessionId,
-        });
+        }, { actorId: 'actor:devflow-consolidator', sessionId });
         const expiresAt = Date.now() + 30 * 24 * 60 * 60 * 1000;
         this.store.setExpires(entry.id, expiresAt);
         return entry;
@@ -1062,6 +1107,7 @@ export class MemoryEngine {
         return { decision: 'keep' };
     }
     close() {
+        this.commands.close();
         this.store.close();
     }
     // --- Event Recording & Extraction Pipeline ---
@@ -1106,7 +1152,7 @@ export class MemoryEngine {
             const existing = existingByContent.get(candidate.content);
             if (existing) {
                 if (existing.source === 'rule_engine' && existing.status !== desiredStatus) {
-                    this.store.update(existing.id, { status: desiredStatus });
+                    this.updateStoredRow(existing, { status: desiredStatus });
                     existing.status = desiredStatus;
                 }
                 continue;
@@ -1118,6 +1164,9 @@ export class MemoryEngine {
                 source: 'rule_engine',
                 confidence: candidate.confidence,
                 scope: '',
+            }, {
+                actorId: 'actor:devflow-rule-engine',
+                sessionId: 'session:rule-engine',
             }, desiredStatus, { indexDerived: false });
             saved.push(entry);
             existingByContent.set(candidate.content, this.store.get(entry.id));