@prmichaelsen/remember-mcp 3.15.7 → 3.16.2

package/dist/server.js

@@ -1935,7 +1935,13 @@ var COMMON_MEMORY_PROPERTIES = [
   { name: "total_significance", dataType: configure.dataType.NUMBER },
   // REM metadata
   { name: "rem_touched_at", dataType: configure.dataType.TEXT },
-  { name: "rem_visits", dataType: configure.dataType.INT }
+  { name: "rem_visits", dataType: configure.dataType.INT },
+  // Curation scoring (M36)
+  { name: "curated_score", dataType: configure.dataType.NUMBER },
+  { name: "editorial_score", dataType: configure.dataType.NUMBER },
+  { name: "click_count", dataType: configure.dataType.INT },
+  { name: "share_count", dataType: configure.dataType.INT },
+  { name: "comment_count", dataType: configure.dataType.INT }
 ];
 var PUBLISHED_MEMORY_PROPERTIES = [
   // Publication metadata
@@ -2586,7 +2592,13 @@ var ALL_MEMORY_PROPERTIES = [
   "functional_significance",
   "total_significance",
   "rem_touched_at",
-  "rem_visits"
+  "rem_visits",
+  // Curation scoring (M36)
+  "curated_score",
+  "editorial_score",
+  "click_count",
+  "share_count",
+  "comment_count"
 ];
 async function fetchMemoryWithAllProperties(collection, memoryId) {
   try {
@@ -3362,6 +3374,99 @@ var MemoryService = class {
       total_pool_size: totalPoolSize
     };
   }
+  // ── By Curated (composite quality score) ──────────────────────────
+  async byCurated(input) {
+    const limit = input.limit ?? 50;
+    const offset = input.offset ?? 0;
+    const direction = input.direction ?? "desc";
+    const memoryFilters = buildMemoryOnlyFilters(this.collection, input.filters);
+    const ghostFilters = [];
+    if (input.ghost_context) {
+      ghostFilters.push(buildTrustFilter(this.collection, input.ghost_context.accessor_trust_level));
+    }
+    if (!input.ghost_context?.include_ghost_content && !input.filters?.types?.includes("ghost")) {
+      ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("ghost"));
+    }
+    if (!input.filters?.types?.includes("rem")) {
+      ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("rem"));
+    }
+    const hasQuery = input.query?.trim();
+    const fetchLimit = (limit + offset) * 2;
+    const executeScoredQuery = async (useDeletedFilter) => {
+      const deletedFilter = useDeletedFilter ? buildDeletedFilter(this.collection, input.deleted_filter || "exclude") : null;
+      const scoredFilter = this.collection.filter.byProperty("curated_score").greaterThan(0);
+      const combined = combineFiltersWithAnd([deletedFilter, memoryFilters, scoredFilter, ...ghostFilters].filter((f) => f !== null));
+      if (hasQuery) {
+        const queryOptions2 = {
+          limit: fetchLimit,
+          alpha: 0.7,
+          query: hasQuery
+        };
+        if (combined)
+          queryOptions2.filters = combined;
+        return this.collection.query.hybrid(hasQuery, queryOptions2);
+      }
+      const queryOptions = {
+        limit: fetchLimit,
+        sort: this.collection.sort.byProperty("curated_score", direction === "asc")
+      };
+      if (combined)
+        queryOptions.filters = combined;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const executeUnscoredQuery = async (useDeletedFilter) => {
+      const deletedFilter = useDeletedFilter ? buildDeletedFilter(this.collection, input.deleted_filter || "exclude") : null;
+      const unscoredFilters = [];
+      const combined = combineFiltersWithAnd([deletedFilter, memoryFilters, ...ghostFilters].filter((f) => f !== null));
+      const queryOptions = {
+        limit: Math.ceil(fetchLimit / 4),
+        sort: this.collection.sort.byProperty("created_at", false)
+        // newest first
+      };
+      if (combined)
+        queryOptions.filters = combined;
+      return this.collection.query.fetchObjects(queryOptions);
+    };
+    const scoredResults = await this.retryWithoutDeletedFilter(executeScoredQuery);
+    const unscoredResults = await this.retryWithoutDeletedFilter(executeUnscoredQuery);
+    const scored = [];
+    for (const obj of scoredResults.objects) {
+      const doc = normalizeDoc({ id: obj.uuid, ...obj.properties });
+      if (doc.doc_type === "memory" && doc.curated_score > 0) {
+        scored.push(doc);
+      }
+    }
+    if (hasQuery) {
+      scored.sort((a, b) => {
+        const aScore = a.curated_score ?? 0;
+        const bScore = b.curated_score ?? 0;
+        return direction === "asc" ? aScore - bScore : bScore - aScore;
+      });
+    }
+    const unscored = [];
+    for (const obj of unscoredResults.objects) {
+      const doc = normalizeDoc({ id: obj.uuid, ...obj.properties });
+      if (doc.doc_type === "memory" && !doc.curated_score) {
+        unscored.push(doc);
+      }
+    }
+    const interleaved = interleaveDiscovery({
+      rated: scored,
+      discovery: unscored,
+      offset,
+      limit
+    });
+    const memories = interleaved.map((item) => ({
+      ...item.item,
+      ...item.is_discovery ? { is_discovery: true } : {}
+    }));
+    return {
+      memories,
+      total: memories.length,
+      offset,
+      limit
+    };
+  }
   // ── Find Similar (vector) ──────────────────────────────────────────
   async findSimilar(input) {
     if (!input.memory_id && !input.text)
@@ -3378,6 +3483,7 @@ var MemoryService = class {
       ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("ghost"));
     }
     ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("rem"));
