@prmichaelsen/remember-mcp 2.6.2 → 2.6.3

package/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.6.3] - 2026-02-16
+
+### 🐛 Fixed
+
+- **CRITICAL: Fixed Empty Published Memories Bug**
+  - Published memories were empty shells with no content, title, or properties
+  - Root cause: `fetchObjectById()` calls missing `returnProperties` parameter
+  - Fixed in `remember_publish` and `remember_confirm` (executePublishMemory)
+  - All published memories now include complete property data
+
+### ✨ Added
+
+- **New Utility Function**: `fetchMemoryWithAllProperties()`
+  - Centralized helper in `src/weaviate/client.ts`
+  - Ensures all memory properties are fetched consistently
+  - Prevents future bugs from missing properties
+  - Includes `ALL_MEMORY_PROPERTIES` constant (20+ properties)
+
+### 🔧 Improved
+
+- Enhanced debug logging in publish flow
+  - Added property count verification
+  - Added hasTitle and hasContent checks
+  - Better diagnostics for troubleshooting
+
+### 🎯 Impact
+
+- **Fixes**: All published memories since v2.4.0 were empty
+- **Search**: Published memories now searchable (have content)
+- **Discovery**: Space functionality now works as designed
+- **Note**: Existing empty memories need to be re-published
+
+---
+
 ## [2.6.2] - 2026-02-16
 
 ### 🔒 Security

package/agent/progress.yaml

@@ -2,10 +2,10 @@
 
 project:
   name: remember-mcp
-  version: 2.5.1
+  version: 2.6.3
   started: 2026-02-11
   status: in_progress
-  current_milestone: M11
+  current_milestone: M12
   last_updated: 2026-02-16
 
 milestones:
@@ -162,7 +162,26 @@ milestones:
       ✅ No memory duplication across spaces
       ✅ All tests passing with multi-space support
       ✅ Documentation updated with multi-space examples
-    
+     
+  - id: M12
+    name: Comment System (Phase 1)
+    status: in_progress
+    progress: 60%
+    started: 2026-02-16
+    completed: null
+    estimated_weeks: 1
+    tasks_completed: 3
+    tasks_total: 5
+    notes: |
+      ✅ Task 55: Added 3 comment fields to schema (parent_id, thread_root_id, moderation_flags)
+      ✅ Task 56: Updated remember_search_space with include_comments parameter
+      ✅ Task 57: Updated remember_query_space with include_comments parameter
+      📋 Task 58: Add Comment Unit Tests (pending)
+      📋 Task 59: Update Documentation for Comments (pending)
+      ✅ Zero new tools required - reuses existing infrastructure
+      ✅ Backward compatible - comments excluded by default
+      ✅ Released v2.6.0 with comment system foundation
+     
   - id: M7
     name: Trust & Permissions
     status: not_started
@@ -406,11 +425,97 @@ tasks:
         ✅ Context inclusion toggle
         ✅ Integrated into server.ts and server-factory.ts
 
+  milestone_12:
+    - id: task-55
+      name: Add Comment Fields to Weaviate Schema
+      status: completed
+      file: agent/tasks/task-55-add-comment-fields-to-schema.md
+      estimated_hours: 2
+      completed_date: 2026-02-16
+      notes: |
+        ✅ Added 3 fields to Memory schema: parent_id, thread_root_id, moderation_flags
+        ✅ Added same fields to Memory_public collection
+        ✅ Enables infinite comment nesting
+        ✅ Per-space moderation support
+        ✅ Released in v2.6.0
+      
+    - id: task-56
+      name: Update remember_search_space for Comments
+      status: completed
+      file: agent/tasks/task-56-update-search-space-for-comments.md
+      estimated_hours: 2
+      completed_date: 2026-02-16
+      notes: |
+        ✅ Added include_comments parameter (default: false)
+        ✅ Comments excluded from search by default
+        ✅ Opt-in via include_comments: true
+        ✅ Backward compatible
+        ✅ Released in v2.6.0
+      
+    - id: task-57
+      name: Update remember_query_space for Comments
+      status: completed
+      file: agent/tasks/task-57-update-query-space-for-comments.md
+      estimated_hours: 1
+      completed_date: 2026-02-16
+      notes: |
+        ✅ Added include_comments parameter (default: false)
+        ✅ Same filtering logic as search_space
+        ✅ Backward compatible
+        ✅ Released in v2.6.0
+      
+    - id: task-58
+      name: Add Comment Unit Tests
+      status: not_started
+      file: agent/tasks/task-58-add-comment-unit-tests.md
+      estimated_hours: 3
+      notes: |
+        📋 Pending: Schema tests, filtering tests, edge cases
+        📋 Test infinite nesting support
+        📋 Test moderation flags
+      
+    - id: task-59
+      name: Update Documentation for Comments
+      status: not_started
+      file: agent/tasks/task-59-update-documentation-for-comments.md
+      estimated_hours: 2
+      notes: |
+        📋 Pending: README updates, CHANGELOG entry, examples
+        📋 Document comment creation workflow
+        📋 Add threading examples
+      
+    - id: task-60
+      name: Standardize Structured Logging
+      status: completed
+      file: agent/tasks/task-60-standardize-structured-logging.md
+      estimated_hours: 3
+      completed_date: 2026-02-16
+      notes: |
+        ✅ Replaced 54 console.log/error/warn calls with structured logger
+        ✅ Updated 8 files: confirmation-token.service, publish, confirm, deny, weaviate client/schema/space-schema, firestore init, config
+        ✅ All logs include context objects (service, module, tool names)
+        ✅ Fixed circular dependency in config.ts with dynamic import
+        ✅ Released in v2.6.1
+      
+    - id: task-61
+      name: Enhance Confirmation Tool Safety Guidelines
+      status: completed
+      file: agent/tasks/task-61-enhance-confirmation-tool-descriptions.md
+      estimated_hours: 1
+      completed_date: 2026-02-16
+      notes: |
+        ✅ Enhanced remember_confirm tool description with 5 critical safety requirements
+        ✅ Enhanced remember_deny tool description with same safety guidelines
+        ✅ Added JSDoc comments explaining proper workflow
+        ✅ Prevents agents from bypassing user consent
+        ✅ Visual indicators (⚠️) for critical requirements
+        ✅ Released in v2.6.2
+
 documentation:
   design_documents: 23
