@prmichaelsen/remember-mcp 3.15.7 → 3.16.2

package/src/ghost-persona.e2e.ts

@@ -10,11 +10,11 @@ import {
   e2eEnsureCollection, e2eCleanup, parseResult, waitForIndex,
 } from './e2e-helpers.js';
 import { handleGhostConfig } from './tools/ghost-config.js';
-import { handleCreateGhostMemory } from './tools/create-ghost-memory.js';
-import { handleSearchGhostMemory } from './tools/search-ghost-memory.js';
-import { handleUpdateGhostMemory } from './tools/update-ghost-memory.js';
-import { handleQueryGhostMemory } from './tools/query-ghost-memory.js';
-import { handleSearchGhostMemoryBy } from './tools/search-ghost-memory-by.js';
+import { handleCreateInternalMemory } from './tools/create-internal-memory.js';
+import { handleSearchInternalMemory } from './tools/search-internal-memory.js';
+import { handleUpdateInternalMemory } from './tools/update-internal-memory.js';
+import { handleQueryInternalMemory } from './tools/query-internal-memory.js';
+import { handleSearchInternalMemoryBy } from './tools/search-internal-memory-by.js';
 import { handleGetCore } from './tools/get-core.js';
 
 const ownerId = e2eUserId('ghost_owner');