+    ghostFilters.push(this.collection.filter.byProperty("content_type").notEqual("comment"));
     let memoryObj = null;
     if (input.memory_id) {
       memoryObj = await this.collection.query.fetchObjectById(input.memory_id, {
@@ -3569,6 +3675,28 @@ var MemoryService = class {
       orphaned_relationship_ids: orphanedIds
     };
   }
+  // ── Engagement Counters ───────────────────────────────────────────
+  async incrementClick(memoryId) {
+    await this.incrementCounter(memoryId, "click_count");
+  }
+  async incrementShare(memoryId) {
+    await this.incrementCounter(memoryId, "share_count");
+  }
+  async incrementComment(memoryId) {
+    await this.incrementCounter(memoryId, "comment_count");
+  }
+  async incrementCounter(memoryId, field) {
+    const existing = await this.collection.query.fetchObjectById(memoryId, {
+      returnProperties: [field]
+    });
+    if (!existing)
+      throw new Error(`Memory not found: ${memoryId}`);
+    const current = existing.properties?.[field] ?? 0;
+    await this.collection.data.update({
+      id: memoryId,
+      properties: { [field]: current + 1 }
+    });
+  }
 };
 
 // node_modules/@prmichaelsen/remember-core/dist/services/relationship.service.js
@@ -5010,6 +5138,42 @@ var SpaceService = class {
     });
     return { spaces_searched: spacesSearched, groups_searched: groupsSearched, results, total_pool_size: totalPoolSize };
   }
