@prmichaelsen/remember-mcp 2.3.1 → 2.5.0

package/agent/milestones/milestone-11-unified-public-collection.md

@@ -0,0 +1,205 @@
+# Milestone 11: Unified Public Collection
+
+**Goal**: Implement unified `Memory_public` collection with multi-space support
+**Duration**: 1-2 weeks
+**Dependencies**: M10 (Shared Spaces & Confirmation Flow)
+**Status**: Not Started
+
+---
+
+## Overview
+
+Replace per-space collections (`Memory_the_void`, `Memory_dogs`, etc.) with a unified `Memory_public` collection where memories can belong to multiple spaces simultaneously. This enables multi-space search, eliminates duplication, and provides a more flexible and scalable architecture.
+
+This milestone introduces:
+- **Unified Collection**: Single `Memory_public` for all public spaces
+- **Multi-Space Support**: `spaces: string[]` array instead of single `space_id`
+- **Multi-Space Search**: Query multiple spaces in one call
+- **No Duplication**: One memory, multiple spaces
+- **Efficient Storage**: N× reduction in documents
+
+---
+
+## Deliverables
+
+### 1. Type System Updates
+- Update `SpaceMemory` interface: `space_id: string` → `spaces: string[]`
+- Update type exports and constants
+- Backward compatibility considerations
+
+### 2. Schema Updates
+- Add `spaces` array field to Weaviate schema
+- Create `Memory_public` collection
+- Update space schema utilities
+- Collection name constants
+
+### 3. Tool Updates (5 tools)
+- Update `remember_publish` - Support `spaces` array parameter
+- Update `remember_confirm` - Handle multi-space publishing
+- Update `remember_search_space` - Multi-space search with `containsAny`
+- Update `remember_query_space` - Multi-space RAG queries
+- Update `remember_deny` - No changes needed
+
+### 4. Migration Strategy
+- Backward compatibility during transition
+- Data migration plan (if needed)
+- Deprecation timeline
+
+### 5. Testing & Documentation
+- Update unit tests for all affected tools
+- Add multi-space test scenarios
+- Update README with multi-space examples
+- Update API documentation
+
+---
+
+## Success Criteria
+
+- [ ] `SpaceMemory` type uses `spaces: string[]`
+- [ ] `Memory_public` collection created successfully
+- [ ] `remember_publish` accepts `spaces` array
+- [ ] Can publish to multiple spaces in one call
+- [ ] `remember_search_space` accepts `spaces` array
+- [ ] Multi-space search returns results from all requested spaces
+- [ ] No memory duplication across spaces
+- [ ] All 5 space tools work with new architecture
+- [ ] TypeScript compiles without errors
+- [ ] All tests passing (including new multi-space tests)
+- [ ] Build successful
+- [ ] README updated with multi-space examples
+- [ ] Backward compatibility maintained (if applicable)
+
+---
+
+## Key Files to Modify
+
+```
+src/
+├── types/
+│   └── space-memory.ts              # Update SpaceMemory interface
+├── weaviate/
+│   └── space-schema.ts              # Update schema, add Memory_public
+└── tools/
+    ├── publish.ts                   # Support spaces array
+    ├── confirm.ts                   # Handle multi-space publish
+    ├── search-space.ts              # Multi-space search
+    └── query-space.ts               # Multi-space query
+
+tests/
+└── unit/
+    ├── space-schema.test.ts         # Add multi-space tests
+    ├── publish.test.ts              # Add multi-space tests
+    ├── search-space.test.ts         # Add multi-space tests
+    └── query-space.test.ts          # Add multi-space tests
+```
+
+---
+
+## Implementation Tasks
+
+See individual task documents:
+- Task 46: Update SpaceMemory Types for Multi-Space
+- Task 47: Update Space Schema with Spaces Array
+- Task 48: Create Memory_public Collection
+- Task 49: Update remember_publish for Multi-Space
+- Task 50: Update remember_confirm for Multi-Space
+- Task 51: Update remember_search_space for Multi-Space
+- Task 52: Update remember_query_space for Multi-Space
+- Task 53: Add Multi-Space Unit Tests
+- Task 54: Update Documentation for Multi-Space
+
+---
+
+## Architecture Notes
+
+### Before (Per-Space Collections)
+```
+Memory_the_void     → Only "The Void" memories
+Memory_dogs         → Only "Dogs" memories
+Memory_cats         → Only "Cats" memories
+```
+
+**Problems**:
+- Can't search multiple spaces at once
+- Memory duplication if published to multiple spaces
+- Collection proliferation
+
+### After (Unified Collection)
+```
+Memory_public       → ALL public memories
+  - spaces: ["the_void"]
+  - spaces: ["dogs", "cats"]
+  - spaces: ["the_void", "dogs"]
+```
+
+**Benefits**:
+- ✅ Multi-space search in one query
+- ✅ No duplication
+- ✅ Efficient storage
+- ✅ Flexible space management
+
+### Multi-Space Search Example
+```typescript
+remember_search_space({
+  spaces: ["the_void", "dogs"],  // ✅ Multiple spaces!
+  query: "cute dog pictures"
+})
+
+// Weaviate filter:
+collection.filter.byProperty('spaces').containsAny(['the_void', 'dogs'])
+```
+
+---
+
+## Migration Strategy
+
+### Phase 1: Add Support (v2.4.0 - Backward Compatible)
+- Add `spaces` field to schema (keep `space_id` temporarily)
+- Support both `space` and `spaces` parameters
+- Create `Memory_public` collection
+- Dual-write to both old and new collections
+
+### Phase 2: Migrate Data (v2.5.0)
+- Copy existing memories from per-space to unified
+- Verify data integrity
+- Mark old collections as deprecated
+
+### Phase 3: Remove Old (v3.0.0 - Breaking Change)
+- Remove `space_id` field
+- Remove per-space collections
+- Remove backward compatibility code
+- Update all documentation
+
+---
+
+## Testing Strategy
+
+1. **Unit Tests**: Each tool with multi-space scenarios
+2. **Integration Tests**: Full publish → search workflow
+3. **Migration Tests**: Data migration validation
+4. **Performance Tests**: Compare single vs. multi-space queries
+
+---
+
+## Breaking Changes
+
+**v3.0.0 (Future)**:
+- Remove `space_id` field from SpaceMemory
+- Remove per-space collections
+- Remove `space` parameter (use `spaces` only)
+
+**Migration Guide**:
+```typescript
+// Before (v2.3.x)
+remember_publish({ memory_id: "abc", target: "the_void" })
+remember_search_space({ space: "the_void", query: "..." })
+
+// After (v3.0.0)
+remember_publish({ memory_id: "abc", spaces: ["the_void"] })
+remember_search_space({ spaces: ["the_void"], query: "..." })
+```
+
+---
+
+**Next Milestone**: M12 - Comment System (3 schema fields only!)
+**Blockers**: None (builds on M10)