-  milestone_documents: 10
+  milestone_documents: 11
   pattern_documents: 5
-  task_documents: 33
+  task_documents: 61
 
 progress:
   planning: 100%
@@ -418,6 +523,33 @@ progress:
   overall: 50%
 
 recent_work:
+  - date: 2026-02-16
+    description: Comment System, Structured Logging, and Safety Guidelines (v2.6.0-v2.6.2)
+    items:
+      - 🎉 M12 STARTED: Comment System (Phase 1) - 60% complete (3/5 tasks)
+      - ✅ Task 55: Added 3 comment fields to Weaviate schema
+      - ✅ parent_id, thread_root_id, moderation_flags fields added
+      - ✅ Enables infinite comment nesting with no depth limit
+      - ✅ Per-space moderation flags support
+      - ✅ Task 56: Updated remember_search_space with include_comments parameter
+      - ✅ Comments excluded by default for clean discovery
+      - ✅ Opt-in via include_comments: true
+      - ✅ Task 57: Updated remember_query_space with include_comments parameter
+      - ✅ Same filtering logic as search_space
+      - ✅ Released v2.6.0 with comment system foundation
+      - ✅ Task 60: Standardized structured logging across 8 files
+      - ✅ Replaced 54 console.log/error/warn calls with logger.info/error/warn/debug
+      - ✅ All logs include context objects (service, module, tool names)
+      - ✅ Fixed circular dependency in config.ts with dynamic import
+      - ✅ Released v2.6.1 with structured logging
+      - ✅ Task 61: Enhanced confirmation tool safety guidelines
+      - ✅ Added 5 critical safety requirements to remember_confirm and remember_deny
+      - ✅ Prevents agents from chaining confirmations without user consent
+      - ✅ Visual indicators (⚠️) and JSDoc comments added
+      - ✅ Released v2.6.2 with safety enhancements
+      - 📋 Next: Complete M12 with Tasks 58-59 (tests + documentation)
+      - 📋 6 commits ready to push to origin
+      
   - date: 2026-02-16
     description: ACP Initialization Complete - Multi-Space Architecture Verified (v2.5.1)
     items:
@@ -743,18 +875,21 @@ recent_work:
       - ✅ Build successful
 
 next_steps:
-  - Deploy v2.5.1 to Cloud Run and verify multi-space functionality
-  - Test multi-space publishing workflow end-to-end
-  - Test multi-space search across multiple spaces
-  - Verify Firestore request creation with enhanced error handling
-  - Check Cloud Run logs for diagnostic output from ConfirmationTokenService
-  - Consider implementing comment system (v2.6.0) - 3 schema fields only!
+  - Complete Task 58: Add Comment Unit Tests (3 hours)
+  - Complete Task 59: Update Documentation for Comments (2 hours)
+  - Push 6 commits to origin (v2.6.0, v2.6.1, v2.6.2)
+  - Deploy v2.6.2 to Cloud Run
+  - Test comment system end-to-end (create, search, thread fetching)
+  - Test structured logging in Cloud Run logs
+  - Verify confirmation tool safety guidelines in production
+  - Complete M12: Comment System (Phase 1)
   - Start M5: Template System (15 default templates + auto-suggestion)
   - Optional: Create integration tests (Task 6)
   - Optional: Add development documentation (Task 7)
   - Consider M6: Auth & Multi-Tenancy
 
 notes:
+  - 🚀 Milestone 12 (Comment System Phase 1) IN PROGRESS - 60% complete!
   - 🎉 Milestone 11 (Unified Public Collection) COMPLETED!
   - 🎉 Milestone 10 (Shared Spaces & Confirmation Flow) COMPLETED!
   - 🎉 Milestone 4 (User Preferences) COMPLETED!
@@ -769,6 +904,10 @@ notes:
   - ✅ M4: 2/2 preference tools complete (100% progress)
   - ✅ M10: 10/10 shared space tools complete (100% progress)
   - ✅ M11: 9/9 multi-space architecture tasks complete (100% progress)
+  - 🚀 M12: 3/5 comment system tasks complete (60% progress)
+  - ✅ Comment system foundation implemented (v2.6.0)
+  - ✅ Structured logging standardized (v2.6.1)
+  - ✅ Confirmation tool safety enhanced (v2.6.2)
   - ✅ Complete memory CRUD operations (create, read, update, delete)
   - ✅ Complete relationship CRUD operations (create, read, update, delete)
   - ✅ Advanced search capabilities (hybrid, similarity, RAG queries)