+  // ── By Curated (composite quality score) ──────────────────────────
+  async byCurated(input, authContext) {
+    const spaces = input.spaces || [];
+    const groups = input.groups || [];
+    const limit = input.limit ?? 50;
+    const offset = input.offset ?? 0;
+    const direction = input.direction ?? "desc";
+    this.validateSpaceGroupInput(spaces, groups, input.moderation_filter || "approved", authContext);
+    const fetchLimit = (limit + offset) * 2;
+    const hasQuery = input.query?.trim();
+    const { allResults, spacesSearched, groupsSearched } = await this.fetchAcrossCollections(input, spaces, groups, async (collection, baseFilters) => {
+      const combined = baseFilters.length > 0 ? Filters4.and(...baseFilters) : void 0;
+      if (hasQuery) {
+        const opts2 = { limit: fetchLimit, alpha: 0.7, query: hasQuery };
+        if (combined)
+          opts2.filters = combined;
+        return (await collection.query.hybrid(hasQuery, opts2)).objects;
+      }
+      const opts = {
+        limit: fetchLimit,
+        sort: collection.sort.byProperty("curated_score", direction === "asc")
+      };
+      if (combined)
+        opts.filters = combined;
+      return (await collection.query.fetchObjects(opts)).objects;
+    });
+    const deduped = dedupeBySourceId(allResults, input.dedupe);
+    deduped.sort((a, b) => {
+      const aVal = a.properties?.curated_score ?? 0;
+      const bVal = b.properties?.curated_score ?? 0;
+      return direction === "desc" ? bVal - aVal : aVal - bVal;
+    });
+    const paginated = deduped.slice(offset, offset + limit);
+    const memories = paginated.filter((obj) => obj.properties?.doc_type === "memory").map((obj) => ({ id: obj.uuid, ...obj.properties }));
+    return { spaces_searched: spacesSearched, groups_searched: groupsSearched, memories, total: memories.length, offset, limit };
+  }
   // ── Private: Validate Space/Group Input ───────────────────────────
   validateSpaceGroupInput(spaces, groups, moderationFilter, authContext) {
     if (spaces.length > 0) {
@@ -5154,6 +5318,18 @@ var REM_STATE_COLLECTION = `${BASE}.rem_state`;
 // node_modules/@prmichaelsen/remember-core/dist/services/rem.clustering.js
 import { Filters as Filters5 } from "weaviate-client";
 
+// node_modules/@prmichaelsen/remember-core/dist/services/rem.service.js
+import { Filters as Filters9 } from "weaviate-client";
+
+// node_modules/@prmichaelsen/remember-core/dist/services/scoring-context.service.js
+import { Filters as Filters6 } from "weaviate-client";
+
+// node_modules/@prmichaelsen/remember-core/dist/services/rem.pruning.js
+import { Filters as Filters7 } from "weaviate-client";
+
+// node_modules/@prmichaelsen/remember-core/dist/services/rem.reconciliation.js
+import { Filters as Filters8 } from "weaviate-client";
+
 // node_modules/@prmichaelsen/remember-core/dist/services/classification.service.js
 var GENRES = [
   "short_story",
@@ -5789,12 +5965,12 @@ var searchMemoryTool = {
   }
 };
 async function handleSearchMemory(args, userId, authContext) {
-  const ghostMode = authContext?.ghostMode;
-  const searchUserId = ghostMode?.owner_user_id ?? userId;
-  const debug = createDebugLogger({ tool: "remember_search_memory", userId: searchUserId, operation: ghostMode ? "ghost search" : "search memory" });
+  const internalContext = authContext?.internalContext;
+  const searchUserId = internalContext?.owner_user_id ?? userId;
+  const debug = createDebugLogger({ tool: "remember_search_memory", userId: searchUserId, operation: internalContext ? "internal search" : "search memory" });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args, ghostMode: !!ghostMode });
+    debug.trace("Arguments", { args, internalContext: !!internalContext });
     if (!args.query || args.query.trim() === "") {
       throw new Error("Query cannot be empty");
     }
@@ -5803,18 +5979,21 @@ async function handleSearchMemory(args, userId, authContext) {
       userId: searchUserId,
       query: args.query,
       includeRelationships,
-      ghostMode: !!ghostMode
+      internalContext: !!internalContext
     });
     const collection = getMemoryCollection2(searchUserId);
     const alpha = args.alpha ?? 0.7;
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
     const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
