@prmichaelsen/remember-mcp 3.15.7 → 3.16.2

package/dist/server-factory.js

@@ -1931,7 +1931,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
@@ -2582,7 +2588,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 {
@@ -3358,6 +3370,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)
@@ -3374,6 +3479,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, {
@@ -3565,6 +3671,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
@@ -5006,6 +5134,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) {
@@ -5150,6 +5314,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",
@@ -5785,12 +5961,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");
     }
@@ -5799,18 +5975,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,
@@ -6156,7 +6335,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: {
@@ -6299,27 +6478,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,
@@ -7431,7 +7613,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.
@@ -8277,16 +8459,16 @@ var searchByTool = {
   }
 };
 async function handleSearchBy(args, userId, authContext) {
-  const ghostMode = authContext?.ghostMode;
-  const searchUserId = ghostMode?.owner_user_id ?? userId;
+  const internalContext = authContext?.internalContext;
+  const searchUserId = internalContext?.owner_user_id ?? userId;
   const debug = createDebugLogger({ tool: "remember_search_by", userId: searchUserId, operation: `search by ${args.mode}` });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args, ghostMode: !!ghostMode });
+    debug.trace("Arguments", { args, internalContext: !!internalContext });
     const { memory } = createCoreServices(searchUserId);
-    const ghostContext = ghostMode ? {
-      accessor_trust_level: ghostMode.accessor_trust_level,
-      owner_user_id: ghostMode.owner_user_id
+    const ghostContext = internalContext?.accessor_trust_level != null ? {
+      accessor_trust_level: internalContext.accessor_trust_level,
+      owner_user_id: internalContext.owner_user_id
     } : void 0;
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
@@ -8398,45 +8580,78 @@ async function handleSearchBy(args, userId, authContext) {
   }
 }
 
-// src/tools/create-ghost-memory.ts
-var createGhostMemoryTool = {
-  name: "remember_create_ghost_memory",
-  description: `Create a ghost memory (cross-user interaction record).
+// src/utils/internal-tags.ts
+function buildInternalTags(authContext) {
+  const ctx = authContext.internalContext;
+  if (!ctx)
+    return [];
+  if (ctx.type === "agent") {
+    return ["agent"];
+  }
+  const tags = ["ghost"];
+  switch (ctx.ghost_type) {
+    case "user":
+      tags.push("ghost_type:user");
+      if (ctx.owner_user_id) {
+        tags.push(`ghost_owner:user:${ctx.owner_user_id}`);
+      }
+      break;
+    case "space":
+      tags.push("ghost_type:space");
+      if (ctx.ghost_space) {
+        tags.push(`ghost_owner:space:${ctx.ghost_space}`);
+      }
+      break;
+    case "group":
+      tags.push("ghost_type:group");
+      if (ctx.ghost_group) {
+        tags.push(`ghost_owner:group:${ctx.ghost_group}`);
+      }
+      break;
+  }
+  return tags;
+}
+
+// src/tools/create-internal-memory.ts
+var createInternalMemoryTool = {
+  name: "remember_create_internal_memory",
+  description: `Create an internal memory (ghost observation or agent note) based on the current session context.
+
+  In ghost mode: creates a ghost memory tracking conversation observations, impressions,
+  and insights. Automatically tagged with ghost source isolation tags.
 
-  Ghost memories track what happened during ghost conversations \u2014 observations,
-  impressions, and insights about the accessor. Automatically sets content_type
-  to 'ghost' and adds ghost-specific tags.
+  In agent mode: creates an agent memory for AI observations and notes.
+  Automatically tagged with agent tags.
 
-  Ghost memories are excluded from default searches. They are only visible when
-  explicitly searching with content_type: 'ghost' or using ghost memory tools.`,
+  Content type and tags are determined by the platform session context.
+  This tool errors if no internal session context is present.`,
   inputSchema: {
     type: "object",
     properties: {
-      content: { type: "string", description: "Ghost memory content" },
+      content: { type: "string", description: "Memory content" },
       title: { type: "string", description: "Optional title" },
-      tags: { type: "array", items: { type: "string" }, description: "Additional tags (ghost-specific tags added automatically)" },
+      tags: { type: "array", items: { type: "string" }, description: "Additional tags (internal tags added automatically)" },
       weight: { type: "number", minimum: 0, maximum: 1, description: "Significance (0-1)" },
       trust: { type: "number", minimum: 0, maximum: 1, description: "Trust level (0-1)" },
-      feel_salience: { type: "number", minimum: 0, maximum: 1, description: "How unexpected/novel (0-1)" },
-      feel_social_weight: { type: "number", minimum: 0, maximum: 1, description: "Relationship/reputation impact (0-1)" },
-      feel_narrative_importance: { type: "number", minimum: 0, maximum: 1, description: "Story arc importance (0-1)" }
+      feel_salience: { type: "number", minimum: 0, maximum: 1 },
+      feel_social_weight: { type: "number", minimum: 0, maximum: 1 },
+      feel_narrative_importance: { type: "number", minimum: 0, maximum: 1 }
     },
     required: ["content"]
   }
 };
