@prmichaelsen/remember-mcp 3.14.12 → 3.14.15

package/dist/server.js

@@ -855,24 +855,7 @@ var DEFAULT_PREFERENCES = {
 var SUPPORTED_SPACES = [
   "the_void",
   "profiles",
-  "spaces",
-  "ghosts",
-  "poems",
-  "recipes",
-  "quotes",
-  "dreams",
-  "travel",
-  "music",
-  "pets",
-  "books",
-  "funny",
-  "ideas",
-  "art",
-  "fitness",
-  "how_to",
-  "movies",
-  "nature",
-  "journal"
+  "ghosts"
 ];
 var SPACE_CONTENT_TYPE_RESTRICTIONS = {
   profiles: "profile",
@@ -1561,6 +1544,12 @@ function buildDocTypeFilters(collection, docType, filters) {
   if (filters?.date_to) {
     filterList.push(collection.filter.byProperty("created_at").lessOrEqual(new Date(filters.date_to)));
   }
+  if (filters?.relationship_count_min !== void 0) {
+    filterList.push(collection.filter.byProperty("relationship_count").greaterOrEqual(filters.relationship_count_min));
+  }
+  if (filters?.relationship_count_max !== void 0) {
+    filterList.push(collection.filter.byProperty("relationship_count").lessOrEqual(filters.relationship_count_max));
+  }
   if (filters?.tags && filters.tags.length > 0) {
     filterList.push(collection.filter.byProperty("tags").containsAny(filters.tags));
   }
@@ -1731,7 +1720,7 @@ var PreferencesDatabaseService = class {
 };
 
 // node_modules/@prmichaelsen/remember-core/dist/services/confirmation-token.service.js
-import { randomUUID } from "crypto";
+var randomUUID = () => globalThis.crypto.randomUUID();
 var ConfirmationTokenService = class {
   EXPIRY_MINUTES = 5;
   logger;
@@ -2107,12 +2096,7 @@ var MemoryService = class {
       const combinedFilters = combineFiltersWithAnd([deletedFilter, memoryFilters, ...ghostFilters].filter((f) => f !== null));
       const queryOptions = {
         limit: limit + offset,
-        sort: [
-          {
-            property: "created_at",
-            order: direction
-          }
-        ]
+        sort: this.collection.sort.byProperty("created_at", direction === "asc")
       };
       if (combinedFilters) {
         queryOptions.filters = combinedFilters;
@@ -2156,13 +2140,7 @@ var MemoryService = class {
       const combinedFilters = combineFiltersWithAnd([deletedFilter, memoryFilters, ...ghostFilters, ...densityFilters].filter((f) => f !== null));
       const queryOptions = {
         limit: limit + offset,
-        sort: [
-          {
-            property: "relationship_count",
-            order: "desc"
-            // Highest first
-          }
-        ]
+        sort: this.collection.sort.byProperty("relationship_count", false)
       };
       if (combinedFilters) {
         queryOptions.filters = combinedFilters;
@@ -2664,6 +2642,18 @@ async function registerCollection(entry) {
 }
 
 // node_modules/@prmichaelsen/remember-core/dist/database/weaviate/v2-collections.js
+var collectionCache = /* @__PURE__ */ new Map();
+var COLLECTION_CACHE_TTL_MS = 6e4;
+function isCollectionCached(collectionName) {
+  const expiresAt = collectionCache.get(collectionName);
+  if (expiresAt !== void 0 && Date.now() < expiresAt)
+    return true;
+  collectionCache.delete(collectionName);
+  return false;
+}
+function cacheCollection(collectionName) {
+  collectionCache.set(collectionName, Date.now() + COLLECTION_CACHE_TTL_MS);
+}
 var COMMON_MEMORY_PROPERTIES = [
   // Core content
   { name: "content", dataType: configure.dataType.TEXT },
@@ -2822,9 +2812,12 @@ async function reconcileCollectionProperties(client2, collectionName, expectedPr
 }
 async function ensureGroupCollection(client2, groupId) {
   const collectionName = `Memory_groups_${groupId}`;
+  if (isCollectionCached(collectionName))
+    return false;
   const exists = await client2.collections.exists(collectionName);
   if (exists) {
     await reconcileCollectionProperties(client2, collectionName, [...COMMON_MEMORY_PROPERTIES, ...PUBLISHED_MEMORY_PROPERTIES]);
+    cacheCollection(collectionName);
     return false;
   }
   const schema = createGroupCollectionSchema(groupId);
@@ -2835,6 +2828,7 @@ async function ensureGroupCollection(client2, groupId) {
     owner_id: groupId,
     created_at: (/* @__PURE__ */ new Date()).toISOString()
   });
+  cacheCollection(collectionName);
   return true;
 }
 
@@ -2845,10 +2839,13 @@ function isValidSpaceId(spaceId) {
 }
 async function ensurePublicCollection(client2) {
   const collectionName = PUBLIC_COLLECTION_NAME;
-  const exists = await client2.collections.exists(collectionName);
-  if (!exists) {
-    const schema = createSpaceCollectionSchema();
-    await client2.collections.create(schema);
+  if (!isCollectionCached(collectionName)) {
+    const exists = await client2.collections.exists(collectionName);
+    if (!exists) {
+      const schema = createSpaceCollectionSchema();
+      await client2.collections.create(schema);
+    }
+    cacheCollection(collectionName);
   }
   return client2.collections.get(collectionName);
 }
@@ -3676,16 +3673,22 @@ function getMemoryCollection(userId) {
 var coreLogger = createLogger("info");
 var tokenService = new ConfirmationTokenService(coreLogger);
 var preferencesService = new PreferencesDatabaseService(coreLogger);
+var coreServicesCache = /* @__PURE__ */ new Map();
 function createCoreServices(userId) {
+  const cached = coreServicesCache.get(userId);
+  if (cached)
+    return cached;
   const collection = getMemoryCollection(userId);
   const weaviateClient = getWeaviateClient();
-  return {
+  const services = {
     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;
 }
 
 // src/tools/create-memory.ts
@@ -3953,8 +3956,8 @@ async function handleSearchMemory(args, userId, authContext) {
     const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, ghostExclusionFilter, searchFilters].filter((f) => f !== null));
     const searchOptions = {
       alpha,
-      limit: limit + offset
-      // Get extra for offset
+      limit,
+      offset
     };
     if (combinedFilters) {
       searchOptions.filters = combinedFilters;
@@ -3966,10 +3969,9 @@ async function handleSearchMemory(args, userId, authContext) {
       deletedFilter: args.deleted_filter || "exclude"
     });
     const results = await collection.query.hybrid(args.query, searchOptions);
-    const paginatedResults = results.objects.slice(offset);
     const memories = [];
     const relationships = [];
-    for (const obj of paginatedResults) {
+    for (const obj of results.objects) {
       const doc = {
         id: obj.uuid,
         ...obj.properties
@@ -6013,13 +6015,10 @@ async function removeUserTrust2(ownerUserId, targetUserId) {
   });
 }
 async function blockUser2(ownerUserId, targetUserId) {
-  const current = await getGhostConfig2(ownerUserId);
-  if (current.blocked_users.includes(targetUserId)) {
-    return;
-  }
-  const blocked_users = [...current.blocked_users, targetUserId];
   const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
-  await setDocument(collectionPath, docId, { blocked_users }, { merge: true });
+  await setDocument(collectionPath, docId, {
+    blocked_users: FieldValue.arrayUnion(targetUserId)
+  }, { merge: true });
   logger.info("User blocked from ghost access", {
     service: SERVICE,
     ownerUserId,
@@ -6027,13 +6026,10 @@ async function blockUser2(ownerUserId, targetUserId) {
   });
 }
 async function unblockUser2(ownerUserId, targetUserId) {
-  const current = await getGhostConfig2(ownerUserId);
-  if (!current.blocked_users.includes(targetUserId)) {
-    return;
-  }
-  const blocked_users = current.blocked_users.filter((id) => id !== targetUserId);
   const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
-  await setDocument(collectionPath, docId, { blocked_users }, { merge: true });
+  await setDocument(collectionPath, docId, {
+    blocked_users: FieldValue.arrayRemove(targetUserId)
+  }, { merge: true });
   logger.info("User unblocked from ghost access", {
     service: SERVICE,
     ownerUserId,
@@ -6249,8 +6245,10 @@ async function initServer() {
   logger.info("Connecting to databases...");
   await initWeaviateClient();
   initFirestore();
-  const weaviateOk = await testWeaviateConnection();
-  const firestoreOk = await testFirestoreConnection();
+  const [weaviateOk, firestoreOk] = await Promise.all([
+    testWeaviateConnection(),
+    testFirestoreConnection()
+  ]);
   if (!weaviateOk || !firestoreOk) {
     throw new Error("Database connection failed");
   }

package/dist/services/access-control.d.ts

@@ -89,13 +89,13 @@ export declare function resetBlock(ownerUserId: string, accessorUserId: string,
 /**
  * Resolve the trust level for an accessor from GhostConfig.
  *
- * Priority: per_user_trust → default_friend_trust → default_public_trust → 0
+ * Priority: per_user_trust → default_friend_trust (if friends) → default_public_trust → 0
  *
- * Note: "friend" vs "public" distinction will be determined by the calling
- * context in M16 (friend list, social graph). For now, non-per_user accessors
- * fall through to default_public_trust.
+ * Checks Firestore relationships collection to determine friend status.
  */
-export declare function resolveAccessorTrustLevel(ghostConfig: GhostConfig, accessorUserId: string): number;
+export declare function resolveAccessorTrustLevel(ghostConfig: GhostConfig, ownerUserId: string, accessorUserId: string): Promise<number>;
+/** Clear the friend status cache (for tests or forced refresh) */
+export declare function invalidateFriendCache(): void;
 /**
  * Format an AccessResult into a human-readable message.
  */

package/dist/services/ghost-config.service.d.ts

@@ -30,10 +30,12 @@ export declare function setUserTrust(ownerUserId: string, targetUserId: string,
 export declare function removeUserTrust(ownerUserId: string, targetUserId: string): Promise<void>;
 /**
  * Block a user from ghost access.
+ * Uses FieldValue.arrayUnion for atomic add without reading first (idempotent).
  */
 export declare function blockUser(ownerUserId: string, targetUserId: string): Promise<void>;
 /**
  * Unblock a user from ghost access.
+ * Uses FieldValue.arrayRemove for atomic remove without reading first (safe if not present).
  */
 export declare function unblockUser(ownerUserId: string, targetUserId: string): Promise<void>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "3.14.12",
+  "version": "3.14.15",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",
@@ -50,7 +50,7 @@
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@prmichaelsen/firebase-admin-sdk-v8": "^2.2.0",
     "@prmichaelsen/mcp-auth": "^7.0.4",
-    "@prmichaelsen/remember-core": "^0.22.5",
+    "@prmichaelsen/remember-core": "^0.24.2",
     "dotenv": "^16.4.5",
     "uuid": "^13.0.0",
     "weaviate-client": "^3.2.0"

package/src/core-services.ts

@@ -30,21 +30,35 @@ const coreLogger: Logger = createLogger('info');
 const tokenService = new ConfirmationTokenService(coreLogger);
 const preferencesService = new PreferencesDatabaseService(coreLogger);
 
+/** Cached CoreServices per userId — avoids re-instantiation on every tool call */
+const coreServicesCache = new Map<string, CoreServices>();
+
 /**
- * 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 function createCoreServices(userId: string): CoreServices {
+  const cached = coreServicesCache.get(userId);
+  if (cached) return cached;
+
   const collection = getMemoryCollection(userId);
   const weaviateClient = getWeaviateClient();
 
-  return {
+  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;
+}
+
+/** Clear the core services cache (for tests or forced refresh) */
+export function invalidateCoreServicesCache(): void {
+  coreServicesCache.clear();
 }
 
 export { coreLogger, tokenService, preferencesService };

package/src/server-factory.ts

@@ -45,6 +45,10 @@ import { querySpaceTool, handleQuerySpace } from './tools/query-space.js';
 import { moderateTool, handleModerate } from './tools/moderate.js';
 import { ghostConfigTool, handleGhostConfig } from './tools/ghost-config.js';
 
+// Import services (static — avoids dynamic import overhead on hot path)
+import { getGhostConfig } from './services/ghost-config.service.js';
+import { resolveAccessorTrustLevel } from './services/access-control.js';
+
 export interface ServerOptions {
   name?: string;
   version?: string;
@@ -175,10 +179,8 @@ export async function createServer(
   // Resolve ghost mode trust level from Firestore if ghost mode is configured
   let resolvedGhostMode: import('./types/auth.js').GhostModeContext | undefined;
   if (options.ghostMode) {
-    const { getGhostConfig } = await import('./services/ghost-config.service.js');
-    const { resolveAccessorTrustLevel } = await import('./services/access-control.js');
     const ghostConfig = await getGhostConfig(options.ghostMode.owner_user_id);
-    const trustLevel = resolveAccessorTrustLevel(ghostConfig, options.ghostMode.accessor_user_id);
+    const trustLevel = await resolveAccessorTrustLevel(ghostConfig, options.ghostMode.owner_user_id, options.ghostMode.accessor_user_id);
     resolvedGhostMode = {
       owner_user_id: options.ghostMode.owner_user_id,
       accessor_user_id: options.ghostMode.accessor_user_id,

package/src/server.ts

@@ -57,9 +57,11 @@ async function initServer(): Promise<Server> {
   await initWeaviateClient();
   initFirestore();
 
-  // Test connections
-  const weaviateOk = await testWeaviateConnection();
-  const firestoreOk = await testFirestoreConnection();
+  // Test connections in parallel
+  const [weaviateOk, firestoreOk] = await Promise.all([
+    testWeaviateConnection(),
+    testFirestoreConnection(),
+  ]);
 
   if (!weaviateOk || !firestoreOk) {
     throw new Error('Database connection failed');

package/src/services/access-control.spec.ts

@@ -207,36 +207,36 @@ describe('checkMemoryAccess', () => {
 // ─── resolveAccessorTrustLevel ─────────────────────────────────────────────
 
 describe('resolveAccessorTrustLevel', () => {
-  it('returns per_user_trust when set', () => {
+  it('returns per_user_trust when set', async () => {
     const config = createEnabledGhostConfig({ per_user_trust: { 'alice': 0.9 } });
-    expect(resolveAccessorTrustLevel(config, 'alice')).toBe(0.9);
+    expect(await resolveAccessorTrustLevel(config, 'owner', 'alice')).toBe(0.9);
   });
 
-  it('falls through to default_public_trust when no per_user_trust', () => {
+  it('falls through to default_public_trust when no per_user_trust', async () => {
     const config = createEnabledGhostConfig({ default_public_trust: 0.3 });
-    expect(resolveAccessorTrustLevel(config, 'stranger')).toBe(0.3);
+    expect(await resolveAccessorTrustLevel(config, 'owner', 'stranger')).toBe(0.3);
   });
 
-  it('returns 0 when default_public_trust not set', () => {
+  it('returns 0 when default_public_trust not set', async () => {
     const config = createEnabledGhostConfig({ default_public_trust: 0 });
-    expect(resolveAccessorTrustLevel(config, 'unknown')).toBe(0);
+    expect(await resolveAccessorTrustLevel(config, 'owner', 'unknown')).toBe(0);
   });
 
-  it('per_user_trust takes priority over default', () => {
+  it('per_user_trust takes priority over default', async () => {
     const config = createEnabledGhostConfig({
       default_public_trust: 0.1,
       per_user_trust: { 'bob': 0.8 },
     });
-    expect(resolveAccessorTrustLevel(config, 'bob')).toBe(0.8);
-    expect(resolveAccessorTrustLevel(config, 'carol')).toBe(0.1);
+    expect(await resolveAccessorTrustLevel(config, 'owner', 'bob')).toBe(0.8);
+    expect(await resolveAccessorTrustLevel(config, 'owner', 'carol')).toBe(0.1);
   });
 
-  it('per_user_trust of 0 is used (not falsy fallthrough)', () => {
+  it('per_user_trust of 0 is used (not falsy fallthrough)', async () => {
     const config = createEnabledGhostConfig({
       default_public_trust: 0.5,
       per_user_trust: { 'restricted': 0 },
     });
-    expect(resolveAccessorTrustLevel(config, 'restricted')).toBe(0);
+    expect(await resolveAccessorTrustLevel(config, 'owner', 'restricted')).toBe(0);
   });
 });
 

package/src/services/access-control.ts

@@ -164,7 +164,7 @@ export async function checkMemoryAccess(
   }
 
   // 5. Check trust level
-  const accessorTrust = resolveAccessorTrustLevel(ghostConfig, accessorUserId);
+  const accessorTrust = await resolveAccessorTrustLevel(ghostConfig, ownerUserId, accessorUserId);
   const memoryTrust = memory.trust;
 
   if (!isTrustSufficient(memoryTrust, accessorTrust)) {
@@ -250,22 +250,88 @@ export async function resetBlock(
 /**
  * Resolve the trust level for an accessor from GhostConfig.
  *
- * Priority: per_user_trust → default_friend_trust → default_public_trust → 0
+ * Priority: per_user_trust → default_friend_trust (if friends) → default_public_trust → 0
  *
- * Note: "friend" vs "public" distinction will be determined by the calling
- * context in M16 (friend list, social graph). For now, non-per_user accessors
- * fall through to default_public_trust.
+ * Checks Firestore relationships collection to determine friend status.
  */
-export function resolveAccessorTrustLevel(ghostConfig: GhostConfig, accessorUserId: string): number {
+export async function resolveAccessorTrustLevel(
+  ghostConfig: GhostConfig,
+  ownerUserId: string,
+  accessorUserId: string
+): Promise<number> {
   // 1. Per-user override
   if (accessorUserId in ghostConfig.per_user_trust) {
     return ghostConfig.per_user_trust[accessorUserId];
   }
 
-  // 2. Fall through to public trust (friend detection deferred to M16)
+  // 2. Check if accessor is a friend
+  const isFriend = await checkIfFriend(ownerUserId, accessorUserId);
+
+  if (isFriend) {
+    return ghostConfig.default_friend_trust ?? 0.25;
+  }
+
+  // 3. Fall through to public trust
   return ghostConfig.default_public_trust ?? 0;
 }
 
+// ─── Friend Cache ─────────────────────────────────────────────────────────
+
+/** TTL cache for friend status lookups (avoids redundant Firestore reads) */
+const friendCache = new Map<string, { result: boolean; expiresAt: number }>();
+const FRIEND_CACHE_TTL_MS = 60_000; // 60 seconds
+
+/** Clear the friend status cache (for tests or forced refresh) */
+export function invalidateFriendCache(): void {
+  friendCache.clear();
+}
+
+/**
+ * Check if accessor is a friend of owner by querying relationships collection.
+ * Results are cached for 60 seconds per user pair.
+ */
+async function checkIfFriend(ownerUserId: string, accessorUserId: string): Promise<boolean> {
+  // Check cache first (sorted key so a:b and b:a hit the same entry)
+  const cacheKey = [ownerUserId, accessorUserId].sort().join(':');
+  const cached = friendCache.get(cacheKey);
+  if (cached && Date.now() < cached.expiresAt) {
+    return cached.result;
+  }
+
+  try {
+    const { queryDocuments } = await import('../firestore/init.js');
+    const BASE = process.env.FIRESTORE_BASE_PATH || 'agentbase';
+
+    // Run both direction queries in parallel
+    const [forward, reverse] = await Promise.all([
+      queryDocuments(`${BASE}.relationships`, {
+        where: [
+          { field: 'from_user_id', op: '==', value: ownerUserId },
+          { field: 'to_user_id', op: '==', value: accessorUserId },
+          { field: 'friend', op: '==', value: true },
+        ],
+        limit: 1,
+      }),
+      queryDocuments(`${BASE}.relationships`, {
+        where: [
+          { field: 'from_user_id', op: '==', value: accessorUserId },
+          { field: 'to_user_id', op: '==', value: ownerUserId },
+          { field: 'friend', op: '==', value: true },
+        ],
+        limit: 1,
+      }),
+    ]);
+
+    const result = forward.length > 0 || reverse.length > 0;
+    friendCache.set(cacheKey, { result, expiresAt: Date.now() + FRIEND_CACHE_TTL_MS });
+    return result;
+  } catch (error) {
+    console.error('[checkIfFriend] Error checking friend status:', error);
+    // On error, treat as not friends (safer default)
+    return false;
+  }
+}
+
 // ─── Message Formatting ───────────────────────────────────────────────────
 
 /**

package/src/services/ghost-config.service.spec.ts

@@ -15,6 +15,10 @@ import * as firestoreInit from '../firestore/init';
 jest.mock('../firestore/init', () => ({
   getDocument: jest.fn(),
   setDocument: jest.fn(),
+  FieldValue: {
+    arrayUnion: (...elements: any[]) => ({ _type: 'arrayUnion', _value: elements }),
+    arrayRemove: (...elements: any[]) => ({ _type: 'arrayRemove', _value: elements }),
+  },
 }));
 
 jest.mock('../firestore/paths', () => ({
@@ -179,8 +183,7 @@ describe('GhostConfigService', () => {
   });
 
   describe('blockUser', () => {
-    it('adds user to blocked list', async () => {
-      mockGetDocument.mockResolvedValue({ blocked_users: [] });
+    it('adds user to blocked list using FieldValue.arrayUnion', async () => {
       mockSetDocument.mockResolvedValue(undefined);
 
       await blockUser('owner-1', 'bad-user');
@@ -188,21 +191,23 @@ describe('GhostConfigService', () => {
       expect(mockSetDocument).toHaveBeenCalledWith(
         'test-remember-mcp.users/owner-1/ghost_config',
         'settings',
-        { blocked_users: ['bad-user'] },
+        { blocked_users: { _type: 'arrayUnion', _value: ['bad-user'] } },
         { merge: true }
       );
+      // No read needed — arrayUnion is idempotent
+      expect(mockGetDocument).not.toHaveBeenCalled();
     });
 
-    it('does not duplicate already blocked user', async () => {
-      mockGetDocument.mockResolvedValue({ blocked_users: ['bad-user'] });
+    it('does not duplicate already blocked user (arrayUnion is idempotent)', async () => {
+      mockSetDocument.mockResolvedValue(undefined);
 
       await blockUser('owner-1', 'bad-user');
 
-      expect(mockSetDocument).not.toHaveBeenCalled();
+      // arrayUnion handles dedup atomically — always writes
+      expect(mockSetDocument).toHaveBeenCalledTimes(1);
     });
 
-    it('preserves existing blocked users', async () => {
-      mockGetDocument.mockResolvedValue({ blocked_users: ['user-a'] });
+    it('preserves existing blocked users (arrayUnion appends atomically)', async () => {
       mockSetDocument.mockResolvedValue(undefined);
 
       await blockUser('owner-1', 'user-b');
@@ -210,15 +215,14 @@ describe('GhostConfigService', () => {
       expect(mockSetDocument).toHaveBeenCalledWith(
         'test-remember-mcp.users/owner-1/ghost_config',
         'settings',
-        { blocked_users: ['user-a', 'user-b'] },
+        { blocked_users: { _type: 'arrayUnion', _value: ['user-b'] } },
         { merge: true }
       );
     });
   });
 
   describe('unblockUser', () => {
-    it('removes user from blocked list', async () => {
-      mockGetDocument.mockResolvedValue({ blocked_users: ['bad-user', 'other'] });
+    it('removes user from blocked list using FieldValue.arrayRemove', async () => {
       mockSetDocument.mockResolvedValue(undefined);
 
       await unblockUser('owner-1', 'bad-user');
@@ -226,17 +230,20 @@ describe('GhostConfigService', () => {
       expect(mockSetDocument).toHaveBeenCalledWith(
         'test-remember-mcp.users/owner-1/ghost_config',
         'settings',
-        { blocked_users: ['other'] },
+        { blocked_users: { _type: 'arrayRemove', _value: ['bad-user'] } },
         { merge: true }
       );
+      // No read needed — arrayRemove is safe if element not present
+      expect(mockGetDocument).not.toHaveBeenCalled();
     });
 
-    it('does nothing if user not blocked', async () => {
-      mockGetDocument.mockResolvedValue({ blocked_users: [] });
+    it('is safe when user not blocked (arrayRemove is idempotent)', async () => {
+      mockSetDocument.mockResolvedValue(undefined);
 
       await unblockUser('owner-1', 'not-blocked');
 
-      expect(mockSetDocument).not.toHaveBeenCalled();
+      // arrayRemove always writes — safe no-op if element not present
+      expect(mockSetDocument).toHaveBeenCalledTimes(1);
     });
   });
 

package/src/services/ghost-config.service.ts

@@ -9,7 +9,7 @@
  * See agent/design/local.ghost-persona-system.md
  */
 
-import { getDocument, setDocument } from '../firestore/init.js';
+import { getDocument, setDocument, FieldValue } from '../firestore/init.js';
 import { BASE } from '../firestore/paths.js';
 import { logger } from '../utils/logger.js';
 import type { GhostConfig, TrustEnforcementMode } from '../types/ghost-config.js';
@@ -121,19 +121,16 @@ export async function removeUserTrust(
 
 /**
  * Block a user from ghost access.
+ * Uses FieldValue.arrayUnion for atomic add without reading first (idempotent).
  */
 export async function blockUser(
   ownerUserId: string,
   targetUserId: string
 ): Promise<void> {
-  const current = await getGhostConfig(ownerUserId);
-  if (current.blocked_users.includes(targetUserId)) {
-    return; // already blocked
-  }
-
-  const blocked_users = [...current.blocked_users, targetUserId];
   const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
-  await setDocument(collectionPath, docId, { blocked_users }, { merge: true });
+  await setDocument(collectionPath, docId, {
+    blocked_users: FieldValue.arrayUnion(targetUserId),
+  }, { merge: true });
 
   logger.info('User blocked from ghost access', {
     service: SERVICE,
@@ -144,19 +141,16 @@ export async function blockUser(
 
 /**
  * Unblock a user from ghost access.
+ * Uses FieldValue.arrayRemove for atomic remove without reading first (safe if not present).
  */
 export async function unblockUser(
   ownerUserId: string,
   targetUserId: string
 ): Promise<void> {
-  const current = await getGhostConfig(ownerUserId);
-  if (!current.blocked_users.includes(targetUserId)) {
-    return; // not blocked
-  }
-
-  const blocked_users = current.blocked_users.filter(id => id !== targetUserId);
   const { collectionPath, docId } = getGhostConfigPath(ownerUserId);
-  await setDocument(collectionPath, docId, { blocked_users }, { merge: true });
+  await setDocument(collectionPath, docId, {
+    blocked_users: FieldValue.arrayRemove(targetUserId),
+  }, { merge: true });
 
   logger.info('User unblocked from ghost access', {
     service: SERVICE,