package/agent/progress.yaml

@@ -391,6 +391,32 @@ progress:
   overall: 50%
 
 recent_work:
+  - date: 2026-02-16
+    description: ACP Initialization Complete - Project Status Verified
+    items:
+      - ✅ ACP initialization workflow executed via @acp.init command
+      - ⚠️  ACP updates available (v1.2.1 with new command format)
+      - ✅ All agent documentation reviewed (23 design docs, 10 milestones, 33 tasks, 5 patterns)
+      - ✅ Project status verified: M1-M4 complete (100%), M10 in progress
+      - ✅ Version 2.3.1 confirmed (latest patch release)
+      - ✅ 53 unit tests passing (1 skipped integration test)
+      - ✅ Test coverage: 29.76% overall
+      - ✅ TypeScript compiles without errors
+      - ✅ Build successful (dual export: server + factory)
+      - ✅ All 17 MCP tools implemented and working
+      - ✅ M10 Shared Spaces: 5 tools implemented (publish, confirm, deny, search_space, query_space)
+      - ✅ Token-based confirmation system operational
+      - ✅ Space collections: Memory_the_void with snake_case naming
+      - ✅ Confirmation token service with 5-minute expiry
+      - ✅ Space memory types and schema complete
+      - ✅ Multi-tenant architecture with per-user isolation
+      - ✅ Vector search with Weaviate + metadata with Firestore
+      - ✅ 45 content types with dynamic descriptions
+      - ✅ N-way relationships with bidirectional tracking
+      - ✅ User preferences system (6 categories)
+      - 📋 M10 implementation appears complete - needs verification
+      - 📋 Ready to verify M10 completion and update documentation
+      
   - date: 2026-02-16
     description: Created Milestone 10 and Tasks for Shared Spaces
     items:

package/agent/scripts/install.sh

@@ -55,6 +55,7 @@ mkdir -p "$TARGET_DIR/agent/patterns"
 mkdir -p "$TARGET_DIR/agent/tasks"
 mkdir -p "$TARGET_DIR/agent/commands"
 mkdir -p "$TARGET_DIR/agent/scripts"
+mkdir -p "$TARGET_DIR/agent/reports"
 
 # Create .gitkeep files
 touch "$TARGET_DIR/agent/design/.gitkeep"
@@ -62,6 +63,15 @@ touch "$TARGET_DIR/agent/milestones/.gitkeep"
 touch "$TARGET_DIR/agent/patterns/.gitkeep"
 touch "$TARGET_DIR/agent/tasks/.gitkeep"
 
+# Create agent/.gitignore to exclude reports from version control
+cat > "$TARGET_DIR/agent/.gitignore" << 'EOF'
+# Agent Context Protocol - Local Files
+# These files are generated locally and should not be committed
+
+# Reports directory - generated by @acp.report command
+reports/
+EOF
+
 echo -e "${GREEN}✓${NC} Directory structure created"
 echo ""
 
@@ -113,6 +123,20 @@ echo "   cp agent/progress.template.yaml agent/progress.yaml"
 echo ""
 echo "4. Read AGENT.md for complete documentation"
 echo ""
+echo -e "${BLUE}ACP Commands Available:${NC}"
+echo ""
+echo "  ${GREEN}@acp.init${NC}                    - Initialize agent context (start here!)"
+echo "  ${GREEN}@acp.proceed${NC}                 - Continue with next task"
+echo "  ${GREEN}@acp.status${NC}                  - Display project status"
+echo "  ${GREEN}@acp.update${NC}                  - Update progress tracking"
+echo "  ${GREEN}@acp.sync${NC}                    - Sync documentation with code"
+echo "  ${GREEN}@acp.validate${NC}                - Validate ACP documents"
+echo "  ${GREEN}@acp.report${NC}                  - Generate project report"
+echo "  ${GREEN}@acp.version-check${NC}           - Show current ACP version"
+echo "  ${GREEN}@acp.version-check-for-updates${NC} - Check for ACP updates"
+echo "  ${GREEN}@acp.version-update${NC}          - Update ACP to latest version"
+echo "  ${GREEN}@acp.package-install${NC}         - Install third-party command packages"
+echo ""
 echo -e "${BLUE}For AI agents:${NC}"
-echo "Type 'AGENT.md: Initialize' to get started."
+echo "Type '${GREEN}@acp.init${NC}' to get started."
 echo ""

package/agent/scripts/update.sh

@@ -41,6 +41,20 @@ fi
 echo -e "${GREEN}✓${NC} Latest files fetched"
 echo ""
 
+# Ensure reports directory exists and is ignored
+mkdir -p "agent/reports"
+if [ ! -f "agent/.gitignore" ]; then
+    echo "Creating agent/.gitignore..."
+    cat > "agent/.gitignore" << 'EOF'
+# Agent Context Protocol - Local Files
+# These files are generated locally and should not be committed
+
+# Reports directory - generated by @acp.report command
+reports/
+EOF
+    echo -e "${GREEN}✓${NC} Created agent/.gitignore"
+fi
+
 echo "Updating ACP files..."
 
 # Update template files (only .template.md files from these directories)
@@ -77,6 +91,12 @@ echo -e "${GREEN}✓${NC} All files updated"
 echo ""
 echo -e "${GREEN}Update complete!${NC}"
 echo ""
+echo -e "${BLUE}What was updated:${NC}"
+echo "  ✓ AGENT.md (methodology documentation)"
+echo "  ✓ Template files (design, milestone, task, pattern)"
+echo "  ✓ Command files (all ACP commands)"
+echo "  ✓ Utility scripts (update, check-for-updates, version, etc.)"
+echo ""
 echo -e "${BLUE}Next steps:${NC}"
 echo "1. Review changes: git diff"
 echo "2. See what changed: git status"
