@remnic/core 1.1.31 → 9.3.515

package/src/access-idempotency.ts

@@ -1,6 +1,6 @@
 import { mkdir, open, readFile, rename, stat, unlink, utimes, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 
 type AccessIdempotencyEntry = {
   recordedAt: string;
@@ -13,6 +13,8 @@ type AccessIdempotencyTestHooks = {
   lockTimeoutMs?: number;
   staleLockMs?: number;
   lockHeartbeatMs?: number;
+  beforeLockOwnerWrite?: (lockPath: string, ownerToken: string) => Promise<void> | void;
+  beforeStaleLockUnlink?: () => Promise<void> | void;
 };
 
 let testHooks: AccessIdempotencyTestHooks | null = null;
@@ -171,8 +173,17 @@ export class AccessIdempotencyStore {
     const startedAt = Date.now();
 
     while (true) {
+      const ownerToken = `${process.pid}:${randomUUID()}`;
       try {
         const handle = await open(lockPath, "wx");
+        try {
+          await testHooks?.beforeLockOwnerWrite?.(lockPath, ownerToken);
+          await handle.writeFile(ownerToken, "utf-8");
+        } catch (error) {
+          await handle.close().catch(() => undefined);
+          await unlink(lockPath).catch(() => undefined);
+          throw error;
+        }
         let heartbeat: NodeJS.Timeout | null = null;
         if (lockHeartbeatMs > 0) {
           heartbeat = setInterval(() => {
@@ -187,14 +198,24 @@ export class AccessIdempotencyStore {
             clearInterval(heartbeat);
           }
           await handle.close().catch(() => undefined);
-          await unlink(lockPath).catch(() => undefined);
+          await unlinkLockIfOwner(lockPath, ownerToken, staleLockMs);
         }
       } catch (error) {
         if (!isAlreadyExistsError(error)) throw error;
         try {
           const lockStat = await stat(lockPath);
+          const lockOwner = await readLockOwner(lockPath);
           if (Date.now() - lockStat.mtimeMs > staleLockMs) {
-            await unlink(lockPath).catch(() => undefined);
+            await testHooks?.beforeStaleLockUnlink?.();
+            const removed = await unlinkStaleLockIfUnchanged({
+              lockPath,
+              observedOwner: lockOwner,
+              observedMtimeMs: lockStat.mtimeMs,
+              staleLockMs,
+            });
+            if (!removed) {
+              await sleep(10);
+            }
             continue;
           }
         } catch {
@@ -227,6 +248,118 @@ function isAlreadyExistsError(error: unknown): boolean {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
 
+async function readLockOwner(lockPath: string): Promise<string | null> {
+  try {
+    return await readFile(lockPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+async function unlinkLockIfOwner(lockPath: string, ownerToken: string, staleLockMs: number): Promise<void> {
+  const reclaimHandle = await openStaleReclaimLock(`${lockPath}.reclaim`, staleLockMs);
+  if (!reclaimHandle) return;
+  try {
+    await reclaimHandle.writeFile(`${process.pid}:${Date.now()}`, "utf-8");
+    await unlinkLockIfOwnerWhileReclaimHeld(lockPath, ownerToken);
+  } finally {
+    await reclaimHandle.close().catch(() => undefined);
+    await unlink(`${lockPath}.reclaim`).catch(() => undefined);
+  }
+}
+
+async function unlinkLockIfOwnerWhileReclaimHeld(lockPath: string, ownerToken: string): Promise<void> {
+  let handle: Awaited<ReturnType<typeof open>>;
+  try {
+    handle = await open(lockPath, "r");
+  } catch {
+    return;
+  }
+  try {
+    const openedStat = await handle.stat();
+    const currentOwner = await handle.readFile("utf-8");
+    if (currentOwner !== ownerToken) return;
+    let currentStat: Awaited<ReturnType<typeof stat>>;
+    try {
+      currentStat = await stat(lockPath);
+    } catch {
+      return;
+    }
+    if (!isSameFileIdentity(openedStat, currentStat)) return;
+  } finally {
+    await handle.close().catch(() => undefined);
+  }
+  await unlink(lockPath).catch(() => undefined);
+}
+
+function isSameFileIdentity(left: Awaited<ReturnType<typeof stat>>, right: Awaited<ReturnType<typeof stat>>): boolean {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+
+async function unlinkStaleLockIfUnchanged(options: {
+  lockPath: string;
+  observedOwner: string | null;
+  observedMtimeMs: number;
+  staleLockMs: number;
+}): Promise<boolean> {
+  const reclaimPath = `${options.lockPath}.reclaim`;
+  const reclaimHandle = await openStaleReclaimLock(reclaimPath, options.staleLockMs);
+  if (!reclaimHandle) return false;
+  try {
+    await reclaimHandle.writeFile(`${process.pid}:${Date.now()}`, "utf-8");
+    return await unlinkStaleLockIfStillOwned(options);
+  } finally {
+    await reclaimHandle.close().catch(() => undefined);
+    await unlink(reclaimPath).catch(() => undefined);
+  }
+}
+
+async function openStaleReclaimLock(
+  reclaimPath: string,
+  staleLockMs: number,
+): Promise<Awaited<ReturnType<typeof open>> | null> {
+  try {
+    return await open(reclaimPath, "wx");
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+  }
+
+  try {
+    const reclaimStat = await stat(reclaimPath);
+    if (Date.now() - reclaimStat.mtimeMs <= staleLockMs) return null;
+    await unlink(reclaimPath);
+  } catch {
+    return null;
+  }
+
+  try {
+    return await open(reclaimPath, "wx");
+  } catch (error) {
+    if (isAlreadyExistsError(error)) return null;
+    throw error;
+  }
+}
+
+async function unlinkStaleLockIfStillOwned(options: {
+  lockPath: string;
+  observedOwner: string | null;
+  observedMtimeMs: number;
+  staleLockMs: number;
+}): Promise<boolean> {
+  let currentStat: Awaited<ReturnType<typeof stat>>;
+  try {
+    currentStat = await stat(options.lockPath);
+  } catch {
+    return true;
+  }
+  if (currentStat.mtimeMs !== options.observedMtimeMs) return false;
+  if (Date.now() - currentStat.mtimeMs <= options.staleLockMs) return false;
+  const currentOwner = await readLockOwner(options.lockPath);
+  if (currentOwner !== options.observedOwner) return false;
+  await unlink(options.lockPath);
+  return true;
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/access-mcp.test.ts

@@ -30,6 +30,24 @@ function makeMockService(briefingFn?: () => Promise<unknown>): EngramAccessServi
     recallExplain: () => Promise.resolve(null),
     store: () => Promise.resolve({ id: "synthetic-id", stored: true }),
     suggest: () => Promise.resolve({ id: "synthetic-id" }),
+    memoryStore: () => Promise.resolve({
+      schemaVersion: 1,
+      operation: "memory_store",
+      namespace: "default",
+      dryRun: true,
+      accepted: true,
+      queued: false,
+      status: "validated",
+    }),
+    suggestionSubmit: () => Promise.resolve({
+      schemaVersion: 1,
+      operation: "suggestion_submit",
+      namespace: "default",
+      dryRun: true,
+      accepted: true,
+      queued: false,
+      status: "validated",
+    }),
     daySum: () => Promise.resolve({ summary: "" }),
     memoryGet: () => Promise.resolve(null),
     memoryTimeline: () => Promise.resolve([]),
@@ -181,6 +199,143 @@ test("MCP maintenance: hourly summarization dispatches to the access service", a
   assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
 });
 
+test("MCP memory write tools reject malformed arguments before dispatch", async () => {
+  for (const toolName of ["engram.memory_store", "engram.suggestion_submit"]) {
+    for (const badArgs of [
+      {
+        content: "valid durable content",
+        category: "fact",
+        confidence: "0.9",
+        dryRun: true,
+      },
+      {
+        content: "valid durable content",
+        category: "fact",
+        tags: ["project", 123],
+        dryRun: true,
+      },
+      {
+        content: "valid durable content",
+        category: "fact",
+        dryRun: true,
+        unknownField: "must be rejected",
+      },
+    ]) {
+      let dispatched = false;
+      const service = {
+        ...makeMockService(),
+        memoryStore: async () => {
+          dispatched = true;
+          return {
+            schemaVersion: 1,
+            operation: "memory_store",
+            namespace: "default",
+            dryRun: true,
+            accepted: true,
+            queued: false,
+            status: "validated",
+          };
+        },
+        suggestionSubmit: async () => {
+          dispatched = true;
+          return {
+            schemaVersion: 1,
+            operation: "suggestion_submit",
+            namespace: "default",
+            dryRun: true,
+            accepted: true,
+            queued: false,
+            status: "validated",
+          };
+        },
+      } as unknown as EngramAccessService;
+      const server = new EngramMcpServer(service);
+
+      const response = await server.handleRequest(makeToolRequest(toolName, badArgs));
+      const result = (response as Record<string, unknown> & {
+        result?: { isError?: boolean; content?: Array<{ text?: string }> };
+      }).result;
+
+      assert.equal(result?.isError, true, `${toolName} should reject ${JSON.stringify(badArgs)}`);
+      assert.equal(dispatched, false, `${toolName} should not dispatch malformed writes`);
+    }
+  }
+});
+
+test("MCP session override is injected only into tools that accept sessionKey", async () => {
+  let capsuleListArgs: Record<string, unknown> | undefined;
+  let observeArgs: Record<string, unknown> | undefined;
+  const service = {
+    ...makeMockService(),
+    capsuleList: async (args: Record<string, unknown>) => {
+      capsuleListArgs = args;
+      return { capsules: [] };
+    },
+    observe: async (args: Record<string, unknown>) => {
+      observeArgs = args;
+      return { ok: true };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+
+  const capsuleResponse = await server.handleRequest(
+    makeToolRequest("engram.capsule_list"),
+    { sessionKeyOverride: "adapter-session" },
+  );
+  const observeResponse = await server.handleRequest(
+    makeToolRequest("engram.observe", {
+      messages: [{ role: "user", content: "hello" }],
+    }),
+    { sessionKeyOverride: "adapter-session" },
+  );
+
+  assert.deepEqual(capsuleListArgs, {
+    namespace: undefined,
+    principal: undefined,
+  });
+  assert.deepEqual(observeArgs, {
+    sessionKey: "adapter-session",
+    messages: [{ role: "user", content: "hello", parts: undefined, rawContent: undefined, sourceFormat: undefined }],
+    namespace: undefined,
+    authenticatedPrincipal: undefined,
+    skipExtraction: false,
+    cwd: undefined,
+    projectTag: undefined,
+  });
+  assert.equal((capsuleResponse as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+  assert.equal((observeResponse as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+});
+
+test("MCP capsule import forwards encrypted archive passphrase", async () => {
+  let received: Record<string, unknown> | undefined;
+  const service = {
+    ...makeMockService(),
+    capsuleImport: async (args: Record<string, unknown>) => {
+      received = args;
+      return { imported: true };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+
+  const response = await server.handleRequest(
+    makeToolRequest("engram.capsule_import", {
+      archivePath: "~/capsules/team.capsule.json.gz.enc",
+      namespace: "team",
+      mode: "overwrite",
+      passphrase: "correct horse battery staple",
+    }),
+  );
+
+  assert.deepEqual(received, {
+    archivePath: path.join(os.homedir(), "capsules/team.capsule.json.gz.enc"),
+    namespace: "team",
+    principal: undefined,
+    mode: "overwrite",
+    passphrase: "correct horse battery staple",
+  });
+  assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+});
+
 test("MCP contradiction scan uses writable namespace resolver", async () => {
   const resolverCalls: Array<{ namespace: string | undefined; principal: string | undefined }> = [];
   const storage = {

package/src/access-mcp.ts

@@ -8,13 +8,16 @@ import {
   type CapsuleExportRequest,
   type CapsuleImportRequest,
   type CapsuleListRequest,
+  type MemoryStoreRequest,
   type SchemaName,
   type SchemaTypeFor,
+  type SuggestionSubmitRequest,
 } from "./access-schema.js";
 import { readEnvVar } from "./runtime/env.js";
 import type { RecallDisclosure, RecallPlanMode } from "./types.js";
 import { validateBriefingFormat } from "./briefing.js";
 import { buildCitationGuidance, type CitationMetadata } from "./citations.js";
+import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { expandTildePath } from "./utils/path.js";
 import {
   REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE,
@@ -35,6 +38,14 @@ type JsonRpcRequest = {
   params?: Record<string, unknown>;
 };
 
+type McpRequestOptions = {
+  principalOverride?: string;
+  namespaceOverride?: string;
+  sessionKeyOverride?: string;
+  sessionId?: string;
+  correlationId?: string;
+};
+
 type McpTool = {
   name: string;
   title?: string;
@@ -87,6 +98,34 @@ function resolveChatGptInspectorRecallSessionKey(
 }
 
 const STRICT_MCP_SCHEMA_KEYS: Partial<Record<SchemaName, readonly string[]>> = {
+  memoryStore: [
+    "schemaVersion",
+    "idempotencyKey",
+    "dryRun",
+    "sessionKey",
+    "content",
+    "category",
+    "confidence",
+    "namespace",
+    "tags",
+    "entityRef",
+    "ttl",
+    "sourceReason",
+  ],
+  suggestionSubmit: [
+    "schemaVersion",
+    "idempotencyKey",
+    "dryRun",
+    "sessionKey",
+    "content",
+    "category",
+    "confidence",
+    "namespace",
+    "tags",
+    "entityRef",
+    "ttl",
+    "sourceReason",
+  ],
   capsuleExport: [
     "name",
     "namespace",
@@ -96,7 +135,7 @@ const STRICT_MCP_SCHEMA_KEYS: Partial<Record<SchemaName, readonly string[]>> = {
     "includeTranscripts",
     "encrypt",
   ],
-  capsuleImport: ["archivePath", "namespace", "mode"],
+  capsuleImport: ["archivePath", "namespace", "mode", "passphrase"],
   capsuleList: ["namespace"],
 };
 
@@ -126,6 +165,12 @@ function parseMcpRequest<N extends SchemaName>(
   );
 }
 
+function getObjectProperties(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
 async function getMcpServerVersion(): Promise<string> {
   const envVersion =
     readEnvVar("OPENCLAW_ENGRAM_VERSION")?.trim() ||
@@ -574,6 +619,10 @@ export class EngramMcpServer {
               enum: ["skip", "overwrite", "fork"],
               description: "Conflict handling mode. Defaults to skip.",
             },
+            passphrase: {
+              type: "string",
+              description: "Passphrase for encrypted capsule archives.",
+            },
           },
           required: ["archivePath"],
           additionalProperties: false,
@@ -821,6 +870,7 @@ export class EngramMcpServer {
           properties: {
             query: { type: "string", description: "Search query" },
             sessionKey: { type: "string", description: "Optional session filter" },
+            sessionPrefix: { type: "string", description: "Optional session prefix filter" },
             namespace: { type: "string" },
             limit: { type: "number", description: "Max results to return" },
           },
@@ -1671,7 +1721,7 @@ export class EngramMcpServer {
     return sid;
   }
 
-  async handleRequest(request: JsonRpcRequest, options?: { principalOverride?: string; sessionId?: string; correlationId?: string }): Promise<Record<string, unknown> | null> {
+  async handleRequest(request: JsonRpcRequest, options?: McpRequestOptions): Promise<Record<string, unknown> | null> {
     const id = request.id ?? null;
     const method = request.method ?? "";
 
@@ -1794,6 +1844,25 @@ export class EngramMcpServer {
           }
           argumentsObject = params.arguments as Record<string, unknown>;
         }
+        if (
+          !("namespace" in argumentsObject) &&
+          options?.namespaceOverride &&
+          this.toolAcceptsArgument(name, "namespace")
+        ) {
+          argumentsObject = { ...argumentsObject, namespace: options.namespaceOverride };
+        }
+        const skipSessionKeyOverride =
+          toLegacyToolName(name) === "engram.lcm_search" &&
+          typeof argumentsObject.sessionPrefix === "string" &&
+          argumentsObject.sessionPrefix.length > 0;
+        if (
+          !("sessionKey" in argumentsObject) &&
+          !skipSessionKeyOverride &&
+          options?.sessionKeyOverride &&
+          this.toolAcceptsArgument(name, "sessionKey")
+        ) {
+          argumentsObject = { ...argumentsObject, sessionKey: options.sessionKeyOverride };
+        }
         const effectivePrincipal = options?.principalOverride ?? this.authenticatedPrincipal;
         const result = await this.callTool(name, argumentsObject, effectivePrincipal, options?.sessionId);
         return {
@@ -1915,6 +1984,16 @@ export class EngramMcpServer {
     output.write(message);
   }
 
+  private toolAcceptsArgument(name: string, key: string): boolean {
+    const tool = this.tools.find((entry) => entry.name === name);
+    const inputSchema = getObjectProperties(tool?.inputSchema);
+    const properties = getObjectProperties(inputSchema?.properties);
+    if (properties && Object.prototype.hasOwnProperty.call(properties, key)) {
+      return true;
+    }
+    return inputSchema?.additionalProperties === true;
+  }
+
   /**
    * Determine whether oai-mem-citation guidance should be appended to recall.
    * Returns true when explicitly enabled via config OR when auto-detect is
@@ -2070,12 +2149,13 @@ export class EngramMcpServer {
         const hasCodingContext = "codingContext" in args;
         if (!hasCodingContext && hasProjectTag) {
           const tag = (args.projectTag as string).trim();
+          const projectId = projectTagProjectId(tag);
           this.service.setCodingContext({
             sessionKey,
             codingContext: {
-              projectId: `tag:${tag}`,
+              projectId,
               branch: null,
-              rootPath: `tag:${tag}`,
+              rootPath: projectId,
               defaultBranch: null,
             },
           });
@@ -2324,6 +2404,7 @@ export class EngramMcpServer {
           namespace: body.namespace,
           principal: effectivePrincipal,
           mode: body.mode,
+          passphrase: body.passphrase,
         });
       }
       case "engram.capsule_list": {
@@ -2383,38 +2464,42 @@ export class EngramMcpServer {
           effectivePrincipal,
         );
       }
-      case "engram.memory_store":
+      case "engram.memory_store": {
+        const body: MemoryStoreRequest = parseMcpRequest("memoryStore", args);
         return this.service.memoryStore({
-          schemaVersion: typeof args.schemaVersion === "number" ? args.schemaVersion : undefined,
-          idempotencyKey: typeof args.idempotencyKey === "string" ? args.idempotencyKey : undefined,
-          dryRun: args.dryRun === true,
-          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : undefined,
+          schemaVersion: body.schemaVersion,
+          idempotencyKey: body.idempotencyKey,
+          dryRun: body.dryRun,
+          sessionKey: body.sessionKey,
           authenticatedPrincipal: effectivePrincipal,
-          content: typeof args.content === "string" ? args.content : "",
-          category: typeof args.category === "string" ? args.category : undefined,
-          confidence: typeof args.confidence === "number" ? args.confidence : undefined,
-          namespace: typeof args.namespace === "string" ? args.namespace : undefined,
-          tags: Array.isArray(args.tags) ? args.tags.filter((tag): tag is string => typeof tag === "string") : undefined,
-          entityRef: typeof args.entityRef === "string" ? args.entityRef : undefined,
-          ttl: typeof args.ttl === "string" ? args.ttl : undefined,
-          sourceReason: typeof args.sourceReason === "string" ? args.sourceReason : undefined,
+          content: body.content,
+          category: body.category,
+          confidence: body.confidence,
+          namespace: body.namespace,
+          tags: body.tags,
+          entityRef: body.entityRef,
+          ttl: body.ttl,
+          sourceReason: body.sourceReason,
         });
-      case "engram.suggestion_submit":
+      }
+      case "engram.suggestion_submit": {
+        const body: SuggestionSubmitRequest = parseMcpRequest("suggestionSubmit", args);
         return this.service.suggestionSubmit({
-          schemaVersion: typeof args.schemaVersion === "number" ? args.schemaVersion : undefined,
-          idempotencyKey: typeof args.idempotencyKey === "string" ? args.idempotencyKey : undefined,
-          dryRun: args.dryRun === true,
-          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : undefined,
+          schemaVersion: body.schemaVersion,
+          idempotencyKey: body.idempotencyKey,
+          dryRun: body.dryRun,
+          sessionKey: body.sessionKey,
           authenticatedPrincipal: effectivePrincipal,
-          content: typeof args.content === "string" ? args.content : "",
-          category: typeof args.category === "string" ? args.category : undefined,
-          confidence: typeof args.confidence === "number" ? args.confidence : undefined,
-          namespace: typeof args.namespace === "string" ? args.namespace : undefined,
-          tags: Array.isArray(args.tags) ? args.tags.filter((tag): tag is string => typeof tag === "string") : undefined,
-          entityRef: typeof args.entityRef === "string" ? args.entityRef : undefined,
-          ttl: typeof args.ttl === "string" ? args.ttl : undefined,
-          sourceReason: typeof args.sourceReason === "string" ? args.sourceReason : undefined,
+          content: body.content,
+          category: body.category,
+          confidence: body.confidence,
+          namespace: body.namespace,
+          tags: body.tags,
+          entityRef: body.entityRef,
+          ttl: body.ttl,
+          sourceReason: body.sourceReason,
         });
+      }
       case "engram.entity_get":
         return this.service.entityGet(
           typeof args.name === "string" ? args.name : "",
@@ -2448,6 +2533,7 @@ export class EngramMcpServer {
         return this.service.lcmSearch({
           query: typeof args.query === "string" ? args.query : "",
           sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : undefined,
+          sessionPrefix: typeof args.sessionPrefix === "string" ? args.sessionPrefix : undefined,
           namespace: typeof args.namespace === "string" ? args.namespace : undefined,
           limit: typeof args.limit === "number" && Number.isFinite(args.limit) ? args.limit : undefined,
           authenticatedPrincipal: effectivePrincipal,

package/src/access-schema.ts

@@ -136,10 +136,26 @@ export const recallExplainRequestSchema = z.object({
  * `POST /engram/v1/coding-context` and the MCP `remnic.set_coding_context`
  * tool (PR 7). `codingContext: null` clears the attached context.
  */
-export const setCodingContextRequestSchema = z.object({
-  sessionKey: z.string().trim().min(1, "sessionKey is required").max(512),
-  codingContext: codingContextSchema,
-});
+export const setCodingContextRequestSchema = z
+  .object({
+    sessionKey: z.string().trim().min(1, "sessionKey is required").max(512),
+    codingContext: codingContextSchema.optional(),
+    /**
+     * Project tag shorthand for non-git-based project scoping. When
+     * `codingContext` is omitted, this becomes
+     * `{ projectId: "tag:<projectTag>", branch: null, rootPath: "tag:<projectTag>", defaultBranch: null }`.
+     */
+    projectTag: z.string().trim().min(1, "projectTag must be non-empty when provided").max(256).optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (value.codingContext === undefined && value.projectTag === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "codingContext or projectTag is required",
+        path: ["codingContext"],
+      });
+    }
+  });
 
 // ---------------------------------------------------------------------------
 // Observe
@@ -278,6 +294,7 @@ export const trustZoneDemoSeedRequestSchema = z.object({
 export const lcmSearchRequestSchema = z.object({
   query: z.string().min(1, "query is required"),
   sessionKey: sessionKeySchema,
+  sessionPrefix: z.string().trim().min(1).max(512).optional(),
   namespace: namespaceSchema,
   limit: z.number().int().min(1).max(100).optional(),
 });
@@ -362,6 +379,7 @@ export const capsuleImportRequestSchema = z
     archivePath: z.string().trim().min(1, "archivePath is required").max(4096),
     namespace: namespaceSchema,
     mode: z.enum(["skip", "overwrite", "fork"]).optional(),
+    passphrase: z.string().min(1, "passphrase must not be empty").max(4096).optional(),
   });
 
 export const capsuleListRequestSchema = z

package/src/access-service-project-tag.test.ts

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { EngramAccessService } from "./access-service.js";
+import { projectTagProjectId } from "./coding/coding-namespace.js";
+import type { CodingContext } from "./types.js";
+
+test("projectTag auto-resolution uses the shared project tag canonicalizer", async () => {
+  const contexts = new Map<string, CodingContext>();
+  const service = new EngramAccessService({
+    config: {
+      memoryDir: "/tmp/remnic-access-service-project-tag-test",
+      recallCrossNamespaceBudgetEnabled: false,
+      recallCrossNamespaceBudgetWindowMs: 60_000,
+      recallCrossNamespaceBudgetSoftLimit: 10,
+      recallCrossNamespaceBudgetHardLimit: 30,
+      codingMode: {
+        projectScope: true,
+      },
+    },
+    getCodingContextForSession: (sessionKey: string) => contexts.get(sessionKey) ?? null,
+    setCodingContextForSession: (sessionKey: string, context: CodingContext) => {
+      contexts.set(sessionKey, context);
+    },
+  } as any);
+
+  await (service as any).maybeAttachCodingContext("session-a", {
+    projectTag: "Blend/Supply",
+  });
+
+  const projectId = projectTagProjectId("Blend/Supply");
+  assert.deepEqual(contexts.get("session-a"), {
+    projectId,
+    branch: null,
+    rootPath: projectId,
+    defaultBranch: null,
+  });
+});