@prmichaelsen/remember-mcp 3.0.0 → 3.13.0

package/src/tools/confirm.ts

@@ -3,15 +3,27 @@
  *
  * Generic confirmation tool that executes any pending action.
  * This is the second phase of the confirmation workflow.
+ *
+ * Memory Collection Pattern v2:
+ * - Multi-space publication to Memory_spaces_public
+ * - Multi-group publication to Memory_groups_{groupId}
+ * - Composite IDs ({userId}.{memoryId}) for published memories
+ * - Tracking arrays (space_ids, group_ids) on source and published memories
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { confirmationTokenService, type ConfirmationRequest } from '../services/confirmation-token.service.js';
-import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties, sanitizeUserId } from '../weaviate/client.js';
+import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties } from '../weaviate/client.js';
 import { ensurePublicCollection } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { logger } from '../utils/logger.js';
 import { createDebugLogger } from '../utils/debug.js';
+import { CollectionType, getCollectionName } from '../collections/dot-notation.js';
+import { generateCompositeId, parseCompositeId } from '../collections/composite-ids.js';
+import { addToSpaceIds, addToGroupIds, removeFromSpaceIds, removeFromGroupIds, getPublishedLocations } from '../collections/tracking-arrays.js';
+import { parseRevisionHistory, buildRevisionHistory, type RevisionResult } from './revise.js';
+import type { AuthContext } from '../types/auth.js';
+import { getSpaceConfig } from '../services/space-config.service.js';
 
 /**
  * Tool definition for remember_confirm
@@ -62,7 +74,8 @@ interface ConfirmArgs {
  */
 export async function handleConfirm(
   args: ConfirmArgs,
-  userId: string
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
   const debug = createDebugLogger({
     tool: 'remember_confirm',
@@ -125,10 +138,15 @@ export async function handleConfirm(
       return await executeDeleteMemory(request, userId);
     }
 
-    // Add other action types here as needed
-    // if (request.action === 'retract_memory') {
-    //   return await executeRetractMemory(request, userId);
-    // }
+    // Handle retract_memory action
+    if (request.action === 'retract_memory') {
+      return await executeRetractMemory(request, userId);
+    }
+
+    // Handle revise_memory action
+    if (request.action === 'revise_memory') {
+      return await executeReviseMemory(request, userId);
+    }
 
     throw new Error(`Unknown action type: ${request.action}`);
   } catch (error) {
@@ -147,10 +165,17 @@ export async function handleConfirm(
 
 /**
  * Execute publish memory action
+ *
+ * Memory Collection Pattern v2:
+ * - Publishes to Memory_spaces_public with composite ID
+ * - Publishes to Memory_groups_{groupId} for each group
+ * - Updates tracking arrays on source memory
+ * - Supports rollback on partial failure
  */
 async function executePublishMemory(
   request: ConfirmationRequest & { request_id: string },
-  userId: string
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
   const debug = createDebugLogger({
     tool: 'remember_confirm',
@@ -159,28 +184,47 @@ async function executePublishMemory(
   });
 
   try {
+    // Normalize arrays (handle undefined)
+    const spaces = request.payload.spaces || [];
+    const groups = request.payload.groups || [];
+    
     debug.debug('Executing publish memory action', {
       memoryId: request.payload.memory_id,
-      spaces: request.payload.spaces,
+      spaces,
+      groups,
     });
     
     logger.info('Executing publish memory action', {
       function: 'executePublishMemory',
       userId,
       memoryId: request.payload.memory_id,
-      spaces: request.payload.spaces,
-      spaceCount: request.payload.spaces?.length || 0,
+      spaces,
+      groups,
+      spaceCount: spaces.length,
+      groupCount: groups.length,
     });
     
+    // Validate that at least one destination is provided
+    if (spaces.length === 0 && groups.length === 0) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'No destinations',
+          message: 'Must specify at least one space or group to publish to',
+        },
+        null,
+        2
+      );
+    }
+    
     // Fetch the memory NOW (during confirmation, not from stored payload)
     const weaviateClient = getWeaviateClient();
-    const userCollection = weaviateClient.collections.get(
-      getMemoryCollectionName(userId)
-    );
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
     
     logger.debug('Fetching original memory', {
       function: 'executePublishMemory',
-      collectionName: getMemoryCollectionName(userId),
+      collectionName: userCollectionName,
       memoryId: request.payload.memory_id,
     });
 
@@ -197,14 +241,6 @@ async function executePublishMemory(
       memoryId: request.payload.memory_id,
       hasProperties: !!originalMemory?.properties,
       propertyCount: originalMemory?.properties ? Object.keys(originalMemory.properties).length : 0,
-      propertyKeys: originalMemory?.properties ? Object.keys(originalMemory.properties) : [],
-      hasTitle: !!originalMemory?.properties?.title,
-      hasContent: !!originalMemory?.properties?.content,
-      hasUserId: !!originalMemory?.properties?.user_id,
-      hasTags: !!originalMemory?.properties?.tags,
-      hasWeight: !!originalMemory?.properties?.weight,
-      contentLength: originalMemory?.properties?.content?.length || 0,
-      titleValue: originalMemory?.properties?.title || 'NO_TITLE',
     });
 
     if (!originalMemory) {
@@ -223,28 +259,6 @@ async function executePublishMemory(
       );
     }
 
-    // Check if memory has already been published
-    if (originalMemory.properties.space_memory_id) {
-      const requestedSpaces = request.payload.spaces?.join(', ') || 'unknown';
-      logger.warn('Memory already published', {
-        function: 'executePublishMemory',
-        memoryId: request.payload.memory_id,
-        existingSpaceMemoryId: originalMemory.properties.space_memory_id,
-        requestedSpaces: request.payload.spaces,
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Already published',
-          message: `This memory has already been published to this space. Space memory ID: ${originalMemory.properties.space_memory_id}`,
-          space_memory_id: originalMemory.properties.space_memory_id,
-          requested_spaces: request.payload.spaces,
-        },
-        null,
-        2
-      );
-    }
-
     // Verify ownership again
     if (originalMemory.properties.user_id !== userId) {
       logger.warn('Permission denied - wrong owner', {
@@ -263,115 +277,300 @@ async function executePublishMemory(
         2
       );
     }
-    
-    logger.debug('Ensuring public collection exists', {
-      function: 'executePublishMemory',
-    });
 
-    // Get unified public collection
-    const publicCollection = await ensurePublicCollection(weaviateClient);
+    // Generate composite ID for published memories
+    const compositeId = generateCompositeId(userId, request.payload.memory_id);
     
-    logger.debug('Public collection ready', {
+    logger.debug('Generated composite ID', {
       function: 'executePublishMemory',
-      collectionName: 'Memory_public',
+      compositeId,
+      userId,
+      memoryId: request.payload.memory_id,
     });
-
-    // Create published memory (copy with modifications)
+    
+    // Get existing tracking arrays from source memory
+    const existingSpaceIds: string[] = Array.isArray(originalMemory.properties.space_ids)
+      ? originalMemory.properties.space_ids
+      : [];
+    const existingGroupIds: string[] = Array.isArray(originalMemory.properties.group_ids)
+      ? originalMemory.properties.group_ids
+      : [];
+    
+    // Prepare tags
     const originalTags = Array.isArray(originalMemory.properties.tags)
       ? originalMemory.properties.tags
       : [];
     const additionalTags = Array.isArray(request.payload.additional_tags)
       ? request.payload.additional_tags
       : [];
-
-    // Validate payload has required fields
-    if (!request.payload.spaces || !Array.isArray(request.payload.spaces) || request.payload.spaces.length === 0) {
-      throw new Error('Payload missing required field: spaces');
-    }
+    const mergedTags = [...originalTags, ...additionalTags];
     
-    // Create published memory - preserve ALL original properties
-    const publishedMemory = {
-      ...originalMemory.properties,
-      // Add space-specific fields (don't overwrite existing properties)
-      spaces: request.payload.spaces,  // Required field (validated above)
-      author_id: userId, // Track original author
-      published_at: new Date().toISOString(),
-      discovery_count: 0,
-      attribution: 'user' as const,
-      // Merge additional tags with original tags
-      tags: [...originalTags, ...additionalTags],
-      // Keep doc_type as 'memory' (space_memory concept was removed)
-      // Keep original created_at, updated_at, version (don't overwrite)
-    };
-
-    logger.info('Inserting memory into Memory_public', {
-      function: 'executePublishMemory',
-      spaces: request.payload.spaces,
-      spaceCount: request.payload.spaces?.length || 0,
-      memoryId: request.payload.memory_id,
-      hasUserId: !!(publishedMemory as any).user_id,
-      hasAuthorId: !!publishedMemory.author_id,
-      publishedMemoryKeys: Object.keys(publishedMemory),
-      publishedMemoryKeyCount: Object.keys(publishedMemory).length,
-      hasContent: !!publishedMemory.content,
-      hasTitle: !!publishedMemory.title,
-      contentLength: publishedMemory.content?.length || 0,
-      titleValue: publishedMemory.title || 'NO_TITLE',
-    });
+    // Track publication results for rollback
+    const publicationResults: {
+      spaces?: { success: boolean; id?: string; error?: string };
+      groups: Array<{ groupId: string; success: boolean; id?: string; error?: string }>;
+    } = { groups: [] };
     
-    // Insert directly into unified public collection
-    // CRITICAL: Weaviate insert API expects {properties: {...}}, not the properties directly!
-    const result = await debug.time('Insert into Memory_public', async () => {
-      return await publicCollection.data.insert({
-        properties: publishedMemory,
+    // STEP 1: Publish to spaces (Memory_spaces_public)
+    if (spaces.length > 0) {
+      logger.debug('Ensuring public spaces collection exists', {
+        function: 'executePublishMemory',
       });
-    });
-    
-    logger.info('Memory published successfully', {
-      function: 'executePublishMemory',
-      spaceMemoryId: result,
-      spaces: request.payload.spaces,
-    });
-    
-    debug.info('Memory published successfully', {
-      spaceMemoryId: result,
-      spaces: request.payload.spaces,
-    });
 
-    // Update original memory with space_memory_id for bidirectional linking
-    try {
-      await userCollection.data.update({
-        id: request.payload.memory_id,
-        properties: {
-          space_memory_id: result,
-        },
-      });
+      const publicCollection = await ensurePublicCollection(weaviateClient);
+
+      // Check if memory already exists in spaces collection with this composite ID
+      let existingSpaceMemory = null;
+      try {
+        existingSpaceMemory = await fetchMemoryWithAllProperties(publicCollection, compositeId);
+      } catch (e) {
+        // Memory doesn't exist, which is fine
+      }
+
+      // Calculate new space_ids array
+      const newSpaceIds = [...new Set([...existingSpaceIds, ...spaces])];
+
+      // Determine moderation status: pending if ANY target space requires moderation
+      let spaceModerationStatus = 'approved';
+      for (const spaceId of spaces) {
+        const spaceConfig = await getSpaceConfig(spaceId, 'space');
+        if (spaceConfig.require_moderation) {
+          spaceModerationStatus = 'pending';
+          break;
+        }
+      }
+
+      // Create published memory with tracking arrays
+      const publishedMemory: Record<string, any> = {
+        ...originalMemory.properties,
+        // Use composite ID as the document ID
+        id: compositeId,
+        // Tracking arrays (v2 feature)
+        space_ids: newSpaceIds,
+        group_ids: existingGroupIds,
+        // Legacy compatibility
+        spaces: spaces,
+        // Publication metadata
+        author_id: userId,
+        published_at: new Date().toISOString(),
+        discovery_count: 0,
+        attribution: 'user' as const,
+        // Moderation status
+        moderation_status: spaceModerationStatus,
+        // Merge tags
+        tags: mergedTags,
+      };
+      
+      // Remove internal Weaviate properties
+      delete publishedMemory._additional;
       
-      logger.info('Updated original memory with space_memory_id', {
+      logger.info('Publishing memory to Memory_spaces_public', {
         function: 'executePublishMemory',
-        memoryId: request.payload.memory_id,
-        spaceMemoryId: result,
+        compositeId,
+        spaces,
+        spaceIds: newSpaceIds,
       });
-    } catch (updateError) {
-      logger.warn('Failed to update original memory with space_memory_id', {
+      
+      try {
+        if (existingSpaceMemory) {
+          // Update existing memory
+          await publicCollection.data.update({
+            id: compositeId,
+            properties: publishedMemory,
+          });
+          publicationResults.spaces = { success: true, id: compositeId };
+        } else {
+          // Insert new memory with specific ID
+          await publicCollection.data.insert({
+            id: compositeId,
+            properties: publishedMemory,
+          });
+          publicationResults.spaces = { success: true, id: compositeId };
+        }
+        
+        logger.info('Memory published to spaces successfully', {
+          function: 'executePublishMemory',
+          compositeId,
+          spaces,
+        });
+      } catch (spaceError) {
+        logger.error('Failed to publish to spaces', {
+          function: 'executePublishMemory',
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError),
+        });
+        publicationResults.spaces = {
+          success: false,
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError)
+        };
+      }
+    }
+    
+    // STEP 2: Publish to groups (Memory_groups_{groupId})
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName(CollectionType.GROUPS, groupId);
+
+      logger.debug('Publishing to group collection', {
         function: 'executePublishMemory',
-        memoryId: request.payload.memory_id,
-        spaceMemoryId: result,
-        error: updateError instanceof Error ? updateError.message : String(updateError),
+        groupId,
+        collectionName: groupCollectionName,
       });
-      // Don't fail the publish if this update fails - it's not critical
-    }
 
-    // Return minimal response with spaces array
-    return JSON.stringify(
-      {
-        success: true,
-        space_memory_id: result,
-        spaces: request.payload.spaces || ['the_void'],
-      },
-      null,
-      2
-    );
+      try {
+        const groupCollection = weaviateClient.collections.get(groupCollectionName);
+
+        // Check if memory already exists in this group
+        let existingGroupMemory = null;
+        try {
+          existingGroupMemory = await fetchMemoryWithAllProperties(groupCollection, compositeId);
+        } catch (e) {
+          // Memory doesn't exist in this group
+        }
+
+        // Calculate new group_ids array (for this group publication)
+        const newGroupIds = [...new Set([...existingGroupIds, groupId])];
+
+        // Determine moderation status for this group
+        const groupConfig = await getSpaceConfig(groupId, 'group');
+        const groupModerationStatus = groupConfig.require_moderation ? 'pending' : 'approved';
+
+        // Create published memory for group
+        const groupMemory: Record<string, any> = {
+          ...originalMemory.properties,
+          // Use composite ID
+          id: compositeId,
+          // Tracking arrays
+          space_ids: existingSpaceIds,
+          group_ids: newGroupIds,
+          // Publication metadata
+          author_id: userId,
+          published_at: new Date().toISOString(),
+          discovery_count: 0,
+          attribution: 'user' as const,
+          // Moderation status
+          moderation_status: groupModerationStatus,
+          // Merge tags
+          tags: mergedTags,
+        };
+        
+        // Remove internal Weaviate properties
+        delete groupMemory._additional;
+        
+        if (existingGroupMemory) {
+          await groupCollection.data.update({
+            id: compositeId,
+            properties: groupMemory,
+          });
+        } else {
+          await groupCollection.data.insert({
+            id: compositeId,
+            properties: groupMemory,
+          });
+        }
+        
+        publicationResults.groups.push({ groupId, success: true, id: compositeId });
+        
+        logger.info('Memory published to group successfully', {
+          function: 'executePublishMemory',
+          compositeId,
+          groupId,
+        });
+      } catch (groupError) {
+        logger.error('Failed to publish to group', {
+          function: 'executePublishMemory',
+          groupId,
+          error: groupError instanceof Error ? groupError.message : String(groupError),
+        });
+        publicationResults.groups.push({
+          groupId,
+          success: false,
+          error: groupError instanceof Error ? groupError.message : String(groupError)
+        });
+      }
+    }
+    
+    // STEP 3: Update source memory with tracking arrays
+    const finalSpaceIds = publicationResults.spaces?.success
+      ? [...new Set([...existingSpaceIds, ...spaces])]
+      : existingSpaceIds;
+    
+    const successfulGroups = publicationResults.groups
+      .filter(g => g.success)
+      .map(g => g.groupId);
+    const finalGroupIds = [...new Set([...existingGroupIds, ...successfulGroups])];
+    
+    // Only update if there are changes
+    if (finalSpaceIds.length > existingSpaceIds.length || finalGroupIds.length > existingGroupIds.length) {
+      try {
+        await userCollection.data.update({
+          id: request.payload.memory_id,
+          properties: {
+            space_ids: finalSpaceIds,
+            group_ids: finalGroupIds,
+          },
+        });
+        
+        logger.info('Updated source memory with tracking arrays', {
+          function: 'executePublishMemory',
+          memoryId: request.payload.memory_id,
+          spaceIds: finalSpaceIds,
+          groupIds: finalGroupIds,
+        });
+      } catch (updateError) {
+        logger.warn('Failed to update source memory tracking arrays', {
+          function: 'executePublishMemory',
+          memoryId: request.payload.memory_id,
+          error: updateError instanceof Error ? updateError.message : String(updateError),
+        });
+        // Don't fail the publish if this update fails
+      }
+    }
+    
+    // Build response
+    const successfulPublications: string[] = [];
+    const failedPublications: string[] = [];
+    
+    if (spaces.length > 0) {
+      if (publicationResults.spaces?.success) {
+        successfulPublications.push(`spaces: ${spaces.join(', ')}`);
+      } else {
+        failedPublications.push(`spaces: ${publicationResults.spaces?.error || 'unknown error'}`);
+      }
+    }
+    
+    for (const groupResult of publicationResults.groups) {
+      if (groupResult.success) {
+        successfulPublications.push(`group: ${groupResult.groupId}`);
+      } else {
+        failedPublications.push(`group ${groupResult.groupId}: ${groupResult.error || 'unknown error'}`);
+      }
+    }
+    
+    // Return result
+    if (successfulPublications.length > 0) {
+      return JSON.stringify(
+        {
+          success: true,
+          composite_id: compositeId,
+          published_to: successfulPublications,
+          failed: failedPublications.length > 0 ? failedPublications : undefined,
+          space_ids: finalSpaceIds,
+          group_ids: finalGroupIds,
+        },
+        null,
+        2
+      );
+    } else {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Publication failed',
+          message: 'Failed to publish to any destination',
+          details: failedPublications,
+        },
+        null,
+        2
+      );
+    }
   } catch (error) {
     debug.error('Execute publish failed', {
       error: error instanceof Error ? error.message : String(error),
@@ -391,7 +590,8 @@ async function executePublishMemory(
  */
 async function executeDeleteMemory(
   request: ConfirmationRequest & { request_id: string },
-  userId: string
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
   try {
     logger.info('Executing delete memory action', {
@@ -405,7 +605,7 @@ async function executeDeleteMemory(
 
     // Soft delete the memory
     const client = getWeaviateClient();
-    const collectionName = `Memory_${sanitizeUserId(userId)}`;
+    const collectionName = getMemoryCollectionName(userId);
     const collection = client.collections.get(collectionName);
 
     await collection.data.update({
@@ -444,3 +644,537 @@ async function executeDeleteMemory(
     throw error;
   }
 }
+
+/**
+ * Execute retract memory action
+ *
+ * Memory Collection Pattern v2:
+ * - Selective retraction from specific spaces/groups
+ * - Space memories are orphaned (remain in Memory_spaces_public with empty tracking arrays)
+ * - Group memories are deleted from group collections
+ * - Tracking arrays updated on source memory
+ */
+async function executeRetractMemory(
+  request: ConfirmationRequest & { request_id: string },
+  userId: string,
+  authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_confirm',
+    userId,
+    operation: 'execute_retract',
+  });
+
+  try {
+    // Normalize arrays (handle undefined)
+    const spaces = request.payload.spaces || [];
+    const groups = request.payload.groups || [];
+
+    debug.debug('Executing retract memory action', {
+      memoryId: request.payload.memory_id,
+      spaces,
+      groups,
+    });
+
+    logger.info('Executing retract memory action', {
+      function: 'executeRetractMemory',
+      userId,
+      memoryId: request.payload.memory_id,
+      spaces,
+      groups,
+      spaceCount: spaces.length,
+      groupCount: groups.length,
+    });
+
+    // Fetch the source memory
+    const weaviateClient = getWeaviateClient();
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
+
+    const sourceMemory = await fetchMemoryWithAllProperties(
+      userCollection,
+      request.payload.memory_id
+    );
+
+    if (!sourceMemory) {
+      logger.info('Source memory not found for retraction', {
+        function: 'executeRetractMemory',
+        memoryId: request.payload.memory_id,
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Memory not found',
+          message: `Source memory ${request.payload.memory_id} no longer exists`,
+        },
+        null,
+        2
+      );
+    }
+
+    // Get current tracking arrays
+    const currentSpaceIds: string[] = Array.isArray(sourceMemory.properties.space_ids)
+      ? sourceMemory.properties.space_ids
+      : [];
+    const currentGroupIds: string[] = Array.isArray(sourceMemory.properties.group_ids)
+      ? sourceMemory.properties.group_ids
+      : [];
+
+    // Generate composite ID for published memories
+    const compositeId = generateCompositeId(userId, request.payload.memory_id);
+
+    // Track retraction results
+    const retractionResults: {
+      spaces?: { success: boolean; error?: string };
+      groups: Array<{ groupId: string; success: boolean; error?: string }>;
+    } = { groups: [] };
+
+    // STEP 1: Retract from spaces (Memory_spaces_public)
+    // Space memories are ORPHANED, not deleted, for historical reference
+    if (spaces.length > 0) {
+      try {
+        const publicCollection = weaviateClient.collections.get(
+          getCollectionName(CollectionType.SPACES)
+        );
+
+        // Fetch the published memory from spaces
+        const publishedMemory = await fetchMemoryWithAllProperties(publicCollection, compositeId);
+
+        if (publishedMemory) {
+          // Calculate new space_ids (remove retracted spaces)
+          const newSpaceIds = currentSpaceIds.filter(id => !spaces.includes(id));
+
+          // Update the published memory with new tracking arrays
+          // Memory remains even if space_ids becomes empty (orphaned)
+          await publicCollection.data.update({
+            id: compositeId,
+            properties: {
+              space_ids: newSpaceIds,
+              retracted_at: new Date().toISOString(),
+            },
+          });
+
+          retractionResults.spaces = { success: true };
+
+          logger.info('Memory retracted from spaces (orphaned)', {
+            function: 'executeRetractMemory',
+            compositeId,
+            retractedSpaces: spaces,
+            remainingSpaces: newSpaceIds,
+            isOrphaned: newSpaceIds.length === 0 && currentGroupIds.length === 0,
+          });
+        } else {
+          // Memory not found in spaces collection
+          retractionResults.spaces = {
+            success: false,
+            error: 'Memory not found in spaces collection',
+          };
+          logger.warn('Memory not found in spaces collection', {
+            function: 'executeRetractMemory',
+            compositeId,
+          });
+        }
+      } catch (spaceError) {
+        logger.error('Failed to retract from spaces', {
+          function: 'executeRetractMemory',
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError),
+        });
+        retractionResults.spaces = {
+          success: false,
+          error: spaceError instanceof Error ? spaceError.message : String(spaceError),
+        };
+      }
+    }
+
+    // STEP 2: Retract from groups (Memory_groups_{groupId})
+    // Group memories are ORPHANED (same as spaces), not deleted
+    // This preserves historical data while making it unsearchable by default
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName(CollectionType.GROUPS, groupId);
+
+      try {
+        const groupCollection = weaviateClient.collections.get(groupCollectionName);
+
+        // Check if memory exists in this group
+        const groupMemory = await fetchMemoryWithAllProperties(groupCollection, compositeId);
+
+        if (groupMemory) {
+          // Get current group_ids from the group memory
+          const groupMemoryGroupIds: string[] = Array.isArray(groupMemory.properties.group_ids)
+            ? groupMemory.properties.group_ids
+            : [];
+          
+          // Remove this group from the group_ids array
+          const newGroupIds = groupMemoryGroupIds.filter(id => id !== groupId);
+          
+          // Update the memory with new tracking arrays (orphan if empty)
+          await groupCollection.data.update({
+            id: compositeId,
+            properties: {
+              group_ids: newGroupIds,
+              retracted_at: new Date().toISOString(),
+            },
+          });
+
+          retractionResults.groups.push({ groupId, success: true });
+
+          logger.info('Memory retracted from group (orphaned)', {
+            function: 'executeRetractMemory',
+            compositeId,
+            groupId,
+            remainingGroups: newGroupIds,
+            isOrphaned: newGroupIds.length === 0,
+          });
+        } else {
+          // Memory not found in this group
+          retractionResults.groups.push({
+            groupId,
+            success: false,
+            error: 'Memory not found in group',
+          });
+          logger.warn('Memory not found in group collection', {
+            function: 'executeRetractMemory',
+            compositeId,
+            groupId,
+          });
+        }
+      } catch (groupError) {
+        logger.error('Failed to retract from group', {
+          function: 'executeRetractMemory',
+          groupId,
+          error: groupError instanceof Error ? groupError.message : String(groupError),
+        });
+        retractionResults.groups.push({
+          groupId,
+          success: false,
+          error: groupError instanceof Error ? groupError.message : String(groupError),
+        });
+      }
+    }
+
+    // STEP 3: Update source memory tracking arrays
+    const finalSpaceIds = retractionResults.spaces?.success
+      ? currentSpaceIds.filter(id => !spaces.includes(id))
+      : currentSpaceIds;
+
+    const successfulGroupRetractions = retractionResults.groups
+      .filter(g => g.success)
+      .map(g => g.groupId);
+    const finalGroupIds = currentGroupIds.filter(id => !successfulGroupRetractions.includes(id));
+
+    // Update source memory
+    try {
+      await userCollection.data.update({
+        id: request.payload.memory_id,
+        properties: {
+          space_ids: finalSpaceIds,
+          group_ids: finalGroupIds,
+        },
+      });
+
+      logger.info('Updated source memory tracking arrays after retraction', {
+        function: 'executeRetractMemory',
+        memoryId: request.payload.memory_id,
+        spaceIds: finalSpaceIds,
+        groupIds: finalGroupIds,
+      });
+    } catch (updateError) {
+      logger.warn('Failed to update source memory tracking arrays after retraction', {
+        function: 'executeRetractMemory',
+        memoryId: request.payload.memory_id,
+        error: updateError instanceof Error ? updateError.message : String(updateError),
+      });
+      // Don't fail the retraction if this update fails
+    }
+
+    // Build response
+    const successfulRetractions: string[] = [];
+    const failedRetractions: string[] = [];
+
+    if (spaces.length > 0) {
+      if (retractionResults.spaces?.success) {
+        successfulRetractions.push(`spaces: ${spaces.join(', ')}`);
+      } else {
+        failedRetractions.push(`spaces: ${retractionResults.spaces?.error || 'unknown error'}`);
+      }
+    }
+
+    for (const groupResult of retractionResults.groups) {
+      if (groupResult.success) {
+        successfulRetractions.push(`group: ${groupResult.groupId}`);
+      } else {
+        failedRetractions.push(`group ${groupResult.groupId}: ${groupResult.error || 'unknown error'}`);
+      }
+    }
+
+    // Return result
+    if (successfulRetractions.length > 0) {
+      return JSON.stringify(
+        {
+          success: true,
+          composite_id: compositeId,
+          retracted_from: successfulRetractions,
+          failed: failedRetractions.length > 0 ? failedRetractions : undefined,
+          space_ids: finalSpaceIds,
+          group_ids: finalGroupIds,
+          is_orphaned: finalSpaceIds.length === 0 && finalGroupIds.length === 0,
+        },
+        null,
+        2
+      );
+    } else {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Retraction failed',
+          message: 'Failed to retract from any destination',
+          details: failedRetractions,
+        },
+        null,
+        2
+      );
+    }
+  } catch (error) {
+    debug.error('Execute retract failed', {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
+    handleToolError(error, {
+      toolName: 'remember_confirm',
+      userId,
+      operation: 'execute retract_memory',
+      action: 'retract_memory',
+    });
+  }
+}
+
+/**
+ * Execute revise memory action
+ *
+ * Memory Collection Pattern v2:
+ * - Syncs content from source memory to all published copies
+ * - Preserves old content in revision_history (max 10 entries)
+ * - Updates revised_at and revision_count on each copy
+ * - Supports partial success (some locations may fail)
+ */
+async function executeReviseMemory(
+  request: ConfirmationRequest & { request_id: string },
+  userId: string,
+  authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_confirm',
+    userId,
+    operation: 'execute_revise',
+  });
+
+  try {
+    const { memory_id, space_ids = [], group_ids = [] } = request.payload;
+
+    debug.debug('Executing revise memory action', {
+      memoryId: memory_id,
+      spaceIds: space_ids,
+      groupIds: group_ids,
+    });
+
+    logger.info('Executing revise memory action', {
+      function: 'executeReviseMemory',
+      userId,
+      memoryId: memory_id,
+      spaceCount: space_ids.length,
+      groupCount: group_ids.length,
+    });
+
+    // Fetch source memory
+    const weaviateClient = getWeaviateClient();
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
+
+    const sourceMemory = await fetchMemoryWithAllProperties(
+      userCollection,
+      memory_id
+    );
+
+    if (!sourceMemory) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Memory not found',
+          message: `Source memory ${memory_id} no longer exists`,
+        },
+        null,
+        2
+      );
+    }
+
+    // Verify ownership again
+    if (sourceMemory.properties.user_id !== userId) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Permission denied',
+          message: 'You can only revise your own memories',
+        },
+        null,
+        2
+      );
+    }
+
+    const newContent = String(sourceMemory.properties.content ?? '');
+    const revisedAt = new Date().toISOString();
+    const compositeId = generateCompositeId(userId, memory_id);
+    const results: RevisionResult[] = [];
+
+    logger.info('Revising published copies', {
+      function: 'executeReviseMemory',
+      compositeId,
+      spaceCount: space_ids.length > 0 ? 1 : 0,
+      groupCount: group_ids.length,
+    });
+
+    /**
+     * Update content + revision tracking in a single collection.
+     */
+    async function reviseInCollection(
+      collectionName: string,
+      locationLabel: string
+    ): Promise<void> {
+      try {
+        const collection = weaviateClient.collections.get(collectionName);
+        const publishedMemory = await fetchMemoryWithAllProperties(
+          collection,
+          compositeId
+        );
+
+        if (!publishedMemory) {
+          results.push({
+            location: locationLabel,
+            status: 'skipped',
+            error: 'Published copy not found (may have been deleted)',
+          });
+          logger.warn('Published copy not found in collection', {
+            function: 'executeReviseMemory',
+            collectionName,
+            compositeId,
+          });
+          return;
+        }
+
+        const oldContent = String(publishedMemory.properties.content ?? '');
+
+        // Build updated revision history (only if content actually changed)
+        let revisionHistory = parseRevisionHistory(
+          publishedMemory.properties.revision_history
+        );
+        if (oldContent !== newContent) {
+          revisionHistory = buildRevisionHistory(
+            revisionHistory,
+            oldContent,
+            revisedAt
+          );
+        }
+
+        const currentRevisionCount =
+          typeof publishedMemory.properties.revision_count === 'number'
+            ? publishedMemory.properties.revision_count
+            : 0;
+
+        await collection.data.update({
+          id: compositeId,
+          properties: {
+            content: newContent,
+            revised_at: revisedAt,
+            revision_count: currentRevisionCount + 1,
+            revision_history: JSON.stringify(revisionHistory),
+          },
+        });
+
+        results.push({ location: locationLabel, status: 'success' });
+
+        logger.info('Revised published memory in collection', {
+          function: 'executeReviseMemory',
+          collectionName,
+          compositeId,
+          revisionCount: currentRevisionCount + 1,
+          contentChanged: oldContent !== newContent,
+        });
+      } catch (err) {
+        results.push({
+          location: locationLabel,
+          status: 'failed',
+          error: err instanceof Error ? err.message : String(err),
+        });
+        logger.error('Failed to revise in collection', {
+          function: 'executeReviseMemory',
+          collectionName,
+          compositeId,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
+
+    // Revise in Memory_spaces_public (single collection for all spaces)
+    if (space_ids.length > 0) {
+      await reviseInCollection(
+        getCollectionName(CollectionType.SPACES),
+        'Memory_spaces_public'
+      );
+    }
+
+    // Revise in each group's collection
+    for (const groupId of group_ids) {
+      await reviseInCollection(
+        getCollectionName(CollectionType.GROUPS, groupId),
+        `Memory_groups_${groupId}`
+      );
+    }
+
+    const successCount = results.filter(r => r.status === 'success').length;
+    const failedCount = results.filter(r => r.status === 'failed').length;
+    const skippedCount = results.filter(r => r.status === 'skipped').length;
+
+    logger.info('Revise execution complete', {
+      function: 'executeReviseMemory',
+      userId,
+      memoryId: memory_id,
+      successCount,
+      failedCount,
+      skippedCount,
+    });
+
+    return JSON.stringify(
+      {
+        success: successCount > 0,
+        composite_id: compositeId,
+        revised_at: revisedAt,
+        summary: {
+          total: results.length,
+          success: successCount,
+          failed: failedCount,
+          skipped: skippedCount,
+        },
+        results,
+        ...(failedCount > 0
+          ? {
+              warnings: [
+                `Failed to revise ${failedCount} of ${results.length} location(s)`,
+              ],
+            }
+          : {}),
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    debug.error('Execute revise failed', {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
+    handleToolError(error, {
+      toolName: 'remember_confirm',
+      userId,
+      operation: 'execute revise_memory',
+      action: 'revise_memory',
+    });
+  }
+}