-    const trustFilter = ghostMode ? buildTrustFilter(collection, ghostMode.accessor_trust_level) : null;
+    const trustFilter = internalContext?.accessor_trust_level != null ? buildTrustFilter(collection, internalContext.accessor_trust_level) : null;
     const searchFilters = includeRelationships ? buildCombinedSearchFilters(collection, args.filters) : buildMemoryOnlyFilters(collection, args.filters);
     const hasExplicitTypeFilter = args.filters?.types && args.filters.types.length > 0;
-    const ghostExclusionFilter = !hasExplicitTypeFilter ? collection.filter.byProperty("content_type").notEqual("ghost") : null;
-    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, ghostExclusionFilter, searchFilters].filter((f) => f !== null));
+    const internalExclusionFilter = !hasExplicitTypeFilter ? combineFiltersWithAnd([
+      collection.filter.byProperty("content_type").notEqual("ghost"),
+      collection.filter.byProperty("content_type").notEqual("agent")
+    ]) : null;
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, internalExclusionFilter, searchFilters].filter((f) => f !== null));
     const searchOptions = {
       alpha,
       limit,
@@ -6160,7 +6339,7 @@ async function handleFindSimilar(args, userId, authContext) {
       deleted_filter: args.deleted_filter
     });
     const filteredMemories = coreResult.similar_memories.filter(
-      (m) => m.content_type !== "ghost"
+      (m) => m.content_type !== "ghost" && m.content_type !== "agent"
     );
     const result = {
       query: {
@@ -6303,27 +6482,30 @@ var queryMemoryTool = {
   }
 };
 async function handleQueryMemory(args, userId, authContext) {
-  const ghostMode = authContext?.ghostMode;
-  const searchUserId = ghostMode?.owner_user_id ?? userId;
-  const debug = createDebugLogger({ tool: "remember_query_memory", userId: searchUserId, operation: ghostMode ? "ghost query" : "query memory" });
+  const internalContext = authContext?.internalContext;
+  const searchUserId = internalContext?.owner_user_id ?? userId;
+  const debug = createDebugLogger({ tool: "remember_query_memory", userId: searchUserId, operation: internalContext ? "internal query" : "query memory" });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args, ghostMode: !!ghostMode });
+    debug.trace("Arguments", { args, internalContext: !!internalContext });
     if (!args.query || args.query.trim() === "") {
       throw new Error("Query cannot be empty");
     }
-    logger.info("Querying memories", { userId: searchUserId, query: args.query, ghostMode: !!ghostMode });
+    logger.info("Querying memories", { userId: searchUserId, query: args.query, internalContext: !!internalContext });
     const collection = getMemoryCollection2(searchUserId);
     const limit = args.limit ?? 5;
     const minRelevance = args.min_relevance ?? 0.6;
     const includeContext = args.include_context ?? true;
     const format = args.format ?? "detailed";
     const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || "exclude");
-    const trustFilter = ghostMode ? buildTrustFilter(collection, ghostMode.accessor_trust_level) : null;
+    const trustFilter = internalContext?.accessor_trust_level != null ? buildTrustFilter(collection, internalContext.accessor_trust_level) : null;
     const searchFilters = buildCombinedSearchFilters(collection, args.filters);
     const hasExplicitTypeFilter = args.filters?.types && args.filters.types.length > 0;
