@prmichaelsen/remember-mcp 3.15.7 → 3.16.2

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

@@ -0,0 +1,87 @@
+/**
+ * remember_search_internal_memory tool
+ * Wraps search_memory with auto-scoped content type and ghost source filters.
+ */
+
+import { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
+import type { AuthContext } from '../types/auth.js';
+import { handleSearchMemory } from './search-memory.js';
+import { buildInternalTags } from '../utils/internal-tags.js';
+
+export const 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: 'Additional tag filters' },
+      limit: { type: 'number', description: 'Max results. Default: 10' },
+      offset: { type: 'number' },
+      deleted_filter: { type: 'string', enum: ['exclude', 'include', 'only'] },
+    },
+    required: ['query'],
+  },
+};
+
+export interface SearchInternalMemoryArgs {
+  query: string;
+  alpha?: number;
+  tags?: string[];
+  limit?: number;
+  offset?: number;
+  deleted_filter?: 'exclude' | 'include' | 'only';
+}
+
+export async function handleSearchInternalMemory(
+  args: SearchInternalMemoryArgs,
+  userId: string,
+  authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_search_internal_memory', userId, operation: 'search internal memories' });
+  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.' });
+    }
+
+    // Build scope tags for ghost source isolation (no override allowed)
+    const allTags = buildInternalTags(authContext!);
+    // Scope tags = everything except the base 'ghost' or 'agent' tag (those are covered by type filter)
+    const scopeTags = allTags.filter(t => t !== 'ghost' && t !== 'agent');
+    const userTags = args.tags ?? [];
+    const mergedTags = [...new Set([...scopeTags, ...userTags])];
+
+    // Delegate to search_memory with type + scope filters
+    return await handleSearchMemory(
+      {
+        query: args.query,
+        alpha: args.alpha,
+        limit: args.limit,
+        offset: args.offset,
+        filters: {
+          types: [ctx.type] as any,
+          tags: mergedTags.length > 0 ? mergedTags : undefined,
+        },
+        deleted_filter: args.deleted_filter,
+      },
+      userId,
+      authContext
+    );
+  } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
+    handleToolError(error, {
+      toolName: 'remember_search_internal_memory',
+      operation: 'search internal memories',
+      userId,
+    });
+  }
+}

package/src/tools/search-memory.ts

@@ -155,13 +155,13 @@ export async function handleSearchMemory(
   userId: string,
   authContext?: AuthContext
 ): Promise<string> {
-  const ghostMode = authContext?.ghostMode;
+  const internalContext = authContext?.internalContext;
   // In ghost mode, search the ghost owner's collection instead of the caller's
-  const searchUserId = ghostMode?.owner_user_id ?? userId;
-  const debug = createDebugLogger({ tool: 'remember_search_memory', userId: searchUserId, operation: ghostMode ? 'ghost search' : 'search memory' });
+  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 });
     // Validate query is not empty
     if (!args.query || args.query.trim() === '') {
       throw new Error('Query cannot be empty');
@@ -173,7 +173,7 @@ export async function handleSearchMemory(
       userId: searchUserId,
       query: args.query,
       includeRelationships,
-      ghostMode: !!ghostMode,
+      internalContext: !!internalContext,
     });
 
     const collection = getMemoryCollection(searchUserId);
@@ -185,8 +185,8 @@ export async function handleSearchMemory(
     const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || 'exclude');
 
     // Build trust filter for ghost mode (resolved server-side, never from tool args)
-    const trustFilter = ghostMode
-      ? buildTrustFilter(collection, ghostMode.accessor_trust_level)
+    const trustFilter = internalContext?.accessor_trust_level != null
+      ? buildTrustFilter(collection, internalContext.accessor_trust_level)
       : null;
 
     // Build filters using v3 API
