@prmichaelsen/remember-mcp 3.14.12 → 3.14.15

package/CHANGELOG.md

@@ -5,6 +5,26 @@ 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).
 
+## [3.14.14] - 2026-03-04
+
+### Changed
+
+- Parallelize `checkIfFriend` Firestore queries with `Promise.all` (task-77)
+- Add 60-second TTL cache to `checkIfFriend` for friend status lookups (task-78)
+- Memoize `createCoreServices` per userId to avoid per-request service instantiation (task-79)
+- Parallelize startup health checks (`testWeaviateConnection` + `testFirestoreConnection`) (task-80)
+- Optimize `blockUser`/`unblockUser` with `FieldValue.arrayUnion`/`arrayRemove` — eliminates read RPC (task-81)
+- Use native Weaviate `offset` parameter in `search-memory` instead of JS `slice()` (task-82)
+- Convert dynamic `import()` to static imports for ghost-config and access-control in server-factory (task-84)
+
+## [3.14.13] - 2026-03-04
+
+### Fixed
+
+- Fix `resolveAccessorTrustLevel` call sites to match new async 3-param signature (ownerUserId added for friend detection)
+- Rewrite `checkIfFriend` to use `queryDocuments` from firebase-admin-sdk-v8 (was using nonexistent `getFirestore()`)
+- Update access-control tests to use async/await with ownerUserId parameter
+
 ## [3.14.0] - 2026-02-28
 
 ### Changed

package/agent/milestones/milestone-18-performance-tuning.md