@@ -833,8 +972,10 @@ build_status:
   - ✅ Source maps generated
   - ✅ Type definitions generated (.d.ts files)
   - ✅ Package exports configured for both entry points
-  - ✅ Version 2.0.1 published (patch release - error logging)
-  - ✅ 30 TypeScript source files (added error-handler.ts)
+  - ✅ Version 2.6.2 published (patch release - safety guidelines)
+  - ✅ Version 2.6.1 published (patch release - structured logging)
+  - ✅ Version 2.6.0 published (minor release - comment system)
+  - ✅ 30 TypeScript source files
   - ✅ All 12 tools implemented
   - ✅ Weaviate v3 filter API implemented
   - ✅ Or/And operator validation implemented
@@ -857,6 +998,12 @@ tools_status:
   preference_tools:
     - ✅ remember_set_preference (src/tools/set-preference.ts)
     - ✅ remember_get_preferences (src/tools/get-preferences.ts)
+  space_tools:
+    - ✅ remember_publish (src/tools/publish.ts) - Multi-space support
+    - ✅ remember_confirm (src/tools/confirm.ts) - Enhanced safety guidelines
+    - ✅ remember_deny (src/tools/deny.ts) - Enhanced safety guidelines
+    - ✅ remember_search_space (src/tools/search-space.ts) - Comment filtering
+    - ✅ remember_query_space (src/tools/query-space.ts) - Comment filtering
 
 implementation_notes:
   - All 12 core tools implemented and integrated
@@ -899,3 +1046,6 @@ task_20_completion:
   releases:
     - v1.0.0: Major release with breaking change (async createServer)
     - v1.0.1: Patch release with Or operator bug fix
+    - v2.6.0: Minor release with comment system foundation
+    - v2.6.1: Patch release with structured logging
+    - v2.6.2: Patch release with confirmation tool safety guidelines

package/agent/tasks/task-62-fix-confirmation-response-storage.md

