fix(memory): scope operator plugin retrieval

packages/memory/src/operator-memory-plugin.ts

@@ -2,16 +2,19 @@ import type { Insight, InsightSearchResult, MemoryAdapter } from './types.js';
 
 /** Immutable server-derived boundary; callers never choose an adapter namespace. */
 export interface OperatorMemoryScope {
-  tenantId: string;
-  ownerId: string;
-  sessionId: string;
-  namespace: string;
+  readonly tenantId: string;
+  readonly ownerId: string;
+  readonly sessionId: string;
 }
 
 export interface OperatorMemoryConfig {
-  adapter: MemoryAdapter;
-  instanceId: string;
-  maxStartupContext?: number;
+  /** Adapter injection is deployment/lifecycle configuration, never caller input. */
+  readonly adapter: MemoryAdapter;
+  /** Configured agent identity; it is metadata rather than a storage key default. */
+  readonly instanceId: string;
+  /** Configured storage partition; callers cannot select a namespace. */
+  readonly namespace: string;
+  readonly maxStartupContext?: number;
   redact(content: string): string;
 }
 
@@ -34,20 +37,32 @@ export interface OperatorMemoryPlugin {
   startupContext(scope: OperatorMemoryScope): Promise<OperatorMemoryResult[]>;
 }
 
-function scopedUserId(scope: OperatorMemoryScope): string {
-  return `${scope.tenantId}:${scope.ownerId}:${scope.namespace}`;
+function scopedUserId(scope: OperatorMemoryScope, namespace: string): string {
+  // JSON tuple encoding avoids delimiter collisions between independently scoped IDs.
+  return JSON.stringify([namespace, scope.tenantId, scope.ownerId, scope.sessionId]);
+}
+
+function normalizeConfig(config: OperatorMemoryConfig): OperatorMemoryConfig {
+  const instanceId = config.instanceId.trim();
+  const namespace = config.namespace.trim();
+  const maxStartupContext = config.maxStartupContext ?? 8;
+  if (instanceId.length === 0 || namespace.length === 0) {
+    throw new Error('Operator memory instance ID and namespace must be configured');
+  }
+  if (!Number.isSafeInteger(maxStartupContext) || maxStartupContext < 1) {
+    throw new Error('Operator memory startup context limit must be a positive integer');
+  }
+  return Object.freeze({ ...config, instanceId, namespace, maxStartupContext });
 }
 
 /** Creates a leaf-package, replaceable memory adapter facade. */
 export function createOperatorMemoryPlugin(config: OperatorMemoryConfig): OperatorMemoryPlugin {
-  const mapResult = (
-    scope: OperatorMemoryScope,
-    result: InsightSearchResult,
-  ): OperatorMemoryResult => ({
+  const pluginConfig = normalizeConfig(config);
+  const mapResult = (result: InsightSearchResult): OperatorMemoryResult => ({
     ...result,
     provenance: {
-      instanceId: config.instanceId,
-      namespace: scope.namespace,
+      instanceId: pluginConfig.instanceId,
+      namespace: pluginConfig.namespace,
       source: String(result.metadata?.['source'] ?? 'retrieval'),
     },
   });
@@ -56,18 +71,28 @@ export function createOperatorMemoryPlugin(config: OperatorMemoryConfig): Operat
     query: string,
     limit = 10,
   ): Promise<OperatorMemoryResult[]> =>
-    (await config.adapter.searchInsights(scopedUserId(scope), query, { limit })).map((result) =>
-      mapResult(scope, result),
-    );
+    (
+      await pluginConfig.adapter.searchInsights(
+        scopedUserId(scope, pluginConfig.namespace),
+        query,
+        {
+          limit,
+        },
+      )
+    ).map(mapResult);
   return {
     async capture(scope, input) {
       return config.adapter.storeInsight({
-        userId: scopedUserId(scope),
-        content: config.redact(input.content),
+        userId: scopedUserId(scope, pluginConfig.namespace),
+        content: pluginConfig.redact(input.content),
         source: input.source,
         category: input.category,
         relevanceScore: 1,
-        metadata: { namespace: scope.namespace, instanceId: config.instanceId },
+        metadata: {
+          namespace: pluginConfig.namespace,
+          instanceId: pluginConfig.instanceId,
+          source: input.source,
+        },
       });
     },
     search,
@@ -75,10 +100,13 @@ export function createOperatorMemoryPlugin(config: OperatorMemoryConfig): Operat
       return search(scope, '*', limit);
     },
     async stats(scope) {
-      return { namespace: scope.namespace, resultCount: (await search(scope, '*', 100)).length };
+      return {
+        namespace: pluginConfig.namespace,
+        resultCount: (await search(scope, '*', 100)).length,
+      };
     },
     async startupContext(scope) {
-      return search(scope, '*', config.maxStartupContext ?? 8);
+      return search(scope, '*', pluginConfig.maxStartupContext);
     },
   };
 }