@mxf-dev/core 2.0.5 → 3.0.0

package/dist/services/MemoryService.js

@@ -27,7 +27,7 @@
  * CONSOLIDATED: Includes cognitive operations from AgentMemoryService
  * for LLM workflows (observations, reasoning, plans, reflections).
  */
-import { Observable, of } from 'rxjs';
+import { firstValueFrom, Observable, of, throwError } from 'rxjs';
 import { MxfMeilisearchService } from './MxfMeilisearchService.js';
 import { v4 as uuidv4 } from 'uuid';
 import { MemoryScope, MemoryPersistenceLevel, createMemoryValidator } from '../types/MemoryTypes.js';
@@ -70,6 +70,9 @@ export class MemoryService {
     relationshipMemory = new Map();
     generalData = new Map();
     cognitiveMemory = new Map();
+    agentMutationTails = new Map();
+    channelMutationTails = new Map();
+    relationshipMutationTails = new Map();
     // Configuration
     config;
     // Optional persistence service (server-only)
@@ -85,10 +88,6 @@ export class MemoryService {
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.persistenceService = config.persistenceService;
-        if (this.persistenceService) {
-        }
-        else {
-        }
         // Set up event listeners
         this.setupEventListeners();
     }
@@ -96,291 +95,464 @@ export class MemoryService {
      * Set up event listeners
      */
     setupEventListeners() {
-        // Listen for memory update events to keep cache in sync
-        EventBus.server.on(Events.Memory.UPDATE_RESULT, (data) => {
-            if (data.scope === MemoryScope.AGENT && data.memory) {
-                this.agentMemory.set(data.id, data.memory);
-                // ;
-            }
-            else if (data.scope === MemoryScope.CHANNEL && data.memory) {
-                this.channelMemory.set(data.id, data.memory);
-                // ;
+        // Return each request promise so EventBus.drain() retains ownership of
+        // acknowledged memory work until persistence and the response event
+        // have both completed.
+        EventBus.server.on(Events.Memory.GET, (event) => this.handleMemoryGetRequest(event));
+        EventBus.server.on(Events.Memory.UPDATE, (event) => this.handleMemoryUpdateRequest(event));
+        EventBus.server.on(Events.Memory.DELETE, (event) => this.handleMemoryDeleteRequest(event));
+    }
+    validateMemoryRequestIdentity(event) {
+        this.validator.assertIsNonEmptyString(event.agentId, 'Memory request agentId is required');
+        this.validator.assertIsNonEmptyString(event.channelId, 'Memory request channelId is required');
+        this.validator.assertIsNonEmptyString(event.data.operationId, 'Memory operationId is required');
+        this.validator.validateMemoryScope(event.data.scope);
+    }
+    requireScalarMemoryId(id, scope) {
+        if (Array.isArray(id)) {
+            throw new Error(`${scope} memory requires a scalar ID`);
+        }
+        this.validator.assertIsNonEmptyString(id, `${scope} memory ID is required`);
+        return id;
+    }
+    /**
+     * Agent-scoped requests address the requesting agent's own memory. The
+     * socket gateway checks this too; the service checks it again so no other
+     * caller of the event bridge can read or change another agent's memory by
+     * naming it.
+     */
+    requireOwnAgentMemoryId(id, requestingAgentId) {
+        const agentId = this.requireScalarMemoryId(id, MemoryScope.AGENT);
+        if (agentId !== requestingAgentId) {
+            throw new Error('Agent memory requests are limited to the requesting agent');
+        }
+        return agentId;
+    }
+    /**
+     * Channel-scoped requests address the request's own channel: either the
+     * whole channel document (id equal to the request channel) or one of its
+     * keyed sub-resources (`channel:...:<channelId>`, validated where the key
+     * is resolved).
+     */
+    requireOwnChannelMemoryId(id, requestChannelId) {
+        const channelMemoryId = this.requireScalarMemoryId(id, MemoryScope.CHANNEL);
+        if (!channelMemoryId.startsWith('channel:') && channelMemoryId !== requestChannelId) {
+            throw new Error('Channel memory requests are limited to the request channel');
+        }
+        return channelMemoryId;
+    }
+    /**
+     * Relationship-scoped requests must come from one of the two agents in
+     * the relationship, and the channel component must match the request.
+     */
+    requireRelationshipMemoryId(id, channelId, requestingAgentId) {
+        if (!Array.isArray(id) || (id.length !== 2 && id.length !== 3)) {
+            throw new Error('Relationship memory requires two agent IDs and an optional channel ID');
+        }
+        id.forEach((part, index) => {
+            this.validator.assertIsNonEmptyString(part, `Relationship memory ID part ${index} is required`);
+        });
+        if (id.length === 3 && id[2] !== channelId) {
+            throw new Error('Relationship memory channel must match the request channel');
+        }
+        if (id[0] !== requestingAgentId && id[1] !== requestingAgentId) {
+            throw new Error('Relationship memory requests are limited to a participant of the relationship');
+        }
+        return [id[0], id[1], channelId];
+    }
+    ownsPathOrDescendant(value, reservedPath) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        return Object.keys(value).some(key => key === reservedPath || key.startsWith(`${reservedPath}.`));
+    }
+    getChannelMemoryKey(key, expectedChannelId) {
+        const prefixes = [
+            { prefix: 'channel:context:history:', kind: 'history' },
+            { prefix: 'channel:messages:', kind: 'messages' },
+            { prefix: 'channel:context:', kind: 'context' }
+        ];
+        const matched = prefixes.find(({ prefix }) => key.startsWith(prefix));
+        if (!matched) {
+            throw new Error(`Unsupported channel memory key: ${key}`);
+        }
+        const channelId = key.slice(matched.prefix.length);
+        this.validator.assertIsNonEmptyString(channelId, 'Channel memory key channelId is required');
+        if (expectedChannelId && channelId !== expectedChannelId) {
+            throw new Error('Channel memory key must match the request channel');
+        }
+        return { channelId, kind: matched.kind };
+    }
+    async getKeyedChannelMemory(key, requestChannelId) {
+        const { channelId, kind } = this.getChannelMemoryKey(key, requestChannelId);
+        if (!this.persistenceService && this.generalData.has(key)) {
+            return this.generalData.get(key);
+        }
+        const channelMemory = this.persistenceService
+            ? await firstValueFrom(this.persistenceService.getChannelMemory(channelId))
+            : await firstValueFrom(this.getChannelMemory(channelId));
+        const value = kind === 'messages'
+            ? channelMemory.conversationHistory
+            : kind === 'context'
+                ? channelMemory.sharedState?.context
+                : channelMemory.customData?.contextHistory;
+        const cachedMemory = this.channelMemory.get(channelId);
+        this.channelMemory.set(channelId, {
+            ...channelMemory,
+            sharedCognitiveInsights: cachedMemory?.sharedCognitiveInsights ?? {
+                systemSummaries: [],
+                topicExtractions: [],
+                collaborativeReflections: []
             }
-            else if (data.scope === MemoryScope.RELATIONSHIP && data.memory) {
-                this.relationshipMemory.set(data.id, data.memory);
-                // ;
+        });
+        if (value !== undefined) {
+            this.generalData.set(key, value);
+        }
+        else {
+            this.generalData.delete(key);
+        }
+        return value ?? null;
+    }
+    serializeChannelMutation(channelId, operation) {
+        const previousTail = this.channelMutationTails.get(channelId) ?? Promise.resolve();
+        const result = previousTail.then(operation);
+        const nextTail = result.then(() => undefined, () => undefined);
+        this.channelMutationTails.set(channelId, nextTail);
+        return result.finally(() => {
+            if (this.channelMutationTails.get(channelId) === nextTail) {
+                this.channelMutationTails.delete(channelId);
             }
         });
-        // Set up EventBus bridge for Memory.UPDATE events
-        // This bridges EventBus memory events to internal memory operations
-        // Required for ChannelContextMemoryOperations to save data
-        EventBus.server.on(Events.Memory.UPDATE, (event) => {
-            try {
-                // Extract memory operation data from the event (handle EventBus forwarding nesting)
-                const memoryEventData = event.data.scope ? event.data : event.data.data;
-                // Validate required fields
-                this.validator.assertIsString(memoryEventData.scope, 'Memory scope is required');
-                this.validator.assertIsString(memoryEventData.operationId, 'Operation ID is required');
-                // Determine the action based on memory scope and handle UPDATE operations
-                if (memoryEventData.scope === MemoryScope.CHANNEL) {
-                    // For channel data, store by key (e.g., "channel:context:${channelId}")
-                    const memoryKey = memoryEventData.id; // Use the id as the key
-                    const memoryData = memoryEventData.data;
-                    if (memoryKey && memoryData) {
-                        // Store the data in generalData map (in-memory cache)
-                        this.generalData.set(memoryKey, memoryData);
-                        // Also persist to MongoDB for durability (if persistence service available)
-                        // Extract actual context data - it's wrapped in another object with the key
-                        const actualContextData = memoryData[memoryKey];
-                        if (actualContextData && actualContextData.channelId && this.persistenceService) {
-                            try {
-                                // Convert to IChannelMemory format for persistence
-                                const channelMemoryUpdate = {
-                                    id: `${actualContextData.channelId}-context`,
-                                    channelId: actualContextData.channelId,
-                                    createdAt: new Date(actualContextData.createdAt || Date.now()),
-                                    updatedAt: new Date(),
-                                    persistenceLevel: 'persistent',
-                                    sharedState: { context: actualContextData },
-                                    notes: { channelContext: 'Auto-saved from ChannelContextService' },
-                                    conversationHistory: [],
-                                    customData: { contextMetadata: memoryEventData.metadata || {} }
-                                };
-                                // Persist to MongoDB (fire and forget for performance)
-                                this.persistenceService.saveChannelMemory(channelMemoryUpdate)
-                                    .subscribe({
-                                    next: () => this.logger.info(`Channel context persisted to MongoDB for ${actualContextData.channelId}`),
-                                    error: (err) => this.logger.warn(`Failed to persist channel context to MongoDB: ${err.message}`)
-                                });
-                            }
-                            catch (persistError) {
-                                this.logger.warn(`Error persisting channel context: ${persistError}`);
-                            }
-                        }
-                        // Create success result payload
-                        const updateResultData = {
-                            operationId: memoryEventData.operationId,
-                            scope: MemoryScope.CHANNEL,
-                            id: memoryKey,
-                            memory: memoryData
-                        };
-                        const systemAgentId = 'SYSTEM_AGENT';
-                        const channelId = event.channelId || 'NO_CHANNEL';
-                        const payload = createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId, channelId, updateResultData);
-                        EventBus.server.emit(Events.Memory.UPDATE_RESULT, payload);
-                    }
-                    else {
-                        this.logger.warn(`Invalid UPDATE data - missing key or data: key=${memoryKey}, data=${!!memoryData}`);
-                    }
-                }
+    }
+    serializeAgentMutation(agentId, operation) {
+        const previousTail = this.agentMutationTails.get(agentId) ?? Promise.resolve();
+        const result = previousTail.then(operation);
+        const nextTail = result.then(() => undefined, () => undefined);
+        this.agentMutationTails.set(agentId, nextTail);
+        return result.finally(() => {
+            if (this.agentMutationTails.get(agentId) === nextTail) {
+                this.agentMutationTails.delete(agentId);
             }
-            catch (error) {
-                this.logger.error(`Error handling Memory.UPDATE event: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+    serializeRelationshipMutation(agentId1, agentId2, channelId, operation) {
+        const relationshipKey = this.getRelationshipKey(agentId1, agentId2, channelId);
+        const previousTail = this.relationshipMutationTails.get(relationshipKey) ?? Promise.resolve();
+        const result = previousTail.then(operation);
+        const nextTail = result.then(() => undefined, () => undefined);
+        this.relationshipMutationTails.set(relationshipKey, nextTail);
+        return result.finally(() => {
+            if (this.relationshipMutationTails.get(relationshipKey) === nextTail) {
+                this.relationshipMutationTails.delete(relationshipKey);
             }
         });
-        // Set up EventBus bridge for Memory.GET events
-        // This bridges EventBus memory events to internal memory operations
-        // Required for ChannelContextMessageOperations to work with the memory system
-        EventBus.server.on(Events.Memory.GET, (event) => {
-            try {
-                // Extract memory operation data from the event (handle EventBus forwarding nesting)
-                const memoryEventData = event.data.scope ? event.data : event.data.data;
-                // Validate required fields
-                this.validator.assertIsString(memoryEventData.scope, 'Memory scope is required');
-                this.validator.assertIsString(memoryEventData.operationId, 'Operation ID is required');
-                let memoryObservable = null;
-                // Determine the action based on memory scope and handle GET operations
-                switch (memoryEventData.scope) {
-                    case MemoryScope.CHANNEL:
-                        // Determine the memory key to look up - prioritize key field over id field
-                        const memoryKey = memoryEventData.key || (Array.isArray(memoryEventData.id) ? memoryEventData.id[0] : memoryEventData.id);
-                        if (memoryKey) {
-                            // For channel data, look up by key (e.g., "channel:messages:${channelId}" or "channel:context:${channelId}")
-                            const channelMemory = this.generalData.get(memoryKey);
-                            // Create result payload
-                            const getResultData = {
-                                operationId: memoryEventData.operationId,
-                                scope: MemoryScope.CHANNEL,
-                                id: memoryKey, // Use the memory key as the id for proper matching
-                                memory: channelMemory || null
-                            };
-                            const systemAgentId = 'SYSTEM_AGENT';
-                            const noChannelId = 'NO_CHANNEL';
-                            const payload = createMemoryGetResultEventPayload(Events.Memory.GET_RESULT, systemAgentId, noChannelId, getResultData);
-                            //// this.logger.info(`[CRITICAL] MemoryService emitting GET_RESULT:`, Object.keys(payload));
-                            EventBus.server.emit(Events.Memory.GET_RESULT, payload);
-                        }
-                        else {
-                            this.logger.warn(`[DEBUG] No memory key found in GET event data`);
-                        }
-                        break;
-                    case MemoryScope.AGENT:
-                        if (typeof memoryEventData.id === 'string') {
-                            // ;
-                            memoryObservable = this.getAgentMemory(memoryEventData.id);
-                            // Subscribe to the observable and emit result
-                            memoryObservable.subscribe({
-                                next: (agentMemory) => {
-                                    // Create result payload
-                                    const getResultData = {
-                                        operationId: memoryEventData.operationId,
-                                        scope: MemoryScope.AGENT,
-                                        id: memoryEventData.id,
-                                        memory: agentMemory || null
-                                    };
-                                    const payload = createMemoryGetResultEventPayload(Events.Memory.GET_RESULT, event.agentId, event.channelId, getResultData);
-                                    EventBus.server.emit(Events.Memory.GET_RESULT, payload);
-                                },
-                                error: (error) => {
-                                    this.logger.error(`Error getting agent memory: ${error}`);
-                                    // Create error result payload
-                                    const getResultData = {
-                                        operationId: memoryEventData.operationId,
-                                        scope: MemoryScope.AGENT,
-                                        id: memoryEventData.id,
-                                        memory: null
-                                    };
-                                    const payload = createMemoryGetResultEventPayload(Events.Memory.GET_RESULT, event.agentId, event.channelId, getResultData);
-                                    EventBus.server.emit(Events.Memory.GET_RESULT, payload);
-                                }
-                            });
-                        }
-                        break;
-                    case MemoryScope.RELATIONSHIP:
-                        // Handle relationship memory GET
-                        break;
-                    default:
-                        this.logger.warn(`Unsupported memory scope: ${memoryEventData.scope}`);
+    }
+    getAtomicMutation(kind, value, expectedContextUpdatedAt) {
+        switch (kind) {
+            case 'messages':
+                if (!Array.isArray(value) || value.length === 0) {
+                    throw new Error('Keyed channel message updates require a non-empty array');
                 }
+                return { kind: 'append_messages', messages: value };
+            case 'context':
+                if (!value || typeof value !== 'object' || Array.isArray(value)) {
+                    throw new Error('Keyed channel context updates require an object');
+                }
+                return {
+                    kind: 'replace_context',
+                    context: value,
+                    expectedUpdatedAt: expectedContextUpdatedAt
+                };
+            case 'history':
+                if (!Array.isArray(value) || value.length === 0) {
+                    throw new Error('Keyed channel history updates require a non-empty array');
+                }
+                return { kind: 'append_context_history', entries: value, retainLast: 100 };
+        }
+    }
+    getDeleteMutation(kind) {
+        switch (kind) {
+            case 'messages':
+                return { kind: 'delete_messages' };
+            case 'context':
+                return { kind: 'delete_context' };
+            case 'history':
+                return { kind: 'delete_context_history' };
+        }
+    }
+    async mutateLocalChannelMemory(channelId, mutation) {
+        const deleting = mutation.kind.startsWith('delete_');
+        const existingMemory = this.channelMemory.get(channelId);
+        if (deleting && !existingMemory) {
+            return { found: false, memory: null, value: null };
+        }
+        const originalMemory = existingMemory ?? await firstValueFrom(this.getChannelMemory(channelId));
+        if (mutation.kind === 'replace_context') {
+            const existingContext = originalMemory.sharedState?.context;
+            const actualUpdatedAt = existingContext?.updatedAt;
+            const versionMatches = mutation.expectedUpdatedAt === undefined
+                ? existingContext === undefined
+                : actualUpdatedAt === mutation.expectedUpdatedAt;
+            if (!versionMatches) {
+                return { found: false, memory: originalMemory, value: existingContext ?? null };
+            }
+        }
+        const targetExists = mutation.kind === 'delete_messages'
+            ? originalMemory.conversationHistory !== undefined
+            : mutation.kind === 'delete_context'
+                ? Object.prototype.hasOwnProperty.call(originalMemory.sharedState ?? {}, 'context')
+                : mutation.kind === 'delete_context_history'
+                    ? Object.prototype.hasOwnProperty.call(originalMemory.customData ?? {}, 'contextHistory')
+                    : true;
+        if (!targetExists) {
+            return { found: false, memory: originalMemory, value: null };
+        }
+        let updatedMemory;
+        let value;
+        switch (mutation.kind) {
+            case 'append_messages':
+                value = [...(originalMemory.conversationHistory ?? []), ...mutation.messages];
+                updatedMemory = { ...originalMemory, conversationHistory: value };
+                break;
+            case 'replace_context':
+                value = mutation.context;
+                updatedMemory = {
+                    ...originalMemory,
+                    sharedState: { ...originalMemory.sharedState, context: value }
+                };
+                break;
+            case 'append_context_history':
+                value = [
+                    ...(originalMemory.customData?.contextHistory ?? []),
+                    ...mutation.entries
+                ].slice(-mutation.retainLast);
+                updatedMemory = {
+                    ...originalMemory,
+                    customData: { ...originalMemory.customData, contextHistory: value }
+                };
+                break;
+            case 'delete_messages':
+                value = [];
+                updatedMemory = { ...originalMemory, conversationHistory: [] };
+                break;
+            case 'delete_context': {
+                const sharedState = { ...originalMemory.sharedState };
+                delete sharedState.context;
+                value = null;
+                updatedMemory = { ...originalMemory, sharedState };
+                break;
             }
-            catch (error) {
-                this.logger.error('[ERROR] Error processing EventBus Memory.GET:', error);
-                // Log error details for debugging without creating fake event payloads
-                const operationId = event.data?.operationId || '[NO_OPERATION_ID]';
-                const memoryId = event.data?.id || event.data?.key || '[NO_MEMORY_ID]';
-                this.logger.error(`Memory GET operation failed - OperationId: ${operationId}, MemoryId: ${memoryId}, Error: ${error.message}`);
-                // Cannot emit GET_RESULT event without valid agentId and channelId from original request
-                // Original event should have contained these required identifiers
-                this.logger.warn('Cannot emit Memory.GET_RESULT event - original event lacked valid agentId/channelId. Memory operation errors should be handled by the requesting component.');
+            case 'delete_context_history': {
+                const customData = { ...originalMemory.customData };
+                delete customData.contextHistory;
+                value = null;
+                updatedMemory = { ...originalMemory, customData };
+                break;
             }
+        }
+        updatedMemory.updatedAt = new Date();
+        this.channelMemory.set(channelId, updatedMemory);
+        return { found: true, memory: updatedMemory, value };
+    }
+    async executeKeyedChannelMutation(key, requestChannelId, mutation) {
+        const { channelId } = this.getChannelMemoryKey(key, requestChannelId);
+        return this.serializeChannelMutation(channelId, async () => {
+            const result = this.persistenceService
+                ? await firstValueFrom(this.persistenceService.mutateChannelMemory(channelId, mutation))
+                : await this.mutateLocalChannelMemory(channelId, mutation);
+            if (result.memory) {
+                const cachedMemory = this.channelMemory.get(channelId);
+                this.channelMemory.set(channelId, {
+                    ...result.memory,
+                    sharedCognitiveInsights: cachedMemory?.sharedCognitiveInsights ?? {
+                        systemSummaries: [],
+                        topicExtractions: [],
+                        collaborativeReflections: []
+                    }
+                });
+            }
+            if (result.found) {
+                this.generalData.set(key, result.value);
+            }
+            else {
+                this.generalData.delete(key);
+            }
+            return result;
         });
-        // Set up EventBus bridge for Memory.UPDATE events
-        EventBus.server.on(Events.Memory.UPDATE, (event) => {
-            try {
-                // Extract memory operation data from the event (handle EventBus forwarding nesting)
-                const memoryEventData = event.data.scope ? event.data : event.data.data;
-                // Validate required fields
-                this.validator.assertIsString(memoryEventData.scope, 'Memory scope is required');
-                this.validator.assertIsString(memoryEventData.operationId, 'Operation ID is required');
-                // Handle UPDATE operations
-                switch (memoryEventData.scope) {
-                    case MemoryScope.CHANNEL:
-                        // For UPDATE operations, the id field contains the memory key
-                        const updateMemoryKey = Array.isArray(memoryEventData.id) ? memoryEventData.id[0] : memoryEventData.id;
-                        // Handle the actual data structure from ChannelContextMessageOperations and ChannelContextMemoryOperations
-                        // Data comes in format: 
-                        // - { "channel:messages:${channelId}": [...messages] } for messages
-                        // - { "channel:context:${channelId}": {...context} } for context
-                        if (memoryEventData.data && typeof memoryEventData.data === 'object') {
-                            // Check if the data is already properly keyed or needs to be keyed
-                            const dataKeys = Object.keys(memoryEventData.data);
-                            if (updateMemoryKey.startsWith('channel:')) {
-                                // Direct storage: id field is the memory key, data field contains the actual data
-                                // ;
-                                // If data has nested structure with the same key, extract the nested data
-                                const actualData = memoryEventData.data[updateMemoryKey] || memoryEventData.data;
-                                // Check if data has actually changed before updating
-                                const existingData = this.generalData.get(updateMemoryKey);
-                                const dataHasChanged = !this.isDataEqual(existingData, actualData);
-                                if (!dataHasChanged) {
-                                    // ;
-                                    return; // Skip update and event emission
-                                }
-                                // ;
-                                this.generalData.set(updateMemoryKey, actualData);
-                                // Create success result payload
-                                const updateResult = {
-                                    operationId: memoryEventData.operationId,
-                                    scope: MemoryScope.CHANNEL,
-                                    id: updateMemoryKey, // Use the memory key as the id for proper matching
-                                    memory: actualData
-                                };
-                                const systemAgentId = 'SYSTEM_AGENT';
-                                const noChannelId = 'NO_CHANNEL';
-                                const payload = createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId, noChannelId, updateResult);
-                                // ;
-                                EventBus.server.emit(Events.Memory.UPDATE_RESULT, payload);
-                            }
-                            else {
-                                // Legacy format: Find any channel-related key and data in the data object
-                                const channelKey = dataKeys.find(key => key.startsWith('channel:messages:') || key.startsWith('channel:context:'));
-                                if (channelKey && memoryEventData.data[channelKey]) {
-                                    // ;
-                                    const newData = memoryEventData.data[channelKey];
-                                    // Check if data has actually changed before updating
-                                    const existingData = this.generalData.get(channelKey);
-                                    const dataHasChanged = !this.isDataEqual(existingData, newData);
-                                    if (!dataHasChanged) {
-                                        // ;
-                                        return; // Skip update and event emission
-                                    }
-                                    // Store the data by the key (messages array or context object)
-                                    // ;
-                                    this.generalData.set(channelKey, newData);
-                                    // Create success result payload
-                                    const updateResult = {
-                                        operationId: memoryEventData.operationId,
-                                        scope: MemoryScope.CHANNEL,
-                                        id: channelKey, // Use the memory key as the id for proper matching
-                                        memory: newData
-                                    };
-                                    const systemAgentId = 'SYSTEM_AGENT';
-                                    const noChannelId = 'NO_CHANNEL';
-                                    const payload = createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId, noChannelId, updateResult);
-                                    // ;
-                                    EventBus.server.emit(Events.Memory.UPDATE_RESULT, payload);
-                                }
-                                else {
-                                    this.logger.warn(`No recognized channel key found in data keys: ${dataKeys.join(', ')}`);
-                                }
-                            }
-                        }
-                        break;
-                    case MemoryScope.AGENT:
-                        // Handle agent memory UPDATE
-                        if (typeof memoryEventData.id === 'string' && memoryEventData.data) {
-                            // CRITICAL: Must subscribe to Observable to trigger execution!
-                            // The request context routes the UPDATE_RESULT back to the
-                            // requesting agent with its own operationId — without it the
-                            // SDK's pending save can never observe its result.
-                            this.updateAgentMemory(memoryEventData.id, memoryEventData.data, {
-                                operationId: memoryEventData.operationId,
-                                requesterAgentId: event.agentId,
-                                requesterChannelId: event.channelId
-                            }).subscribe({
-                                next: () => null,
-                                error: (err) => this.logger.error(`Agent memory update failed for ${memoryEventData.id}: ${err}`)
-                            });
+    }
+    async updateKeyedChannelMemory(key, value, requestChannelId, expectedContextUpdatedAt) {
+        const { kind } = this.getChannelMemoryKey(key, requestChannelId);
+        const result = await this.executeKeyedChannelMutation(key, requestChannelId, this.getAtomicMutation(kind, value, expectedContextUpdatedAt));
+        if (!result.found) {
+            throw new Error(`Channel context changed concurrently while updating ${key}`);
+        }
+        return result.value;
+    }
+    async deleteKeyedChannelMemory(key) {
+        const { kind } = this.getChannelMemoryKey(key);
+        const result = await this.executeKeyedChannelMutation(key, undefined, this.getDeleteMutation(kind));
+        if (result.found) {
+            this.generalData.delete(key);
+        }
+        return result.found;
+    }
+    async handleMemoryGetRequest(event) {
+        let responseId = event.data.id;
+        try {
+            this.validateMemoryRequestIdentity(event);
+            let memory;
+            switch (event.data.scope) {
+                case MemoryScope.AGENT: {
+                    const agentId = this.requireOwnAgentMemoryId(event.data.id, event.agentId);
+                    responseId = agentId;
+                    memory = await firstValueFrom(this.getAgentMemory(agentId));
+                    break;
+                }
+                case MemoryScope.CHANNEL: {
+                    const channelMemoryId = this.requireOwnChannelMemoryId(event.data.key ?? event.data.id, event.channelId);
+                    responseId = channelMemoryId;
+                    memory = channelMemoryId.startsWith('channel:')
+                        ? await this.getKeyedChannelMemory(channelMemoryId, event.channelId)
+                        : await firstValueFrom(this.getChannelMemory(channelMemoryId));
+                    break;
+                }
+                case MemoryScope.RELATIONSHIP: {
+                    const [agentId1, agentId2, channelId] = this.requireRelationshipMemoryId(event.data.id, event.channelId, event.agentId);
+                    responseId = [agentId1, agentId2, channelId];
+                    memory = await firstValueFrom(this.getRelationshipMemory(agentId1, agentId2, channelId));
+                    break;
+                }
+            }
+            EventBus.server.emit(Events.Memory.GET_RESULT, createMemoryGetResultEventPayload(Events.Memory.GET_RESULT, event.agentId, event.channelId, {
+                operationId: event.data.operationId,
+                scope: event.data.scope,
+                id: responseId,
+                memory
+            }));
+        }
+        catch (error) {
+            this.emitMemoryGetError(event, responseId, error);
+        }
+    }
+    async handleMemoryUpdateRequest(event) {
+        let responseId = event.data.id;
+        try {
+            this.validateMemoryRequestIdentity(event);
+            this.validator.assertIsObject(event.data.data, 'Memory update data is required');
+            let memory;
+            switch (event.data.scope) {
+                case MemoryScope.AGENT: {
+                    const agentId = this.requireOwnAgentMemoryId(event.data.id, event.agentId);
+                    responseId = agentId;
+                    memory = await firstValueFrom(this.updateAgentMemory(agentId, event.data.data));
+                    break;
+                }
+                case MemoryScope.CHANNEL: {
+                    const channelMemoryId = this.requireOwnChannelMemoryId(event.data.id, event.channelId);
+                    responseId = channelMemoryId;
+                    const embeddedMemoryKeys = Object.keys(event.data.data)
+                        .filter(key => key.startsWith('channel:'));
+                    const keyedMemoryId = channelMemoryId.startsWith('channel:')
+                        ? channelMemoryId
+                        : embeddedMemoryKeys.length === 1
+                            ? embeddedMemoryKeys[0]
+                            : undefined;
+                    if (keyedMemoryId) {
+                        responseId = keyedMemoryId;
+                        const nestedValue = event.data.data[keyedMemoryId];
+                        const value = nestedValue === undefined ? event.data.data : nestedValue;
+                        const expectedContextUpdatedAt = event.data.metadata?.expectedContextUpdatedAt;
+                        if (expectedContextUpdatedAt !== undefined &&
+                            (typeof expectedContextUpdatedAt !== 'number' ||
+                                !Number.isFinite(expectedContextUpdatedAt) ||
+                                expectedContextUpdatedAt < 0)) {
+                            throw new Error('Memory update expectedContextUpdatedAt must be a non-negative number');
                         }
-                        break;
-                    case MemoryScope.RELATIONSHIP:
-                        // Handle relationship memory UPDATE
-                        break;
-                    default:
-                        this.logger.warn(`Unsupported memory scope: ${memoryEventData.scope}`);
+                        memory = await this.updateKeyedChannelMemory(keyedMemoryId, value, event.channelId, expectedContextUpdatedAt);
+                    }
+                    else {
+                        memory = await firstValueFrom(this.updateChannelMemory(channelMemoryId, event.data.data));
+                    }
+                    break;
+                }
+                case MemoryScope.RELATIONSHIP: {
+                    const [agentId1, agentId2, channelId] = this.requireRelationshipMemoryId(event.data.id, event.channelId, event.agentId);
+                    responseId = [agentId1, agentId2, channelId];
+                    memory = await firstValueFrom(this.updateRelationshipMemory(agentId1, agentId2, channelId, event.data.data));
+                    break;
                 }
             }
-            catch (error) {
-                this.logger.error('[ERROR] Error processing EventBus Memory.UPDATE:', error);
-                // Log error details for debugging without creating fake event payloads
-                const operationId = event.data?.operationId || '[NO_OPERATION_ID]';
-                const memoryId = event.data?.id || '[NO_MEMORY_ID]';
-                this.logger.error(`Memory UPDATE operation failed - OperationId: ${operationId}, MemoryId: ${memoryId}, Error: ${error.message}`);
-                // Cannot emit UPDATE_RESULT event without valid agentId and channelId from original request
-                // Original event should have contained these required identifiers
-                this.logger.warn('Cannot emit Memory.UPDATE_RESULT event - original event lacked valid agentId/channelId. Memory operation errors should be handled by the requesting component.');
+            EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, event.agentId, event.channelId, {
+                operationId: event.data.operationId,
+                scope: event.data.scope,
+                id: responseId,
+                memory
+            }));
+        }
+        catch (error) {
+            this.emitMemoryUpdateError(event, responseId, error);
+        }
+    }
+    async handleMemoryDeleteRequest(event) {
+        let responseId = event.data.id;
+        try {
+            this.validateMemoryRequestIdentity(event);
+            if (event.data.scope === MemoryScope.RELATIONSHIP) {
+                responseId = this.requireRelationshipMemoryId(event.data.id, event.channelId, event.agentId);
             }
-        });
+            else if (event.data.scope === MemoryScope.AGENT) {
+                responseId = this.requireOwnAgentMemoryId(event.data.id, event.agentId);
+            }
+            else {
+                responseId = this.requireOwnChannelMemoryId(event.data.id, event.channelId);
+                if (responseId.startsWith('channel:')) {
+                    this.getChannelMemoryKey(responseId, event.channelId);
+                }
+            }
+            const success = await firstValueFrom(this.deleteMemory(event.data.scope, responseId));
+            EventBus.server.emit(Events.Memory.DELETE_RESULT, createMemoryDeleteResultEventPayload(Events.Memory.DELETE_RESULT, event.agentId, event.channelId, {
+                operationId: event.data.operationId,
+                scope: event.data.scope,
+                id: responseId,
+                success
+            }));
+        }
+        catch (error) {
+            this.emitMemoryDeleteError(event, responseId, error);
+        }
+    }
+    emitMemoryGetError(event, id, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Memory GET failed: ${message}`);
+        EventBus.server.emit(Events.Memory.GET_RESULT, createMemoryGetResultEventPayload(Events.Memory.GET_RESULT, event.agentId, event.channelId, {
+            operationId: event.data.operationId,
+            scope: event.data.scope,
+            id,
+            memory: null,
+            error: message
+        }));
+    }
+    emitMemoryUpdateError(event, id, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Memory UPDATE failed: ${message}`);
+        EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, event.agentId, event.channelId, {
+            operationId: event.data.operationId,
+            scope: event.data.scope,
+            id,
+            memory: null,
+            error: message
+        }));
+    }
+    emitMemoryDeleteError(event, id, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Memory DELETE failed: ${message}`);
+        EventBus.server.emit(Events.Memory.DELETE_RESULT, createMemoryDeleteResultEventPayload(Events.Memory.DELETE_RESULT, event.agentId, event.channelId, {
+            operationId: event.data.operationId,
+            scope: event.data.scope,
+            id,
+            success: false,
+            error: message
+        }));
     }
     /**
      * Get the singleton instance
@@ -417,9 +589,10 @@ export class MemoryService {
                 persistence.getAgentMemory(agentId).subscribe({
                     next: (loadedMemory) => {
                         // Enhance the loaded memory with cognitive memory structure
+                        const loadedCognitiveMemory = loadedMemory.cognitiveMemory;
                         const enhancedMemory = {
                             ...loadedMemory,
-                            cognitiveMemory: loadedMemory.cognitiveMemory || {
+                            cognitiveMemory: loadedCognitiveMemory ?? {
                                 observationIds: [],
                                 reasoningIds: [],
                                 planIds: [],
@@ -432,11 +605,9 @@ export class MemoryService {
                         observer.complete();
                     },
                     error: (error) => {
-                        this.logger.warn(`Failed to load agent memory from MongoDB for ${agentId}: ${error.message}`);
-                        // Fall back to creating new memory
-                        const newMemory = this.createNewAgentMemory(agentId);
-                        observer.next(newMemory);
-                        observer.complete();
+                        const message = error instanceof Error ? error.message : String(error);
+                        this.logger.error(`Failed to load agent memory from MongoDB for ${agentId}: ${message}`);
+                        observer.error(error);
                     }
                 });
             });
@@ -468,126 +639,81 @@ export class MemoryService {
             }
         };
         this.agentMemory.set(agentId, newMemory);
-        const operationId_agent_get_new = uuidv4();
-        const systemAgentId_agent_get_new = 'SYSTEM_AGENT';
-        const noChannelId_agent_get_new = 'NO_CHANNEL';
-        const updateResultData_agent_get_new = {
-            operationId: operationId_agent_get_new,
-            scope: MemoryScope.AGENT,
-            id: agentId,
-            memory: newMemory
-        };
-        EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId_agent_get_new, noChannelId_agent_get_new, updateResultData_agent_get_new));
         return newMemory;
     }
     /**
      * Update agent memory
      *
-     * When the update was requested over the wire (SDK → Events.Memory.UPDATE),
-     * requestContext carries the requester's operationId and identity. The
-     * UPDATE_RESULT emitted here must echo that operationId and be addressed to
-     * the requesting agent: the SDK matches results by operationId, and event
-     * forwarding routes them by payload.agentId. Before this parameter existed,
-     * agent-scope results were emitted with a freshly generated operationId under
-     * SYSTEM_AGENT — no SDK save round-trip could ever observe its own result, so
-     * every awaited save hung forever and every fire-and-forget save leaked its
-     * result listener.
-     *
      * @param pAgentId Agent ID
      * @param updates Memory updates
-     * @param requestContext Requester identity for result routing (wire requests only)
      * @returns Observable of updated agent memory
      */
-    updateAgentMemory(pAgentId, updates, requestContext) {
+    updateAgentMemory(pAgentId, updates) {
         this.validator.assertIsNonEmptyString(pAgentId, 'Agent ID must be a non-empty string');
         this.validator.assertIsObject(updates, 'Updates must be an object');
-        // Get existing memory or create new one
         return new Observable(observer => {
-            this.getAgentMemory(pAgentId).subscribe(originalAgentMemory => {
-                // Apply updates
-                const updatedMemory = {
-                    ...originalAgentMemory,
-                    ...updates,
-                    updatedAt: new Date(),
-                    // Ensure these fields can't be overridden
-                    id: originalAgentMemory.id,
-                    agentId: originalAgentMemory.agentId,
-                    createdAt: originalAgentMemory.createdAt
-                };
-                // Deep merge for nested objects
-                if (updates.notes) {
-                    updatedMemory.notes = { ...originalAgentMemory.notes, ...updates.notes };
-                }
-                if (updates.customData) {
-                    updatedMemory.customData = { ...originalAgentMemory.customData, ...updates.customData };
-                }
-                if (updates.cognitiveMemory) {
-                    updatedMemory.cognitiveMemory = {
-                        ...originalAgentMemory.cognitiveMemory,
-                        ...updates.cognitiveMemory
-                    };
-                }
-                // Replace conversation history if provided (SDK sends full array, not incremental)
-                if (updates.conversationHistory !== undefined) {
-                    updatedMemory.conversationHistory = updates.conversationHistory;
-                }
-                // Store updated memory in cache
-                this.agentMemory.set(pAgentId, updatedMemory);
-                // Persist to MongoDB if persistence service is available (async, non-blocking)
-                if (this.persistenceService) {
-                    this.persistenceService.saveAgentMemory(updatedMemory)
-                        .subscribe({
-                        next: () => null,
-                        error: (err) => this.logger.warn(`Failed to persist agent memory to MongoDB for ${pAgentId}: ${err.message}`)
+            let cancelled = false;
+            void (async () => {
+                try {
+                    const enhancedStoredMemory = await this.serializeAgentMutation(pAgentId, async () => {
+                        const originalAgentMemory = await firstValueFrom(this.getAgentMemory(pAgentId));
+                        const updatedMemory = {
+                            ...originalAgentMemory,
+                            ...updates,
+                            updatedAt: new Date(),
+                            id: originalAgentMemory.id,
+                            agentId: originalAgentMemory.agentId,
+                            createdAt: originalAgentMemory.createdAt,
+                            notes: updates.notes
+                                ? { ...originalAgentMemory.notes, ...updates.notes }
+                                : originalAgentMemory.notes,
+                            customData: updates.customData
+                                ? { ...originalAgentMemory.customData, ...updates.customData }
+                                : originalAgentMemory.customData,
+                            cognitiveMemory: updates.cognitiveMemory
+                                ? {
+                                    ...originalAgentMemory.cognitiveMemory,
+                                    ...updates.cognitiveMemory
+                                }
+                                : originalAgentMemory.cognitiveMemory
+                        };
+                        const storedMemory = this.persistenceService
+                            ? await firstValueFrom(this.persistenceService.saveAgentMemory(updatedMemory))
+                            : updatedMemory;
+                        const enhancedMemory = {
+                            ...storedMemory,
+                            cognitiveMemory: updatedMemory.cognitiveMemory
+                        };
+                        this.agentMemory.set(pAgentId, enhancedMemory);
+                        return enhancedMemory;
                     });
+                    if (updates.conversationHistory && updates.conversationHistory.length > 0) {
+                        const contentToExtract = updates.conversationHistory
+                            .slice(-3)
+                            .filter((message) => typeof message.content === 'string' && message.content.length > 0)
+                            .map(message => message.content)
+                            .join('\n\n');
+                        if (contentToExtract.length > 0) {
+                            const channelContext = `agent-memory-${pAgentId}`;
+                            const memoryId = `agent-${pAgentId}-${Date.now()}`;
+                            this.triggerEntityExtraction(channelContext, memoryId, contentToExtract)
+                                .catch(error => this.logger.warn(`Entity extraction failed: ${error instanceof Error ? error.message : String(error)}`));
+                        }
+                    }
+                    if (!cancelled) {
+                        observer.next(enhancedStoredMemory);
+                        observer.complete();
+                    }
                 }
-                // Trigger entity extraction from conversation history if Knowledge Graph is enabled
-                // This extracts entities and relationships for the Knowledge Graph
-                if (updates.conversationHistory && updates.conversationHistory.length > 0) {
-                    const lastMessages = updates.conversationHistory.slice(-3);
-                    const contentToExtract = lastMessages
-                        .filter((msg) => typeof msg.content === 'string' && msg.content.length > 0)
-                        .map(msg => msg.content)
-                        .join('\n\n');
-                    if (contentToExtract.length > 0) {
-                        // Use agent ID as channel context for agent-level memories
-                        // Entities extracted from agent memory are scoped to a pseudo-channel
-                        const channelContext = `agent-memory-${pAgentId}`;
-                        const memoryId = `agent-${pAgentId}-${Date.now()}`;
-                        this.triggerEntityExtraction(channelContext, memoryId, contentToExtract)
-                            .catch(err => this.logger.warn(`Entity extraction failed: ${err.message}`));
+                catch (error) {
+                    if (!cancelled) {
+                        observer.error(error);
                     }
                 }
-                // Emit update event through EventBus. Echo the requester's
-                // operationId and address the result to the requesting agent so
-                // the SDK's pending save resolves; internal callers (no
-                // requestContext) keep the system-level identity.
-                const operationId = requestContext?.operationId ?? uuidv4();
-                const updateResultData = {
-                    operationId,
-                    scope: MemoryScope.AGENT,
-                    id: pAgentId,
-                    memory: updatedMemory
-                };
-                const resultAgentId = requestContext?.requesterAgentId ?? 'SYSTEM_AGENT';
-                const resultChannelId = requestContext?.requesterChannelId ?? 'NO_CHANNEL';
-                const payload = createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, resultAgentId, resultChannelId, updateResultData);
-                EventBus.server.emit(Events.Memory.UPDATE_RESULT, payload);
-                observer.next(updatedMemory);
-                observer.complete();
-            }, error => {
-                // Errors must reach the requester too — a save whose failure is
-                // only logged server-side leaves the requesting SDK waiting forever.
-                const updateResultData_agent_update_error = {
-                    operationId: requestContext?.operationId ?? uuidv4(),
-                    scope: MemoryScope.AGENT,
-                    id: pAgentId,
-                    memory: null,
-                    error: error.message
-                };
-                EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, requestContext?.requesterAgentId ?? 'SYSTEM_AGENT', requestContext?.requesterChannelId ?? 'NO_CHANNEL', updateResultData_agent_update_error));
-                observer.error(error);
-            });
+            })();
+            return () => {
+                cancelled = true;
+            };
         });
     }
     /**
@@ -884,15 +1010,35 @@ export class MemoryService {
      * @returns Observable of channel memory
      */
     getChannelMemory(channelId) {
-        // ;
         this.validator.assertIsNonEmptyString(channelId, 'Channel ID must be a non-empty string');
-        // Return from cache if available
-        if (this.channelMemory.has(channelId)) {
-            const memory = this.channelMemory.get(channelId);
-            // ;
-            return of(memory);
+        const existingMemory = this.channelMemory.get(channelId);
+        if (existingMemory) {
+            return of(existingMemory);
+        }
+        const getPersistedChannelMemory = this.persistenceService?.getChannelMemory;
+        if (this.persistenceService && !getPersistedChannelMemory) {
+            return throwError(() => new Error('Channel memory persistence is not available'));
+        }
+        if (getPersistedChannelMemory) {
+            return new Observable(observer => {
+                getPersistedChannelMemory.call(this.persistenceService, channelId).subscribe({
+                    next: (loadedMemory) => {
+                        const enhancedMemory = {
+                            ...loadedMemory,
+                            sharedCognitiveInsights: {
+                                systemSummaries: [],
+                                topicExtractions: [],
+                                collaborativeReflections: []
+                            }
+                        };
+                        this.channelMemory.set(channelId, enhancedMemory);
+                        observer.next(enhancedMemory);
+                        observer.complete();
+                    },
+                    error: (error) => observer.error(error)
+                });
+            });
         }
-        // Create new memory
         const newMemory = {
             id: uuidv4(),
             channelId,
@@ -915,16 +1061,6 @@ export class MemoryService {
             }
         };
         this.channelMemory.set(channelId, newMemory);
-        const operationId_channel_get_new = uuidv4();
-        const systemAgentId_channel_get_new = 'SYSTEM_AGENT';
-        const noChannelId_channel_get_new = 'NO_CHANNEL';
-        const updateResultData_channel_get_new = {
-            operationId: operationId_channel_get_new,
-            scope: MemoryScope.CHANNEL,
-            id: channelId,
-            memory: newMemory
-        };
-        EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId_channel_get_new, noChannelId_channel_get_new, updateResultData_channel_get_new));
         return of(newMemory);
     }
     /**
@@ -935,65 +1071,77 @@ export class MemoryService {
      */
     updateChannelMemory(channelId, updates) {
         this.validator.assertIsNonEmptyString(channelId, 'Channel ID must be a non-empty string');
+        this.validator.assertIsObject(updates, 'Channel memory updates must be an object');
+        if (this.ownsPathOrDescendant(updates, 'conversationHistory') ||
+            this.ownsPathOrDescendant(updates, 'sharedState.context') ||
+            this.ownsPathOrDescendant(updates, 'customData.contextHistory') ||
+            this.ownsPathOrDescendant(updates.sharedState, 'context') ||
+            this.ownsPathOrDescendant(updates.customData, 'contextHistory')) {
+            throw new Error('Reserved channel memory fields must use the atomic keyed-memory operations');
+        }
         return new Observable(observer => {
-            this.getChannelMemory(channelId).subscribe(originalChannelMemory => {
-                // Create updated memory by merging with original
-                const updatedMemory = {
-                    ...originalChannelMemory, // This spreads all base properties
-                    channelId,
-                    lastActivity: updates.lastActivity || originalChannelMemory.lastActivity || Date.now(),
-                    messageCount: updates.messageCount !== undefined ? updates.messageCount : originalChannelMemory.messageCount,
-                    participants: updates.participants
-                        ? [...new Set([...(originalChannelMemory.participants || []), ...updates.participants])]
-                        : originalChannelMemory.participants,
-                    topics: updates.topics
-                        ? [...new Set([...(originalChannelMemory.topics || []), ...updates.topics])]
-                        : originalChannelMemory.topics,
-                    summary: updates.summary || originalChannelMemory.summary,
-                    conversationHistory: [...(originalChannelMemory.conversationHistory || [])],
-                    sharedCognitiveInsights: {
-                        ...originalChannelMemory.sharedCognitiveInsights,
-                        ...updates.sharedCognitiveInsights
+            let cancelled = false;
+            void (async () => {
+                try {
+                    const enhancedStoredMemory = await this.serializeChannelMutation(channelId, async () => {
+                        const originalMemory = await firstValueFrom(this.getChannelMemory(channelId));
+                        const updatedMemory = {
+                            ...originalMemory,
+                            ...updates,
+                            id: originalMemory.id,
+                            channelId,
+                            createdAt: originalMemory.createdAt,
+                            updatedAt: new Date(),
+                            notes: updates.notes
+                                ? { ...originalMemory.notes, ...updates.notes }
+                                : originalMemory.notes,
+                            sharedState: updates.sharedState
+                                ? { ...originalMemory.sharedState, ...updates.sharedState }
+                                : originalMemory.sharedState,
+                            customData: updates.customData
+                                ? { ...originalMemory.customData, ...updates.customData }
+                                : originalMemory.customData,
+                            participants: updates.participants
+                                ? [...new Set([...(originalMemory.participants ?? []), ...updates.participants])]
+                                : originalMemory.participants,
+                            topics: updates.topics
+                                ? [...new Set([...(originalMemory.topics ?? []), ...updates.topics])]
+                                : originalMemory.topics,
+                            conversationHistory: updates.conversationHistory
+                                ? [
+                                    ...(originalMemory.conversationHistory ?? []),
+                                    ...updates.conversationHistory
+                                ]
+                                : originalMemory.conversationHistory,
+                            sharedCognitiveInsights: {
+                                ...originalMemory.sharedCognitiveInsights,
+                                ...updates.sharedCognitiveInsights
+                            }
+                        };
+                        const storedMemory = this.persistenceService
+                            ? await firstValueFrom(this.persistenceService.saveChannelMemory(updatedMemory))
+                            : updatedMemory;
+                        const enhancedMemory = {
+                            ...storedMemory,
+                            sharedCognitiveInsights: updatedMemory.sharedCognitiveInsights
+                        };
+                        this.channelMemory.set(channelId, enhancedMemory);
+                        return enhancedMemory;
+                    });
+                    if (!cancelled) {
+                        observer.next(enhancedStoredMemory);
+                        observer.complete();
                     }
-                };
-                // Handle conversation history updates  
-                if (updates.conversationHistory && updates.conversationHistory.length > 0) {
-                    updatedMemory.conversationHistory = [
-                        ...(originalChannelMemory.conversationHistory || []),
-                        ...updates.conversationHistory
-                    ];
                 }
-                // Store updated memory in cache
-                this.channelMemory.set(channelId, updatedMemory);
-                // Emit update event through EventBus
-                const operationId = uuidv4();
-                const updateResultData = {
-                    operationId,
-                    scope: MemoryScope.CHANNEL,
-                    id: channelId,
-                    memory: updatedMemory
-                };
-                // Define standard agentId and channelId for system-level memory events
-                const systemAgentId = 'SYSTEM_AGENT';
-                const systemChannelId = channelId; // Use the actual channel ID for channel operations
-                const payload = createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId, systemChannelId, updateResultData);
-                EventBus.server.emit(Events.Memory.UPDATE_RESULT, payload);
-                observer.next(updatedMemory);
-                observer.complete();
-            }, error => {
-                const operationId_channel_update_error = uuidv4();
-                const updateResultData_channel_update_error = {
-                    operationId: operationId_channel_update_error,
-                    scope: MemoryScope.CHANNEL,
-                    id: channelId,
-                    memory: null,
-                    error: error.message
-                };
-                const systemAgentId_channel_update_error = 'SYSTEM_AGENT';
-                const systemChannelId_channel_update_error = channelId;
-                EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId_channel_update_error, systemChannelId_channel_update_error, updateResultData_channel_update_error));
-                observer.error(error);
-            });
+                catch (error) {
+                    if (!cancelled) {
+                        observer.error(error);
+                    }
+                }
+            })();
+            return () => {
+                cancelled = true;
+            };
         });
     }
     /**
@@ -1017,7 +1165,22 @@ export class MemoryService {
         if (existingMemory) {
             return of(existingMemory);
         }
-        // Create new memory
+        const getPersistedRelationshipMemory = this.persistenceService?.getRelationshipMemory;
+        if (this.persistenceService && !getPersistedRelationshipMemory) {
+            return throwError(() => new Error('Relationship memory persistence is not available'));
+        }
+        if (channelId && getPersistedRelationshipMemory) {
+            return new Observable(observer => {
+                getPersistedRelationshipMemory.call(this.persistenceService, sortedId1, sortedId2, channelId).subscribe({
+                    next: (loadedMemory) => {
+                        this.relationshipMemory.set(relationshipKey, loadedMemory);
+                        observer.next(loadedMemory);
+                        observer.complete();
+                    },
+                    error: (error) => observer.error(error)
+                });
+            });
+        }
         const newMemory = {
             id: uuidv4(),
             agentId1: sortedId1,
@@ -1031,16 +1194,6 @@ export class MemoryService {
             customData: {}
         };
         this.relationshipMemory.set(relationshipKey, newMemory);
-        const operationId_rel_get_new = uuidv4();
-        const systemAgentId_rel_get_new = 'SYSTEM_AGENT';
-        const noChannelId_rel_get_new = 'NO_CHANNEL';
-        const updateResultData_rel_get_new = {
-            operationId: operationId_rel_get_new,
-            scope: MemoryScope.RELATIONSHIP,
-            id: relationshipKey,
-            memory: newMemory
-        };
-        EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId_rel_get_new, noChannelId_rel_get_new, updateResultData_rel_get_new));
         return of(newMemory);
     }
     /**
@@ -1057,91 +1210,163 @@ export class MemoryService {
         this.validator.assertIsNonEmptyString(pChannelId, 'Channel ID must be a non-empty string');
         this.validator.assertIsObject(updates, 'Updates must be an object');
         const relationshipKey = this.getRelationshipKey(pAgentId1, pAgentId2, pChannelId);
-        // Get existing memory or create new one
         return new Observable(observer => {
-            this.getRelationshipMemory(pAgentId1, pAgentId2, pChannelId).subscribe(originalRelationshipMemory => {
-                // Apply updates
-                const updatedMemory = {
-                    ...originalRelationshipMemory,
-                    ...updates,
-                    updatedAt: new Date(),
-                    // Ensure these fields can't be overridden
-                    id: originalRelationshipMemory.id,
-                    agentId1: originalRelationshipMemory.agentId1,
-                    agentId2: originalRelationshipMemory.agentId2,
-                    channelId: originalRelationshipMemory.channelId,
-                    createdAt: originalRelationshipMemory.createdAt
-                };
-                // Deep merge for nested objects (if any)
-                // Example: if (updates.customData) { updatedMemory.customData = { ...originalRelationshipMemory.customData, ...updates.customData }; }
-                // Update in-memory store
-                this.relationshipMemory.set(relationshipKey, updatedMemory);
-                const operationId_rel_update_success = uuidv4();
-                const systemAgentId_rel_update_success = 'SYSTEM_AGENT';
-                const noChannelId_rel_update_success = 'NO_CHANNEL'; // General system event
-                const updateResultData_rel_update_success = {
-                    operationId: operationId_rel_update_success,
-                    scope: MemoryScope.RELATIONSHIP,
-                    id: relationshipKey,
-                    memory: updatedMemory
-                };
-                EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId_rel_update_success, noChannelId_rel_update_success, updateResultData_rel_update_success));
-                // Return updated memory
-                observer.next(updatedMemory);
-                observer.complete();
-            }, error => {
-                const operationId_rel_update_error = uuidv4();
-                const systemAgentId_rel_update_error = 'SYSTEM_AGENT';
-                const noChannelId_rel_update_error = 'NO_CHANNEL';
-                // Reconstruct the key for the 'id' field as it was the one attempted for the update.
-                const attemptedRelationshipKey = this.getRelationshipKey(pAgentId1, pAgentId2, pChannelId);
-                const updateResultData_rel_update_error = {
-                    operationId: operationId_rel_update_error,
-                    scope: MemoryScope.RELATIONSHIP,
-                    id: attemptedRelationshipKey, // Use the key that was attempted
-                    memory: null,
-                    error: error.message
-                };
-                EventBus.server.emit(Events.Memory.UPDATE_RESULT, createMemoryUpdateResultEventPayload(Events.Memory.UPDATE_RESULT, systemAgentId_rel_update_error, noChannelId_rel_update_error, updateResultData_rel_update_error));
-                observer.error(error);
-            });
+            let cancelled = false;
+            void (async () => {
+                try {
+                    const storedMemory = await this.serializeRelationshipMutation(pAgentId1, pAgentId2, pChannelId, async () => {
+                        const originalMemory = await firstValueFrom(this.getRelationshipMemory(pAgentId1, pAgentId2, pChannelId));
+                        const updatedMemory = {
+                            ...originalMemory,
+                            ...updates,
+                            id: originalMemory.id,
+                            agentId1: originalMemory.agentId1,
+                            agentId2: originalMemory.agentId2,
+                            channelId: originalMemory.channelId,
+                            createdAt: originalMemory.createdAt,
+                            updatedAt: new Date(),
+                            notes: updates.notes
+                                ? { ...originalMemory.notes, ...updates.notes }
+                                : originalMemory.notes,
+                            customData: updates.customData
+                                ? { ...originalMemory.customData, ...updates.customData }
+                                : originalMemory.customData
+                        };
+                        const saveRelationshipMemory = this.persistenceService?.saveRelationshipMemory;
+                        if (this.persistenceService && !saveRelationshipMemory) {
+                            throw new Error('Relationship memory persistence is not available');
+                        }
+                        const persistedMemory = saveRelationshipMemory
+                            ? await firstValueFrom(saveRelationshipMemory.call(this.persistenceService, updatedMemory))
+                            : updatedMemory;
+                        this.relationshipMemory.set(relationshipKey, persistedMemory);
+                        return persistedMemory;
+                    });
+                    if (!cancelled) {
+                        observer.next(storedMemory);
+                        observer.complete();
+                    }
+                }
+                catch (error) {
+                    if (!cancelled) {
+                        observer.error(error);
+                    }
+                }
+            })();
+            return () => {
+                cancelled = true;
+            };
         });
     }
     /**
      * Delete memory by scope and ID
      * @param scope Memory scope
-     * @param id Entity ID
+     * @param id Entity ID or relationship composite ID
      * @returns Observable of success status
      */
     deleteMemory(scope, id) {
         this.validator.validateMemoryScope(scope);
-        this.validator.assertIsNonEmptyString(id, 'ID must be a non-empty string');
-        let success = false;
-        const operationId = uuidv4(); // Generate operationId for the event data
-        switch (scope) {
-            case MemoryScope.AGENT:
-                success = this.agentMemory.delete(id);
-                break;
-            case MemoryScope.CHANNEL:
-                success = this.channelMemory.delete(id);
-                break;
-            case MemoryScope.RELATIONSHIP:
-                success = this.relationshipMemory.delete(id);
-                break;
+        if (scope === MemoryScope.RELATIONSHIP) {
+            if (!Array.isArray(id) || id.length !== 3) {
+                throw new Error('Relationship memory deletion requires agentId1, agentId2, and channelId');
+            }
+            id.forEach((part, index) => {
+                this.validator.assertIsNonEmptyString(part, `Relationship delete ID part ${index}`);
+            });
         }
-        // Emit delete event through EventBus
-        const deleteResultData = {
-            operationId,
-            scope,
-            id,
-            success
-        };
-        // Define standard agentId and channelId for system-level memory events
-        const systemAgentId = 'SYSTEM_AGENT'; // Or a more specific system agent ID
-        const noChannelId = 'NO_CHANNEL'; // Or a more specific system channel ID or null if appropriate
-        const payload = createMemoryDeleteResultEventPayload(Events.Memory.DELETE_RESULT, systemAgentId, noChannelId, deleteResultData);
-        EventBus.server.emit(Events.Memory.DELETE_RESULT, payload);
-        return of(success);
+        else {
+            this.validator.assertIsNonEmptyString(id, 'Memory ID must be a non-empty string');
+        }
+        return new Observable(observer => {
+            let cancelled = false;
+            void (async () => {
+                try {
+                    if (scope === MemoryScope.CHANNEL &&
+                        typeof id === 'string' &&
+                        id.startsWith('channel:')) {
+                        const success = await this.deleteKeyedChannelMemory(id);
+                        if (!cancelled) {
+                            observer.next(success);
+                            observer.complete();
+                        }
+                        return;
+                    }
+                    const deleteAuthoritatively = async () => {
+                        const deletePersistentMemory = this.persistenceService?.deleteMemory;
+                        if (this.persistenceService && !deletePersistentMemory) {
+                            throw new Error('Memory deletion persistence is not available');
+                        }
+                        const persisted = deletePersistentMemory
+                            ? await firstValueFrom(deletePersistentMemory.call(this.persistenceService, scope, id))
+                            : false;
+                        if (this.persistenceService && !persisted) {
+                            return false;
+                        }
+                        let cached = false;
+                        switch (scope) {
+                            case MemoryScope.AGENT: {
+                                const agentId = id;
+                                cached = this.agentMemory.delete(agentId);
+                                for (const [key, memory] of this.relationshipMemory.entries()) {
+                                    if (memory.agentId1 === agentId || memory.agentId2 === agentId) {
+                                        cached = this.relationshipMemory.delete(key) || cached;
+                                    }
+                                }
+                                for (const [key, memory] of this.cognitiveMemory.entries()) {
+                                    if (memory.agentId === agentId) {
+                                        cached = this.cognitiveMemory.delete(key) || cached;
+                                    }
+                                }
+                                break;
+                            }
+                            case MemoryScope.CHANNEL: {
+                                const channelId = id;
+                                cached = this.channelMemory.has(channelId);
+                                cached = this.channelMemory.delete(channelId) || cached;
+                                for (const key of this.generalData.keys()) {
+                                    if (key.endsWith(`:${channelId}`)) {
+                                        cached = this.generalData.delete(key) || cached;
+                                    }
+                                }
+                                break;
+                            }
+                            case MemoryScope.RELATIONSHIP: {
+                                const [agentId1, agentId2, channelId] = id;
+                                cached = this.relationshipMemory.delete(this.getRelationshipKey(agentId1, agentId2, channelId));
+                                break;
+                            }
+                        }
+                        return this.persistenceService ? persisted : cached;
+                    };
+                    let deleted;
+                    switch (scope) {
+                        case MemoryScope.AGENT:
+                            deleted = await this.serializeAgentMutation(id, deleteAuthoritatively);
+                            break;
+                        case MemoryScope.CHANNEL:
+                            deleted = await this.serializeChannelMutation(id, deleteAuthoritatively);
+                            break;
+                        case MemoryScope.RELATIONSHIP: {
+                            const [agentId1, agentId2, channelId] = id;
+                            deleted = await this.serializeRelationshipMutation(agentId1, agentId2, channelId, deleteAuthoritatively);
+                            break;
+                        }
+                    }
+                    if (!cancelled) {
+                        observer.next(deleted);
+                        observer.complete();
+                    }
+                }
+                catch (error) {
+                    if (!cancelled) {
+                        observer.error(error);
+                    }
+                }
+            })();
+            return () => {
+                cancelled = true;
+            };
+        });
     }
     /**
      * Clear all memory of a specific scope
@@ -1404,7 +1629,7 @@ export class MemoryService {
             }
         }
         catch (error) {
-            this.logger.warn(`[MemoryService] Entity extraction failed for memory ${memoryId}: ${error.message}`);
+            this.logger.warn(`[MemoryService] Entity extraction failed for memory ${memoryId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
@@ -1458,11 +1683,13 @@ export class MemoryService {
         // Handle objects
         if (Array.isArray(data1) || Array.isArray(data2))
             return false;
-        const keys1 = Object.keys(data1);
-        const keys2 = Object.keys(data2);
+        const record1 = data1;
+        const record2 = data2;
+        const keys1 = Object.keys(record1);
+        const keys2 = Object.keys(record2);
         if (keys1.length !== keys2.length)
             return false;
-        return keys1.every(key => keys2.includes(key) && this.isDataEqual(data1[key], data2[key]));
+        return keys1.every(key => keys2.includes(key) && this.isDataEqual(record1[key], record2[key]));
     }
 }
 //# sourceMappingURL=MemoryService.js.map