@@ -0,0 +1,323 @@
+# Task 62: Fix Confirmation Response Storage
+
+**Milestone**: M12 (Comment System / Bug Fixes)
+**Estimated Time**: 2 hours
+**Dependencies**: None
+**Status**: Not Started
+**Priority**: High
+
+---
+
+## Objective
+
+Fix bug where `remember_confirm` executes actions successfully but doesn't store the response data in the Firestore confirmation record. This prevents agents and users from verifying action results and breaks the audit trail.
+
+---
+
+## Context
+
+**Current Behavior:**
+1. `remember_confirm` validates token and marks request as "confirmed"
+2. Action executes successfully (e.g., `executePublishMemory`)
+3. Response data (space_memory_id, etc.) is returned to agent
+4. **BUG**: Response data is NOT saved to Firestore
+5. Database record shows `status: confirmed` but no response/result data
+
+**Impact:**
+- ⚠️ Agents cannot verify publication success
+- ⚠️ No space_memory_id available for reference
+- ⚠️ Audit trail incomplete
+- ⚠️ Cannot track what happened after confirmation
+
+**Root Cause:**
+- `ConfirmationRequest` interface lacks `response` field
+- `confirmRequest()` method only updates status, not response
+- `executePublishMemory()` returns data but doesn't persist it
+
+---
+
+## Steps
+
+### 1. Update ConfirmationRequest Interface
+
+Add response field to store action results:
+
+```typescript
+// src/services/confirmation-token.service.ts
+
+export interface ConfirmationRequest {
+  user_id: string;
+  token: string;
+  action: string;
+  target_collection?: string;
+  payload: any;
+  created_at: string;
+  expires_at: string;
+  status: 'pending' | 'confirmed' | 'denied' | 'expired' | 'retracted';
+  confirmed_at?: string;
+  response?: any;  // ✅ ADD THIS - Stores action execution result
+}
+```
+
+### 2. Add storeResponse Method
+
+Create method to store response data after action execution:
+
+```typescript
+// src/services/confirmation-token.service.ts
+
+/**
+ * Store response data for a confirmed request
+ * 
+ * @param userId - User ID
+ * @param requestId - Request ID
+ * @param response - Response data from action execution
+ */
+async storeResponse(
+  userId: string,
+  requestId: string,
+  response: any
+): Promise<void> {
+  logger.info('Storing confirmation response', {
+    service: 'ConfirmationTokenService',
+    userId,
+    requestId,
+    hasResponse: !!response,
+  });
+
+  const docPath = `users/${userId}/requests/${requestId}`;
+  
+  await updateDocument(docPath, {
+    response,
+    updated_at: new Date().toISOString(),
+  });
+  
+  logger.info('Response stored successfully', {
+    service: 'ConfirmationTokenService',
+    requestId,
+  });
+}
+```
+
+### 3. Update handleConfirm to Store Response
+
+Modify `remember_confirm` to persist response data:
+
+```typescript
+// src/tools/confirm.ts
+
+export async function handleConfirm(
+  args: ConfirmArgs,
+  userId: string
+): Promise<string> {
+  try {
+    logger.info('Starting confirmation', {
+      tool: 'remember_confirm',
+      userId,
+      token: args.token,
+    });
+    
+    // Validate and confirm token
+    const request = await confirmationTokenService.confirmRequest(userId, args.token);
+    
+    if (!request) {
+      logger.info('Token invalid or expired', {
+        tool: 'remember_confirm',
+        userId,
+      });
+      return JSON.stringify({
+        success: false,
+        error: 'Invalid or expired token',
+        message: 'The confirmation token is invalid, expired, or has already been used.',
+      }, null, 2);
+    }
+
+    logger.info('Executing confirmed action', {
+      tool: 'remember_confirm',
+      action: request.action,
+      userId,
+    });
+
+    // Execute action based on type
+    let responseJson: string;
+    if (request.action === 'publish_memory') {
+      responseJson = await executePublishMemory(request, userId);
+    } else {
+      throw new Error(`Unknown action type: ${request.action}`);
+    }
+
+    // ✅ NEW: Parse and store response data
+    try {
+      const responseData = JSON.parse(responseJson);
+      
+      logger.info('Storing action response', {
+        tool: 'remember_confirm',
+        requestId: request.request_id,
+        success: responseData.success,
+      });
+      
+      await confirmationTokenService.storeResponse(
+        userId,
+        request.request_id,
+        responseData
+      );
+      
+      logger.info('Response stored successfully', {
+        tool: 'remember_confirm',
+        requestId: request.request_id,
+      });
+    } catch (parseError) {
+      logger.warn('Failed to parse/store response', {
+        tool: 'remember_confirm',
+        error: parseError instanceof Error ? parseError.message : String(parseError),
+      });
+      // Don't fail the whole operation if storage fails
+    }
+
+    // Return response to agent
+    return responseJson;
+  } catch (error) {
+    handleToolError(error, {
+      toolName: 'remember_confirm',
+      userId,
+      operation: 'confirm action',
+      token: args.token,
+    });
+  }
+}
+```
+
+### 4. Update Tests
+
+Add tests for response storage:
+
+```typescript
+// tests/unit/confirmation-token.service.test.ts
+
+describe('ConfirmationTokenService', () => {
+  describe('storeResponse', () => {
+    it('should store response data for confirmed request', async () => {
+      const service = new ConfirmationTokenService();
+      const userId = 'test-user';
+      const requestId = 'test-request';
+      const response = {
+        success: true,
+        space_memory_id: 'space-123',
+        spaces: ['the_void'],
+      };
+
+      await service.storeResponse(userId, requestId, response);
+
+      // Verify response was stored
+      const request = await getDocument(`users/${userId}/requests/${requestId}`);
+      expect(request.response).toEqual(response);
+      expect(request.updated_at).toBeDefined();
+    });
+  });
+});
+```
+
+### 5. Update Documentation
+
+Document the response field in design docs:
+
+```markdown
+# agent/design/publish-tools-confirmation-flow.md
+
+## Confirmation Record Structure
+
+After confirmation, the record includes:
+- `status`: 'confirmed'
+- `confirmed_at`: ISO timestamp
+- `response`: Action execution result (NEW)
+  - For publish_memory: { success, space_memory_id, spaces }
+  - For other actions: Action-specific response data
+```
+
+---
+
+## Verification
+
+- [ ] ConfirmationRequest interface has `response?: any` field
+- [ ] `storeResponse()` method exists in ConfirmationTokenService
+- [ ] `handleConfirm` calls `storeResponse()` after action execution
+- [ ] Response data is persisted to Firestore
+- [ ] Agent receives response data in tool output
+- [ ] Database record contains response field after confirmation
+- [ ] Tests pass for response storage
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+- [ ] Manual test: Publish memory and verify response in Firestore
+
+---
+
+## Expected Output
+
+**Before Fix:**
+```json
+{
+  "status": "confirmed",
+  "confirmed_at": "2026-02-16T21:44:39.154Z",
+  "action": "publish_memory",
+  "payload": { "memory_id": "...", "spaces": ["the_void"] }
+  // ❌ No response field
+}
+```
+
+**After Fix:**
+```json
+{
+  "status": "confirmed",
+  "confirmed_at": "2026-02-16T21:44:39.154Z",
+  "action": "publish_memory",
+  "payload": { "memory_id": "...", "spaces": ["the_void"] },
+  "response": {
+    "success": true,
+    "space_memory_id": "9b536938-1188-4e69-b3cd-4362d84fff1c",
+    "spaces": ["the_void"]
+  }
+}
+```
+
+---
+
+## Common Issues and Solutions
+
+### Issue 1: Response not storing
+
+**Cause**: Parse error or Firestore write failure
+**Solution**: Check logs for errors, verify Firestore permissions
+
+### Issue 2: Response field undefined
+
+**Cause**: Old records don't have response field
+**Solution**: This is expected - only new confirmations will have response
+
+### Issue 3: Response too large for Firestore
+
+**Cause**: Response data exceeds Firestore document size limit (1MB)
+**Solution**: Store only essential fields (space_memory_id, success, spaces)
+
+---
+
+## Resources
+
+- [Firestore Document Limits](https://firebase.google.com/docs/firestore/quotas)
+- [ConfirmationTokenService](../src/services/confirmation-token.service.ts)
+- [remember_confirm Tool](../src/tools/confirm.ts)
+- [Confirmation Flow Design](../design/publish-tools-confirmation-flow.md)
+
+---
+
+## Notes
+
+- This is a backward-compatible change - old records without response field will continue to work
+- Response storage is best-effort - if it fails, the action still succeeds
+- Response data is primarily for audit trail and debugging
+- Agents receive response data regardless of storage success
+- Consider adding response field to remember_deny as well (for consistency)
+
+---
+
+**Status**: Not Started
+**Recommendation**: Implement this fix before completing M12 to ensure proper audit trail

package/agent/tasks/task-63-fix-fetchobjectbyid-missing-properties.md

@@ -0,0 +1,397 @@
+# Task 63: Fix fetchObjectById Missing Properties in Publish Flow
+
+**Milestone**: M12 (Bug Fixes)
+**Estimated Time**: 1 hour
+**Dependencies**: None
+**Status**: Not Started
+**Priority**: CRITICAL 🚨
+
+---
+
+## Objective
+
+Fix critical bug where `remember_publish` and `remember_confirm` (executePublishMemory) fail to fetch all memory properties because they don't specify `returnProperties` parameter in `fetchObjectById()` calls. This causes published memories to be empty shells with only metadata and vectors.
+
+---
+
+## Context
+
+**Critical Bug Discovered**: Published memories in `Memory_public` have no content!
+
+**Symptom**:
+- Space memory created with ID ✅
+- Vector embedding generated ✅
+- Metadata exists ✅
+- **All properties missing** ❌ (no title, content, tags, etc.)
+
+**Root Cause**:
+Weaviate v3 API `fetchObjectById()` requires explicit `returnProperties` parameter. Without it, only metadata is returned, not the actual property values.
+
+**Affected Code**:
+1. [`src/tools/publish.ts:125`](src/tools/publish.ts) - `remember_publish` tool
+2. [`src/tools/confirm.ts:154`](src/tools/confirm.ts) - `executePublishMemory` function
+
+**Evidence**:
+All other tools correctly specify `returnProperties`:
+- `update-relationship.ts:100` ✅ Specifies properties
+- `create-relationship.ts:119` ✅ Specifies properties  
+- `find-similar.ts:120` ✅ Specifies properties
+- `update-memory.ts:119` ✅ Specifies properties
+- `delete-relationship.ts:66` ✅ Specifies properties
+- `delete-memory.ts:72` ✅ Specifies properties
+- **`publish.ts:125`** ❌ Missing returnProperties
+- **`confirm.ts:154`** ❌ Missing returnProperties
+
+---
+
+## Steps
+
+### 1. Create Utility Function for Consistent Property Fetching
+
+Create a helper function to ensure all memory properties are always fetched:
+
+```typescript
+// src/weaviate/client.ts (add after existing functions)
+
+/**
+ * List of all memory properties to fetch
+ * Centralized to ensure consistency across all tools
+ */
+export const ALL_MEMORY_PROPERTIES = [
+  'user_id',
+  'doc_type',
+  'type',
+  'title',
+  'content',
+  'tags',
+  'weight',
+  'base_weight',
+  'trust_level',
+  'context',
+  'location',
+  'relationships',
+  'created_at',
+  'updated_at',
+  'version',
+  'attribution',
+  'source_url',
+  'author',
+  'parent_id',
+  'thread_root_id',
+  'moderation_flags',
+] as const;
+
+/**
+ * Fetch a memory object by ID with all properties
+ *
+ * @param collection - Weaviate collection
+ * @param memoryId - Memory ID to fetch
+ * @returns Memory object with all properties
+ */
+export async function fetchMemoryWithAllProperties(
+  collection: any,
+  memoryId: string
+) {
+  return await collection.query.fetchObjectById(memoryId, {
+    returnProperties: ALL_MEMORY_PROPERTIES,
+  });
+}
+```
+
+### 2. Fix remember_publish Tool
+
+Update `fetchObjectById` call to return all properties:
+
+```typescript
+// src/tools/publish.ts (around line 125)
+
+// BEFORE (BROKEN):
+const memory = await userCollection.query.fetchObjectById(args.memory_id);
+
+// AFTER (FIXED):
+const memory = await userCollection.query.fetchObjectById(args.memory_id, {
+  returnProperties: [
+    'user_id',
+    'doc_type',
+    'type',
+    'title',
+    'content',
+    'tags',
+    'weight',
+    'base_weight',
+    'trust_level',
+    'context',
+    'location',
+    'relationships',
+    'created_at',
+    'updated_at',
+    'version',
+    'attribution',
+    'source_url',
+    'author',
+    'parent_id',
+    'thread_root_id',
+    'moderation_flags',
+  ],
+});
+```
+
+### 2. Fix executePublishMemory in remember_confirm
+
+Update `fetchObjectById` call in confirm tool:
+
+```typescript
+// src/tools/confirm.ts (around line 154)
+
+// BEFORE (BROKEN):
+const originalMemory = await userCollection.query.fetchObjectById(
+  request.payload.memory_id
+);
+
+// AFTER (FIXED):
+const originalMemory = await userCollection.query.fetchObjectById(
+  request.payload.memory_id,
+  {
+    returnProperties: [
+      'user_id',
+      'doc_type',
+      'type',
+      'title',
+      'content',
+      'tags',
+      'weight',
+      'base_weight',
+      'trust_level',
+      'context',
+      'location',
+      'relationships',
+      'created_at',
+      'updated_at',
+      'version',
+      'attribution',
+      'source_url',
+      'author',
+      'parent_id',
+      'thread_root_id',
+      'moderation_flags',
+    ],
+  }
+);
+```
+
+### 3. Add Logging to Verify Properties
+
+Add debug logging to confirm properties are fetched:
+
+```typescript
+// src/tools/confirm.ts (after fetch)
+
+logger.debug('Original memory fetch result', {
+  function: 'executePublishMemory',
+  found: !!originalMemory,
+  memoryId: request.payload.memory_id,
+  hasProperties: !!originalMemory?.properties,
+  propertyCount: originalMemory?.properties ? Object.keys(originalMemory.properties).length : 0,
+  hasTitle: !!originalMemory?.properties?.title,
+  hasContent: !!originalMemory?.properties?.content,
+});
+```
+
+### 4. Test the Fix
+
+Manual test to verify properties are copied:
+
+```bash
+# 1. Create a test memory
+remember_create_memory({
+  type: "note",
+  title: "Test Memory",
+  content: "This is test content",
+  tags: ["test"]
+})
+
+# 2. Publish it
+remember_publish({
+  memory_id: "<memory_id>",
+  spaces: ["the_void"]
+})
+
+# 3. Confirm publication
+remember_confirm({
+  token: "<token>"
+})
+
+# 4. Search for it
+remember_search_space({
+  spaces: ["the_void"],
+  query: "test content",
+  include_comments: false
+})
+
+# 5. Verify result has title, content, tags
+```
+
+### 5. Update Tests
+
+Add test case for property copying:
+
+```typescript
+// tests/unit/publish.test.ts
+
+describe('remember_publish', () => {
+  it('should fetch all memory properties', async () => {
+    const mockMemory = {
+      properties: {
+        user_id: 'test-user',
+        title: 'Test Title',
+        content: 'Test Content',
+        tags: ['tag1', 'tag2'],
+        // ... all properties
+      },
+    };
+
+    mockCollection.query.fetchObjectById.mockResolvedValue(mockMemory);
+
+    await handlePublish({ memory_id: 'test-id', spaces: ['the_void'] }, 'test-user');
+
+    expect(mockCollection.query.fetchObjectById).toHaveBeenCalledWith(
+      'test-id',
+      expect.objectContaining({
+        returnProperties: expect.arrayContaining([
+          'title',
+          'content',
+          'tags',
+          'user_id',
+          'doc_type',
+        ]),
+      })
+    );
+  });
+});
+```
+
+---
+
+## Verification
+
+- [ ] Created `fetchMemoryWithAllProperties` utility function in `src/weaviate/client.ts`
+- [ ] Created `ALL_MEMORY_PROPERTIES` constant with all 20+ properties
+- [ ] `remember_publish` uses `fetchMemoryWithAllProperties`
+- [ ] `executePublishMemory` uses `fetchMemoryWithAllProperties`
+- [ ] Utility function exported from client module
+- [ ] Debug logging shows property count > 0
+- [ ] Debug logging shows `hasTitle: true` and `hasContent: true`
+- [ ] Manual test: Published memory has title, content, tags
+- [ ] Search returns published memory with full content
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+- [ ] All tests passing
+
+---
+
+## Expected Output
+
+**Before Fix** (Current - BROKEN):
+```json
+{
+  "id": "9b536938-1188-4e69-b3cd-4362d84fff1c",
+  "vector": [...],
+  // ❌ NO PROPERTIES - Empty shell
+}
+```
+
+**After Fix**:
+```json
+{
+  "id": "9b536938-1188-4e69-b3cd-4362d84fff1c",
+  "vector": [...],
+  "properties": {
+    "title": "Breaking the Mold of Boredom",
+    "content": "i feel like i'm boring...",
+    "type": "note",
+    "tags": ["self-discovery", "societal norms", "breaking free"],
+    "author_id": "MnOyIarhz5b8n06TsTovM582NSG2",
+    "spaces": ["the_void"],
+    "published_at": "2026-02-16T21:44:39Z",
+    // ... all other properties
+  }
+}
+```
+
+---
+
+## Impact Analysis
+
+**Severity**: CRITICAL 🚨
+
+**Affected Users**: ALL users who published memories since v2.4.0
+
+**Data Loss**: 
+- All published memories are empty shells
+- Content exists in user collections but not in public space
+- Search returns no results (no content to match)
+- Discovery completely broken
+
+**Workaround**: None - memories must be re-published after fix
+
+**Migration**: 
+- Option 1: Users re-publish memories manually
+- Option 2: Create migration script to re-publish all memories
+- Option 3: Backfill from user collections (requires tracking original IDs)
+
+---
+
+## Common Issues and Solutions
+
+### Issue 1: TypeScript error about returnProperties
+
+**Cause**: Type definition might not include all properties
+**Solution**: Use `as any` if needed or update type definition
+
+### Issue 2: Some properties still missing
+
+**Cause**: Property list incomplete
+**Solution**: Check schema.ts for all property names
+
+### Issue 3: Old memories still empty
+
+**Cause**: This fix only affects new publications
+**Solution**: Users must re-publish or run migration script
+
+---
+
+## Resources
+
+- [Weaviate v3 Query API](https://weaviate.io/developers/weaviate/api/graphql/get)
+- [Memory Schema](../src/weaviate/schema.ts)
+- [Space Schema](../src/weaviate/space-schema.ts)
+- [Other fetchObjectById Examples](../src/tools/)
+
+---
+
+## Notes
+
+- **This is more critical than Task 62** (response storage)
+- Task 62 affects audit trail, Task 63 affects core functionality
+- Without this fix, the entire publish/space feature is broken
+- This bug has been in production since shared spaces were released
+- All published memories need to be re-published after fix
+- Consider adding integration test to catch this in future
+- ✅ Created `fetchMemoryWithAllProperties` helper function
+- This prevents the bug from recurring in future code
+- Consider migrating other tools to use the utility function
+- Consider adding ESLint rule to prevent direct `fetchObjectById` usage
+
+---
+
+## Related Tasks
+
+- **Task 62**: Fix confirmation response storage (audit trail)
+- **Task 58**: Add comment unit tests
+- **Task 59**: Update documentation
+
+---
+
+**Status**: Not Started
+**Recommendation**: FIX IMMEDIATELY - This breaks core functionality
+**Priority**: CRITICAL - Must be fixed before any other M12 tasks

package/dist/server-factory.js

@@ -565,6 +565,34 @@ function sanitizeUserId(userId) {
 function getMemoryCollectionName(userId) {
   return `Memory_${sanitizeUserId(userId)}`;
 }
+var ALL_MEMORY_PROPERTIES = [
+  "user_id",
+  "doc_type",
+  "type",
+  "title",
+  "content",
+  "tags",
+  "weight",
+  "base_weight",
+  "trust_level",
+  "context",
+  "location",
+  "relationships",
+  "created_at",
+  "updated_at",
+  "version",
+  "attribution",
+  "source_url",
+  "author",
+  "parent_id",
+  "thread_root_id",
+  "moderation_flags"
+];
+async function fetchMemoryWithAllProperties(collection, memoryId) {
+  return await collection.query.fetchObjectById(memoryId, {
+    returnProperties: ALL_MEMORY_PROPERTIES
+  });
+}
 
 // src/firestore/init.ts
 init_config();
@@ -3833,11 +3861,15 @@ async function handlePublish(args, userId) {
       memoryId: args.memory_id
     });
     const userCollection = weaviateClient.collections.get(collectionName);
-    const memory = await userCollection.query.fetchObjectById(args.memory_id);
+    const memory = await fetchMemoryWithAllProperties(userCollection, args.memory_id);
     logger.debug("Memory fetch result", {
       tool: "remember_publish",
       found: !!memory,
-      memoryId: args.memory_id
+      memoryId: args.memory_id,
+      hasProperties: !!memory?.properties,
+      propertyCount: memory?.properties ? Object.keys(memory.properties).length : 0,
+      hasTitle: !!memory?.properties?.title,
+      hasContent: !!memory?.properties?.content
     });
     if (!memory) {
       logger.info("Memory not found", {
@@ -4024,13 +4056,18 @@ async function executePublishMemory(request, userId) {
       collectionName: getMemoryCollectionName(userId),
       memoryId: request.payload.memory_id
     });
-    const originalMemory = await userCollection.query.fetchObjectById(
+    const originalMemory = await fetchMemoryWithAllProperties(
+      userCollection,
       request.payload.memory_id
     );
     logger.debug("Original memory fetch result", {
       function: "executePublishMemory",
       found: !!originalMemory,
-      memoryId: request.payload.memory_id
+      memoryId: request.payload.memory_id,
+      hasProperties: !!originalMemory?.properties,
+      propertyCount: originalMemory?.properties ? Object.keys(originalMemory.properties).length : 0,
+      hasTitle: !!originalMemory?.properties?.title,
+      hasContent: !!originalMemory?.properties?.content
     });
     if (!originalMemory) {
       logger.info("Original memory not found", {

package/dist/server.js

@@ -611,6 +611,34 @@ function sanitizeUserId(userId) {
 function getMemoryCollectionName(userId) {
   return `Memory_${sanitizeUserId(userId)}`;
 }
+var ALL_MEMORY_PROPERTIES = [
+  "user_id",
+  "doc_type",
+  "type",
+  "title",
+  "content",
+  "tags",
+  "weight",
+  "base_weight",
+  "trust_level",
+  "context",
+  "location",
+  "relationships",
+  "created_at",
+  "updated_at",
+  "version",
+  "attribution",
+  "source_url",
+  "author",
+  "parent_id",
+  "thread_root_id",
+  "moderation_flags"
+];
+async function fetchMemoryWithAllProperties(collection, memoryId) {
+  return await collection.query.fetchObjectById(memoryId, {
+    returnProperties: ALL_MEMORY_PROPERTIES
+  });
+}
 
 // src/firestore/init.ts
 init_config();
@@ -3901,11 +3929,15 @@ async function handlePublish(args, userId) {
       memoryId: args.memory_id
     });
     const userCollection = weaviateClient.collections.get(collectionName);
-    const memory = await userCollection.query.fetchObjectById(args.memory_id);
+    const memory = await fetchMemoryWithAllProperties(userCollection, args.memory_id);
     logger.debug("Memory fetch result", {
       tool: "remember_publish",
       found: !!memory,
-      memoryId: args.memory_id
+      memoryId: args.memory_id,
+      hasProperties: !!memory?.properties,
+      propertyCount: memory?.properties ? Object.keys(memory.properties).length : 0,
+      hasTitle: !!memory?.properties?.title,
+      hasContent: !!memory?.properties?.content
     });
     if (!memory) {
       logger.info("Memory not found", {
@@ -4092,13 +4124,18 @@ async function executePublishMemory(request, userId) {
       collectionName: getMemoryCollectionName(userId),
       memoryId: request.payload.memory_id
     });
-    const originalMemory = await userCollection.query.fetchObjectById(
+    const originalMemory = await fetchMemoryWithAllProperties(
+      userCollection,
       request.payload.memory_id
     );
     logger.debug("Original memory fetch result", {
       function: "executePublishMemory",
       found: !!originalMemory,
-      memoryId: request.payload.memory_id
+      memoryId: request.payload.memory_id,
+      hasProperties: !!originalMemory?.properties,
+      propertyCount: originalMemory?.properties ? Object.keys(originalMemory.properties).length : 0,
+      hasTitle: !!originalMemory?.properties?.title,
+      hasContent: !!originalMemory?.properties?.content
     });
     if (!originalMemory) {
       logger.info("Original memory not found", {

package/dist/weaviate/client.d.ts

@@ -33,6 +33,22 @@ export declare function getTemplateCollectionName(userId: string): string;
  * Get collection name for user's audit logs
  */
 export declare function getAuditCollectionName(userId: string): string;
+/**
+ * List of all memory properties to fetch
+ * Centralized to ensure consistency across all tools
+ */
+export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "type", "title", "content", "tags", "weight", "base_weight", "trust_level", "context", "location", "relationships", "created_at", "updated_at", "version", "attribution", "source_url", "author", "parent_id", "thread_root_id", "moderation_flags"];
+/**
+ * Fetch a memory object by ID with all properties
+ *
+ * This utility ensures all memory properties are fetched consistently
+ * across all tools, preventing bugs where properties are missing.
+ *
+ * @param collection - Weaviate collection
+ * @param memoryId - Memory ID to fetch
+ * @returns Memory object with all properties
+ */
+export declare function fetchMemoryWithAllProperties(collection: any, memoryId: string): Promise<any>;
 /**
  * Check if collection exists
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/tools/confirm.ts

@@ -7,7 +7,7 @@
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { confirmationTokenService, type ConfirmationRequest } from '../services/confirmation-token.service.js';
-import { getWeaviateClient, getMemoryCollectionName } 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';
@@ -151,7 +151,8 @@ async function executePublishMemory(
       memoryId: request.payload.memory_id,
     });
 
-    const originalMemory = await userCollection.query.fetchObjectById(
+    const originalMemory = await fetchMemoryWithAllProperties(
+      userCollection,
       request.payload.memory_id
     );
     
@@ -159,6 +160,10 @@ async function executePublishMemory(
       function: 'executePublishMemory',
       found: !!originalMemory,
       memoryId: request.payload.memory_id,
+      hasProperties: !!originalMemory?.properties,
+      propertyCount: originalMemory?.properties ? Object.keys(originalMemory.properties).length : 0,
+      hasTitle: !!originalMemory?.properties?.title,
+      hasContent: !!originalMemory?.properties?.content,
     });
 
     if (!originalMemory) {

package/src/tools/publish.ts

@@ -7,7 +7,7 @@
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { confirmationTokenService } from '../services/confirmation-token.service.js';
-import { getWeaviateClient, getMemoryCollectionName } from '../weaviate/client.js';
+import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties } from '../weaviate/client.js';
 import { isValidSpaceId } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
@@ -122,12 +122,16 @@ export async function handlePublish(
     
     const userCollection = weaviateClient.collections.get(collectionName);
 
-    const memory = await userCollection.query.fetchObjectById(args.memory_id);
+    const memory = await fetchMemoryWithAllProperties(userCollection, args.memory_id);
     
     logger.debug('Memory fetch result', {
       tool: 'remember_publish',
       found: !!memory,
       memoryId: args.memory_id,
+      hasProperties: !!memory?.properties,
+      propertyCount: memory?.properties ? Object.keys(memory.properties).length : 0,
+      hasTitle: !!memory?.properties?.title,
+      hasContent: !!memory?.properties?.content,
     });
 
     if (!memory) {

package/src/weaviate/client.ts

@@ -139,6 +139,53 @@ export function getAuditCollectionName(userId: string): string {
   return `Audit_${sanitizeUserId(userId)}`;
 }
 
+/**
+ * List of all memory properties to fetch
+ * Centralized to ensure consistency across all tools
+ */
+export const ALL_MEMORY_PROPERTIES = [
+  'user_id',
+  'doc_type',
+  'type',
+  'title',
+  'content',
+  'tags',
+  'weight',
+  'base_weight',
+  'trust_level',
+  'context',
+  'location',
+  'relationships',
+  'created_at',
+  'updated_at',
+  'version',
+  'attribution',
+  'source_url',
+  'author',
+  'parent_id',
+  'thread_root_id',
+  'moderation_flags',
+] as const;
+
+/**
+ * Fetch a memory object by ID with all properties
+ *
+ * This utility ensures all memory properties are fetched consistently
+ * across all tools, preventing bugs where properties are missing.
+ *
+ * @param collection - Weaviate collection
+ * @param memoryId - Memory ID to fetch
+ * @returns Memory object with all properties
+ */
+export async function fetchMemoryWithAllProperties(
+  collection: any,
+  memoryId: string
+) {
+  return await collection.query.fetchObjectById(memoryId, {
+    returnProperties: ALL_MEMORY_PROPERTIES,
+  });
+}
+
 /**
  * Check if collection exists
  */