@remnic/core 1.1.30 → 9.3.515

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,
+  });
+});

package/src/access-service.ts

@@ -7,6 +7,7 @@ import { AccessIdempotencyStore, hashAccessIdempotencyPayload } from "./access-i
 import { AccessAuditAdapter, type AccessAuditConfig, type AccessAuditResult } from "./access-audit.js";
 import type { AnomalyDetectorResult } from "./recall-audit-anomaly.js";
 import { resolveGitContext } from "./coding/git-context.js";
+import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { WorkStorage } from "./work/storage.js";
 import {
   exportWorkBoardMarkdown,
@@ -141,9 +142,12 @@ import {
   buildOfflineSyncSnapshot,
   buildOfflineSyncSnapshotFromBase,
   buildOfflineSyncSnapshotForPaths,
+  iterateOfflineSyncSnapshotFileRecords,
+  OFFLINE_SYNC_SNAPSHOT_FORMAT,
   readOfflineSyncFileContentChunk,
   type OfflineSyncApplyFileContentChunkResult,
   type OfflineSyncApplyChangesetResult,
+  type OfflineSyncFileRecord,
   type OfflineSyncFileContentChunk,
   type OfflineSyncFileState,
   type OfflineSyncSnapshot,
@@ -666,6 +670,11 @@ export interface EngramAccessOfflineSyncSnapshotResponse extends OfflineSyncSnap
   namespace: string;
 }
 
+export interface EngramAccessOfflineSyncSnapshotStreamResponse extends Omit<OfflineSyncSnapshot, "files"> {
+  namespace: string;
+  files: AsyncIterable<OfflineSyncFileRecord>;
+}
+
 export interface EngramAccessOfflineSyncFilesResponse extends OfflineSyncSnapshot {
   namespace: string;
 }
@@ -801,6 +810,7 @@ export interface EngramAccessObserveResponse {
 export interface EngramAccessLcmSearchRequest {
   query: string;
   sessionKey?: string;
+  sessionPrefix?: string;
   namespace?: string;
   limit?: number;
   authenticatedPrincipal?: string;
@@ -1713,11 +1723,11 @@ export class EngramAccessService {
     if (this.orchestrator.getCodingContextForSession(sessionKey)) return;
     // projectTag takes priority over cwd.
     if (typeof options.projectTag === "string" && options.projectTag.trim().length > 0) {
-      const tag = options.projectTag.trim();
+      const projectId = projectTagProjectId(options.projectTag);
       this.orchestrator.setCodingContextForSession(sessionKey, {
-        projectId: `tag:${tag}`,
+        projectId,
         branch: null,
-        rootPath: `tag:${tag}`,
+        rootPath: projectId,
         defaultBranch: null,
       });
       return;
@@ -3902,10 +3912,14 @@ export class EngramAccessService {
     const lcmSessionKey = request.sessionKey && namespace !== this.orchestrator.config.defaultNamespace
       ? `${namespace}:${request.sessionKey}`
       : request.sessionKey;
+    const lcmSessionPrefix = request.sessionPrefix && namespace !== this.orchestrator.config.defaultNamespace
+      ? `${namespace}:${request.sessionPrefix}`
+      : request.sessionPrefix;
     const rawResults = await this.orchestrator.lcmEngine.searchContextFull(
       request.query,
       limit,
       lcmSessionKey,
+      lcmSessionPrefix,
     );
 
     const results = rawResults.map((r: { session_id: string; content: string; turn_index: number }) => ({
@@ -4603,13 +4617,8 @@ export class EngramAccessService {
     const resolvedNs = this.resolveReadableNamespace(namespace, principal);
     const namespaceFilter = resolvedNs !== this.orchestrator.config.defaultNamespace ? resolvedNs : undefined;
 
-    const results = collection === "global"
-      ? (await this.orchestrator.qmd.searchGlobal(query, maxResults)).filter((r) =>
-          namespaceFilter
-            ? r.path.includes(`/namespaces/${namespaceFilter}/`) ||
-              (!r.path.includes("/namespaces/") && namespaceFilter === this.orchestrator.config.defaultNamespace)
-            : true,
-        )
+    const results = collection === "global" && !namespaceFilter
+      ? await this.orchestrator.qmd.searchGlobal(query, maxResults)
       : await this.orchestrator.searchAcrossNamespaces({
           query,
           namespaces: namespaceFilter ? [namespaceFilter] : undefined,
@@ -5627,6 +5636,29 @@ export class EngramAccessService {
     };
   }
 
+  async offlineSyncSnapshotStream(
+    options: Omit<EngramAccessOfflineSyncSnapshotRequest, "baseCapturedAt" | "baseFiles"> = {},
+  ): Promise<EngramAccessOfflineSyncSnapshotStreamResponse> {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const storageHash = createHash("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    return {
+      namespace: resolvedNamespace,
+      format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
+      schemaVersion: 1,
+      createdAt: new Date().toISOString(),
+      sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
+      includeTranscripts: options.includeTranscripts !== false,
+      files: iterateOfflineSyncSnapshotFileRecords({
+        root: storage.dir,
+        includeContent: options.includeContent === true,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
+      }),
+    };
+  }
+
   async offlineSyncFiles(
     options: EngramAccessOfflineSyncFilesRequest,
   ): Promise<EngramAccessOfflineSyncFilesResponse> {

package/src/active-recall.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile } from "node:fs/promises";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -452,6 +452,34 @@ test("active recall transcript persistence sanitizes agent and session path segm
   assert.match(raw, /"sessionKey":"session\/\.\.\/\.\.\/escape"/);
 });
 
+test("active recall transcript persistence failures do not abort generated summaries", async () => {
+  const transcriptFile = path.join(
+    await mkdtemp(path.join(os.tmpdir(), "active-recall-transcript-file-")),
+    "not-a-directory",
+  );
+  await writeFile(transcriptFile, "existing file", "utf8");
+  const engine = createActiveRecallEngine(
+    {
+      async recall() {
+        return "Primary recall";
+      },
+      async generateSummary() {
+        return { text: "useful summary", modelUsed: "gpt-5.5" };
+      },
+    },
+    baseConfig({
+      persistTranscripts: true,
+      transcriptDir: transcriptFile,
+    }),
+  );
+
+  const result = await engine.run(baseInput());
+
+  assert.equal(result.summary, "useful summary");
+  assert.equal(result.modelUsed, "gpt-5.5");
+  assert.equal(result.transcriptPath, null);
+});
+
 test("active recall transcript persistence encodes bare dot path segments", async () => {
   const transcriptDir = await mkdtemp(path.join(os.tmpdir(), "active-recall-transcript-"));
   const engine = createActiveRecallEngine(