-    const ghostExclusionFilter = !hasExplicitTypeFilter ? collection.filter.byProperty("content_type").notEqual("ghost") : null;
-    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, ghostExclusionFilter, searchFilters].filter((f) => f !== null));
+    const internalExclusionFilter = !hasExplicitTypeFilter ? combineFiltersWithAnd([
+      collection.filter.byProperty("content_type").notEqual("ghost"),
+      collection.filter.byProperty("content_type").notEqual("agent")
+    ]) : null;
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, internalExclusionFilter, searchFilters].filter((f) => f !== null));
     const searchOptions = {
       limit,
       distance: 1 - minRelevance,
@@ -7435,7 +7617,7 @@ async function handleDeny(args, userId, authContext) {
 }
 
 // src/tools/search-space.ts
-import { Filters as Filters6 } from "weaviate-client";
+import { Filters as Filters10 } from "weaviate-client";
 var searchSpaceTool = {
   name: "remember_search_space",
   description: `Search shared spaces and/or groups to discover memories from other users.

package/dist/tools/{create-ghost-memory.d.ts → create-internal-memory.d.ts}

@@ -1,9 +1,10 @@
 /**
- * remember_create_ghost_memory tool
- * Creates a ghost memory with hardcoded content_type and ghost-specific tags
+ * remember_create_internal_memory tool
+ * Creates a ghost or agent memory based on the current session's InternalContext.
+ * Content type and tags are derived from platform HTTP headers, not tool args.
  */
 import type { AuthContext } from '../types/auth.js';
-export declare const createGhostMemoryTool: {
+export declare const createInternalMemoryTool: {
     name: string;
     description: string;
     inputSchema: {
@@ -40,25 +41,22 @@ export declare const createGhostMemoryTool: {
                 type: string;
                 minimum: number;
                 maximum: number;
-                description: string;
             };
             feel_social_weight: {
                 type: string;
                 minimum: number;
                 maximum: number;
-                description: string;
             };
             feel_narrative_importance: {
                 type: string;
                 minimum: number;
                 maximum: number;
-                description: string;
             };
         };
         required: string[];
     };
 };
-export interface CreateGhostMemoryArgs {
+export interface CreateInternalMemoryArgs {
     content: string;
     title?: string;
     tags?: string[];
@@ -66,5 +64,5 @@ export interface CreateGhostMemoryArgs {
     trust?: number;
     [key: string]: any;
 }
-export declare function handleCreateGhostMemory(args: CreateGhostMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
-//# sourceMappingURL=create-ghost-memory.d.ts.map
+export declare function handleCreateInternalMemory(args: CreateInternalMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
+//# sourceMappingURL=create-internal-memory.d.ts.map

package/dist/tools/internal-tools.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=internal-tools.spec.d.ts.map

package/dist/tools/{query-ghost-memory.d.ts → query-internal-memory.d.ts}

@@ -1,9 +1,9 @@
 /**
- * remember_query_ghost_memory tool
- * Wraps query_memory with hardcoded ghost type filter
+ * remember_query_internal_memory tool
+ * Wraps query_memory with auto-scoped content type and ghost source filters.
  */
 import type { AuthContext } from '../types/auth.js';
-export declare const queryGhostMemoryTool: {
+export declare const queryInternalMemoryTool: {
     name: string;
     description: string;
     inputSchema: {
@@ -25,10 +25,10 @@ export declare const queryGhostMemoryTool: {
         required: string[];
     };
 };
-export interface QueryGhostMemoryArgs {
+export interface QueryInternalMemoryArgs {
     query: string;
     limit?: number;
     min_relevance?: number;
 }
-export declare function handleQueryGhostMemory(args: QueryGhostMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
-//# sourceMappingURL=query-ghost-memory.d.ts.map
+export declare function handleQueryInternalMemory(args: QueryInternalMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
+//# sourceMappingURL=query-internal-memory.d.ts.map

package/dist/tools/{search-ghost-memory-by.d.ts → search-internal-memory-by.d.ts}

@@ -1,10 +1,10 @@
 /**
- * remember_search_ghost_memory_by tool
- * Wraps search_by with hardcoded ghost type filter
+ * remember_search_internal_memory_by tool
+ * Wraps search_by with auto-scoped content type and ghost source filters.
  */
 import type { AuthContext } from '../types/auth.js';
 import type { SearchByMode } from './search-by.js';
-export declare const searchGhostMemoryByTool: {
+export declare const searchInternalMemoryByTool: {
     name: string;
     description: string;
     inputSchema: {
@@ -41,7 +41,7 @@ export declare const searchGhostMemoryByTool: {
         required: string[];
     };
 };
-export interface SearchGhostMemoryByArgs {
+export interface SearchInternalMemoryByArgs {
     mode: SearchByMode;
     query?: string;
     sort_order?: 'asc' | 'desc';
@@ -50,5 +50,5 @@ export interface SearchGhostMemoryByArgs {
     offset?: number;
     deleted_filter?: 'exclude' | 'include' | 'only';
 }
-export declare function handleSearchGhostMemoryBy(args: SearchGhostMemoryByArgs, userId: string, authContext?: AuthContext): Promise<string>;
-//# sourceMappingURL=search-ghost-memory-by.d.ts.map
+export declare function handleSearchInternalMemoryBy(args: SearchInternalMemoryByArgs, userId: string, authContext?: AuthContext): Promise<string>;
+//# sourceMappingURL=search-internal-memory-by.d.ts.map

package/dist/tools/{search-ghost-memory.d.ts → search-internal-memory.d.ts}

@@ -1,9 +1,9 @@
 /**
- * remember_search_ghost_memory tool
- * Wraps search_memory with hardcoded ghost type filter
+ * remember_search_internal_memory tool
+ * Wraps search_memory with auto-scoped content type and ghost source filters.
  */
 import type { AuthContext } from '../types/auth.js';
-export declare const searchGhostMemoryTool: {
+export declare const searchInternalMemoryTool: {
     name: string;
     description: string;
     inputSchema: {
@@ -41,7 +41,7 @@ export declare const searchGhostMemoryTool: {
         required: string[];
     };
 };
-export interface SearchGhostMemoryArgs {
+export interface SearchInternalMemoryArgs {
     query: string;
     alpha?: number;
     tags?: string[];
@@ -49,5 +49,5 @@ export interface SearchGhostMemoryArgs {
     offset?: number;
     deleted_filter?: 'exclude' | 'include' | 'only';
 }
-export declare function handleSearchGhostMemory(args: SearchGhostMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
-//# sourceMappingURL=search-ghost-memory.d.ts.map
+export declare function handleSearchInternalMemory(args: SearchInternalMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
+//# sourceMappingURL=search-internal-memory.d.ts.map

package/dist/tools/{update-ghost-memory.d.ts → update-internal-memory.d.ts}

@@ -1,9 +1,9 @@
 /**
- * remember_update_ghost_memory tool
- * Updates a ghost memory after validating content_type
+ * remember_update_internal_memory tool
+ * Updates a ghost or agent memory after validating content_type matches session context.
  */
 import type { AuthContext } from '../types/auth.js';
-export declare const updateGhostMemoryTool: {
+export declare const updateInternalMemoryTool: {
     name: string;
     description: string;
     inputSchema: {
@@ -39,7 +39,7 @@ export declare const updateGhostMemoryTool: {
         required: string[];
     };
 };
-export interface UpdateGhostMemoryArgs {
+export interface UpdateInternalMemoryArgs {
     memory_id: string;
     content?: string;
     title?: string;
@@ -47,5 +47,5 @@ export interface UpdateGhostMemoryArgs {
     weight?: number;
     trust?: number;
 }
-export declare function handleUpdateGhostMemory(args: UpdateGhostMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
-//# sourceMappingURL=update-ghost-memory.d.ts.map
+export declare function handleUpdateInternalMemory(args: UpdateInternalMemoryArgs, userId: string, authContext?: AuthContext): Promise<string>;
+//# sourceMappingURL=update-internal-memory.d.ts.map

package/dist/types/auth.d.ts

@@ -24,20 +24,34 @@ export interface UserCredentials {
     user_id: string;
     group_memberships: GroupMembership[];
 }
-/** Ghost conversation context — resolved server-side, never from tool args */
-export interface GhostModeContext {
-    /** The ghost owner's user ID (whose memories are being searched) */
-    owner_user_id: string;
-    /** The accessor's user ID (who is chatting with the ghost) */
+/**
+ * Internal context for ghost/agent sessions — resolved server-side from
+ * platform HTTP headers, never from tool args.
+ *
+ * Replaces the former GhostModeContext. All ghost identity, trust, and
+ * agent context is unified here.
+ */
+export interface InternalContext {
+    /** Whether this is a ghost or agent session */
+    type: 'ghost' | 'agent';
+    /** Ghost sub-type (required when type is 'ghost') */
+    ghost_type?: 'user' | 'space' | 'group';
+    /** Space ID (space ghosts only) */
+    ghost_space?: string;
+    /** Group ID (group ghosts only) */
+    ghost_group?: string;
+    /** The ghost owner's user ID (user ghosts — whose memories are searched) */
+    owner_user_id?: string;
+    /** The accessor's user ID (who is conversing) */
     accessor_user_id: string;
     /** Resolved trust level (looked up from GhostConfig, not user-supplied) */
-    accessor_trust_level: number;
+    accessor_trust_level?: number;
 }
 export interface AuthContext {
     accessToken: string | null;
     credentials: UserCredentials | null;
-    /** Present when the server is running in ghost conversation mode */
-    ghostMode?: GhostModeContext;
+    /** Present when the server is running in ghost or agent mode */
+    internalContext?: InternalContext;
 }
 export type WriteMode = 'owner_only' | 'group_editors' | 'anyone';
 export interface CredentialsProvider {

package/dist/utils/internal-tags.d.ts

@@ -0,0 +1,14 @@
+import type { AuthContext } from '../types/auth.js';
+/**
+ * Build tags for internal (ghost/agent) memories based on the current
+ * session's InternalContext. These tags implement ghost source isolation
+ * so memories from different ghost conversations are distinguishable.
+ *
+ * Tag scheme:
+ *   User ghost (alice):        ['ghost', 'ghost_type:user', 'ghost_owner:user:alice']
+ *   Space ghost (music-lovers): ['ghost', 'ghost_type:space', 'ghost_owner:space:music-lovers']
+ *   Group ghost (band-mates):   ['ghost', 'ghost_type:group', 'ghost_owner:group:band-mates']
+ *   Agent:                      ['agent']
+ */
+export declare function buildInternalTags(authContext: AuthContext): string[];
+//# sourceMappingURL=internal-tags.d.ts.map

package/dist/utils/internal-tags.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=internal-tags.spec.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "3.15.7",
+  "version": "3.16.2",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",
@@ -51,8 +51,7 @@
     "@google-cloud/vision": "^5.3.4",
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@prmichaelsen/firebase-admin-sdk-v8": "^2.2.0",
-    "@prmichaelsen/mcp-auth": "^7.0.4",
-    "@prmichaelsen/remember-core": "^0.45.0",
+    "@prmichaelsen/remember-core": "^0.49.16",
     "dotenv": "^16.4.5",
     "uuid": "^13.0.0",
     "weaviate-client": "^3.2.0"

package/src/e2e-helpers.ts

@@ -24,12 +24,14 @@ export function e2eAuthContext(): AuthContext {
   return { accessToken: null, credentials: null };
 }
 
-/** AuthContext with ghost mode for cross-user tests */
+/** AuthContext with ghost internal context for cross-user tests */
 export function e2eGhostAuthContext(ownerUserId: string, accessorUserId: string, trustLevel = 0.5): AuthContext {
   return {
     accessToken: null,
     credentials: null,
-    ghostMode: {
+    internalContext: {
+      type: 'ghost',
+      ghost_type: 'user',
       owner_user_id: ownerUserId,
       accessor_user_id: accessorUserId,
       accessor_trust_level: trustLevel,