@prmichaelsen/remember-mcp 2.6.7 → 2.6.8

package/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.8] - 2026-02-17
+
+### 🐛 Fixed
+
+- **Critical Build Error**: Added missing `poetry` content type metadata to `src/constants/content-types.ts`
+  - Fixed TypeScript compilation error: "Property 'poetry' is missing in type Record<ContentType, ContentTypeMetadata>"
+  - Added poetry definition with category, description, examples, and common fields
+  - Updated `CONTENT_TYPE_CATEGORIES` to include poetry in creative category
+  - Build now successful
+
+### ✨ Added
+
+- **Task 66: Comment Field Initialization in Tools**
+  - Updated `remember_create_memory` tool to initialize comment fields
+    - Added `parent_id`, `thread_root_id`, `moderation_flags` to `CreateMemoryArgs` interface
+    - New memories created with `parent_id: null`, `thread_root_id: null`, `moderation_flags: []`
+  - Updated `remember_update_memory` tool to support comment field updates
+    - Added comment fields to tool schema and `UpdateMemoryArgs` interface
+    - Can now update `parent_id`, `thread_root_id`, and `moderation_flags`
+  - Space memory tools automatically include comment fields via spread operator
+  - Created task documentation: `agent/tasks/task-66-initialize-comment-fields-in-tools.md`
+
+### 📝 Changed
+
+- Updated `agent/progress.yaml` with Task 66 completion and build fix details
+- All new memories now have consistent schema with comment fields initialized
+
+### 🎯 Impact
+
+- **Schema Consistency**: All new memories have comment fields, matching migrated old memories
+- **Comment System Ready**: Can create comments, nested comments, and manage moderation flags
+- **Build Stability**: TypeScript compiles without errors, all 81 tests passing
+
+---
+
 ## [2.6.6] - 2026-02-16
 
 ### 🔧 Improved

package/agent/progress.yaml

@@ -523,6 +523,42 @@ progress:
   overall: 50%
 
 recent_work:
+  - date: 2026-02-17
+    description: Fixed Build Error & Completed Task 66 - Comment Field Initialization
+    items:
+      - ✅ Fixed critical TypeScript build error in content-types.ts
+      - ✅ Added missing 'poetry' content type metadata
+      - ✅ Build now successful - TypeScript compiles without errors
+      - ✅ Task 66 COMPLETED: Initialize comment fields in create/update tools
+      - ✅ Updated remember_create_memory tool schema with comment fields
+      - ✅ Updated CreateMemoryArgs interface with parent_id, thread_root_id, moderation_flags
+      - ✅ Initialized comment fields to defaults in handleCreateMemory (null, null, [])
+      - ✅ Updated remember_update_memory tool schema with comment fields
+      - ✅ Updated UpdateMemoryArgs interface with comment fields
+      - ✅ Added comment field update logic in handleUpdateMemory
+      - ✅ All 81 tests passing (1 skipped integration test)
+      - ✅ Test coverage: 33.12% overall
+      - ✅ New memories now created with comment fields initialized
+      - ✅ Can create comments with parent_id and thread_root_id set
+      - ✅ Can update comment fields via remember_update_memory
+      - 📋 Ready for M12 completion: Tasks 58-59 remaining
+      
+  - date: 2026-02-17
+    description: ACP Initialization Complete - Project Context Loaded
+    items:
+      - ✅ ACP initialization workflow executed via @acp.init command
+      - ⚠️  ACP updates available (v1.4.3 with improved script color output)
+      - ✅ All agent documentation reviewed (23 design docs, 11 milestones, 66 tasks, 5 patterns)
+      - ✅ Project status verified: M1-M4, M10-M11 complete (100%), M12 in progress (60%)
+      - ✅ Version 2.6.7 confirmed (latest release)
+      - ✅ 53 unit tests passing (1 skipped integration test)
+      - ⚠️  TypeScript compilation error: Missing 'poetry' in content-types.ts
+      - ✅ All 17 MCP tools implemented and working
+      - ✅ M12 Comment System: 3/5 tasks complete (schema, search, query updates)
+      - 📋 Remaining M12 tasks: Task 58 (unit tests), Task 59 (documentation)
+      - 📋 Build blocked by TypeScript error in content-types.ts
+      - 📋 Need to fix 'poetry' content type metadata
+      
   - date: 2026-02-16
     description: Comment System, Structured Logging, and Safety Guidelines (v2.6.0-v2.6.2)
     items:

package/agent/tasks/task-65-migrate-old-memories-schema.md