@@ -85,3 +105,20 @@ echo ""
 echo "For detailed changelog:"
 echo "  https://github.com/prmichaelsen/agent-context-protocol/blob/mainline/CHANGELOG.md"
 echo ""
+echo -e "${BLUE}ACP Commands Available:${NC}"
+echo ""
+echo "  ${GREEN}@acp.init${NC}                    - Initialize agent context (run after update!)"
+echo "  ${GREEN}@acp.proceed${NC}                 - Continue with next task"
+echo "  ${GREEN}@acp.status${NC}                  - Display project status"
+echo "  ${GREEN}@acp.update${NC}                  - Update progress tracking"
+echo "  ${GREEN}@acp.sync${NC}                    - Sync documentation with code"
+echo "  ${GREEN}@acp.validate${NC}                - Validate ACP documents"
+echo "  ${GREEN}@acp.report${NC}                  - Generate project report"
+echo "  ${GREEN}@acp.version-check${NC}           - Show current ACP version"
+echo "  ${GREEN}@acp.version-check-for-updates${NC} - Check for ACP updates"
+echo "  ${GREEN}@acp.version-update${NC}          - Update ACP to latest version"
+echo "  ${GREEN}@acp.package-install${NC}         - Install third-party command packages"
+echo ""
+echo -e "${BLUE}For AI agents:${NC}"
+echo "Type '${GREEN}@acp.init${NC}' to reload context with updated files."
+echo ""

package/agent/tasks/task-46-update-spacememory-types.md

@@ -0,0 +1,94 @@
+# Task 46: Update SpaceMemory Types for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 1 hour
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the `SpaceMemory` interface to use `spaces: string[]` instead of `space_id: string`, enabling memories to belong to multiple spaces simultaneously.
+
+---
+
+## Steps
+
+### 1. Update SpaceMemory Interface
+
+**File**: `src/types/space-memory.ts`
+
+**Changes**:
+```typescript
+// Before
+export interface SpaceMemory extends Omit<Memory, 'user_id' | 'doc_type'> {
+  space_id: string;  // ❌ Single space
+  author_id: string;
+  // ...
+}
+
+// After
+export interface SpaceMemory extends Omit<Memory, 'user_id' | 'doc_type'> {
+  spaces: string[];  // ✅ Multiple spaces!
+  author_id: string;
+  // ...
+}
+```
+
+### 2. Update Type Exports
+
+**File**: `src/types/space-memory.ts`
+
+- Update `SpaceSearchOptions` if needed
+- Update `SpaceSearchResult` if needed
+- Keep `SpaceId` type and `SUPPORTED_SPACES` constant
+
+### 3. Add Backward Compatibility (Optional)
+
+Consider adding a migration helper:
+```typescript
+export function migrateSpaceMemory(old: any): SpaceMemory {
+  if (old.space_id && !old.spaces) {
+    return {
+      ...old,
+      spaces: [old.space_id],
+    };
+  }
+  return old;
+}
+```
+
+### 4. Update Type Tests
+
+**File**: Create `src/types/space-memory.spec.ts` if needed
+
+Test that:
+- SpaceMemory interface has `spaces` array
+- Type checking works correctly
+- Migration helper works (if implemented)
+
+---
+
+## Verification
+
+- [ ] `SpaceMemory` interface uses `spaces: string[]`
+- [ ] No `space_id` field in interface
+- [ ] Type exports updated
+- [ ] TypeScript compiles without errors
+- [ ] No breaking changes to existing code (yet)
+- [ ] Documentation comments updated
+
+---
+
+## Files Modified
+
+- `src/types/space-memory.ts` - Update interface
+
+## Files Created
+
+- `src/types/space-memory.spec.ts` - Type tests (optional)
+
+---
+
+**Next Task**: Task 47 - Update Space Schema with Spaces Array

package/agent/tasks/task-47-update-space-schema.md