@@ -195,14 +195,17 @@ export async function handleSearchMemory(
       ? buildCombinedSearchFilters(collection, args.filters)
       : buildMemoryOnlyFilters(collection, args.filters);
 
-    // Exclude ghost memories by default (unless explicitly searching for them)
+    // Exclude ghost and agent memories by default (unless explicitly searching for them)
     const hasExplicitTypeFilter = args.filters?.types && args.filters.types.length > 0;
-    const ghostExclusionFilter = !hasExplicitTypeFilter
-      ? collection.filter.byProperty('content_type').notEqual('ghost')
+    const internalExclusionFilter = !hasExplicitTypeFilter
+      ? combineFiltersWithAnd([
+          collection.filter.byProperty('content_type').notEqual('ghost'),
+          collection.filter.byProperty('content_type').notEqual('agent'),
+        ])
       : null;
 
-    // Combine deleted filter, trust filter, ghost exclusion, and search filters
-    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, ghostExclusionFilter, searchFilters].filter(f => f !== null));
+    // Combine deleted filter, trust filter, internal exclusion, and search filters
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, internalExclusionFilter, searchFilters].filter(f => f !== null));
 
     // Build search options (native offset handled by Weaviate)
     const searchOptions: any = {

package/src/tools/search-space.ts

@@ -161,6 +161,7 @@ export function buildBaseFilters(collection: any, args: SearchSpaceArgs): any[]
   if (args.content_type) filterList.push(collection.filter.byProperty('content_type').equal(args.content_type));
   if (!args.include_comments && !args.content_type) filterList.push(collection.filter.byProperty('content_type').notEqual('comment'));
   if (!args.content_type) filterList.push(collection.filter.byProperty('content_type').notEqual('ghost'));
+  if (!args.content_type) filterList.push(collection.filter.byProperty('content_type').notEqual('agent'));
   if (args.tags && args.tags.length > 0) args.tags.forEach(tag => filterList.push(collection.filter.byProperty('tags').containsAny([tag])));
   if (args.min_weight !== undefined) filterList.push(collection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
   if (args.max_weight !== undefined) filterList.push(collection.filter.byProperty('weight').lessOrEqual(args.max_weight));

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

@@ -1,6 +1,6 @@
 /**
- * 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 { handleToolError } from '../utils/error-handler.js';
@@ -9,13 +9,14 @@ import type { AuthContext } from '../types/auth.js';
 import { createCoreServices } from '../core-services.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 
-export const updateGhostMemoryTool = {
-  name: 'remember_update_ghost_memory',
-  description: 'Update a ghost memory. Only works on memories with content_type: ghost.',
+export const 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' } },
@@ -26,7 +27,7 @@ export const updateGhostMemoryTool = {
   },
 };
 
-export interface UpdateGhostMemoryArgs {
+export interface UpdateInternalMemoryArgs {
   memory_id: string;
   content?: string;
   title?: string;
@@ -35,25 +36,30 @@ export interface UpdateGhostMemoryArgs {
   trust?: number;
 }
 
-export async function handleUpdateGhostMemory(
-  args: UpdateGhostMemoryArgs,
+export async function handleUpdateInternalMemory(
+  args: UpdateInternalMemoryArgs,
   userId: string,
   authContext?: AuthContext
 ): Promise<string> {
-  const debug = createDebugLogger({ tool: 'remember_update_ghost_memory', userId, operation: 'update ghost memory' });
+  const debug = createDebugLogger({ tool: 'remember_update_internal_memory', userId, operation: 'update internal memory' });
   try {
     debug.info('Tool invoked');
-    debug.trace('Arguments', { args });
 
-    // Validate the memory is a ghost memory
+    const ctx = authContext?.internalContext;
+    if (!ctx) {
+      return JSON.stringify({ error: 'Internal context required. X-Internal-Type header must be set.' });
+    }
+
+    // Validate the memory matches the current content type
     const collection = getMemoryCollection(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 as any).content_type !== 'ghost') {
+    const existingType = (existing.properties as any).content_type;
+    if (existingType !== ctx.type) {
       return JSON.stringify({
-        error: `Memory ${args.memory_id} is not a ghost memory (content_type: ${(existing.properties as any).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.`,
       });
     }
 
@@ -72,13 +78,13 @@ export async function handleUpdateGhostMemory(
       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,
     });

package/src/types/auth.ts

@@ -28,21 +28,35 @@ export interface UserCredentials {
   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';

package/src/utils/internal-tags.spec.ts

@@ -0,0 +1,104 @@
+import { buildInternalTags } from './internal-tags.js';
+import type { AuthContext } from '../types/auth.js';
+
+describe('buildInternalTags', () => {
+  const baseAuth: AuthContext = { accessToken: null, credentials: null };
+
+  it('returns empty array when no internalContext', () => {
+    expect(buildInternalTags(baseAuth)).toEqual([]);
+  });
+
+  it('returns ["agent"] for agent context', () => {
+    const auth: AuthContext = {
+      ...baseAuth,
+      internalContext: { type: 'agent', accessor_user_id: 'bob' },
+    };
+    expect(buildInternalTags(auth)).toEqual(['agent']);
+  });
+
+  it('returns correct tags for user ghost', () => {
+    const auth: AuthContext = {
+      ...baseAuth,
+      internalContext: {
+        type: 'ghost',
+        ghost_type: 'user',
+        owner_user_id: 'alice',
+        accessor_user_id: 'bob',
+      },
+    };
+    expect(buildInternalTags(auth)).toEqual([
+      'ghost',
+      'ghost_type:user',
+      'ghost_owner:user:alice',
+    ]);
+  });
+
+  it('returns correct tags for space ghost', () => {
+    const auth: AuthContext = {
+      ...baseAuth,
+      internalContext: {
+        type: 'ghost',
+        ghost_type: 'space',
+        ghost_space: 'music-lovers',
+        accessor_user_id: 'bob',
+      },
+    };
+    expect(buildInternalTags(auth)).toEqual([
+      'ghost',
+      'ghost_type:space',
+      'ghost_owner:space:music-lovers',
+    ]);
+  });
+
+  it('returns correct tags for group ghost', () => {
+    const auth: AuthContext = {
+      ...baseAuth,
+      internalContext: {
+        type: 'ghost',
+        ghost_type: 'group',
+        ghost_group: 'band-mates',
+        accessor_user_id: 'bob',
+      },
+    };
+    expect(buildInternalTags(auth)).toEqual([
+      'ghost',
+      'ghost_type:group',
+      'ghost_owner:group:band-mates',
+    ]);
+  });
+
+  it('returns ["ghost"] only when ghost_type is missing', () => {
+    const auth: AuthContext = {
+      ...baseAuth,
+      internalContext: {
+        type: 'ghost',
+        accessor_user_id: 'bob',
+      },
+    };
+    expect(buildInternalTags(auth)).toEqual(['ghost']);
+  });
+
+  it('returns user ghost tags without owner when owner_user_id is missing', () => {
+    const auth: AuthContext = {
+      ...baseAuth,
+      internalContext: {
+        type: 'ghost',
+        ghost_type: 'user',
+        accessor_user_id: 'bob',
+      },
+    };
+    expect(buildInternalTags(auth)).toEqual(['ghost', 'ghost_type:user']);
+  });
+
+  it('returns space ghost tags without owner when ghost_space is missing', () => {
+    const auth: AuthContext = {
+      ...baseAuth,
+      internalContext: {
+        type: 'ghost',
+        ghost_type: 'space',
+        accessor_user_id: 'bob',
+      },
+    };
+    expect(buildInternalTags(auth)).toEqual(['ghost', 'ghost_type:space']);
+  });
+});

package/src/utils/internal-tags.ts

@@ -0,0 +1,46 @@
+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 function buildInternalTags(authContext: AuthContext): string[] {
+  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;
+}

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

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

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

@@ -1,103 +0,0 @@
-/**
- * remember_create_ghost_memory tool
- * Creates a ghost memory with hardcoded content_type and ghost-specific tags
- */
-
-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';
-
-export const createGhostMemoryTool = {
-  name: 'remember_create_ghost_memory',
-  description: `Create a ghost memory (cross-user interaction record).
-
-  Ghost memories track what happened during ghost conversations — observations,
-  impressions, and insights about the accessor. Automatically sets content_type
-  to 'ghost' and adds ghost-specific tags.
-
-  Ghost memories are excluded from default searches. They are only visible when
-  explicitly searching with content_type: 'ghost' or using ghost memory tools.`,
-  inputSchema: {
-    type: 'object',
-    properties: {
-      content: { type: 'string', description: 'Ghost memory content' },
-      title: { type: 'string', description: 'Optional title' },
-      tags: { type: 'array', items: { type: 'string' }, description: 'Additional tags (ghost-specific 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)' },
-    },
-    required: ['content'],
-  },
-};
-
-export interface CreateGhostMemoryArgs {
-  content: string;
-  title?: string;
-  tags?: string[];
-  weight?: number;
-  trust?: number;
-  [key: string]: any;
-}
-
-export async function handleCreateGhostMemory(
-  args: CreateGhostMemoryArgs,
-  userId: string,
-  authContext?: AuthContext
-): Promise<string> {
-  const debug = createDebugLogger({ tool: 'remember_create_ghost_memory', userId, operation: 'create ghost memory' });
-  try {
-    debug.info('Tool invoked');
-    debug.trace('Arguments', { args });
-
-    const { memory } = createCoreServices(userId);
-
-    // Build ghost-specific tags
-    const accessorUserId = authContext?.ghostMode?.accessor_user_id;
-    const ghostTags = ['ghost'];
-    if (accessorUserId) {
-      ghostTags.push(`ghost:${accessorUserId}`);
-    }
-
-    // Merge user tags with ghost tags (avoid duplicates)
-    const userTags = args.tags ?? [];
-    const mergedTags = [...new Set([...ghostTags, ...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: 'ghost' as any,
-      weight: args.weight,
-      trust: args.trust,
-      tags: mergedTags,
-      context_summary: 'Ghost memory created via MCP',
-      ...feelFields,
-    } as any);
-
-    return JSON.stringify({
-      memory_id: result.memory_id,
-      created_at: result.created_at,
-      content_type: 'ghost',
-      tags: mergedTags,
-      message: `Ghost 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',
-      userId,
-    });
-  }
-}