@@ -0,0 +1,431 @@
+# Task 65: Migrate Old Memories to Include New Schema Fields
+
+**Milestone**: M12 (Schema Migration)
+**Estimated Time**: 3 hours
+**Dependencies**: Task 63 (fetchMemoryWithAllProperties utility)
+**Status**: Not Started
+**Priority**: CRITICAL 🚨
+
+---
+
+## Objective
+
+Migrate all existing memories in user collections to include new schema fields added in v2.6.0 (comment fields) and ensure schema uniformity. This prevents fetch failures when requesting properties that don't exist on old memory objects.
+
+---
+
+## Context
+
+**Problem**: 
+Old memories created before v2.6.0 don't have the new comment fields:
+- `parent_id` (added in v2.6.0)
+- `thread_root_id` (added in v2.6.0)
+- `moderation_flags` (added in v2.6.0)
+
+When `fetchMemoryWithAllProperties()` tries to fetch these properties from old memories, Weaviate fails because the properties don't exist on those objects.
+
+**Impact**:
+- ❌ Cannot publish old memories (fetch fails)
+- ❌ Cannot update old memories
+- ❌ Cannot search old memories with new property filters
+- ❌ Schema inconsistency across memory objects
+
+**Root Cause**:
+Weaviate doesn't automatically backfill new schema properties on existing objects. When you add a new property to the schema, existing objects don't get that property until they're updated.
+
+---
+
+## Steps
+
+### 1. Create Migration Script
+
+Create a migration script in `/home/prmichaelsen/scripts/`:
+
+```bash
+#!/bin/bash
+# migrate-memory-schema.sh
+# Migrates old memories to include new schema fields
+
+set -e
+
+echo "🔄 Starting memory schema migration..."
+echo "This will add missing fields to all memories in all user collections"
+echo ""
+
+# Run the TypeScript migration script
+cd /home/prmichaelsen/remember-mcp
+npx tsx scripts/migrate-schema.ts
+
+echo ""
+echo "✅ Migration complete!"
+```
+
+### 2. Create TypeScript Migration Script
+
+Create `scripts/migrate-schema.ts`:
+
+```typescript
+/**
+ * Schema Migration Script
+ * 
+ * Adds missing fields to all existing memories:
+ * - parent_id: null (for non-comment memories)
+ * - thread_root_id: null (for non-comment memories)
+ * - moderation_flags: [] (empty array)
+ */
+
+import { initWeaviateClient, getWeaviateClient } from '../src/weaviate/client.js';
+import { config } from '../src/config.js';
+
+interface MigrationStats {
+  collectionsProcessed: number;
+  memoriesUpdated: number;
+  memoriesSkipped: number;
+  errors: number;
+}
+
+async function migrateCollection(collectionName: string): Promise<{ updated: number; skipped: number; errors: number }> {
+  console.log(`\n📦 Processing collection: ${collectionName}`);
+  
+  const client = getWeaviateClient();
+  const collection = client.collections.get(collectionName);
+  
+  let updated = 0;
+  let skipped = 0;
+  let errors = 0;
+  
+  try {
+    // Fetch all objects in batches
+    let offset = 0;
+    const batchSize = 100;
+    let hasMore = true;
+    
+    while (hasMore) {
+      console.log(`  Fetching batch at offset ${offset}...`);
+      
+      const results = await collection.query.fetchObjects({
+        limit: batchSize,
+        offset,
+      });
+      
+      if (!results.objects || results.objects.length === 0) {
+        hasMore = false;
+        break;
+      }
+      
+      console.log(`  Processing ${results.objects.length} memories...`);
+      
+      for (const obj of results.objects) {
+        try {
+          const props = obj.properties;
+          
+          // Check if migration needed
+          const needsMigration = 
+            props.parent_id === undefined ||
+            props.thread_root_id === undefined ||
+            props.moderation_flags === undefined;
+          
+          if (!needsMigration) {
+            skipped++;
+            continue;
+          }
+          
+          // Update with missing fields
+          await collection.data.update({
+            id: obj.uuid,
+            properties: {
+              parent_id: props.parent_id ?? null,
+              thread_root_id: props.thread_root_id ?? null,
+              moderation_flags: props.moderation_flags ?? [],
+            },
+          });
+          
+          updated++;
+          
+          if (updated % 10 === 0) {
+            console.log(`    ✅ Updated ${updated} memories...`);
+          }
+        } catch (error) {
+          errors++;
+          console.error(`    ❌ Error updating ${obj.uuid}:`, error);
+        }
+      }
+      
+      offset += batchSize;
+    }
+  } catch (error) {
+    console.error(`  ❌ Error processing collection:`, error);
+    errors++;
+  }
+  
+  return { updated, skipped, errors };
+}
+
+async function main() {
+  console.log('🚀 Memory Schema Migration');
+  console.log('==========================\n');
+  
+  // Initialize Weaviate
+  await initWeaviateClient();
+  const client = getWeaviateClient();
+  
+  // Get all collections
+  const collections = await client.collections.listAll();
+  
+  // Filter to Memory_ collections only
+  const memoryCollections = collections
+    .map(c => c.name)
+    .filter(name => name.startsWith('Memory_') && name !== 'Memory_public');
+  
+  console.log(`Found ${memoryCollections.length} user memory collections\n`);
+  
+  const stats: MigrationStats = {
+    collectionsProcessed: 0,
+    memoriesUpdated: 0,
+    memoriesSkipped: 0,
+    errors: 0,
+  };
+  
+  // Migrate each collection
+  for (const collectionName of memoryCollections) {
+    const result = await migrateCollection(collectionName);
+    stats.collectionsProcessed++;
+    stats.memoriesUpdated += result.updated;
+    stats.memoriesSkipped += result.skipped;
+    stats.errors += result.errors;
+  }
+  
+  // Also migrate Memory_public if it exists
+  const publicExists = await client.collections.exists('Memory_public');
+  if (publicExists) {
+    console.log('\n📦 Processing Memory_public collection...');
+    const result = await migrateCollection('Memory_public');
+    stats.collectionsProcessed++;
+    stats.memoriesUpdated += result.updated;
+    stats.memoriesSkipped += result.skipped;
+    stats.errors += result.errors;
+  }
+  
+  // Print summary
+  console.log('\n\n📊 Migration Summary');
+  console.log('===================');
+  console.log(`Collections processed: ${stats.collectionsProcessed}`);
+  console.log(`Memories updated: ${stats.memoriesUpdated}`);
+  console.log(`Memories skipped (already migrated): ${stats.memoriesSkipped}`);
+  console.log(`Errors: ${stats.errors}`);
+  
+  if (stats.errors > 0) {
+    console.log('\n⚠️  Some errors occurred. Check logs above.');
+    process.exit(1);
+  } else {
+    console.log('\n✅ Migration completed successfully!');
+    process.exit(0);
+  }
+}
+
+main().catch(error => {
+  console.error('💥 Migration failed:', error);
+  process.exit(1);
+});
+```
+
+### 3. Make Script Executable
+
+```bash
+chmod +x /home/prmichaelsen/scripts/migrate-memory-schema.sh
+```
+
+### 4. Run Migration
+
+```bash
+# Dry run first (optional - add --dry-run flag to script)
+/home/prmichaelsen/scripts/migrate-memory-schema.sh
+
+# Or run directly with tsx
+cd /home/prmichaelsen/remember-mcp
+npx tsx scripts/migrate-schema.ts
+```
+
+### 5. Verify Migration
+
+Check that old memories now have the new fields:
+
+```typescript
+// Test with an old memory ID
+remember_search_memory({
+  query: "",
+  limit: 1
+})
+
+// Verify returned memory has:
+// - parent_id: null
+// - thread_root_id: null
+// - moderation_flags: []
+```
+
+### 6. Test Publish After Migration
+
+```bash
+# Try publishing an old memory
+remember_publish({
+  memory_id: "84edf86d-579d-4cb3-8b5f-2e19462d8c68",
+  spaces: ["the_void"]
+})
+
+# Should succeed now
+```
+
+---
+
+## Verification
+
+- [ ] Migration script created in `/home/prmichaelsen/scripts/`
+- [ ] TypeScript migration script created in `scripts/migrate-schema.ts`
+- [ ] Script is executable
+- [ ] Dry run completed successfully (optional)
+- [ ] Migration executed on all user collections
+- [ ] Migration executed on Memory_public collection
+- [ ] All old memories have `parent_id: null`
+- [ ] All old memories have `thread_root_id: null`
+- [ ] All old memories have `moderation_flags: []`
+- [ ] Can fetch old memories with `fetchMemoryWithAllProperties()`
+- [ ] Can publish old memories successfully
+- [ ] No errors in migration logs
+
+---
+
+## Expected Output
+
+**Before Migration**:
+```json
+{
+  "id": "84edf86d-579d-4cb3-8b5f-2e19462d8c68",
+  "properties": {
+    "title": "Cat grad school",
+    "content": "...",
+    "type": "note",
+    // ❌ No parent_id
+    // ❌ No thread_root_id
+    // ❌ No moderation_flags
+  }
+}
+```
+
+**After Migration**:
+```json
+{
+  "id": "84edf86d-579d-4cb3-8b5f-2e19462d8c68",
+  "properties": {
+    "title": "Cat grad school",
+    "content": "...",
+    "type": "note",
+    "parent_id": null,  // ✅ Added
+    "thread_root_id": null,  // ✅ Added
+    "moderation_flags": []  // ✅ Added
+  }
+}
+```
+
+---
+
+## Migration Statistics Example
+
+```
+📊 Migration Summary
+===================
+Collections processed: 5
+Memories updated: 247
+Memories skipped (already migrated): 0
+Errors: 0
+
+✅ Migration completed successfully!
+```
+
+---
+
+## Common Issues and Solutions
+
+### Issue 1: Permission denied
+
+**Cause**: Script not executable
+**Solution**: `chmod +x /home/prmichaelsen/scripts/migrate-memory-schema.sh`
+
+### Issue 2: Weaviate connection failed
+
+**Cause**: Environment variables not set
+**Solution**: Ensure `.env` file has WEAVIATE_URL and WEAVIATE_API_KEY
+
+### Issue 3: Some memories fail to update
+
+**Cause**: Individual object update errors
+**Solution**: Check error logs, may need to manually fix specific memories
+
+### Issue 4: Migration takes too long
+
+**Cause**: Large number of memories
+**Solution**: Run in batches, add progress indicators
+
+---
+
+## Safety Considerations
+
+**Backup**: 
+- Weaviate doesn't have built-in backup for individual collections
+- Consider exporting memories before migration
+- Migration is additive (only adds fields, doesn't remove)
+
+**Rollback**:
+- If migration fails, new fields will be null/empty
+- Can re-run migration safely (idempotent)
+- No data loss risk (only adding fields)
+
+**Testing**:
+- Test on a single collection first
+- Verify results before migrating all collections
+- Check Memory_public separately
+
+---
+
+## Resources
+
+- [Weaviate Update Objects](https://weaviate.io/developers/weaviate/manage-data/update)
+- [Weaviate Batch Operations](https://weaviate.io/developers/weaviate/manage-data/import)
+- [Schema Evolution Best Practices](https://weaviate.io/developers/weaviate/config-refs/schema)
+
+---
+
+## Notes
+
+- This migration is **required** for v2.6.3+ to work with old memories
+- Migration is idempotent (safe to run multiple times)
+- Only updates memories that need migration (checks first)
+- Processes in batches to avoid memory issues
+- Logs progress for monitoring
+- Can be run on production without downtime
+- Consider scheduling during low-traffic period
+- Estimated time: ~1-5 minutes per 1000 memories
+
+---
+
+## Alternative Approaches
+
+### Option 1: Lazy Migration (NOT RECOMMENDED)
+- Update memories on-demand when accessed
+- Pros: No bulk migration needed
+- Cons: Unpredictable failures, poor UX
+
+### Option 2: Schema-Optional Fetch (NOT RECOMMENDED)
+- Make fetchMemoryWithAllProperties handle missing properties
+- Pros: No migration needed
+- Cons: Inconsistent data, complex error handling
+
+### Option 3: Bulk Migration (RECOMMENDED)
+- Run migration script once to update all memories
+- Pros: Clean, predictable, one-time operation
+- Cons: Requires downtime or careful execution
+
+---
+
+**Status**: Not Started
+**Recommendation**: Run migration immediately to unblock publish functionality
+**Priority**: CRITICAL - Blocks core functionality for users with old memories

package/agent/tasks/task-66-initialize-comment-fields-in-tools.md

@@ -0,0 +1,294 @@
+# Task 66: Support All Schema Fields in Create/Update Tools
+
+**Milestone**: M12 (Comment System / Schema Completeness)
+**Estimated Time**: 2 hours
+**Dependencies**: Task 65 (migration script)
+**Status**: Not Started
+**Priority**: High
+
+---
+
+## Objective
+
+Ensure all create and update tools (both personal and space tools) support ALL schema fields in their input schemas and properly initialize/update them. This includes comment fields and any other fields that may be missing from tool schemas.
+
+---
+
+## Context
+
+**Current Problem**:
+- New memories created via `remember_create_memory` don't have comment fields
+- Space memories created via `remember_publish` may be missing fields
+- Update tools may not support all schema fields
+- After migration (Task 65), old memories will have these fields
+- This creates inconsistency between old and new memories
+
+**Missing Fields**:
+- Comment fields: `parent_id`, `thread_root_id`, `moderation_flags`
+- Potentially other fields not in tool schemas
+
+**Affected Tools**:
+- `remember_create_memory` - Personal memory creation
+- `remember_update_memory` - Personal memory updates
+- `remember_publish` / `remember_confirm` - Space memory creation (via executePublishMemory)
+
+**Impact**:
+- New memories missing fields
+- Inconsistent schema across memories
+- Potential query/filter issues
+- Space memories may be incomplete
+
+---
+
+## Steps
+
+### 1. Update remember_create_memory Tool Schema
+
+Add comment fields to input schema:
+
+```typescript
+// src/tools/create-memory.ts
+
+export const createMemoryTool: Tool = {
+  name: 'remember_create_memory',
+  description: '...',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      // ... existing properties ...
+      
+      // Comment/threading fields (optional)
+      parent_id: {
+        type: 'string',
+        description: 'ID of parent memory or comment (for threading). Leave null for top-level memories.',
+      },
+      thread_root_id: {
+        type: 'string',
+        description: 'Root memory ID for thread. Leave null for top-level memories.',
+      },
+      moderation_flags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}"). Usually empty.',
+        default: [],
+      },
+    },
+    required: ['type', 'content'], // parent_id, thread_root_id, moderation_flags are optional
+  },
+};
+```
+
+### 2. Initialize Comment Fields in handleCreateMemory
+
+Ensure fields are always initialized:
+
+```typescript
+// src/tools/create-memory.ts - in handleCreateMemory function
+
+const memory: Memory = {
+  // ... existing fields ...
+  
+  // Comment/threading fields (initialize to defaults)
+  parent_id: args.parent_id || null,
+  thread_root_id: args.thread_root_id || null,
+  moderation_flags: args.moderation_flags || [],
+  
+  // ... rest of fields ...
+};
+```
+
+### 3. Update remember_update_memory Tool Schema
+
+Add comment fields to update schema:
+
+```typescript
+// src/tools/update-memory.ts
+
+export const updateMemoryTool: Tool = {
+  name: 'remember_update_memory',
+  description: '...',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      // ... existing properties ...
+      
+      // Comment/threading fields (optional)
+      parent_id: {
+        type: 'string',
+        description: 'Update parent ID (for threading)',
+      },
+      thread_root_id: {
+        type: 'string',
+        description: 'Update thread root ID',
+      },
+      moderation_flags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Update moderation flags',
+      },
+    },
+    required: ['memory_id'],
+  },
+};
+```
+
+### 4. Support Comment Fields in handleUpdateMemory
+
+Allow updating comment fields:
+
+```typescript
+// src/tools/update-memory.ts - in handleUpdateMemory function
+
+const updates: Partial<Memory> = {};
+
+// ... existing field updates ...
+
+// Comment/threading fields
+if (args.parent_id !== undefined) {
+  updates.parent_id = args.parent_id;
+}
+if (args.thread_root_id !== undefined) {
+  updates.thread_root_id = args.thread_root_id;
+}
+if (args.moderation_flags !== undefined) {
+  updates.moderation_flags = args.moderation_flags;
+}
+```
+
+### 5. Update Memory Type Interface
+
+Ensure TypeScript types include comment fields:
+
+```typescript
+// src/types/memory.ts
+
+export interface Memory {
+  // ... existing fields ...
+  
+  // Comment/threading fields
+  parent_id?: string | null;
+  thread_root_id?: string | null;
+  moderation_flags?: string[];
+  
+  // ... rest of fields ...
+}
+```
+
+### 6. Test New Memory Creation
+
+Verify new memories have comment fields:
+
+```bash
+# Create a regular memory
+remember_create_memory({
+  type: "note",
+  content: "Test memory"
+})
+
+# Verify it has:
+# - parent_id: null
+# - thread_root_id: null
+# - moderation_flags: []
+
+# Create a comment
+remember_create_memory({
+  type: "comment",
+  content: "Great post!",
+  parent_id: "memory123",
+  thread_root_id: "memory123"
+})
+
+# Verify it has the parent/thread IDs set
+```
+
+---
+
+## Verification
+
+- [ ] `remember_create_memory` input schema includes comment fields
+- [ ] `handleCreateMemory` initializes comment fields to defaults
+- [ ] `remember_update_memory` input schema includes comment fields
+- [ ] `handleUpdateMemory` supports updating comment fields
+- [ ] `Memory` type interface includes comment fields
+- [ ] New memories created with `parent_id: null`
+- [ ] New memories created with `thread_root_id: null`
+- [ ] New memories created with `moderation_flags: []`
+- [ ] Can create comments with parent_id set
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+- [ ] All tests passing
+
+---
+
+## Expected Output
+
+**New Regular Memory**:
+```json
+{
+  "id": "new-memory-id",
+  "type": "note",
+  "content": "Test content",
+  "parent_id": null,
+  "thread_root_id": null,
+  "moderation_flags": [],
+  // ... other fields
+}
+```
+
+**New Comment**:
+```json
+{
+  "id": "comment-id",
+  "type": "comment",
+  "content": "Great post!",
+  "parent_id": "memory123",
+  "thread_root_id": "memory123",
+  "moderation_flags": [],
+  // ... other fields
+}
+```
+
+---
+
+## Common Issues and Solutions
+
+### Issue 1: TypeScript errors about new fields
+
+**Cause**: Memory type not updated
+**Solution**: Add fields to Memory interface in src/types/memory.ts
+
+### Issue 2: Fields not showing in created memories
+
+**Cause**: Not initialized in handleCreateMemory
+**Solution**: Ensure defaults are set (null for IDs, [] for flags)
+
+### Issue 3: Can't update comment fields
+
+**Cause**: handleUpdateMemory doesn't support them
+**Solution**: Add field update logic
+
+---
+
+## Resources
+
+- [Memory Type Definition](../src/types/memory.ts)
+- [remember_create_memory Tool](../src/tools/create-memory.ts)
+- [remember_update_memory Tool](../src/tools/update-memory.ts)
+- [Comment System Design](../design/comment-memory-type.md)
+
+---
+
+## Notes
+
+- This ensures consistency between old (migrated) and new memories
+- Comment fields are optional in input schema
+- Defaults: `parent_id: null`, `thread_root_id: null`, `moderation_flags: []`
+- Only comments should have non-null parent_id/thread_root_id
+- Regular memories always have null for these fields
+- This completes the comment system foundation
+
+---
+
+**Status**: Not Started
+**Recommendation**: Implement after Task 65 migration completes
+**Priority**: High - Ensures schema consistency for all new memories

package/dist/constants/content-types.d.ts

@@ -30,7 +30,7 @@ export declare const CONTENT_TYPE_CATEGORIES: {
     readonly communication: readonly ["email", "conversation", "meeting", "person"];
     readonly content: readonly ["article", "webpage", "social", "presentation", "spreadsheet", "pdf"];
     readonly media: readonly ["image", "video", "audio", "transcript"];
-    readonly creative: readonly ["song", "screenplay", "recipe", "idea", "quote"];
+    readonly creative: readonly ["song", "screenplay", "recipe", "idea", "quote", "poetry"];
     readonly personal: readonly ["journal", "memory", "event"];
     readonly organizational: readonly ["bookmark", "form", "location"];
     readonly business: readonly ["invoice", "contract"];

package/dist/server-factory.js

@@ -981,6 +981,7 @@ var CONTENT_TYPES = [
   "recipe",
   "idea",
   "quote",
+  "poetry",
   // Personal
   "journal",
   "memory",
@@ -1197,6 +1198,13 @@ var CONTENT_TYPE_METADATA = {
     examples: ["Quotes", "Excerpts", "Highlights", "Citations"],
     common_fields: ["author", "source"]
   },
+  poetry: {
+    name: "poetry",
+    category: "creative",
+    description: "Poems and poetic content",
+    examples: ["Poems", "Verses", "Haiku", "Sonnets", "Free verse"],
+    common_fields: ["author", "form", "theme"]
+  },
   // Personal
   journal: {
     name: "journal",
@@ -1391,6 +1399,20 @@ var createMemoryTool = {
         type: "boolean",
         description: "Skip automatic template suggestion",
         default: false
+      },
+      parent_id: {
+        type: "string",
+        description: "ID of parent memory or comment (for threading). Leave null for top-level memories."
+      },
+      thread_root_id: {
+        type: "string",
+        description: "Root memory ID for thread. Leave null for top-level memories."
+      },
+      moderation_flags: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}"). Usually empty.',
+        default: []
       }
     },
     required: ["content"]
@@ -1452,7 +1474,11 @@ async function handleCreateMemory(args, userId, context) {
       structured_content: args.structured_content,
       // Computed weight
       base_weight: args.weight ?? 0.5,
-      computed_weight: args.weight ?? 0.5
+      computed_weight: args.weight ?? 0.5,
+      // Comment/threading fields (initialize to defaults)
+      parent_id: args.parent_id ?? null,
+      thread_root_id: args.thread_root_id ?? null,
+      moderation_flags: args.moderation_flags ?? []
     };
     const result = await collection.data.insert({
       properties: memory
@@ -1889,6 +1915,19 @@ var updateMemoryTool = {
       structured_content: {
         type: "object",
         description: "Updated structured content"
+      },
+      parent_id: {
+        type: "string",
+        description: "Update parent ID (for threading)"
+      },
+      thread_root_id: {
+        type: "string",
+        description: "Update thread root ID"
+      },
+      moderation_flags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Update moderation flags"
       }
     },
     required: ["memory_id"]
@@ -1968,6 +2007,18 @@ async function handleUpdateMemory(args, userId) {
       updates.structured_content = args.structured_content;
       updatedFields.push("structured_content");
     }
+    if (args.parent_id !== void 0) {
+      updates.parent_id = args.parent_id;
+      updatedFields.push("parent_id");
+    }
+    if (args.thread_root_id !== void 0) {
+      updates.thread_root_id = args.thread_root_id;
+      updatedFields.push("thread_root_id");
+    }
+    if (args.moderation_flags !== void 0) {
+      updates.moderation_flags = args.moderation_flags;
+      updatedFields.push("moderation_flags");
+    }
     if (updatedFields.length === 0) {
       throw new Error("No fields provided for update. At least one field must be specified.");
     }

package/dist/server.js

@@ -1049,6 +1049,7 @@ var CONTENT_TYPES = [
   "recipe",
   "idea",
   "quote",
+  "poetry",
   // Personal
   "journal",
   "memory",
@@ -1265,6 +1266,13 @@ var CONTENT_TYPE_METADATA = {
     examples: ["Quotes", "Excerpts", "Highlights", "Citations"],
     common_fields: ["author", "source"]
   },
+  poetry: {
+    name: "poetry",
+    category: "creative",
+    description: "Poems and poetic content",
+    examples: ["Poems", "Verses", "Haiku", "Sonnets", "Free verse"],
+    common_fields: ["author", "form", "theme"]
+  },
   // Personal
   journal: {
     name: "journal",
@@ -1459,6 +1467,20 @@ var createMemoryTool = {
         type: "boolean",
         description: "Skip automatic template suggestion",
         default: false
+      },
+      parent_id: {
+        type: "string",
+        description: "ID of parent memory or comment (for threading). Leave null for top-level memories."
+      },
+      thread_root_id: {
+        type: "string",
+        description: "Root memory ID for thread. Leave null for top-level memories."
+      },
+      moderation_flags: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}"). Usually empty.',
+        default: []
       }
     },
     required: ["content"]
@@ -1520,7 +1542,11 @@ async function handleCreateMemory(args, userId, context) {
       structured_content: args.structured_content,
       // Computed weight
       base_weight: args.weight ?? 0.5,
-      computed_weight: args.weight ?? 0.5
+      computed_weight: args.weight ?? 0.5,
+      // Comment/threading fields (initialize to defaults)
+      parent_id: args.parent_id ?? null,
+      thread_root_id: args.thread_root_id ?? null,
+      moderation_flags: args.moderation_flags ?? []
     };
     const result = await collection.data.insert({
       properties: memory
@@ -1957,6 +1983,19 @@ var updateMemoryTool = {
       structured_content: {
         type: "object",
         description: "Updated structured content"
+      },
+      parent_id: {
+        type: "string",
+        description: "Update parent ID (for threading)"
+      },
+      thread_root_id: {
+        type: "string",
+        description: "Update thread root ID"
+      },
+      moderation_flags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Update moderation flags"
       }
     },
     required: ["memory_id"]
@@ -2036,6 +2075,18 @@ async function handleUpdateMemory(args, userId) {
       updates.structured_content = args.structured_content;
       updatedFields.push("structured_content");
     }
+    if (args.parent_id !== void 0) {
+      updates.parent_id = args.parent_id;
+      updatedFields.push("parent_id");
+    }
+    if (args.thread_root_id !== void 0) {
+      updates.thread_root_id = args.thread_root_id;
+      updatedFields.push("thread_root_id");
+    }
+    if (args.moderation_flags !== void 0) {
+      updates.moderation_flags = args.moderation_flags;
+      updatedFields.push("moderation_flags");
+    }
     if (updatedFields.length === 0) {
       throw new Error("No fields provided for update. At least one field must be specified.");
     }

package/dist/tools/create-memory.d.ts

@@ -60,6 +60,22 @@ export declare const createMemoryTool: {
                 description: string;
                 default: boolean;
             };
+            parent_id: {
+                type: string;
+                description: string;
+            };
+            thread_root_id: {
+                type: string;
+                description: string;
+            };
+            moderation_flags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+                default: never[];
+            };
         };
         required: string[];
     };
@@ -78,6 +94,9 @@ export interface CreateMemoryArgs {
     template_id?: string;
     skip_template_suggestion?: boolean;
     structured_content?: Record<string, any>;
+    parent_id?: string | null;
+    thread_root_id?: string | null;
+    moderation_flags?: string[];
 }
 /**
  * Create memory result

package/dist/tools/update-memory.d.ts

@@ -57,6 +57,21 @@ export declare const updateMemoryTool: {
                 type: string;
                 description: string;
             };
+            parent_id: {
+                type: string;
+                description: string;
+            };
+            thread_root_id: {
+                type: string;
+                description: string;
+            };
+            moderation_flags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
         };
         required: string[];
     };
@@ -74,6 +89,9 @@ export interface UpdateMemoryArgs {
     tags?: string[];
     references?: string[];
     structured_content?: Record<string, any>;
+    parent_id?: string | null;
+    thread_root_id?: string | null;
+    moderation_flags?: string[];
 }
 /**
  * Update memory result

package/dist/types/memory.d.ts

@@ -5,7 +5,7 @@
  * Content types for memories
  * Based on agent/design/content-types-expansion.md
  */
-export type ContentType = 'code' | 'note' | 'documentation' | 'reference' | 'todo' | 'checklist' | 'project' | 'goal' | 'habit' | 'email' | 'conversation' | 'meeting' | 'person' | 'article' | 'webpage' | 'social' | 'image' | 'video' | 'audio' | 'song' | 'transcript' | 'presentation' | 'spreadsheet' | 'pdf' | 'screenplay' | 'recipe' | 'idea' | 'quote' | 'journal' | 'memory' | 'event' | 'bookmark' | 'form' | 'location' | 'invoice' | 'contract' | 'system' | 'action' | 'audit' | 'history';
+export type ContentType = 'code' | 'note' | 'documentation' | 'reference' | 'todo' | 'checklist' | 'project' | 'goal' | 'habit' | 'email' | 'conversation' | 'meeting' | 'person' | 'article' | 'webpage' | 'social' | 'image' | 'video' | 'audio' | 'song' | 'transcript' | 'presentation' | 'spreadsheet' | 'pdf' | 'screenplay' | 'recipe' | 'idea' | 'quote' | 'poetry' | 'journal' | 'memory' | 'event' | 'bookmark' | 'form' | 'location' | 'invoice' | 'contract' | 'system' | 'action' | 'audit' | 'history';
 /**
  * GPS coordinates
  */
@@ -111,6 +111,9 @@ export interface Memory {
     structured_content?: Record<string, any>;
     base_weight: number;
     computed_weight?: number;
+    parent_id?: string | null;
+    thread_root_id?: string | null;
+    moderation_flags?: string[];
 }
 /**
  * Relationship interface

package/package.json

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

package/src/constants/content-types.ts

@@ -42,6 +42,7 @@ export const CONTENT_TYPES: readonly ContentType[] = [
   'recipe',
   'idea',
   'quote',
+  'poetry',
   // Personal
   'journal',
   'memory',
@@ -277,6 +278,13 @@ export const CONTENT_TYPE_METADATA: Record<ContentType, ContentTypeMetadata> = {
     examples: ['Quotes', 'Excerpts', 'Highlights', 'Citations'],
     common_fields: ['author', 'source'],
   },
+  poetry: {
+    name: 'poetry',
+    category: 'creative',
+    description: 'Poems and poetic content',
+    examples: ['Poems', 'Verses', 'Haiku', 'Sonnets', 'Free verse'],
+    common_fields: ['author', 'form', 'theme'],
+  },
 
   // Personal
   journal: {
@@ -379,7 +387,7 @@ export const CONTENT_TYPE_CATEGORIES = {
   communication: ['email', 'conversation', 'meeting', 'person'],
   content: ['article', 'webpage', 'social', 'presentation', 'spreadsheet', 'pdf'],
   media: ['image', 'video', 'audio', 'transcript'],
-  creative: ['song', 'screenplay', 'recipe', 'idea', 'quote'],
+  creative: ['song', 'screenplay', 'recipe', 'idea', 'quote', 'poetry'],
   personal: ['journal', 'memory', 'event'],
   organizational: ['bookmark', 'form', 'location'],
   business: ['invoice', 'contract'],

package/src/tools/create-memory.ts

@@ -80,6 +80,20 @@ export const createMemoryTool = {
         description: 'Skip automatic template suggestion',
         default: false,
       },
+      parent_id: {
+        type: 'string',
+        description: 'ID of parent memory or comment (for threading). Leave null for top-level memories.',
+      },
+      thread_root_id: {
+        type: 'string',
+        description: 'Root memory ID for thread. Leave null for top-level memories.',
+      },
+      moderation_flags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}"). Usually empty.',
+        default: [],
+      },
     },
     required: ['content'],
   },
@@ -99,6 +113,10 @@ export interface CreateMemoryArgs {
   template_id?: string;
   skip_template_suggestion?: boolean;
   structured_content?: Record<string, any>;
+  // Comment/threading fields
+  parent_id?: string | null;
+  thread_root_id?: string | null;
+  moderation_flags?: string[];
 }
 
 /**
@@ -186,6 +204,11 @@ export async function handleCreateMemory(
       // Computed weight
       base_weight: args.weight ?? 0.5,
       computed_weight: args.weight ?? 0.5,
+
+      // Comment/threading fields (initialize to defaults)
+      parent_id: args.parent_id ?? null,
+      thread_root_id: args.thread_root_id ?? null,
+      moderation_flags: args.moderation_flags ?? [],
     };
 
     // Insert into Weaviate v3 API

package/src/tools/update-memory.ts

@@ -70,6 +70,19 @@ export const updateMemoryTool = {
         type: 'object',
         description: 'Updated structured content',
       },
+      parent_id: {
+        type: 'string',
+        description: 'Update parent ID (for threading)',
+      },
+      thread_root_id: {
+        type: 'string',
+        description: 'Update thread root ID',
+      },
+      moderation_flags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Update moderation flags',
+      },
     },
     required: ['memory_id'],
   },
@@ -88,6 +101,10 @@ export interface UpdateMemoryArgs {
   tags?: string[];
   references?: string[];
   structured_content?: Record<string, any>;
+  // Comment/threading fields
+  parent_id?: string | null;
+  thread_root_id?: string | null;
+  moderation_flags?: string[];
 }
 
 /**
@@ -204,6 +221,22 @@ export async function handleUpdateMemory(
       updatedFields.push('structured_content');
     }
 
+    // Update comment/threading fields
+    if (args.parent_id !== undefined) {
+      updates.parent_id = args.parent_id;
+      updatedFields.push('parent_id');
+    }
+
+    if (args.thread_root_id !== undefined) {
+      updates.thread_root_id = args.thread_root_id;
+      updatedFields.push('thread_root_id');
+    }
+
+    if (args.moderation_flags !== undefined) {
+      updates.moderation_flags = args.moderation_flags;
+      updatedFields.push('moderation_flags');
+    }
+
     // Check if any fields were provided
     if (updatedFields.length === 0) {
       throw new Error('No fields provided for update. At least one field must be specified.');

package/src/types/memory.ts

@@ -40,6 +40,7 @@ export type ContentType =
   | 'recipe'
   | 'idea'
   | 'quote'
+  | 'poetry'
   // Personal
   | 'journal'
   | 'memory'
@@ -190,6 +191,11 @@ export interface Memory {
   // Computed Weight (for search ranking)
   base_weight: number; // User-specified
   computed_weight?: number; // Calculated with access multipliers
+
+  // Comment/Threading Fields (for threaded discussions in shared spaces)
+  parent_id?: string | null; // ID of parent memory or comment (null for top-level)
+  thread_root_id?: string | null; // Root memory ID for fetching entire thread (null for top-level)
+  moderation_flags?: string[]; // Per-space moderation flags (format: "{space_id}:{flag_type}")
 }
 
 /**