@prmichaelsen/remember-mcp 2.3.0 → 2.3.4

package/agent/tasks/task-44-implement-remember-retract.md

@@ -0,0 +1,263 @@
+# Task 44: Implement remember_retract Tool
+
+**Milestone**: M11 - Shared Spaces Enhancements (Future)
+**Estimated Time**: 3 hours
+**Dependencies**: M10 (Shared Spaces complete)
+**Status**: Not Started
+
+---
+
+## Objective
+
+Implement the `remember_retract` tool that allows users to unpublish (remove) their memories from shared spaces. Uses the same token-based confirmation pattern as `remember_publish`.
+
+---
+
+## Steps
+
+### 1. Create Tool File
+
+Create `src/tools/retract.ts` with tool definition and handler.
+
+**Actions**:
+- Import required dependencies (token service, Weaviate client, types)
+- Define tool schema with MCP Tool interface
+- Create handler function signature
+- Export both tool definition and handler
+
+**Expected Outcome**: Tool file structure created
+
+### 2. Define Tool Schema
+
+Create MCP tool definition for remember_retract.
+
+**Actions**:
+- Set tool name: `remember_retract`
+- Write clear description for LLM
+- Define input schema with properties:
+  - `space_memory_id` (required): ID of memory in shared space
+  - `space` (required): Space ID (enum: ['the_void'])
+- Add helpful descriptions
+
+**Expected Outcome**: Tool schema complete
+
+### 3. Implement Memory Validation
+
+Verify the space memory exists and user is the author.
+
+**Actions**:
+- Get space Weaviate collection
+- Fetch space memory by ID
+- Check if memory exists
+- Verify `author_id` matches userId (not space_id)
+- Return detailed error if validation fails
+- Include context in error response
+
+**Expected Outcome**: Memory ownership verified
+
+### 4. Create Confirmation Payload
+
+Build the payload to store with the token.
+
+**Actions**:
+- Extract space_memory_id from args
+- Extract space from args
+- Store only IDs (not full content)
+- Keep payload minimal
+
+**Expected Outcome**: Payload structure defined
+
+### 5. Generate Confirmation Token
+
+Use token service to create confirmation request.
+
+**Actions**:
+- Call `confirmationTokenService.createRequest()`
+- Pass userId, action='retract_memory', payload, space
+- Receive requestId and token
+- Handle any errors from token service
+
+**Expected Outcome**: Token generated successfully
+
+### 6. Format Success Response
+
+Return token to agent (minimal response).
+
+**Actions**:
+- Create response object with success flag
+- Include token
+- Keep response minimal (agent already knows memory details)
+- Format as JSON string
+
+**Expected Outcome**: Clear response format
+
+### 7. Update handleConfirm
+
+Add retract action executor to confirm tool.
+
+**Actions**:
+- Open `src/tools/confirm.ts`
+- Add `executeRetractMemory` function
+- Validate token and fetch space memory
+- Verify author_id matches userId
+- Delete memory from space collection
+- Return success with minimal response
+
+**Expected Outcome**: Retract action can be executed
+
+### 8. Implement Error Handling
+
+Handle all error cases gracefully.
+
+**Actions**:
+- Memory not found error
+- Permission denied error (not the author)
+- Invalid space ID error
+- Token service errors
+- Weaviate connection errors
+- Use `handleToolError` utility
+- Include context in all errors
+
+**Expected Outcome**: Comprehensive error handling
+
+### 9. Add Tool to Server
+
+Register tool in both server files.
+
+**Actions**:
+- Import tool in `src/server.ts`
+- Add to tools list in ListToolsRequestSchema handler
+- Add to CallToolRequestSchema handler
+- Repeat for `src/server-factory.ts`
+- Test tool registration
+
+**Expected Outcome**: Tool available in MCP server
+
+### 10. Create Unit Tests
+
+Test the retract tool thoroughly.
+
+**Actions**:
+- Create `src/tools/retract.spec.ts`
+- Test successful token generation
+- Test memory not found error
+- Test permission denied error (wrong author)
+- Test invalid space ID
+- Mock Weaviate and token service
+- Verify response format
+
+**Expected Outcome**: All tests passing
+
+---
+
+## Verification
+
+- [ ] `src/tools/retract.ts` created
+- [ ] Tool schema defined with correct parameters
+- [ ] Memory validation implemented (checks author_id)
+- [ ] Token generation working
+- [ ] Success response formatted correctly
+- [ ] executeRetractMemory added to confirm.ts
+- [ ] Error handling comprehensive
+- [ ] Tool registered in server.ts
+- [ ] Tool registered in server-factory.ts
+- [ ] Unit tests created and passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Tool Schema
+
+```typescript
+export const retractTool = {
+  name: 'remember_retract',
+  description: 'Unpublish a memory from a shared space. The memory will be REMOVED from the shared collection. Generates a confirmation token. Use remember_confirm to execute.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      space_memory_id: {
+        type: 'string',
+        description: 'ID of the memory in the shared space to retract'
+      },
+      space: {
+        type: 'string',
+        description: 'Which space to retract from (snake_case ID)',
+        enum: ['the_void'],
+        default: 'the_void'
+      }
+    },
+    required: ['space_memory_id', 'space']
+  }
+};
+```
+
+---
+
+## Response Format
+
+```json
+{
+  "success": true,
+  "token": "550e8400-e29b-41d4-a716-446655440000"
+}
+```
+
+---
+
+## executeRetractMemory Implementation
+
+```typescript
+async function executeRetractMemory(
+  request: ConfirmationRequest & { request_id: string },
+  userId: string
+): Promise<string> {
+  // Fetch space memory
+  const weaviateClient = getWeaviateClient();
+  const spaceCollection = await ensureSpaceCollection(
+    weaviateClient,
+    request.target_collection || 'the_void'
+  );
+
+  const spaceMemory = await spaceCollection.query.fetchObjectById(
+    request.payload.space_memory_id
+  );
+
+  if (!spaceMemory) {
+    return JSON.stringify({
+      success: false,
+      error: 'Memory not found',
+      message: `Space memory ${request.payload.space_memory_id} no longer exists`,
+    }, null, 2);
+  }
+
+  // Verify user is the author
+  if (spaceMemory.properties.author_id !== userId) {
+    return JSON.stringify({
+      success: false,
+      error: 'Permission denied',
+      message: 'You can only retract your own published memories',
+    }, null, 2);
+  }
+
+  // Delete from space collection
+  await spaceCollection.data.deleteById(request.payload.space_memory_id);
+
+  return JSON.stringify({
+    success: true,
+  }, null, 2);
+}
+```
+
+---
+
+## Related Files
+
+- Design: [`agent/design/publish-tools-confirmation-flow.md`](../design/publish-tools-confirmation-flow.md)
+- Token Service: [`src/services/confirmation-token.service.ts`](../../src/services/confirmation-token.service.ts)
+- Confirm Tool: [`src/tools/confirm.ts`](../../src/tools/confirm.ts)
+- Space Schema: [`src/weaviate/space-schema.ts`](../../src/weaviate/space-schema.ts)
+
+---
+
+**Next Task**: TBD - Part of future milestone for shared spaces enhancements