@@ -79,7 +79,7 @@ describe('E2E: Ghost/Persona', () => {
   // -------------------------------------------------------------------------
 
   it('creates a ghost memory', async () => {
-    const res = parseResult(await handleCreateGhostMemory(
+    const res = parseResult(await handleCreateInternalMemory(
       {
         content: `${accessorId} asked about my favorite hiking trails. They seem genuinely interested in outdoor activities.`,
         weight: 0.6,
@@ -94,7 +94,8 @@ describe('E2E: Ghost/Persona', () => {
     expect(res.memory_id).toBeTruthy();
     expect(res.content_type).toBe('ghost');
     expect(res.tags).toContain('ghost');
-    expect(res.tags).toContain(`ghost:${accessorId}`);
+    expect(res.tags).toContain('ghost_type:user');
+    expect(res.tags).toContain(`ghost_owner:user:${ownerId}`);
     ghostMemoryId = res.memory_id;
     console.log(`  created ghost memory ${ghostMemoryId}`);
   });
@@ -106,10 +107,10 @@ describe('E2E: Ghost/Persona', () => {
   it('searches ghost memories', async () => {
     await waitForIndex(5000);
 
-    // Search ghost memories specifically
-    const res = parseResult(await handleSearchGhostMemory(
+    // Search ghost memories via unified internal tool
+    const res = parseResult(await handleSearchInternalMemory(
       { query: 'hiking trails outdoor activities', limit: 5 },
-      ownerId, ownerAuth,
+      ownerId, ghostAuth,
     ));
 
     expect(res.memories).toBeDefined();
@@ -123,7 +124,7 @@ describe('E2E: Ghost/Persona', () => {
   // -------------------------------------------------------------------------
 
   it('updates the ghost memory', async () => {
-    const res = parseResult(await handleUpdateGhostMemory(
+    const res = parseResult(await handleUpdateInternalMemory(
       {
         memory_id: ghostMemoryId,
         content: `${accessorId} asked about my favorite hiking trails. They seem genuinely interested in outdoor activities. Follow-up: they mentioned they go rock climbing too.`,
@@ -141,10 +142,10 @@ describe('E2E: Ghost/Persona', () => {
   it('queries ghost memories with natural language', async () => {
     await waitForIndex();
 
-    // Use ownerAuth to avoid trust filter — query is already filtered to ghost content_type
-    const res = parseResult(await handleQueryGhostMemory(
+    // Use ghostAuth — query is auto-scoped to ghost content_type via internal context
+    const res = parseResult(await handleQueryInternalMemory(
       { query: 'What are the accessor\'s outdoor interests?', limit: 5, min_relevance: 0.3 },
-      ownerId, ownerAuth,
+      ownerId, ghostAuth,
     ));
 
     expect(res.memories).toBeDefined();
@@ -160,10 +161,10 @@ describe('E2E: Ghost/Persona', () => {
   // This creates an impossible filter: content_type='ghost' AND content_type!='ghost'.
   // Fix: core should skip ghost exclusion when types filter explicitly includes 'ghost'.
   // This test WILL FAIL until the core bug is fixed.
-  it('search_ghost_memory_by byTime returns ghost results', async () => {
-    const res = parseResult(await handleSearchGhostMemoryBy(
+  it('search_internal_memory_by byTime returns ghost results', async () => {
+    const res = parseResult(await handleSearchInternalMemoryBy(
       { mode: 'byTime', limit: 5 },
-      ownerId, ownerAuth,
+      ownerId, ghostAuth,
     ));
 
     expect(res.memories).toBeDefined();

package/src/server-factory.ts

@@ -46,12 +46,12 @@ import { moderateTool, handleModerate } from './tools/moderate.js';
 import { ghostConfigTool, handleGhostConfig } from './tools/ghost-config.js';
 import { searchByTool, handleSearchBy } from './tools/search-by.js';
 
-// Import ghost memory tools
-import { createGhostMemoryTool, handleCreateGhostMemory } from './tools/create-ghost-memory.js';
-import { updateGhostMemoryTool, handleUpdateGhostMemory } from './tools/update-ghost-memory.js';
-import { searchGhostMemoryTool, handleSearchGhostMemory } from './tools/search-ghost-memory.js';
-import { queryGhostMemoryTool, handleQueryGhostMemory } from './tools/query-ghost-memory.js';
-import { searchGhostMemoryByTool, handleSearchGhostMemoryBy } from './tools/search-ghost-memory-by.js';
+// Import unified internal memory tools
+import { createInternalMemoryTool, handleCreateInternalMemory } from './tools/create-internal-memory.js';
+import { updateInternalMemoryTool, handleUpdateInternalMemory } from './tools/update-internal-memory.js';
+import { searchInternalMemoryTool, handleSearchInternalMemory } from './tools/search-internal-memory.js';
+import { queryInternalMemoryTool, handleQueryInternalMemory } from './tools/query-internal-memory.js';
+import { searchInternalMemoryByTool, handleSearchInternalMemoryBy } from './tools/search-internal-memory-by.js';
 
 // Import core introspection tools
 import { getCoreTool, handleGetCore } from './tools/get-core.js';
@@ -65,18 +65,25 @@ export interface ServerOptions {
   name?: string;
   version?: string;
   /**
-   * Ghost mode configuration. When set, the server operates in ghost mode:
-   * - Search/query tools search the ghost owner's collection
-   * - Trust filtering is applied based on the accessor's trust level
-   * - Trust level is resolved server-side from GhostConfig (Firestore)
+   * Internal context for ghost/agent sessions. When set, the server provides
+   * unified internal memory tools with behavior driven by the context type.
    *
-   * agentbase.me sets this when creating a ghost conversation server.
+   * Populated from platform HTTP headers via mcp-auth extras:
+   *   X-Internal-Type → type ('ghost' | 'agent')
+   *   X-Ghost-Owner   → owner_user_id
+   *   X-Ghost-Type    → ghost_type ('user' | 'space' | 'group')
+   *   X-Ghost-Space   → ghost_space
+   *   X-Ghost-Group   → ghost_group
+   *
+   * Trust level is resolved server-side from GhostConfig (Firestore).
    * The LLM never has access to set or override these values.
    */
-  ghostMode?: {
-    /** Ghost owner's user ID (whose memories to search) */
-    owner_user_id: string;
-    /** Accessor's user ID (who is chatting with the ghost) */
+  internalContext?: {
+    type: 'ghost' | 'agent';
+    ghost_type?: 'user' | 'space' | 'group';
+    ghost_space?: string;
+    ghost_group?: string;
+    owner_user_id?: string;
     accessor_user_id: string;
   };
 }
@@ -157,29 +164,72 @@ async function ensureDatabasesInitialized(): Promise<void> {
  * });
  * ```
  */
+/**
+ * Normalize flat mcp-auth extras into structured ServerOptions.
+ *
+ * mcp-auth strips X- prefix and converts hyphens to underscores:
+ *   X-Internal-Type → internal_type
+ *   X-Ghost-Owner   → ghost_owner
+ *   X-Ghost-Type    → ghost_type
+ *   X-Ghost-Space   → ghost_space
+ *   X-Ghost-Group   → ghost_group
+ */
+function normalizeOptions(
+  raw: ServerOptions | Record<string, string | string[] | undefined>,
+  userId: string
+): ServerOptions {
+  // Already structured — has internalContext or no internal_type key
+  if ('internalContext' in raw || !('internal_type' in raw)) {
+    return raw as ServerOptions;
+  }
+
+  // Flat extras from mcp-auth
+  const extras = raw as Record<string, string | string[] | undefined>;
+  const internalType = extras.internal_type as string | undefined;
+
+  if (!internalType) {
+    return {};
+  }
+
+  return {
+    internalContext: {
+      type: internalType as 'ghost' | 'agent',
+      ghost_type: extras.ghost_type as 'user' | 'space' | 'group' | undefined,
+      ghost_space: extras.ghost_space as string | undefined,
+      ghost_group: extras.ghost_group as string | undefined,
+      owner_user_id: extras.ghost_owner as string | undefined,
+      accessor_user_id: userId,
+    },
+  };
+}
+
 export async function createServer(
   accessToken: string,
   userId: string,
-  options: ServerOptions = {}
+  options: ServerOptions | Record<string, string | string[] | undefined> = {}
 ): Promise<Server> {
   // Note: accessToken is not used by remember-mcp (self-managed data)
   // but required by mcp-auth contract. Can be any value including empty string.
-  
+
   if (!userId) {
     throw new Error('userId is required');
   }
-  
+
+  // Normalize: mcp-auth passes flat extras (e.g. { internal_type: 'ghost', ghost_owner: 'alice' })
+  // Direct callers pass structured ServerOptions (e.g. { internalContext: { type: 'ghost', ... } })
+  const opts = normalizeOptions(options, userId);
+
   logger.debug('Creating server instance', { userId });
-  
+
   // Ensure databases are initialized (happens once globally)
   // Initialization must succeed or server creation fails
   await ensureDatabasesInitialized();
-  
+
   // Create MCP server
   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: {
@@ -187,26 +237,38 @@ 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 ghostConfig = await getGhostConfig(options.ghostMode.owner_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,
-      accessor_trust_level: trustLevel,
+
+  // Resolve internal context with trust level from Firestore if ghost mode
+  let resolvedInternalContext: import('./types/auth.js').InternalContext | undefined;
+  if (opts.internalContext) {
+    const ic = opts.internalContext;
+    let accessorTrustLevel: number | undefined;
+
+    if (ic.type === 'ghost' && ic.owner_user_id) {
+      const ghostConfig = await getGhostConfig(ic.owner_user_id);
+      accessorTrustLevel = await resolveAccessorTrustLevel(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,
     });
   }
 
   // Register handlers with userId scope
-  registerHandlers(server, userId, accessToken, resolvedGhostMode);
+  registerHandlers(server, userId, accessToken, resolvedInternalContext);
 
   return server;
 }
@@ -218,7 +280,7 @@ function registerHandlers(
   server: Server,
   userId: string,
   accessToken: string,
-  ghostMode?: import('./types/auth.js').GhostModeContext
+  internalContext?: import('./types/auth.js').InternalContext
 ): void {
   // List available tools
   server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -251,12 +313,12 @@ function registerHandlers(
         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
@@ -272,7 +334,7 @@ function registerHandlers(
     try {
       // Resolve credentials once per request
       const credentials = await credentialsProvider.getCredentials(accessToken, userId);
-      const authContext: AuthContext = { accessToken, credentials, ghostMode };
+      const authContext: AuthContext = { accessToken, credentials, internalContext };
 
       let result: string;
 
@@ -365,24 +427,24 @@ function registerHandlers(
           result = await handleSearchBy(args as any, userId, authContext);
           break;
 
-        case 'remember_create_ghost_memory':
-          result = await handleCreateGhostMemory(args as any, userId, authContext);
+        case 'remember_create_internal_memory':
+          result = await handleCreateInternalMemory(args as any, userId, authContext);
           break;
 
-        case 'remember_update_ghost_memory':
-          result = await handleUpdateGhostMemory(args as any, userId, authContext);
+        case 'remember_update_internal_memory':
+          result = await handleUpdateInternalMemory(args as any, userId, authContext);
           break;
 
-        case 'remember_search_ghost_memory':
-          result = await handleSearchGhostMemory(args as any, userId, authContext);
+        case 'remember_search_internal_memory':
+          result = await handleSearchInternalMemory(args as any, userId, authContext);
           break;
 
-        case 'remember_query_ghost_memory':
-          result = await handleQueryGhostMemory(args as any, userId, authContext);
+        case 'remember_query_internal_memory':
+          result = await handleQueryInternalMemory(args as any, userId, authContext);
           break;
 
-        case 'remember_search_ghost_memory_by':
-          result = await handleSearchGhostMemoryBy(args as any, userId, authContext);
+        case 'remember_search_internal_memory_by':
+          result = await handleSearchInternalMemoryBy(args as any, userId, authContext);
           break;
 
         case 'remember_get_core':

package/src/tools/create-internal-memory.ts

@@ -0,0 +1,105 @@
+/**
+ * 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 { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
+import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
+import { buildInternalTags } from '../utils/internal-tags.js';
+
+export const 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.
+
+  In agent mode: creates an agent memory for AI observations and notes.
+  Automatically tagged with agent tags.
+
+  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: 'Memory content' },
+      title: { type: 'string', description: 'Optional title' },
+      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 },
+      feel_social_weight: { type: 'number', minimum: 0, maximum: 1 },
+      feel_narrative_importance: { type: 'number', minimum: 0, maximum: 1 },
+    },
+    required: ['content'],
+  },
+};
+
+export interface CreateInternalMemoryArgs {
+  content: string;
+  title?: string;
+  tags?: string[];
+  weight?: number;
+  trust?: number;
+  [key: string]: any;
+}
+
+export async function handleCreateInternalMemory(
+  args: CreateInternalMemoryArgs,
+  userId: string,
+  authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_create_internal_memory', userId, operation: 'create internal memory' });
+  try {
+    debug.info('Tool invoked');
+
+    const ctx = authContext?.internalContext;
+    if (!ctx) {
+      return JSON.stringify({ error: 'Internal context required. X-Internal-Type header must be set.' });
+    }
+
+    const { memory } = createCoreServices(userId);
+
+    // Build tags from internal context (ghost source isolation or agent)
+    const internalTags = buildInternalTags(authContext!);
+    const userTags = args.tags ?? [];
+    const mergedTags = [...new Set([...internalTags, ...userTags])];
+
+    // Extract feel_* fields
+    const feelFields: Record<string, number> = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (key.startsWith('feel_') && typeof value === 'number') {
+        feelFields[key] = value;
+      }
+    }
+
+    const result = await memory.create({
+      content: args.content,
+      title: args.title,
+      type: ctx.type as any,
+      weight: args.weight,
+      trust: args.trust,
+      tags: mergedTags,
+      context_summary: `Internal memory created via MCP (${ctx.type})`,
+      ...feelFields,
+    } as any);
+
+    return JSON.stringify({
+      memory_id: result.memory_id,
+      created_at: result.created_at,
+      content_type: ctx.type,
+      tags: mergedTags,
+      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_internal_memory',
+      operation: 'create internal memory',
+      userId,
+    });
+  }
+}

package/src/tools/find-similar.ts

@@ -120,9 +120,9 @@ export async function handleFindSimilar(
       deleted_filter: args.deleted_filter,
     });
 
-    // Post-filter ghost content (core doesn't exclude ghosts)
+    // Post-filter internal content types (core doesn't exclude ghost/agent)
     const filteredMemories = coreResult.similar_memories.filter(
-      (m: any) => m.content_type !== 'ghost'
+      (m: any) => m.content_type !== 'ghost' && m.content_type !== 'agent'
     );
 
     const result: FindSimilarResult = {