-async function handleCreateGhostMemory(args, userId, authContext) {
-  const debug = createDebugLogger({ tool: "remember_create_ghost_memory", userId, operation: "create ghost memory" });
+async function handleCreateInternalMemory(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_create_internal_memory", userId, operation: "create internal memory" });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args });
-    const { memory } = createCoreServices(userId);
-    const accessorUserId = authContext?.ghostMode?.accessor_user_id;
-    const ghostTags = ["ghost"];
-    if (accessorUserId) {
-      ghostTags.push(`ghost:${accessorUserId}`);
+    const ctx = authContext?.internalContext;
+    if (!ctx) {
+      return JSON.stringify({ error: "Internal context required. X-Internal-Type header must be set." });
     }
+    const { memory } = createCoreServices(userId);
+    const internalTags = buildInternalTags(authContext);
     const userTags = args.tags ?? [];
-    const mergedTags = [.../* @__PURE__ */ new Set([...ghostTags, ...userTags])];
+    const mergedTags = [.../* @__PURE__ */ new Set([...internalTags, ...userTags])];
     const feelFields = {};
     for (const [key, value] of Object.entries(args)) {
       if (key.startsWith("feel_") && typeof value === "number") {
@@ -8446,38 +8661,39 @@ async function handleCreateGhostMemory(args, userId, authContext) {
     const result = await memory.create({
       content: args.content,
       title: args.title,
-      type: "ghost",
+      type: ctx.type,
       weight: args.weight,
       trust: args.trust,
       tags: mergedTags,
-      context_summary: "Ghost memory created via MCP",
+      context_summary: `Internal memory created via MCP (${ctx.type})`,
       ...feelFields
     });
     return JSON.stringify({
       memory_id: result.memory_id,
       created_at: result.created_at,
-      content_type: "ghost",
+      content_type: ctx.type,
       tags: mergedTags,
-      message: `Ghost memory created successfully with ID: ${result.memory_id}`
+      message: `${ctx.type} memory created successfully with ID: ${result.memory_id}`
     }, null, 2);
   } catch (error) {
     debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
-      toolName: "remember_create_ghost_memory",
-      operation: "create ghost memory",
+      toolName: "remember_create_internal_memory",
+      operation: "create internal memory",
       userId
     });
   }
 }
 
-// src/tools/update-ghost-memory.ts
-var updateGhostMemoryTool = {
-  name: "remember_update_ghost_memory",
-  description: "Update a ghost memory. Only works on memories with content_type: ghost.",
+// src/tools/update-internal-memory.ts
+var updateInternalMemoryTool = {
+  name: "remember_update_internal_memory",
+  description: `Update an internal memory (ghost or agent). Only works on memories matching
+  the current session's content type. Use remember_update_memory for regular memories.`,
   inputSchema: {
     type: "object",
     properties: {
-      memory_id: { type: "string", description: "Ghost memory ID to update" },
+      memory_id: { type: "string", description: "Memory ID to update" },
       content: { type: "string" },
       title: { type: "string" },
       tags: { type: "array", items: { type: "string" } },
@@ -8487,19 +8703,23 @@ var updateGhostMemoryTool = {
     required: ["memory_id"]
   }
 };
-async function handleUpdateGhostMemory(args, userId, authContext) {
-  const debug = createDebugLogger({ tool: "remember_update_ghost_memory", userId, operation: "update ghost memory" });
+async function handleUpdateInternalMemory(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_update_internal_memory", userId, operation: "update internal memory" });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args });
+    const ctx = authContext?.internalContext;
+    if (!ctx) {
+      return JSON.stringify({ error: "Internal context required. X-Internal-Type header must be set." });
+    }
     const collection = getMemoryCollection2(userId);
     const existing = await collection.query.fetchObjectById(args.memory_id);
     if (!existing) {
       return JSON.stringify({ error: `Memory ${args.memory_id} not found` });
     }
-    if (existing.properties.content_type !== "ghost") {
+    const existingType = existing.properties.content_type;
+    if (existingType !== ctx.type) {
       return JSON.stringify({
-        error: `Memory ${args.memory_id} is not a ghost memory (content_type: ${existing.properties.content_type}). Use remember_update_memory for non-ghost memories.`
+        error: `Memory ${args.memory_id} is content_type: ${existingType}, but current session is ${ctx.type}. Use remember_update_memory for non-internal memories.`
       });
     }
     const { memory } = createCoreServices(userId);
@@ -8516,31 +8736,33 @@ async function handleUpdateGhostMemory(args, userId, authContext) {
       updated_at: result.updated_at,
       version: result.version,
       updated_fields: result.updated_fields,
-      message: `Ghost memory updated successfully. Updated fields: ${result.updated_fields.join(", ")}`
+      message: `${ctx.type} memory updated successfully. Updated fields: ${result.updated_fields.join(", ")}`
     }, null, 2);
   } catch (error) {
     debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
-      toolName: "remember_update_ghost_memory",
-      operation: "update ghost memory",
+      toolName: "remember_update_internal_memory",
+      operation: "update internal memory",
       userId,
       memoryId: args.memory_id
     });
   }
 }
 
-// src/tools/search-ghost-memory.ts
-var searchGhostMemoryTool = {
-  name: "remember_search_ghost_memory",
-  description: `Search ghost memories using hybrid semantic + keyword search.
-  Automatically filters to content_type: ghost. Use this to find specific
-  ghost interaction records.`,
+// src/tools/search-internal-memory.ts
+var searchInternalMemoryTool = {
+  name: "remember_search_internal_memory",
+  description: `Search internal memories (ghost or agent) using hybrid semantic + keyword search.
+
+  Automatically scoped to the current session's content type and ghost source.
+  In ghost mode, only shows memories from the current ghost conversation
+  (e.g., only alice's ghost memories, not carol's).`,
   inputSchema: {
     type: "object",
     properties: {
       query: { type: "string", description: "Search query" },
       alpha: { type: "number", minimum: 0, maximum: 1, description: "Semantic vs keyword balance. Default: 0.7" },
-      tags: { type: "array", items: { type: "string" }, description: "Filter by tags" },
+      tags: { type: "array", items: { type: "string" }, description: "Additional tag filters" },
       limit: { type: "number", description: "Max results. Default: 10" },
       offset: { type: "number" },
       deleted_filter: { type: "string", enum: ["exclude", "include", "only"] }
@@ -8548,11 +8770,18 @@ var searchGhostMemoryTool = {
     required: ["query"]
   }
 };
-async function handleSearchGhostMemory(args, userId, authContext) {
-  const debug = createDebugLogger({ tool: "remember_search_ghost_memory", userId, operation: "search ghost memories" });
+async function handleSearchInternalMemory(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_search_internal_memory", userId, operation: "search internal memories" });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args });
+    const ctx = authContext?.internalContext;
+    if (!ctx) {
+      return JSON.stringify({ error: "Internal context required. X-Internal-Type header must be set." });
+    }
+    const allTags = buildInternalTags(authContext);
+    const scopeTags = allTags.filter((t) => t !== "ghost" && t !== "agent");
+    const userTags = args.tags ?? [];
+    const mergedTags = [.../* @__PURE__ */ new Set([...scopeTags, ...userTags])];
     return await handleSearchMemory(
       {
         query: args.query,
@@ -8560,8 +8789,8 @@ async function handleSearchGhostMemory(args, userId, authContext) {
         limit: args.limit,
         offset: args.offset,
         filters: {
-          types: ["ghost"],
-          tags: args.tags
+          types: [ctx.type],
+          tags: mergedTags.length > 0 ? mergedTags : void 0
         },
         deleted_filter: args.deleted_filter
       },
@@ -8571,18 +8800,19 @@ async function handleSearchGhostMemory(args, userId, authContext) {
   } catch (error) {
     debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
-      toolName: "remember_search_ghost_memory",
-      operation: "search ghost memories",
+      toolName: "remember_search_internal_memory",
+      operation: "search internal memories",
       userId
     });
   }
 }
 
-// src/tools/query-ghost-memory.ts
-var queryGhostMemoryTool = {
-  name: "remember_query_ghost_memory",
-  description: `Query ghost memories using natural language (pure semantic search).
-  Automatically filters to content_type: ghost.`,
+// src/tools/query-internal-memory.ts
+var queryInternalMemoryTool = {
+  name: "remember_query_internal_memory",
+  description: `Query internal memories (ghost or agent) using natural language (pure semantic search).
+
+  Automatically scoped to the current session's content type and ghost source.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -8593,18 +8823,24 @@ var queryGhostMemoryTool = {
     required: ["query"]
   }
 };
-async function handleQueryGhostMemory(args, userId, authContext) {
-  const debug = createDebugLogger({ tool: "remember_query_ghost_memory", userId, operation: "query ghost memories" });
+async function handleQueryInternalMemory(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_query_internal_memory", userId, operation: "query internal memories" });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args });
+    const ctx = authContext?.internalContext;
+    if (!ctx) {
+      return JSON.stringify({ error: "Internal context required. X-Internal-Type header must be set." });
+    }
+    const allTags = buildInternalTags(authContext);
+    const scopeTags = allTags.filter((t) => t !== "ghost" && t !== "agent");
     return await handleQueryMemory(
       {
         query: args.query,
         limit: args.limit,
         min_relevance: args.min_relevance,
         filters: {
-          types: ["ghost"]
+          types: [ctx.type],
+          tags: scopeTags.length > 0 ? scopeTags : void 0
         }
       },
       userId,
@@ -8613,45 +8849,43 @@ async function handleQueryGhostMemory(args, userId, authContext) {
   } catch (error) {
     debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
-      toolName: "remember_query_ghost_memory",
-      operation: "query ghost memories",
+      toolName: "remember_query_internal_memory",
+      operation: "query internal memories",
       userId
     });
   }
 }
 
-// src/tools/search-ghost-memory-by.ts
-var searchGhostMemoryByTool = {
-  name: "remember_search_ghost_memory_by",
-  description: `Search ghost memories using specialized sort/discovery modes. Automatically filters to content_type: ghost.
+// src/tools/search-internal-memory-by.ts
+var searchInternalMemoryByTool = {
+  name: "remember_search_internal_memory_by",
+  description: `Search internal memories (ghost or agent) using specialized sort/discovery modes.
+  Automatically scoped to the current session's content type and ghost source.
 
   Modes:
   - byTime: Chronological sort (newest/oldest first)
-  - byDensity: Sort by relationship count (most connected ghost memories)
-  - byRating: Sort by Bayesian rating average (social ratings from spaces)
+  - byDensity: Sort by relationship count (most connected memories)
+  - byRating: Sort by Bayesian rating average
   - byDiscovery: Interleaved rated + unrated content for exploration (4:1 ratio)
-  - byProperty: Sort by any memory property (e.g., feel_trauma, weight, feel_salience). Requires sort_field.
-  - bySignificance: Sort by total_significance (combined emotional + functional score from REM)
-  - byBroad: Massive results with truncated content (content_head/mid/tail ~100 chars each) for scan-and-drill-in workflow
+  - byProperty: Sort by any memory property (e.g., feel_trauma, weight). Requires sort_field.
+  - bySignificance: Sort by total_significance (combined emotional + functional score)
+  - byBroad: Massive results with truncated content for scan-and-drill-in
   - byRandom: Random sampling for serendipitous rediscovery
 
-  Use remember_search_ghost_memory for hybrid semantic+keyword search.
-  Use this tool for structured browsing, sorting, and discovery of ghost interaction records.
-
   Available sort_field values for byProperty:
   Emotions (0-1): feel_emotional_significance, feel_vulnerability, feel_trauma, feel_humor, feel_happiness, feel_sadness, feel_fear, feel_anger, feel_surprise, feel_disgust, feel_contempt, feel_embarrassment, feel_shame, feel_guilt, feel_excitement, feel_pride, feel_intensity, feel_coherence_tension
-  Affect dimensions: feel_valence (-1 to 1), feel_arousal (0-1), feel_dominance (0-1)
-  Functional signals (0-1): functional_salience, functional_urgency, functional_social_weight, functional_agency, functional_novelty, functional_retrieval_utility, functional_narrative_importance, functional_aesthetic_quality, functional_valence, functional_coherence_tension
-  Composite scores: feel_significance, functional_significance, total_significance
+  Affect: feel_valence (-1 to 1), feel_arousal (0-1), feel_dominance (0-1)
+  Functional (0-1): functional_salience, functional_urgency, functional_social_weight, functional_agency, functional_novelty, functional_retrieval_utility, functional_narrative_importance, functional_aesthetic_quality, functional_valence, functional_coherence_tension
+  Composite: feel_significance, functional_significance, total_significance
   Core: weight, trust_score, relationship_count, version
-  REM metadata: rem_visits`,
+  REM: rem_visits`,
   inputSchema: {
     type: "object",
     properties: {
       mode: {
         type: "string",
         enum: ["byTime", "byDensity", "byRating", "byDiscovery", "byProperty", "bySignificance", "byRandom", "byBroad"],
-        description: "Search mode: byTime (chronological), byDensity (most connected), byRating (highest rated), byDiscovery (explore mix), byProperty (sort by field), bySignificance (emotional+functional score), byRandom (random sample), byBroad (scan many truncated)"
+        description: "Search mode"
       },
       query: { type: "string", description: "Optional search query" },
       sort_order: { type: "string", enum: ["asc", "desc"] },
@@ -8663,11 +8897,16 @@ var searchGhostMemoryByTool = {
     required: ["mode"]
   }
 };
-async function handleSearchGhostMemoryBy(args, userId, authContext) {
-  const debug = createDebugLogger({ tool: "remember_search_ghost_memory_by", userId, operation: "search ghost memories by mode" });
+async function handleSearchInternalMemoryBy(args, userId, authContext) {
+  const debug = createDebugLogger({ tool: "remember_search_internal_memory_by", userId, operation: "search internal memories by mode" });
   try {
     debug.info("Tool invoked");
-    debug.trace("Arguments", { args });
+    const ctx = authContext?.internalContext;
+    if (!ctx) {
+      return JSON.stringify({ error: "Internal context required. X-Internal-Type header must be set." });
+    }
+    const allTags = buildInternalTags(authContext);
+    const scopeTags = allTags.filter((t) => t !== "ghost" && t !== "agent");
     return await handleSearchBy(
       {
         mode: args.mode,
@@ -8677,7 +8916,8 @@ async function handleSearchGhostMemoryBy(args, userId, authContext) {
         limit: args.limit,
         offset: args.offset,
         filters: {
-          types: ["ghost"]
+          types: [ctx.type],
+          tags: scopeTags.length > 0 ? scopeTags : void 0
         },
         deleted_filter: args.deleted_filter
       },
@@ -8687,8 +8927,8 @@ async function handleSearchGhostMemoryBy(args, userId, authContext) {
   } catch (error) {
     debug.error("Tool failed", { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
-      toolName: "remember_search_ghost_memory_by",
-      operation: "search ghost memories by mode",
+      toolName: "remember_search_internal_memory_by",
+      operation: "search internal memories by mode",
       userId
     });
   }
@@ -8999,16 +9239,37 @@ async function ensureDatabasesInitialized() {
   })();
   return initializationPromise;
 }
+function normalizeOptions(raw, userId) {
+  if ("internalContext" in raw || !("internal_type" in raw)) {
+    return raw;
+  }
+  const extras = raw;
+  const internalType = extras.internal_type;
+  if (!internalType) {
+    return {};
+  }
+  return {
+    internalContext: {
+      type: internalType,
+      ghost_type: extras.ghost_type,
+      ghost_space: extras.ghost_space,
+      ghost_group: extras.ghost_group,
+      owner_user_id: extras.ghost_owner,
+      accessor_user_id: userId
+    }
+  };
+}
 async function createServer(accessToken, userId, options = {}) {
   if (!userId) {
     throw new Error("userId is required");
   }
+  const opts = normalizeOptions(options, userId);
   logger.debug("Creating server instance", { userId });
   await ensureDatabasesInitialized();
   const server = new Server(
     {
-      name: options.name || "remember-mcp",
-      version: options.version || "0.2.0"
+      name: opts.name || "remember-mcp",
+      version: opts.version || "0.2.0"
     },
     {
       capabilities: {
@@ -9016,25 +9277,35 @@ async function createServer(accessToken, userId, options = {}) {
       }
     }
   );
-  let resolvedGhostMode;
-  if (options.ghostMode) {
-    const ghostConfig = await getGhostConfig2(options.ghostMode.owner_user_id);
-    const trustLevel = await resolveAccessorTrustLevel2(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,
-      accessor_trust_level: trustLevel
+  let resolvedInternalContext;
+  if (opts.internalContext) {
+    const ic = opts.internalContext;
+    let accessorTrustLevel;
+    if (ic.type === "ghost" && ic.owner_user_id) {
+      const ghostConfig = await getGhostConfig2(ic.owner_user_id);
+      accessorTrustLevel = await resolveAccessorTrustLevel2(ghostConfig, ic.owner_user_id, ic.accessor_user_id);
+    }
+    resolvedInternalContext = {
+      type: ic.type,
+      ghost_type: ic.ghost_type,
+      ghost_space: ic.ghost_space,
+      ghost_group: ic.ghost_group,
+      owner_user_id: ic.owner_user_id,
+      accessor_user_id: ic.accessor_user_id,
+      accessor_trust_level: accessorTrustLevel
     };
-    logger.info("Ghost mode resolved", {
-      ownerUserId: resolvedGhostMode.owner_user_id,
-      accessorUserId: resolvedGhostMode.accessor_user_id,
-      trustLevel: resolvedGhostMode.accessor_trust_level
+    logger.info("Internal context resolved", {
+      type: resolvedInternalContext.type,
+      ghostType: resolvedInternalContext.ghost_type,
+      ownerUserId: resolvedInternalContext.owner_user_id,
+      accessorUserId: resolvedInternalContext.accessor_user_id,
+      trustLevel: resolvedInternalContext.accessor_trust_level
     });
   }
-  registerHandlers(server, userId, accessToken, resolvedGhostMode);
+  registerHandlers(server, userId, accessToken, resolvedInternalContext);
   return server;
 }
-function registerHandlers(server, userId, accessToken, ghostMode) {
+function registerHandlers(server, userId, accessToken, internalContext) {
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
       tools: [
@@ -9065,12 +9336,12 @@ function registerHandlers(server, userId, accessToken, ghostMode) {
         ghostConfigTool,
         // Search modes
         searchByTool,
-        // Ghost memory tools
-        createGhostMemoryTool,
-        updateGhostMemoryTool,
-        searchGhostMemoryTool,
-        queryGhostMemoryTool,
-        searchGhostMemoryByTool,
+        // Unified internal memory tools
+        createInternalMemoryTool,
+        updateInternalMemoryTool,
+        searchInternalMemoryTool,
+        queryInternalMemoryTool,
+        searchInternalMemoryByTool,
         // Core introspection
         getCoreTool,
         // Space search modes
@@ -9082,7 +9353,7 @@ function registerHandlers(server, userId, accessToken, ghostMode) {
     const { name, arguments: args } = request.params;
     try {
       const credentials = await credentialsProvider.getCredentials(accessToken, userId);
-      const authContext = { accessToken, credentials, ghostMode };
+      const authContext = { accessToken, credentials, internalContext };
       let result;
       switch (name) {
         case "remember_create_memory":
@@ -9151,20 +9422,20 @@ function registerHandlers(server, userId, accessToken, ghostMode) {
         case "remember_search_by":
           result = await handleSearchBy(args, userId, authContext);
           break;
-        case "remember_create_ghost_memory":
-          result = await handleCreateGhostMemory(args, userId, authContext);
+        case "remember_create_internal_memory":
+          result = await handleCreateInternalMemory(args, userId, authContext);
           break;
-        case "remember_update_ghost_memory":
-          result = await handleUpdateGhostMemory(args, userId, authContext);
+        case "remember_update_internal_memory":
+          result = await handleUpdateInternalMemory(args, userId, authContext);
           break;
-        case "remember_search_ghost_memory":
-          result = await handleSearchGhostMemory(args, userId, authContext);
+        case "remember_search_internal_memory":
+          result = await handleSearchInternalMemory(args, userId, authContext);
           break;
-        case "remember_query_ghost_memory":
-          result = await handleQueryGhostMemory(args, userId, authContext);
+        case "remember_query_internal_memory":
+          result = await handleQueryInternalMemory(args, userId, authContext);
           break;
-        case "remember_search_ghost_memory_by":
-          result = await handleSearchGhostMemoryBy(args, userId, authContext);
+        case "remember_search_internal_memory_by":
+          result = await handleSearchInternalMemoryBy(args, userId, authContext);
           break;
         case "remember_get_core":
           result = await handleGetCore(args, userId, authContext);