package/agent/tasks/task-45-fix-publish-false-success-bug.md

@@ -0,0 +1,230 @@
+# Task 45: Fix remember_publish False Success Bug
+
+**Milestone**: M10 - Shared Spaces & Confirmation Flow (Bug Fix)
+**Estimated Time**: 2 hours
+**Dependencies**: M10 (Tasks 34-40)
+**Status**: Not Started
+**Priority**: HIGH - Critical bug, false positive
+
+---
+
+## Objective
+
+Fix the `remember_publish` and `remember_confirm` tools which report `success: true` but do not actually publish memories to The Void. The operation is completely non-functional - no write occurs, no duplication, no error thrown.
+
+---
+
+## Problem Statement
+
+### Symptoms
+- `remember_confirm` returns `success: true`
+- Database shows `Memory_the_void` collection has 0 objects
+- Memory only exists in personal collection (not copied)
+- No error is thrown
+- False positive misleads users and agents
+
+### Impact
+- Core feature completely non-functional
+- False success responses worse than errors (misleading)
+- Breaks agent reliability and user trust
+- No workaround available
+
+---
+
+## Steps
+
+### 1. Verify Collection Exists
+
+Check if `Memory_the_void` collection exists in Weaviate.
+
+**Actions**:
+- Query Weaviate for collection list
+- Check if `Memory_the_void` exists
+- Verify collection schema if it exists
+- Check write permissions
+
+**Expected Outcome**: Collection status determined
+
+### 2. Review executePublishMemory Function
+
+Examine the publish execution logic in confirm.ts.
+
+**Actions**:
+- Open [`src/tools/confirm.ts`](../../src/tools/confirm.ts)
+- Review `executePublishMemory` function
+- Check if `targetCollection.data.insert()` is called
+- Verify result is returned correctly
+- Check error handling
+
+**Expected Outcome**: Code logic understood
+
+### 3. Add Debug Logging
+
+Add logging to track execution flow.
+
+**Actions**:
+- Add log before collection fetch
+- Add log before memory fetch
+- Add log before insert operation
+- Add log after insert with result
+- Log any caught errors
+
+**Expected Outcome**: Execution flow visible
+
+### 4. Test Locally
+
+Run publish workflow with logging enabled.
+
+**Actions**:
+- Create test memory
+- Call remember_publish
+- Call remember_confirm with token
+- Check logs for execution flow
+- Verify if insert is called
+- Check Weaviate for result
+
+**Expected Outcome**: Root cause identified
+
+### 5. Fix the Bug
+
+Implement the fix based on root cause.
+
+**Possible Fixes**:
+- **If collection doesn't exist**: Ensure `ensureSpaceCollection()` creates it
+- **If insert not called**: Fix logic flow to reach insert
+- **If insert fails silently**: Add proper error handling
+- **If permissions issue**: Fix Weaviate configuration
+- **If wrong collection**: Fix collection name generation
+
+**Expected Outcome**: Bug fixed
+
+### 6. Verify Fix
+
+Test that publish actually works.
+
+**Actions**:
+- Create test memory
+- Publish to The Void
+- Confirm publication
+- Query `Memory_the_void` collection
+- Verify memory exists in space
+- Verify original memory unchanged
+- Test search_space finds it
+
+**Expected Outcome**: Publish works correctly
+
+### 7. Add Integration Test
+
+Create test for full publish workflow.
+
+**Actions**:
+- Create integration test file
+- Test: create → publish → confirm → verify in space
+- Test: search_space finds published memory
+- Test: original memory still in personal collection
+- Requires live Weaviate instance
+
+**Expected Outcome**: Integration test passing
+
+### 8. Update Error Handling
+
+Ensure errors are caught and reported.
+
+**Actions**:
+- Add try-catch around insert operation
+- Return detailed error if insert fails
+- Include Weaviate error details
+- Test error scenarios
+
+**Expected Outcome**: Errors reported accurately
+
+### 9. Test Edge Cases
+
+Verify fix handles edge cases.
+
+**Actions**:
+- Test with large memory
+- Test with memory that has relationships
+- Test with memory that has special characters
+- Test concurrent publishes
+- Test expired token
+
+**Expected Outcome**: All edge cases handled
+
+### 10. Update Documentation
+
+Document the fix.
+
+**Actions**:
+- Add to CHANGELOG (patch version)
+- Update any affected documentation
+- Note in progress.yaml
+- Document root cause for future reference
+
+**Expected Outcome**: Fix documented
+
+---
+
+## Verification
+
+- [ ] Root cause identified
+- [ ] Bug fixed in code
+- [ ] Memory actually written to `Memory_the_void`
+- [ ] Published memory discoverable via search_space
+- [ ] Original memory unchanged in personal collection
+- [ ] Error handling accurate (no false positives)
+- [ ] Integration test created
+- [ ] All tests passing
+- [ ] TypeScript compiles
+- [ ] Build successful
+- [ ] Changes committed and pushed
+
+---
+
+## Investigation Checklist
+
+- [ ] Check if `Memory_the_void` collection exists
+- [ ] Verify `ensureSpaceCollection()` is called
+- [ ] Verify `targetCollection.data.insert()` is called
+- [ ] Check if insert returns a result
+- [ ] Verify result is used in response
+- [ ] Check server logs for errors
+- [ ] Test with actual Weaviate instance
+- [ ] Verify Weaviate write permissions
+
+---
+
+## Expected Fix
+
+The bug is likely in [`src/tools/confirm.ts`](../../src/tools/confirm.ts) in the `executePublishMemory` function. The insert operation may not be executing or may be failing silently.
+
+**Likely Issue**: Missing await, incorrect API usage, or silent error
+
+**Expected Code**:
+```typescript
+const result = await targetCollection.data.insert({
+  properties: publishedMemory as any,
+});
+
+// Verify result
+if (!result) {
+  throw new Error('Failed to insert memory into space collection');
+}
+
+return JSON.stringify({
+  success: true,
+  space_memory_id: result,
+}, null, 2);
+```
+
+---
+
+## Related Files
+
+- Confirm Tool: [`src/tools/confirm.ts`](../../src/tools/confirm.ts)
+- Space Schema: [`src/weaviate/space-schema.ts`](../../src/weaviate/space-schema.ts)
+- Design: [`agent/design/publish-tools-confirmation-flow.md`](../design/publish-tools-confirmation-flow.md)
+
+---
+
+**Next Task**: Investigate and fix immediately - blocks shared spaces feature