@@ -0,0 +1,102 @@
+# Task 47: Update Space Schema with Spaces Array
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 2 hours
+**Dependencies**: Task 46
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the Weaviate space collection schema to include a `spaces` array field and prepare for the unified `Memory_public` collection.
+
+---
+
+## Steps
+
+### 1. Add Spaces Field to Schema
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Add property**:
+```typescript
+{
+  name: 'spaces',
+  dataType: 'text[]' as any,
+  description: 'Spaces this memory is published to (e.g., ["the_void", "dogs"])',
+}
+```
+
+### 2. Update Collection Name Constant
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Add**:
+```typescript
+export const PUBLIC_COLLECTION_NAME = 'Memory_public';
+```
+
+### 3. Create ensurePublicCollection Function
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Add**:
+```typescript
+/**
+ * Ensure the unified public collection exists
+ */
+export async function ensurePublicCollection(
+  client: WeaviateClient
+): Promise<Collection<any>> {
+  const collectionName = PUBLIC_COLLECTION_NAME;
+  
+  const exists = await client.collections.exists(collectionName);
+  
+  if (!exists) {
+    await createSpaceCollection(client, 'public');
+  }
+  
+  return client.collections.get(collectionName);
+}
+```
+
+### 4. Keep Backward Compatibility
+
+**File**: `src/weaviate/space-schema.ts`
+
+- Keep `ensureSpaceCollection()` function for now
+- Keep `getSpaceCollectionName()` function for now
+- Add deprecation comments
+
+### 5. Update Schema Tests
+
+**File**: `src/weaviate/space-schema.spec.ts`
+
+**Add tests**:
+- Test `ensurePublicCollection()` creates `Memory_public`
+- Test `spaces` field is in schema
+- Test backward compatibility functions still work
+
+---
+
+## Verification
+
+- [ ] `spaces` field added to schema as `text[]`
+- [ ] `PUBLIC_COLLECTION_NAME` constant defined
+- [ ] `ensurePublicCollection()` function created
+- [ ] Backward compatibility maintained
+- [ ] Schema tests updated and passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/weaviate/space-schema.ts` - Add spaces field, public collection
+- `src/weaviate/space-schema.spec.ts` - Add tests
+
+---
+
+**Next Task**: Task 48 - Create Memory_public Collection

package/agent/tasks/task-48-create-memory-public-collection.md

@@ -0,0 +1,96 @@
+# Task 48: Create Memory_public Collection
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 1 hour
+**Dependencies**: Task 47
+**Status**: Not Started
+
+---
+
+## Objective
+
+Create the unified `Memory_public` Weaviate collection that will store all public space memories with the new `spaces` array field.
+
+---
+
+## Steps
+
+### 1. Update Collection Creation Logic
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Modify `createSpaceCollection`**:
+```typescript
+async function createSpaceCollection(
+  client: WeaviateClient,
+  spaceId: string
+): Promise<void> {
+  // Handle 'public' as special case
+  const collectionName = spaceId === 'public' 
+    ? PUBLIC_COLLECTION_NAME 
+    : getSpaceCollectionName(spaceId);
+  
+  console.log(`[Weaviate] Creating space collection ${collectionName}...`);
+  
+  // ... rest of schema creation
+}
+```
+
+### 2. Test Collection Creation
+
+**File**: `src/weaviate/space-schema.spec.ts`
+
+**Add test**:
+```typescript
+it('should create Memory_public collection', async () => {
+  const collection = await ensurePublicCollection(mockClient);
+  
+  expect(mockClient.collections.exists).toHaveBeenCalledWith('Memory_public');
+  expect(mockClient.collections.create).toHaveBeenCalled();
+  expect(collection.name).toBe('Memory_public');
+});
+```
+
+### 3. Verify Schema Properties
+
+Ensure `Memory_public` has all required fields:
+- `spaces` array (new)
+- `space_id` (deprecated, for migration)
+- `author_id`
+- `attribution`
+- `published_at`
+- `discovery_count`
+- All standard memory fields
+
+### 4. Test with Actual Weaviate (Optional)
+
+If Weaviate instance available:
+```typescript
+// Manual test
+const client = getWeaviateClient();
+const collection = await ensurePublicCollection(client);
+console.log('Collection created:', collection.name);
+```
+
+---
+
+## Verification
+
+- [ ] `Memory_public` collection can be created
+- [ ] Collection has `spaces` array field
+- [ ] Collection has all required properties
+- [ ] `ensurePublicCollection()` works correctly
+- [ ] Tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/weaviate/space-schema.ts` - Update collection creation
+- `src/weaviate/space-schema.spec.ts` - Add tests
+
+---
+
+**Next Task**: Task 49 - Update remember_publish for Multi-Space