@@ -0,0 +1,45 @@
+# Milestone 18: Performance Tuning
+
+**Status**: Not Started
+**Priority**: Medium
+**Estimated Weeks**: 1
+**Dependencies**: None
+
+---
+
+## Objective
+
+Optimize remember-mcp server performance by eliminating redundant database calls, adding caching for rarely-changing data, parallelizing independent operations, and reducing per-request overhead.
+
+---
+
+## Success Criteria
+
+- [ ] Ghost mode requests do not make redundant Firestore queries for friend status
+- [ ] Core services are cached per-user instead of recreated on every tool call
+- [ ] Server startup parallelizes independent health checks
+- [ ] No functional regressions — all existing tests pass
+- [ ] Measurable latency improvement for ghost mode access checks
+
+---
+
+## Tasks
+
+| # | Task | Status | Est. Hours |
+|---|------|--------|------------|
+| 77 | Parallelize checkIfFriend Firestore queries | Not Started | 0.5 |
+| 78 | Add TTL cache to checkIfFriend | Not Started | 1 |
+| 79 | Memoize createCoreServices per userId | Not Started | 1 |
+| 80 | Parallelize startup health checks | Not Started | 0.5 |
+| 81 | Optimize ghost-config block/unblock with FieldValue | Not Started | 1 |
+| 82 | Use native Weaviate offset in search-memory | Not Started | 0.5 |
+| 83 | Eliminate redundant validateToken in confirm flow | Not Started | 1 |
+| 84 | Convert dynamic imports to static in server-factory | Not Started | 0.5 |
+
+---
+
+## Notes
+
+- Task 63 in remember-core covers Weaviate collection pooling (separate project)
+- Credential provider stub async overhead (#9 from audit) and esbuild parallelization (#10) are too trivial to warrant tasks
+- All changes are internal — no API changes for consumers

package/agent/progress.yaml

@@ -341,6 +341,17 @@ milestones:
       3 tools deferred (search_memory, query_memory, ghost_config) — require core ghost/trust support.
       See: agent/milestones/milestone-17-remember-core-migration.md
 
+  - id: M18
+    name: Performance Tuning
+    status: in_progress
+    progress: 87%
+    estimated_weeks: 1
+    tasks_completed: 7
+    tasks_total: 8
+    notes: |
+      Optimize server performance: parallel queries, caching, memoization.
+      See: agent/milestones/milestone-18-performance-tuning.md
+
 tasks:
   milestone_1:
     - id: task-1
@@ -986,11 +997,84 @@ tasks:
         ✅ Removed empty src/constants/ and src/collections/ directories.
         ✅ Build passing, 390 tests (389 passed, 1 skipped).
 
+  milestone_18:
+    - id: task-77
+      name: Parallelize checkIfFriend Firestore Queries
+      status: completed
+      completed_date: 2026-03-04
+      file: agent/tasks/task-77-parallelize-checkiffriend.md
+      estimated_hours: 0.5
+      notes: |
+        Run forward + reverse friend queries in Promise.all
+
+    - id: task-78
+      name: Add TTL Cache to checkIfFriend
+      status: completed
+      completed_date: 2026-03-04
+      file: agent/tasks/task-78-cache-checkiffriend.md
+      estimated_hours: 1
+      dependencies: [task-77]
+      notes: |
+        60s TTL cache for friend status lookups
+
+    - id: task-79
+      name: Memoize createCoreServices per userId
+      status: completed
+      completed_date: 2026-03-04
+      file: agent/tasks/task-79-memoize-core-services.md
+      estimated_hours: 1
+      notes: |
+        Cache CoreServices instances per userId
+
+    - id: task-80
+      name: Parallelize Startup Health Checks
+      status: completed
+      completed_date: 2026-03-04
+      file: agent/tasks/task-80-parallelize-startup-health-checks.md
+      estimated_hours: 0.5
+      notes: |
+        Promise.all for testWeaviateConnection + testFirestoreConnection
+
+    - id: task-81
+      name: Optimize ghost-config block/unblock with FieldValue
+      status: completed
+      completed_date: 2026-03-04
+      file: agent/tasks/task-81-optimize-ghost-config-block-unblock.md
+      estimated_hours: 1
+      notes: |
+        Use FieldValue.arrayUnion/arrayRemove to skip read RPC
+
+    - id: task-82
+      name: Use Native Weaviate Offset in search-memory
+      status: completed
+      completed_date: 2026-03-04
+      file: agent/tasks/task-82-native-weaviate-offset.md
+      estimated_hours: 0.5
+      notes: |
+        Pass offset to Weaviate instead of JS slice
+
+    - id: task-83
+      name: Eliminate Redundant validateToken in Confirm Flow
+      status: deferred
+      file: agent/tasks/task-83-eliminate-redundant-validatetoken.md
+      estimated_hours: 1
+      notes: |
+        Remove peek-then-consume double read
+
+    - id: task-84
+      name: Convert Dynamic Imports to Static in server-factory
+      status: completed
+      completed_date: 2026-03-04
+      file: agent/tasks/task-84-static-imports-server-factory.md
+      estimated_hours: 0.5
+      notes: |
+        Static imports for ghost-config and access-control
+
 documentation:
   design_documents: 31
-  milestone_documents: 13
+  milestone_documents: 14
   pattern_documents: 7
-  task_documents: 83
+  task_documents: 91
 
 progress:
   planning: 100%

package/agent/tasks/task-77-parallelize-checkiffriend.md

@@ -0,0 +1,62 @@
+# Task 77: Parallelize checkIfFriend Firestore Queries
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 0.5 hours
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Run the two directional friendship queries in `checkIfFriend` concurrently with `Promise.all` instead of sequentially, cutting worst-case latency from ~400ms to ~200ms.
+
+---
+
+## Context
+
+`src/services/access-control.ts` `checkIfFriend()` queries Firestore twice sequentially (owner→accessor, then accessor→owner). These are independent queries that can run in parallel.
+
+---
+
+## Steps
+
+### 1. Refactor checkIfFriend to use Promise.all
+
+**File**: `src/services/access-control.ts`
+
+Replace the sequential pattern:
+```typescript
+const results = await queryDocuments(...forward...);
+if (results.length > 0) return true;
+const reverseResults = await queryDocuments(...reverse...);
+return reverseResults.length > 0;
+```
+
+With parallel:
+```typescript
+const [forward, reverse] = await Promise.all([
+  queryDocuments(...forward...),
+  queryDocuments(...reverse...),
+]);
+return forward.length > 0 || reverse.length > 0;
+```
+
+### 2. Verify tests pass
+
+Run `npx jest --testPathPattern=access-control`.
+
+---
+
+## Verification
+
+- [ ] Both queries run in parallel via Promise.all
+- [ ] All access-control tests pass
+- [ ] TypeScript compiles without errors
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/services/access-control.ts`

package/agent/tasks/task-78-cache-checkiffriend.md

@@ -0,0 +1,78 @@
+# Task 78: Add TTL Cache to checkIfFriend
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 1 hour
+**Dependencies**: Task 77
+**Status**: Not Started
+
+---
+
+## Objective
+
+Cache friend status lookups with a short TTL so repeated ghost mode access checks for the same user pair don't hit Firestore on every memory.
+
+---
+
+## Context
+
+`checkIfFriend` is called from `resolveAccessorTrustLevel` → `checkMemoryAccess`, which runs per-memory in prompt/hybrid enforcement modes. Friend status rarely changes during a session. A 60-second TTL cache eliminates redundant Firestore reads.
+
+---
+
+## Steps
+
+### 1. Add TTL Map cache
+
+**File**: `src/services/access-control.ts`
+
+```typescript
+const friendCache = new Map<string, { result: boolean; expiresAt: number }>();
+const FRIEND_CACHE_TTL_MS = 60_000; // 60 seconds
+```
+
+### 2. Check cache before querying
+
+In `checkIfFriend`, check both directions (key `a:b` and `b:a` are the same friendship):
+```typescript
+const key = [ownerUserId, accessorUserId].sort().join(':');
+const cached = friendCache.get(key);
+if (cached && Date.now() < cached.expiresAt) return cached.result;
+```
+
+### 3. Store result in cache after query
+
+```typescript
+friendCache.set(key, { result, expiresAt: Date.now() + FRIEND_CACHE_TTL_MS });
+```
+
+### 4. Export cache invalidation for tests
+
+```typescript
+export function invalidateFriendCache(): void {
+  friendCache.clear();
+}
+```
+
+### 5. Add tests
+
+- Cache hit returns without Firestore call
+- Cache expires after TTL
+- `invalidateFriendCache()` clears cache
+
+---
+
+## Verification
+
+- [ ] Repeated calls for same user pair don't hit Firestore
+- [ ] Cache expires after 60 seconds
+- [ ] invalidateFriendCache works
+- [ ] All existing tests pass
+- [ ] New cache tests pass
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/services/access-control.ts`
+- `src/services/access-control.spec.ts`

package/agent/tasks/task-79-memoize-core-services.md

@@ -0,0 +1,75 @@
+# Task 79: Memoize createCoreServices per userId
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 1 hour
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Cache `CoreServices` instances per `userId` so that repeated tool calls don't instantiate new `MemoryService`, `RelationshipService`, and `SpaceService` objects on every invocation.
+
+---
+
+## Context
+
+`src/core-services.ts` `createCoreServices(userId)` is called by every tool handler. Each call creates 3 new service instances and calls `getMemoryCollection(userId)` (which calls `client.collections.get()`). In factory mode, the server is scoped to one userId, making all these allocations pure overhead after the first call.
+
+---
+
+## Steps
+
+### 1. Add Map cache
+
+**File**: `src/core-services.ts`
+
+```typescript
+const coreServicesCache = new Map<string, CoreServices>();
+
+export function createCoreServices(userId: string): CoreServices {
+  const cached = coreServicesCache.get(userId);
+  if (cached) return cached;
+
+  const collection = getMemoryCollection(userId);
+  const weaviateClient = getWeaviateClient();
+
+  const services: CoreServices = {
+    memory: new MemoryService(collection, userId, coreLogger),
+    relationship: new RelationshipService(collection, userId, coreLogger),
+    space: new SpaceService(weaviateClient, collection, userId, tokenService, coreLogger),
+    preferences: preferencesService,
+    token: tokenService,
+  };
+
+  coreServicesCache.set(userId, services);
+  return services;
+}
+```
+
+### 2. Export invalidation for tests
+
+```typescript
+export function invalidateCoreServicesCache(): void {
+  coreServicesCache.clear();
+}
+```
+
+### 3. Verify all tests pass
+
+---
+
+## Verification
+
+- [ ] Second call for same userId returns cached instance
+- [ ] Different userIds get different instances
+- [ ] All existing tests pass
+- [ ] TypeScript compiles without errors
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/core-services.ts`

package/agent/tasks/task-80-parallelize-startup-health-checks.md

@@ -0,0 +1,57 @@
+# Task 80: Parallelize Startup Health Checks
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 0.5 hours
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Run `testWeaviateConnection()` and `testFirestoreConnection()` in parallel during server startup to reduce init latency.
+
+---
+
+## Context
+
+`src/server.ts` lines 61-63 run these two independent health checks sequentially. Each is a network round-trip (50-200ms). Running them in parallel saves the latency of the slower one.
+
+---
+
+## Steps
+
+### 1. Update server.ts
+
+**File**: `src/server.ts`
+
+Replace:
+```typescript
+const weaviateOk = await testWeaviateConnection();
+const firestoreOk = await testFirestoreConnection();
+```
+
+With:
+```typescript
+const [weaviateOk, firestoreOk] = await Promise.all([
+  testWeaviateConnection(),
+  testFirestoreConnection(),
+]);
+```
+
+### 2. Verify startup works
+
+---
+
+## Verification
+
+- [ ] Server starts successfully
+- [ ] Both connection tests still run
+- [ ] TypeScript compiles without errors
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/server.ts`

package/agent/tasks/task-81-optimize-ghost-config-block-unblock.md

@@ -0,0 +1,64 @@
+# Task 81: Optimize ghost-config block/unblock with FieldValue
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 1 hour
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Replace read-modify-write pattern in `blockUser` and `unblockUser` with Firestore `FieldValue.arrayUnion` / `FieldValue.arrayRemove` to eliminate the read RPC.
+
+---
+
+## Context
+
+`src/services/ghost-config.service.ts` `blockUser()` and `unblockUser()` each:
+1. Read the entire GhostConfig document from Firestore
+2. Modify the `blocked_users` array in memory
+3. Write the document back
+
+Firestore's `FieldValue.arrayUnion/arrayRemove` can atomically add/remove array elements without reading first, halving the RPC count for these operations.
+
+---
+
+## Steps
+
+### 1. Update blockUser
+
+**File**: `src/services/ghost-config.service.ts`
+
+Replace read-modify-write with:
+```typescript
+await setDocument(collectionPath, docId, {
+  blocked_users: FieldValue.arrayUnion(targetUserId),
+}, { merge: true });
+```
+
+### 2. Update unblockUser
+
+```typescript
+await setDocument(collectionPath, docId, {
+  blocked_users: FieldValue.arrayRemove(targetUserId),
+}, { merge: true });
+```
+
+### 3. Verify ghost-config tests pass
+
+---
+
+## Verification
+
+- [ ] blockUser works without reading first
+- [ ] unblockUser works without reading first
+- [ ] All ghost-config tests pass
+- [ ] TypeScript compiles without errors
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/services/ghost-config.service.ts`

package/agent/tasks/task-82-native-weaviate-offset.md

@@ -0,0 +1,69 @@
+# Task 82: Use Native Weaviate Offset in search-memory
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 0.5 hours
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Pass `offset` directly to Weaviate's hybrid search query instead of fetching `limit + offset` results and slicing in JavaScript.
+
+---
+
+## Context
+
+`src/tools/search-memory.ts` currently fetches extra records and uses `slice(offset)` to implement pagination. Weaviate v3 API supports native `offset` in query options, which reduces network payload for paginated searches.
+
+---
+
+## Steps
+
+### 1. Update search query options
+
+**File**: `src/tools/search-memory.ts`
+
+Replace:
+```typescript
+const searchOptions: any = {
+  alpha: alpha,
+  limit: limit + offset,
+};
+// ...
+const paginatedResults = results.objects.slice(offset);
+```
+
+With:
+```typescript
+const searchOptions: any = {
+  alpha: alpha,
+  limit: limit,
+  offset: offset,
+};
+// ... use results.objects directly
+```
+
+### 2. Check if same pattern exists in other search tools
+
+Check `query-memory.ts`, `search-space.ts`, `query-space.ts`, `find-similar.ts` for the same pattern.
+
+### 3. Verify tests pass
+
+---
+
+## Verification
+
+- [ ] Offset handled by Weaviate, not JS slice
+- [ ] Pagination still works correctly
+- [ ] All search-related tests pass
+- [ ] TypeScript compiles without errors
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/tools/search-memory.ts`
+- Possibly other search tool files

package/agent/tasks/task-83-eliminate-redundant-validatetoken.md

@@ -0,0 +1,53 @@
+# Task 83: Eliminate Redundant validateToken in Confirm Flow
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 1 hour
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Remove the redundant `validateToken` call in the confirm tool's delete_memory path, where `confirmRequest` already retrieves the full token payload.
+
+---
+
+## Context
+
+`src/tools/confirm.ts` calls `tokenService.validateToken()` to peek at the token action type, then immediately calls `tokenService.confirmRequest()` which reads the token again. For the delete_memory path, this is two sequential storage reads when one would suffice.
+
+---
+
+## Steps
+
+### 1. Analyze confirm.ts flow
+
+Read `src/tools/confirm.ts` to understand all action type branches and whether `confirmRequest` returns sufficient data to eliminate the validate step.
+
+### 2. Refactor to single call
+
+If `confirmRequest` returns the full request payload on success, use it directly:
+```typescript
+const confirmed = await tokenService.confirmRequest(userId, args.token);
+if (!confirmed) { return error; }
+// Use confirmed.action to determine path
+```
+
+### 3. Verify all confirm-related tests pass
+
+---
+
+## Verification
+
+- [ ] Only one storage read per confirm call
+- [ ] All action types still handled correctly
+- [ ] All confirm/deny tests pass
+- [ ] TypeScript compiles without errors
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/tools/confirm.ts`

package/agent/tasks/task-84-static-imports-server-factory.md

@@ -0,0 +1,52 @@
+# Task 84: Convert Dynamic Imports to Static in server-factory
+
+**Milestone**: M18 - Performance Tuning
+**Estimated Time**: 0.5 hours
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Replace dynamic `import()` calls for ghost-config and access-control modules in `server-factory.ts` with static top-level imports to eliminate async module resolution overhead on the hot path.
+
+---
+
+## Context
+
+`src/server-factory.ts` lines 177-179 use `await import(...)` for `ghost-config.service.js` and `access-control.js` even though both modules are statically available. Dynamic imports add unnecessary microtask overhead on every server-factory instantiation with ghost mode.
+
+---
+
+## Steps
+
+### 1. Move imports to top level
+
+**File**: `src/server-factory.ts`
+
+Add static imports at the top:
+```typescript
+import { getGhostConfig } from './services/ghost-config.service.js';
+import { resolveAccessorTrustLevel } from './services/access-control.js';
+```
+
+Remove the dynamic imports inside the `if (options.ghostMode)` block.
+
+### 2. Verify tests pass
+
+---
+
+## Verification
+
+- [ ] No dynamic imports for ghost-config or access-control
+- [ ] Ghost mode still works correctly
+- [ ] All server-factory tests pass
+- [ ] TypeScript compiles without errors
+
+---
+
+## Expected Output
+
+**Files Modified**:
+- `src/server-factory.ts`

package/dist/core-services.d.ts

@@ -17,9 +17,11 @@ declare const coreLogger: Logger;
 declare const tokenService: ConfirmationTokenService;
 declare const preferencesService: PreferencesDatabaseService;
 /**
- * Create core services scoped to a specific user.
+ * Create (or return cached) core services scoped to a specific user.
  * Call after databases have been initialized (initWeaviateClient + initFirestore).
  */
 export declare function createCoreServices(userId: string): CoreServices;
+/** Clear the core services cache (for tests or forced refresh) */
+export declare function invalidateCoreServicesCache(): void;
 export { coreLogger, tokenService, preferencesService };
 //# sourceMappingURL=core-services.d.ts.map