package/dist/server-factory.js

@@ -1211,6 +1211,13 @@ var createMemoryTool = {
   Each memory has a weight (significance 0-1) and trust level (access control 0-1).
   Location and context are automatically captured from the request.
   
+  **IMPORTANT - Content vs Summary**:
+  - **content**: MUST be EXACT user-provided text. DO NOT paraphrase or modify.
+  - **summary**: Use for AI-generated summaries or interpretations.
+  - Example: User says "Remember: Meeting at 3pm tomorrow"
+    \u2192 content: "Meeting at 3pm tomorrow" (EXACT)
+    \u2192 summary: "User has meeting on 2026-02-17 at 15:00" (AI interpretation)
+  
   Examples:
   - "Remember that I met Sarah at the conference"
   - "Save this recipe for chocolate chip cookies"
@@ -3248,7 +3255,18 @@ var ConfirmationTokenService = class {
       status: "pending"
     };
     const collectionPath = `users/${userId}/requests`;
+    console.log("[ConfirmationTokenService] Creating request:", {
+      userId,
+      action,
+      targetCollection,
+      collectionPath
+    });
     const docRef = await addDocument(collectionPath, request);
+    console.log("[ConfirmationTokenService] Request created:", {
+      requestId: docRef.id,
+      token,
+      expiresAt: request.expires_at
+    });
     return { requestId: docRef.id, token };
   }
   /**
@@ -3260,6 +3278,11 @@ var ConfirmationTokenService = class {
    */
   async validateToken(userId, token) {
     const collectionPath = `users/${userId}/requests`;
+    console.log("[ConfirmationTokenService] Validating token:", {
+      userId,
+      token,
+      collectionPath
+    });
     const queryOptions = {
       where: [
         { field: "token", op: "==", value: token },
@@ -3268,13 +3291,25 @@ var ConfirmationTokenService = class {
       limit: 1
     };
     const results = await queryDocuments(collectionPath, queryOptions);
+    console.log("[ConfirmationTokenService] Query results:", {
+      resultsFound: results.length,
+      hasResults: results.length > 0
+    });
     if (results.length === 0) {
+      console.log("[ConfirmationTokenService] Token not found or not pending");
       return null;
     }
     const doc = results[0];
     const request = doc.data;
+    console.log("[ConfirmationTokenService] Request found:", {
+      requestId: doc.id,
+      action: request.action,
+      status: request.status,
+      expiresAt: request.expires_at
+    });
     const expiresAt = new Date(request.expires_at);
     if (expiresAt.getTime() < Date.now()) {
+      console.log("[ConfirmationTokenService] Token expired");
       await this.updateStatus(userId, doc.id, "expired");
       return null;
     }
@@ -3573,7 +3608,14 @@ var publishTool = {
 };
 async function handlePublish(args, userId) {
   try {
+    console.log("[remember_publish] Starting publish request:", {
+      userId,
+      memoryId: args.memory_id,
+      target: args.target,
+      additionalTags: args.additional_tags?.length || 0
+    });
     if (!isValidSpaceId(args.target)) {
+      console.log("[remember_publish] Invalid space ID:", args.target);
       return JSON.stringify(
         {
           success: false,
@@ -3589,11 +3631,16 @@ async function handlePublish(args, userId) {
       );
     }
     const weaviateClient = getWeaviateClient();
-    const userCollection = weaviateClient.collections.get(
-      getMemoryCollectionName(userId)
-    );
+    const collectionName = getMemoryCollectionName(userId);
+    console.log("[remember_publish] Fetching memory from collection:", collectionName);
+    const userCollection = weaviateClient.collections.get(collectionName);
     const memory = await userCollection.query.fetchObjectById(args.memory_id);
+    console.log("[remember_publish] Memory fetch result:", {
+      found: !!memory,
+      memoryId: args.memory_id
+    });
     if (!memory) {
+      console.log("[remember_publish] Memory not found");
       return JSON.stringify(
         {
           success: false,
@@ -3643,12 +3690,18 @@ async function handlePublish(args, userId) {
       memory_id: args.memory_id,
       additional_tags: args.additional_tags || []
     };
+    console.log("[remember_publish] Generating confirmation token");
     const { requestId, token } = await confirmationTokenService.createRequest(
       userId,
       "publish_memory",
       payload,
       args.target
     );
+    console.log("[remember_publish] Token generated:", {
+      requestId,
+      token,
+      action: "publish_memory"
+    });
     return JSON.stringify(
       {
         success: true,
@@ -3685,8 +3738,17 @@ var confirmTool = {
 };
 async function handleConfirm(args, userId) {
   try {
+    console.log("[remember_confirm] Starting confirmation:", {
+      userId,
+      token: args.token
+    });
     const request = await confirmationTokenService.confirmRequest(userId, args.token);
+    console.log("[remember_confirm] Token validation result:", {
+      requestFound: !!request,
+      action: request?.action
+    });
     if (!request) {
+      console.log("[remember_confirm] Token invalid or expired");
       return JSON.stringify(
         {
           success: false,
@@ -3697,6 +3759,7 @@ async function handleConfirm(args, userId) {
         2
       );
     }
+    console.log("[remember_confirm] Executing action:", request.action);
     if (request.action === "publish_memory") {
       return await executePublishMemory(request, userId);
     }
@@ -3712,14 +3775,25 @@ async function handleConfirm(args, userId) {
 }
 async function executePublishMemory(request, userId) {
   try {
+    console.log("[executePublishMemory] Starting execution:", {
+      userId,
+      memoryId: request.payload.memory_id,
+      targetSpace: request.target_collection
+    });
     const weaviateClient = getWeaviateClient();
     const userCollection = weaviateClient.collections.get(
       getMemoryCollectionName(userId)
     );
+    console.log("[executePublishMemory] Fetching original memory from:", getMemoryCollectionName(userId));
     const originalMemory = await userCollection.query.fetchObjectById(
       request.payload.memory_id
     );
+    console.log("[executePublishMemory] Original memory fetch result:", {
+      found: !!originalMemory,
+      memoryId: request.payload.memory_id
+    });
     if (!originalMemory) {
+      console.log("[executePublishMemory] Memory not found");
       return JSON.stringify(
         {
           success: false,
@@ -3731,6 +3805,7 @@ async function executePublishMemory(request, userId) {
       );
     }
     if (originalMemory.properties.user_id !== userId) {
+      console.log("[executePublishMemory] Permission denied - wrong owner");
       return JSON.stringify(
         {
           success: false,
@@ -3741,18 +3816,20 @@ async function executePublishMemory(request, userId) {
         2
       );
     }
+    console.log("[executePublishMemory] Ensuring space collection:", request.target_collection || "the_void");
     const targetCollection = await ensureSpaceCollection(
       weaviateClient,
       request.target_collection || "the_void"
     );
+    console.log("[executePublishMemory] Space collection ready");
     const originalTags = Array.isArray(originalMemory.properties.tags) ? originalMemory.properties.tags : [];
     const additionalTags = Array.isArray(request.payload.additional_tags) ? request.payload.additional_tags : [];
     const publishedMemory = {
       ...originalMemory.properties,
-      // Override specific fields
+      // Add space-specific fields
       space_id: request.target_collection || "the_void",
       author_id: userId,
-      // Always attributed
+      // Track original author
       published_at: (/* @__PURE__ */ new Date()).toISOString(),
       discovery_count: 0,
       doc_type: "space_memory",
@@ -3764,8 +3841,17 @@ async function executePublishMemory(request, userId) {
       updated_at: (/* @__PURE__ */ new Date()).toISOString(),
       version: 1
     };
-    const result = await targetCollection.data.insert({
-      properties: publishedMemory
+    console.log("[executePublishMemory] Inserting into space collection:", {
+      spaceId: request.target_collection || "the_void",
+      memoryId: request.payload.memory_id,
+      hasUserId: !!publishedMemory.user_id,
+      hasAuthorId: !!publishedMemory.author_id,
+      hasSpaceId: !!publishedMemory.space_id
+    });
+    const result = await targetCollection.data.insert(publishedMemory);
+    console.log("[executePublishMemory] Insert result:", {
+      success: !!result,
+      spaceMemoryId: result
     });
     return JSON.stringify(
       {