@remnic/core 9.54.4 → 9.54.6

package/src/access-http.test.ts

@@ -5,9 +5,20 @@ import path from "node:path";
 import test from "node:test";
 import { gzipSync } from "node:zlib";
 
-import { EngramAccessHttpServer, type RemnicAdminControls, type RemnicAdminDashboardStatus } from "./access-http.js";
-import { EngramAccessInputError, type EngramAccessRecallRequest, type EngramAccessService } from "./access-service.js";
-import { tokenCapabilityStore, type TokenCapabilities } from "./access-token-capabilities.js";
+import {
+  EngramAccessHttpServer,
+  type RemnicAdminControls,
+  type RemnicAdminDashboardStatus,
+} from "./access-http.js";
+import {
+  EngramAccessInputError,
+  type EngramAccessRecallRequest,
+  type EngramAccessService,
+} from "./access-service.js";
+import {
+  tokenCapabilityStore,
+  type TokenCapabilities,
+} from "./access-token-capabilities.js";
 import { parseConfig } from "./config.js";
 import { readPair, writePair } from "./contradiction/contradiction-review.js";
 import { createChatSession } from "./chat/chat-session.js";
@@ -15,6 +26,7 @@ import { DEFAULT_CHAT_CONFIG } from "./chat/chat-config.js";
 import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { OFFLINE_SYNC_MAX_MTIME_MS } from "./offline-sync.js";
 import type { StorageManager } from "./storage.js";
+import { SupportPassportError } from "./support-passport/errors.js";
 
 test("HTTP server rejects invalid constructor ports", () => {
   const service = {} as EngramAccessService;
@@ -78,13 +90,18 @@ test("HTTP liveness is authenticated and does not run detailed health diagnostic
 
   const status = await server.start();
   try {
-    const denied = await fetch(`http://127.0.0.1:${status.port}/engram/v1/live`);
+    const denied = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/live`,
+    );
     assert.equal(denied.status, 401);
 
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/live`, {
-      headers: { authorization: "Bearer test-token" },
-      signal: AbortSignal.timeout(500),
-    });
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/live`,
+      {
+        headers: { authorization: "Bearer test-token" },
+        signal: AbortSignal.timeout(500),
+      },
+    );
     assert.equal(response.status, 200);
     assert.deepEqual(await response.json(), { ok: true, ready: true });
     assert.equal(healthCalls, 0);
@@ -110,11 +127,17 @@ test("HTTP detailed health route still runs service diagnostics", async () => {
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/health`, {
-      headers: { authorization: "Bearer test-token" },
-    });
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/health`,
+      {
+        headers: { authorization: "Bearer test-token" },
+      },
+    );
     assert.equal(response.status, 200);
-    assert.deepEqual(await response.json(), { ok: true, diagnostics: "complete" });
+    assert.deepEqual(await response.json(), {
+      ok: true,
+      diagnostics: "complete",
+    });
     assert.equal(healthCalls, 1);
   } finally {
     await server.stop();
@@ -138,13 +161,25 @@ test("HTTP memory browse rejects malformed pagination and sort query values", as
 
   const status = await server.start();
   try {
-    for (const query of ["limit=10abc", "offset=1.5", "limit=0", "sort=udpated_desc"]) {
-      const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/memories?${query}`, {
-        headers: { authorization: "Bearer test-token" },
-      });
+    for (const query of [
+      "limit=10abc",
+      "offset=1.5",
+      "limit=0",
+      "sort=udpated_desc",
+    ]) {
+      const response = await fetch(
+        `http://127.0.0.1:${status.port}/engram/v1/memories?${query}`,
+        {
+          headers: { authorization: "Bearer test-token" },
+        },
+      );
       assert.equal(response.status, 400, `${query} should be rejected`);
     }
-    assert.equal(calls.length, 0, "invalid queries must fail before calling memoryBrowse");
+    assert.equal(
+      calls.length,
+      0,
+      "invalid queries must fail before calling memoryBrowse",
+    );
 
     const response = await fetch(
       `http://127.0.0.1:${status.port}/engram/v1/memories?limit=10&offset=1&sort=updated_desc`,
@@ -169,7 +204,11 @@ test("HTTP memory browse rejects malformed pagination and sort query values", as
 });
 
 test("HTTP batch LCM flush isolates namespace failures and charges one write quota", async () => {
-  const calls: Array<{ namespace?: string; sessionKey: string; authenticatedPrincipal?: string }> = [];
+  const calls: Array<{
+    namespace?: string;
+    sessionKey: string;
+    authenticatedPrincipal?: string;
+  }> = [];
   const service = {
     lcmCompactionFlush: async (request: {
       namespace?: string;
@@ -177,7 +216,8 @@ test("HTTP batch LCM flush isolates namespace failures and charges one write quo
       authenticatedPrincipal?: string;
     }) => {
       calls.push(request);
-      if (request.namespace === "team-b") throw new Error("team-b flush failed");
+      if (request.namespace === "team-b")
+        throw new Error("team-b flush failed");
       return { enabled: true, flushed: true };
     },
   } as unknown as EngramAccessService;
@@ -191,17 +231,20 @@ test("HTTP batch LCM flush isolates namespace failures and charges one write quo
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "batch-session",
+          namespaces: ["team-a", "team-b"],
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "batch-session",
-        namespaces: ["team-a", "team-b"],
-      }),
-    });
+    );
     assert.equal(response.status, 200);
     assert.deepEqual(await response.json(), {
       enabled: false,
@@ -230,32 +273,42 @@ test("HTTP batch LCM flush isolates namespace failures and charges one write quo
       },
     ]);
 
-    const conflicting = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const conflicting = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "batch-session",
+          namespace: "team-a",
+          namespaces: ["team-b"],
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "batch-session",
-        namespace: "team-a",
-        namespaces: ["team-b"],
-      }),
-    });
+    );
     assert.equal(conflicting.status, 400);
-    assert.equal(calls.length, 2, "conflicting namespace forms must fail before dispatch");
+    assert.equal(
+      calls.length,
+      2,
+      "conflicting namespace forms must fail before dispatch",
+    );
 
-    const rateLimited = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const rateLimited = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "batch-session",
+          namespaces: ["team-a"],
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "batch-session",
-        namespaces: ["team-a"],
-      }),
-    });
+    );
     assert.equal(rateLimited.status, 429);
     assert.equal(calls.length, 2, "a batch consumes one write quota unit");
   } finally {
@@ -281,19 +334,22 @@ test("HTTP LCM compaction record uses the lifecycle route and write quota", asyn
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/record`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/record`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "record-session",
+          namespace: "team-a",
+          tokensBefore: 100,
+          tokensAfter: 40,
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "record-session",
-        namespace: "team-a",
-        tokensBefore: 100,
-        tokensAfter: 40,
-      }),
-    });
+    );
     assert.equal(response.status, 200);
     assert.deepEqual(await response.json(), {
       enabled: true,
@@ -310,18 +366,21 @@ test("HTTP LCM compaction record uses the lifecycle route and write quota", asyn
       },
     ]);
 
-    const rateLimited = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/record`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const rateLimited = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/record`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "record-session",
+          tokensBefore: 120,
+          tokensAfter: 60,
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "record-session",
-        tokensBefore: 120,
-        tokensAfter: 60,
-      }),
-    });
+    );
     assert.equal(rateLimited.status, 429);
     assert.equal(calls.length, 1);
   } finally {
@@ -330,9 +389,16 @@ test("HTTP LCM compaction record uses the lifecycle route and write quota", asyn
 });
 
 test("HTTP batch LCM flush deduplicates aliases after effective namespace resolution", async () => {
-  const calls: Array<{ namespace?: string; sessionKey: string; authenticatedPrincipal?: string }> = [];
+  const calls: Array<{
+    namespace?: string;
+    sessionKey: string;
+    authenticatedPrincipal?: string;
+  }> = [];
   const service = {
-    configRef: parseConfig({ namespacesEnabled: true, defaultNamespace: "default" }),
+    configRef: parseConfig({
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+    }),
     lcmCompactionFlush: async (request: {
       namespace?: string;
       sessionKey: string;
@@ -351,17 +417,20 @@ test("HTTP batch LCM flush deduplicates aliases after effective namespace resolu
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "effective-namespace-session",
+          namespaces: ["", "default"],
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "effective-namespace-session",
-        namespaces: ["", "default"],
-      }),
-    });
+    );
     assert.equal(response.status, 200);
     assert.deepEqual(await response.json(), {
       enabled: true,
@@ -393,7 +462,6 @@ test("HTTP batch LCM flush deduplicates aliases after effective namespace resolu
   }
 });
 
-
 test("HTTP batch LCM flush isolates per-namespace authorization failures", async () => {
   const calls: string[] = [];
   const service = {
@@ -421,17 +489,20 @@ test("HTTP batch LCM flush isolates per-namespace authorization failures", async
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer scoped-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer scoped-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "authorized-batch-session",
+          namespaces: ["team-a", "team-b"],
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "authorized-batch-session",
-        namespaces: ["team-a", "team-b"],
-      }),
-    });
+    );
     assert.equal(response.status, 200);
     assert.deepEqual(await response.json(), {
       enabled: false,
@@ -473,7 +544,7 @@ test("HTTP admin console assets are public but API routes require bearer authent
     assert.match(app.headers.get("content-type") ?? "", /javascript/);
 
     const api = await fetch(`http://127.0.0.1:${status.port}/engram/v1/health`);
-    const body = await api.json() as { code?: string };
+    const body = (await api.json()) as { code?: string };
     assert.equal(api.status, 401);
     assert.equal(body.code, "unauthorized");
     assert.equal(api.headers.get("www-authenticate"), "Bearer");
@@ -493,7 +564,9 @@ test("HTTP admin console can prefill the primary bearer token when explicitly en
 
   const status = await server.start();
   try {
-    const unauthenticatedShell = await fetch(`http://127.0.0.1:${status.port}/engram/ui/`);
+    const unauthenticatedShell = await fetch(
+      `http://127.0.0.1:${status.port}/engram/ui/`,
+    );
     assert.equal(unauthenticatedShell.status, 200);
     assert.doesNotMatch(await unauthenticatedShell.text(), /test-token/);
 
@@ -504,10 +577,11 @@ test("HTTP admin console can prefill the primary bearer token when explicitly en
     assert.equal(shell.headers.get("cache-control"), "private, no-store");
     assert.equal(shell.headers.get("vary"), "authorization");
     const shellText = await shell.text();
-    assert.match(
-      shellText,
-      /window\.__REMNIC_ADMIN_CONSOLE_PREFILL_TOKEN__="test-token"/,
-    );
+    assert.match(shellText, /Object\.defineProperty\(window,key/);
+    assert.match(shellText, /window\.addEventListener\("pagehide",clear,\{once:true\}\)/);
+    assert.match(shellText, /script\.textContent="";script\.remove\(\)/);
+    assert.match(shellText, /\}\)\("test-token",document\.currentScript\)/);
+    assert.doesNotMatch(shellText, /window\.__REMNIC_ADMIN_CONSOLE_PREFILL_TOKEN__="test-token"/);
 
     const app = await fetch(`http://127.0.0.1:${status.port}/engram/ui/app.js`);
     assert.equal(app.status, 200);
@@ -517,6 +591,59 @@ test("HTTP admin console can prefill the primary bearer token when explicitly en
   }
 });
 
+test("HTTP admin console safely serializes a prefill token into its inline bootstrap", async () => {
+  const token = 'safe</script><script>window.injected=true</script>';
+  const service = {} as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: token,
+    adminConsolePrefillToken: true,
+  });
+
+  const status = await server.start();
+  try {
+    const shell = await fetch(`http://127.0.0.1:${status.port}/engram/ui/`, {
+      headers: { authorization: `Bearer ${token}` },
+    });
+    assert.equal(shell.status, 200);
+    const shellText = await shell.text();
+    assert.doesNotMatch(shellText, /<script>window\.injected=true<\/script>/);
+    assert.match(shellText, /safe\\u003c\/script>\\u003cscript>window\.injected=true\\u003c\/script>/);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP admin console does not disclose the primary token to a dynamic token", async () => {
+  const service = {} as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "primary-token",
+    authTokenEntriesGetter: () => [
+      {
+        token: "scoped-token",
+        capabilities: { version: 1, ops: ["support_passport_cards_list"] },
+      },
+    ],
+    adminConsolePrefillToken: true,
+  });
+
+  const status = await server.start();
+  try {
+    const shell = await fetch(`http://127.0.0.1:${status.port}/engram/ui/`, {
+      headers: { authorization: "Bearer scoped-token" },
+    });
+    assert.equal(shell.status, 200);
+    const body = await shell.text();
+    assert.doesNotMatch(body, /primary-token/);
+    assert.doesNotMatch(body, /__REMNIC_ADMIN_CONSOLE_PREFILL_TOKEN__/);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP admin dashboard endpoints require bearer authentication and apply config patches", async () => {
   const service = {} as EngramAccessService;
   const patches: unknown[] = [];
@@ -562,27 +689,40 @@ test("HTTP admin dashboard endpoints require bearer authentication and apply con
 
   const status = await server.start();
   try {
-    const unauthorized = await fetch(`http://127.0.0.1:${status.port}/engram/v1/admin/dashboard`);
+    const unauthorized = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/admin/dashboard`,
+    );
     assert.equal(unauthorized.status, 401);
 
-    const dashboardResponse = await fetch(`http://127.0.0.1:${status.port}/engram/v1/admin/dashboard`, {
-      headers: { authorization: "Bearer test-token" },
-    });
+    const dashboardResponse = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/admin/dashboard`,
+      {
+        headers: { authorization: "Bearer test-token" },
+      },
+    );
     assert.equal(dashboardResponse.status, 200);
     assert.deepEqual(await dashboardResponse.json(), dashboard);
 
-    const patchResponse = await fetch(`http://127.0.0.1:${status.port}/remnic/v1/admin/config`, {
-      method: "PATCH",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const patchResponse = await fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/admin/config`,
+      {
+        method: "PATCH",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          modelSource: "gateway",
+          gatewayAgentId: "sage-router",
+        }),
       },
-      body: JSON.stringify({ modelSource: "gateway", gatewayAgentId: "sage-router" }),
-    });
+    );
     assert.equal(patchResponse.status, 200);
-    const body = await patchResponse.json() as RemnicAdminDashboardStatus;
+    const body = (await patchResponse.json()) as RemnicAdminDashboardStatus;
     assert.equal(body.config.restartRequired, true);
-    assert.deepEqual(patches, [{ modelSource: "gateway", gatewayAgentId: "sage-router" }]);
+    assert.deepEqual(patches, [
+      { modelSource: "gateway", gatewayAgentId: "sage-router" },
+    ]);
   } finally {
     await server.stop();
   }
@@ -604,17 +744,20 @@ test("HTTP coding-context endpoint accepts projectTag shorthand", async () => {
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/coding-context`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/coding-context`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          sessionKey: "s1",
+          projectTag: "Acme/Webshop",
+        }),
       },
-      body: JSON.stringify({
-        sessionKey: "s1",
-        projectTag: "Acme/Webshop",
-      }),
-    });
+    );
 
     const projectId = projectTagProjectId("Acme/Webshop");
     assert.equal(response.status, 200);
@@ -636,7 +779,10 @@ test("HTTP coding-context endpoint accepts projectTag shorthand", async () => {
 });
 
 test("HTTP contradiction scan uses writable namespace resolver", async () => {
-  const resolverCalls: Array<{ namespace: string | undefined; principal: string | undefined }> = [];
+  const resolverCalls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+  }> = [];
   const storage = {
     readAllMemories: async () => [],
   } as unknown as StorageManager;
@@ -656,9 +802,14 @@ test("HTTP contradiction scan uses writable namespace resolver", async () => {
     localLlmRef: null,
     fallbackLlmRef: null,
     getReadableStorageForNamespace: async () => {
-      throw new Error("readable resolver must not authorize contradiction scan writes");
+      throw new Error(
+        "readable resolver must not authorize contradiction scan writes",
+      );
     },
-    getWritableStorageForNamespace: async (namespace: string | undefined, principal: string | undefined) => {
+    getWritableStorageForNamespace: async (
+      namespace: string | undefined,
+      principal: string | undefined,
+    ) => {
       resolverCalls.push({ namespace, principal });
       return { namespace: namespace ?? "default", storage };
     },
@@ -673,19 +824,24 @@ test("HTTP contradiction scan uses writable namespace resolver", async () => {
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/contradiction-scan`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/contradiction-scan`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ namespace: "team" }),
       },
-      body: JSON.stringify({ namespace: "team" }),
-    });
-    const body = await response.json() as { scanned?: number };
+    );
+    const body = (await response.json()) as { scanned?: number };
 
     assert.equal(response.status, 200);
     assert.equal(body.scanned, 0);
-    assert.deepEqual(resolverCalls, [{ namespace: "team", principal: "writer" }]);
+    assert.deepEqual(resolverCalls, [
+      { namespace: "team", principal: "writer" },
+    ]);
   } finally {
     await server.stop();
   }
@@ -693,7 +849,10 @@ test("HTTP contradiction scan uses writable namespace resolver", async () => {
 
 test("HTTP review list uses readable namespace resolver", async () => {
   const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-http-review-list-"));
-  const resolverCalls: Array<{ namespace: string | undefined; principal: string | undefined }> = [];
+  const resolverCalls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+  }> = [];
   const service = {
     configRef: parseConfig({
       memoryDir: dir,
@@ -701,9 +860,14 @@ test("HTTP review list uses readable namespace resolver", async () => {
       defaultNamespace: "default",
     }),
     memoryDir: dir,
-    getReadableStorageForNamespace: async (namespace: string | undefined, principal: string | undefined) => {
+    getReadableStorageForNamespace: async (
+      namespace: string | undefined,
+      principal: string | undefined,
+    ) => {
       resolverCalls.push({ namespace, principal });
-      throw new EngramAccessInputError(`namespace is not readable: ${namespace}`);
+      throw new EngramAccessInputError(
+        `namespace is not readable: ${namespace}`,
+      );
     },
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
@@ -716,14 +880,19 @@ test("HTTP review list uses readable namespace resolver", async () => {
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/review/contradictions?namespace=team`, {
-      headers: { authorization: "Bearer test-token" },
-    });
-    const body = await response.json() as { error?: string };
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/review/contradictions?namespace=team`,
+      {
+        headers: { authorization: "Bearer test-token" },
+      },
+    );
+    const body = (await response.json()) as { error?: string };
 
     assert.equal(response.status, 400);
     assert.match(body.error ?? "", /namespace is not readable: team/);
-    assert.deepEqual(resolverCalls, [{ namespace: "team", principal: "reader" }]);
+    assert.deepEqual(resolverCalls, [
+      { namespace: "team", principal: "reader" },
+    ]);
   } finally {
     await server.stop();
     await rm(dir, { recursive: true, force: true });
@@ -731,7 +900,9 @@ test("HTTP review list uses readable namespace resolver", async () => {
 });
 
 test("HTTP default review list includes legacy unscoped pairs without mutating storage", async () => {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-http-review-list-default-"));
+  const dir = await mkdtemp(
+    path.join(os.tmpdir(), "remnic-http-review-list-default-"),
+  );
   const legacy = writePair(dir, {
     memoryIds: ["legacy-a", "legacy-b"],
     verdict: "contradicts",
@@ -739,7 +910,10 @@ test("HTTP default review list includes legacy unscoped pairs without mutating s
     confidence: 0.9,
     detectedAt: new Date().toISOString(),
   });
-  const resolverCalls: Array<{ namespace: string | undefined; principal: string | undefined }> = [];
+  const resolverCalls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+  }> = [];
   const storage = {
     readAllMemories: async () => [],
   } as unknown as StorageManager;
@@ -750,7 +924,10 @@ test("HTTP default review list includes legacy unscoped pairs without mutating s
       defaultNamespace: "default",
     }),
     memoryDir: dir,
-    getReadableStorageForNamespace: async (namespace: string | undefined, principal: string | undefined) => {
+    getReadableStorageForNamespace: async (
+      namespace: string | undefined,
+      principal: string | undefined,
+    ) => {
       resolverCalls.push({ namespace, principal });
       return { namespace: namespace ?? "default", storage };
     },
@@ -765,10 +942,13 @@ test("HTTP default review list includes legacy unscoped pairs without mutating s
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/review/contradictions`, {
-      headers: { authorization: "Bearer test-token" },
-    });
-    const body = await response.json() as {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/review/contradictions`,
+      {
+        headers: { authorization: "Bearer test-token" },
+      },
+    );
+    const body = (await response.json()) as {
       total?: number;
       pairs?: Array<{ pairId?: string; namespace?: string }>;
     };
@@ -777,7 +957,9 @@ test("HTTP default review list includes legacy unscoped pairs without mutating s
     assert.equal(body.pairs?.[0]?.pairId, legacy.pairId);
     assert.equal(body.pairs?.[0]?.namespace, undefined);
     assert.equal(readPair(dir, legacy.pairId)?.namespace, undefined);
-    assert.deepEqual(resolverCalls, [{ namespace: undefined, principal: "reader" }]);
+    assert.deepEqual(resolverCalls, [
+      { namespace: undefined, principal: "reader" },
+    ]);
   } finally {
     await server.stop();
     await rm(dir, { recursive: true, force: true });
@@ -794,7 +976,10 @@ test("HTTP review show hides namespace denial as pair_not_found", async () => {
     confidence: 0.9,
     detectedAt: new Date().toISOString(),
   });
-  const resolverCalls: Array<{ namespace: string | undefined; principal: string | undefined }> = [];
+  const resolverCalls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+  }> = [];
   const service = {
     configRef: parseConfig({
       memoryDir: dir,
@@ -802,9 +987,14 @@ test("HTTP review show hides namespace denial as pair_not_found", async () => {
       defaultNamespace: "default",
     }),
     memoryDir: dir,
-    getReadableStorageForNamespace: async (namespace: string | undefined, principal: string | undefined) => {
+    getReadableStorageForNamespace: async (
+      namespace: string | undefined,
+      principal: string | undefined,
+    ) => {
       resolverCalls.push({ namespace, principal });
-      throw new EngramAccessInputError(`namespace is not readable: ${namespace}`);
+      throw new EngramAccessInputError(
+        `namespace is not readable: ${namespace}`,
+      );
     },
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
@@ -817,14 +1007,19 @@ test("HTTP review show hides namespace denial as pair_not_found", async () => {
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/review/contradictions/${pair.pairId}`, {
-      headers: { authorization: "Bearer test-token" },
-    });
-    const body = await response.json() as { error?: string };
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/review/contradictions/${pair.pairId}`,
+      {
+        headers: { authorization: "Bearer test-token" },
+      },
+    );
+    const body = (await response.json()) as { error?: string };
 
     assert.equal(response.status, 404);
     assert.equal(body.error, "pair_not_found");
-    assert.deepEqual(resolverCalls, [{ namespace: "team", principal: "reader" }]);
+    assert.deepEqual(resolverCalls, [
+      { namespace: "team", principal: "reader" },
+    ]);
   } finally {
     await server.stop();
     await rm(dir, { recursive: true, force: true });
@@ -877,7 +1072,7 @@ test("HTTP offline snapshot forwards namespace and transfer options", async () =
       `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/snapshot?namespace=team&include_transcripts=false&content=false`,
       { headers: { authorization: "Bearer test-token" } },
     );
-    const body = await response.json() as {
+    const body = (await response.json()) as {
       namespace?: string;
       includeTranscripts?: boolean;
       files?: unknown[];
@@ -888,13 +1083,17 @@ test("HTTP offline snapshot forwards namespace and transfer options", async () =
     assert.equal(body.namespace, "team");
     assert.equal(body.includeTranscripts, false);
     assert.deepEqual(body.files, []);
-    assert.deepEqual(body.deletions, [{ path: "facts/deleted.md", mtimeMs: 1235 }]);
-    assert.deepEqual(calls, [{
-      namespace: "team",
-      principal: "reader",
-      includeTranscripts: false,
-      includeContent: false,
-    }]);
+    assert.deepEqual(body.deletions, [
+      { path: "facts/deleted.md", mtimeMs: 1235 },
+    ]);
+    assert.deepEqual(calls, [
+      {
+        namespace: "team",
+        principal: "reader",
+        includeTranscripts: false,
+        includeContent: false,
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -947,18 +1146,22 @@ test("HTTP offline snapshot accepts gzipped fast-base bodies", async () => {
 
   const status = await server.start();
   try {
-    const body = gzipSync(JSON.stringify({
-      namespace: "team",
-      includeTranscripts: false,
-      includeContent: false,
-      baseCapturedAt: "2026-05-20T00:00:00.000Z",
-      baseFiles: [{
-        path: "facts/a.md",
-        sha256: "a".repeat(64),
-        bytes: 12,
-        mtimeMs: 1234,
-      }],
-    }));
+    const body = gzipSync(
+      JSON.stringify({
+        namespace: "team",
+        includeTranscripts: false,
+        includeContent: false,
+        baseCapturedAt: "2026-05-20T00:00:00.000Z",
+        baseFiles: [
+          {
+            path: "facts/a.md",
+            sha256: "a".repeat(64),
+            bytes: 12,
+            mtimeMs: 1234,
+          },
+        ],
+      }),
+    );
     const response = await fetch(
       `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/snapshot`,
       {
@@ -971,7 +1174,7 @@ test("HTTP offline snapshot accepts gzipped fast-base bodies", async () => {
         body,
       },
     );
-    const responseBody = await response.json() as { namespace?: string };
+    const responseBody = (await response.json()) as { namespace?: string };
 
     assert.equal(response.status, 200);
     assert.equal(responseBody.namespace, "team");
@@ -983,12 +1186,14 @@ test("HTTP offline snapshot accepts gzipped fast-base bodies", async () => {
       principal: "reader",
       includeTranscripts: false,
       includeContent: false,
-      baseFiles: [{
-        path: "facts/a.md",
-        sha256: "a".repeat(64),
-        bytes: 12,
-        mtimeMs: 1234,
-      }],
+      baseFiles: [
+        {
+          path: "facts/a.md",
+          sha256: "a".repeat(64),
+          bytes: 12,
+          mtimeMs: 1234,
+        },
+      ],
       baseCapturedAt: new Date("2026-05-20T00:00:00.000Z"),
     });
   } finally {
@@ -1055,18 +1260,25 @@ test("HTTP offline snapshot stream emits metadata records as NDJSON", async () =
       .map((line) => JSON.parse(line) as Record<string, unknown>);
 
     assert.equal(response.status, 200);
-    assert.equal(response.headers.get("content-type"), "application/x-ndjson; charset=utf-8");
+    assert.equal(
+      response.headers.get("content-type"),
+      "application/x-ndjson; charset=utf-8",
+    );
     assert.equal(lines[0]?.type, "snapshot");
     assert.equal(lines[0]?.namespace, "team");
-    assert.deepEqual(lines[0]?.deletions, [{ path: "facts/deleted.md", mtimeMs: 1235 }]);
+    assert.deepEqual(lines[0]?.deletions, [
+      { path: "facts/deleted.md", mtimeMs: 1235 },
+    ]);
     assert.equal(lines[1]?.type, "file");
     assert.deepEqual((lines[1]?.file as { path?: string }).path, "facts/a.md");
-    assert.deepEqual(calls, [{
-      namespace: "team",
-      principal: "reader",
-      includeTranscripts: false,
-      includeContent: false,
-    }]);
+    assert.deepEqual(calls, [
+      {
+        namespace: "team",
+        principal: "reader",
+        includeTranscripts: false,
+        includeContent: false,
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -1102,36 +1314,66 @@ test("HTTP offline manifest stream preserves snapshot-stream auth and emits body
     port: 0,
     principal: "reader",
     authTokenEntriesGetter: () => [
-      { token: "wrong-op", capabilities: { version: 1, ops: ["offline_sync_snapshot"] } },
+      {
+        token: "wrong-op",
+        capabilities: { version: 1, ops: ["offline_sync_snapshot"] },
+      },
       {
         token: "wrong-namespace",
-        capabilities: { version: 1, ops: ["offline_sync_snapshot_stream"], namespaces: ["other"] },
+        capabilities: {
+          version: 1,
+          ops: ["offline_sync_snapshot_stream"],
+          namespaces: ["other"],
+        },
       },
       {
         token: "reader",
-        capabilities: { version: 1, ops: ["offline_sync_snapshot_stream"], namespaces: ["team"] },
+        capabilities: {
+          version: 1,
+          ops: ["offline_sync_snapshot_stream"],
+          namespaces: ["team"],
+        },
       },
     ],
     adminConsoleEnabled: false,
   });
   const status = await server.start();
-  const request = (token: string, query = "namespace=team&include_transcripts=false") =>
-    fetch(`http://127.0.0.1:${status.port}/remnic/v1/offline-sync/manifest-stream?${query}`, {
-      headers: { authorization: `Bearer ${token}` },
-    });
+  const request = (
+    token: string,
+    query = "namespace=team&include_transcripts=false",
+  ) =>
+    fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/manifest-stream?${query}`,
+      {
+        headers: { authorization: `Bearer ${token}` },
+      },
+    );
   try {
     assert.equal((await request("wrong-op")).status, 403);
     assert.equal((await request("wrong-namespace")).status, 403);
     assert.equal(calls.length, 0);
-    assert.equal((await request("reader", "namespace=team&include_transcripts=invalid")).status, 400);
-    assert.equal((await request("reader", "namespace=team&content=true")).status, 400);
+    assert.equal(
+      (await request("reader", "namespace=team&include_transcripts=invalid"))
+        .status,
+      400,
+    );
+    assert.equal(
+      (await request("reader", "namespace=team&content=true")).status,
+      400,
+    );
     assert.equal(calls.length, 0);
 
     const response = await request("reader");
     const text = await response.text();
-    const lines = text.trim().split("\n").map((line) => JSON.parse(line) as Record<string, unknown>);
+    const lines = text
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as Record<string, unknown>);
     assert.equal(response.status, 200);
-    assert.equal(response.headers.get("content-type"), "application/x-ndjson; charset=utf-8");
+    assert.equal(
+      response.headers.get("content-type"),
+      "application/x-ndjson; charset=utf-8",
+    );
     assert.equal(lines[0]?.type, "manifest");
     assert.equal(lines[1]?.type, "file");
     assert.deepEqual(lines[1]?.file, {
@@ -1147,15 +1389,18 @@ test("HTTP offline manifest stream preserves snapshot-stream auth and emits body
       },
     });
     assert.doesNotMatch(text, /contentBase64|rawContent|memory body/);
-    assert.deepEqual({
-      namespace: calls[0]?.namespace,
-      principal: calls[0]?.principal,
-      includeTranscripts: calls[0]?.includeTranscripts,
-    }, {
-      namespace: "team",
-      principal: "reader",
-      includeTranscripts: false,
-    });
+    assert.deepEqual(
+      {
+        namespace: calls[0]?.namespace,
+        principal: calls[0]?.principal,
+        includeTranscripts: calls[0]?.includeTranscripts,
+      },
+      {
+        namespace: "team",
+        principal: "reader",
+        includeTranscripts: false,
+      },
+    );
   } finally {
     await server.stop();
   }
@@ -1185,7 +1430,6 @@ test("HTTP offline sync capabilities advertise manifest streaming", async () =>
   }
 });
 
-
 test("HTTP offline files forwards namespace and requested paths", async () => {
   const calls: Array<{
     namespace: string | undefined;
@@ -1242,18 +1486,24 @@ test("HTTP offline files forwards namespace and requested paths", async () => {
         }),
       },
     );
-    const body = await response.json() as { namespace?: string; includeTranscripts?: boolean; files?: unknown[] };
+    const body = (await response.json()) as {
+      namespace?: string;
+      includeTranscripts?: boolean;
+      files?: unknown[];
+    };
 
     assert.equal(response.status, 200);
     assert.equal(body.namespace, "team");
     assert.equal(body.includeTranscripts, false);
     assert.deepEqual(body.files, []);
-    assert.deepEqual(calls, [{
-      namespace: "team",
-      principal: "reader",
-      includeTranscripts: false,
-      paths: ["facts/a.md"],
-    }]);
+    assert.deepEqual(calls, [
+      {
+        namespace: "team",
+        principal: "reader",
+        includeTranscripts: false,
+        paths: ["facts/a.md"],
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -1328,22 +1578,30 @@ test("HTTP offline file-content forwards range options and returns binary metada
 
     assert.equal(response.status, 200);
     assert.equal(body.toString("utf-8"), "hello");
-    assert.equal(response.headers.get("content-type"), "application/octet-stream");
+    assert.equal(
+      response.headers.get("content-type"),
+      "application/octet-stream",
+    );
     assert.equal(response.headers.get("x-remnic-namespace"), "team");
-    assert.equal(response.headers.get("x-remnic-file-path"), "artifacts%2Flarge.txt");
+    assert.equal(
+      response.headers.get("x-remnic-file-path"),
+      "artifacts%2Flarge.txt",
+    );
     assert.equal(response.headers.get("x-remnic-file-sha256"), "a".repeat(64));
     assert.equal(response.headers.get("x-remnic-file-bytes"), "12");
     assert.equal(response.headers.get("x-remnic-file-mtime-ms"), "1234");
     assert.equal(response.headers.get("x-remnic-chunk-offset"), "8");
     assert.equal(response.headers.get("x-remnic-chunk-bytes"), "5");
-    assert.deepEqual(calls, [{
-      namespace: "team",
-      principal: "reader",
-      includeTranscripts: false,
-      path: "artifacts/large.txt",
-      offset: 8,
-      length: 5,
-    }]);
+    assert.deepEqual(calls, [
+      {
+        namespace: "team",
+        principal: "reader",
+        includeTranscripts: false,
+        path: "artifacts/large.txt",
+        offset: 8,
+        length: 5,
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -1433,25 +1691,31 @@ test("HTTP offline apply-file-content forwards binary chunks and metadata", asyn
         body: Buffer.from("hello"),
       },
     );
-    const body = await response.json() as { namespace?: string; applied?: boolean; chunkBytes?: number };
+    const body = (await response.json()) as {
+      namespace?: string;
+      applied?: boolean;
+      chunkBytes?: number;
+    };
 
     assert.equal(response.status, 200);
     assert.equal(body.namespace, "team");
     assert.equal(body.applied, true);
     assert.equal(body.chunkBytes, 5);
-    assert.deepEqual(calls, [{
-      namespace: "team",
-      principal: "writer",
-      includeTranscripts: false,
-      sourceId: "laptop:test",
-      path: "state/lcm.sqlite",
-      sha256: "b".repeat(64),
-      bytes: 5,
-      mtimeMs: 1234,
-      offset: 8,
-      baseSha256: "a".repeat(64),
-      content: "hello",
-    }]);
+    assert.deepEqual(calls, [
+      {
+        namespace: "team",
+        principal: "writer",
+        includeTranscripts: false,
+        sourceId: "laptop:test",
+        path: "state/lcm.sqlite",
+        sha256: "b".repeat(64),
+        bytes: 5,
+        mtimeMs: 1234,
+        offset: 8,
+        baseSha256: "a".repeat(64),
+        content: "hello",
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -1541,7 +1805,12 @@ test("HTTP offline snapshot accepts baseline metadata for fast sync", async () =
       includeTranscripts?: boolean;
       includeContent?: boolean;
       baseCapturedAt?: Date;
-      baseFiles?: Array<{ path: string; sha256: string; bytes: number; mtimeMs: number }>;
+      baseFiles?: Array<{
+        path: string;
+        sha256: string;
+        bytes: number;
+        mtimeMs: number;
+      }>;
     }) => {
       calls.push({
         namespace: options.namespace,
@@ -1585,28 +1854,35 @@ test("HTTP offline snapshot accepts baseline metadata for fast sync", async () =
           includeTranscripts: false,
           includeContent: false,
           baseCapturedAt: "2026-05-31T17:30:08.350Z",
-          baseFiles: [{
-            path: "facts/a.md",
-            sha256: "a".repeat(64),
-            bytes: 12,
-            mtimeMs: 1234,
-          }],
+          baseFiles: [
+            {
+              path: "facts/a.md",
+              sha256: "a".repeat(64),
+              bytes: 12,
+              mtimeMs: 1234,
+            },
+          ],
         }),
       },
     );
-    const body = await response.json() as { namespace?: string; files?: unknown[] };
+    const body = (await response.json()) as {
+      namespace?: string;
+      files?: unknown[];
+    };
 
     assert.equal(response.status, 200);
     assert.equal(body.namespace, "team");
     assert.equal(body.files?.length, 1);
-    assert.deepEqual(calls, [{
-      namespace: "team",
-      principal: "reader",
-      includeTranscripts: false,
-      includeContent: false,
-      baseCapturedAt: "2026-05-31T17:30:08.350Z",
-      baseFileCount: 1,
-    }]);
+    assert.deepEqual(calls, [
+      {
+        namespace: "team",
+        principal: "reader",
+        includeTranscripts: false,
+        includeContent: false,
+        baseCapturedAt: "2026-05-31T17:30:08.350Z",
+        baseFileCount: 1,
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -1639,16 +1915,21 @@ test("HTTP offline snapshot rejects unsafe baseline paths as validation errors",
           "content-type": "application/json",
         },
         body: JSON.stringify({
-          baseFiles: [{
-            path: "../outside.md",
-            sha256: "a".repeat(64),
-            bytes: 12,
-            mtimeMs: 1234,
-          }],
+          baseFiles: [
+            {
+              path: "../outside.md",
+              sha256: "a".repeat(64),
+              bytes: 12,
+              mtimeMs: 1234,
+            },
+          ],
         }),
       },
     );
-    const body = await response.json() as { code?: string; details?: Array<{ field?: string; message?: string }> };
+    const body = (await response.json()) as {
+      code?: string;
+      details?: Array<{ field?: string; message?: string }>;
+    };
 
     assert.equal(response.status, 400);
     assert.equal(body.code, "validation_error");
@@ -1687,16 +1968,21 @@ test("HTTP offline snapshot rejects out-of-range baseline mtimes as validation e
           "content-type": "application/json",
         },
         body: JSON.stringify({
-          baseFiles: [{
-            path: "facts/a.md",
-            sha256: "a".repeat(64),
-            bytes: 12,
-            mtimeMs: OFFLINE_SYNC_MAX_MTIME_MS + 1,
-          }],
+          baseFiles: [
+            {
+              path: "facts/a.md",
+              sha256: "a".repeat(64),
+              bytes: 12,
+              mtimeMs: OFFLINE_SYNC_MAX_MTIME_MS + 1,
+            },
+          ],
         }),
       },
     );
-    const body = await response.json() as { code?: string; details?: Array<{ field?: string; message?: string }> };
+    const body = (await response.json()) as {
+      code?: string;
+      details?: Array<{ field?: string; message?: string }>;
+    };
 
     assert.equal(response.status, 400);
     assert.equal(body.code, "validation_error");
@@ -1730,10 +2016,13 @@ test("HTTP offline snapshot rejects invalid boolean query values", async () => {
       `http://127.0.0.1:${status.port}/engram/v1/offline-sync/snapshot?include_transcripts=maybe`,
       { headers: { authorization: "Bearer test-token" } },
     );
-    const body = await response.json() as { error?: string; code?: string };
+    const body = (await response.json()) as { error?: string; code?: string };
 
     assert.equal(response.status, 400);
-    assert.match(body.error ?? "", /include_transcripts must be one of: true, false/);
+    assert.match(
+      body.error ?? "",
+      /include_transcripts must be one of: true, false/,
+    );
     assert.equal(body.code, "input_error");
     assert.equal(calls, 0);
   } finally {
@@ -1786,24 +2075,32 @@ test("HTTP offline apply validates and forwards changesets", async () => {
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/remnic/v1/offline-sync/apply`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/apply`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ namespace: "team", changeset }),
       },
-      body: JSON.stringify({ namespace: "team", changeset }),
-    });
-    const body = await response.json() as { namespace?: string; appliedUpserts?: number };
+    );
+    const body = (await response.json()) as {
+      namespace?: string;
+      appliedUpserts?: number;
+    };
 
     assert.equal(response.status, 200);
     assert.equal(body.namespace, "team");
     assert.equal(body.appliedUpserts, 0);
-    assert.deepEqual(calls, [{
-      namespace: "team",
-      principal: "writer",
-      changeset,
-    }]);
+    assert.deepEqual(calls, [
+      {
+        namespace: "team",
+        principal: "writer",
+        changeset,
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -1818,17 +2115,19 @@ test("HTTP offline apply accepts bulk changesets above the generic JSON body lim
     createdAt: new Date("2026-05-21T00:00:00Z").toISOString(),
     sourceId: "laptop:test",
     includeTranscripts: true,
-    changes: [{
-      type: "upsert",
-      path: "facts/large.md",
-      file: {
+    changes: [
+      {
+        type: "upsert",
         path: "facts/large.md",
-        sha256: "b".repeat(64),
-        bytes: 256 * 1024,
-        mtimeMs: 1,
-        contentBase64: largeContent,
+        file: {
+          path: "facts/large.md",
+          sha256: "b".repeat(64),
+          bytes: 256 * 1024,
+          mtimeMs: 1,
+          contentBase64: largeContent,
+        },
       },
-    }],
+    ],
   };
   const service = {
     offlineSyncApply: async () => {
@@ -1854,15 +2153,18 @@ test("HTTP offline apply accepts bulk changesets above the generic JSON body lim
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/remnic/v1/offline-sync/apply`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/apply`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ namespace: "team", changeset }),
       },
-      body: JSON.stringify({ namespace: "team", changeset }),
-    });
-    const body = await response.json() as { appliedUpserts?: number };
+    );
+    const body = (await response.json()) as { appliedUpserts?: number };
 
     assert.equal(response.status, 200);
     assert.equal(body.appliedUpserts, 1);
@@ -1890,30 +2192,42 @@ test("HTTP offline apply requires a changeset", async () => {
 
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/offline-sync/apply`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/offline-sync/apply`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ namespace: "team" }),
       },
-      body: JSON.stringify({ namespace: "team" }),
-    });
-    const body = await response.json() as { code?: string; details?: Array<{ field?: string; message?: string }> };
+    );
+    const body = (await response.json()) as {
+      code?: string;
+      details?: Array<{ field?: string; message?: string }>;
+    };
 
     assert.equal(response.status, 400);
     assert.equal(body.code, "validation_error");
     assert.equal(body.details?.[0]?.field, "changeset");
     assert.equal(calls, 0);
 
-    const nullResponse = await fetch(`http://127.0.0.1:${status.port}/engram/v1/offline-sync/apply`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const nullResponse = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/offline-sync/apply`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ namespace: "team", changeset: null }),
       },
-      body: JSON.stringify({ namespace: "team", changeset: null }),
-    });
-    const nullBody = await nullResponse.json() as { code?: string; details?: Array<{ field?: string; message?: string }> };
+    );
+    const nullBody = (await nullResponse.json()) as {
+      code?: string;
+      details?: Array<{ field?: string; message?: string }>;
+    };
 
     assert.equal(nullResponse.status, 400);
     assert.equal(nullBody.code, "validation_error");
@@ -1927,7 +2241,12 @@ test("HTTP offline apply requires a changeset", async () => {
 
 test("HTTP server rejects invalid resourceMetadataUrl at construction", () => {
   const service = {} as EngramAccessService;
-  for (const bad of ["not a url", "ftp://example.com/oauth", "//relative/path", ""]) {
+  for (const bad of [
+    "not a url",
+    "ftp://example.com/oauth",
+    "//relative/path",
+    "",
+  ]) {
     assert.throws(
       () =>
         new EngramAccessHttpServer({
@@ -1959,7 +2278,8 @@ test("HTTP server rejects invalid resourceMetadataUrl at construction", () => {
 
 test("HTTP 401 www-authenticate carries resource_metadata exactly when configured", async () => {
   const service = {} as EngramAccessService;
-  const metadataUrl = "https://example.test/.well-known/oauth-protected-resource";
+  const metadataUrl =
+    "https://example.test/.well-known/oauth-protected-resource";
   const server = new EngramAccessHttpServer({
     service,
     port: 0,
@@ -1969,7 +2289,9 @@ test("HTTP 401 www-authenticate carries resource_metadata exactly when configure
   });
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/health`);
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/health`,
+    );
     assert.equal(response.status, 401);
     assert.equal(
       response.headers.get("www-authenticate"),
@@ -1990,7 +2312,9 @@ test("HTTP 401 www-authenticate is the bare Bearer challenge when resourceMetada
   });
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/health`);
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/health`,
+    );
     assert.equal(response.status, 401);
     assert.equal(response.headers.get("www-authenticate"), "Bearer");
   } finally {
@@ -2014,12 +2338,18 @@ test("HTTP /mcp returns 405 with Allow: POST for GET and DELETE (authorized requ
         headers: { authorization: "Bearer test-token" },
       });
       assert.equal(response.status, 405, `${method} /mcp must be 405`);
-      assert.equal(response.headers.get("allow"), "POST", `${method} /mcp must advertise Allow: POST`);
-      const body = await response.json() as { code?: string };
+      assert.equal(
+        response.headers.get("allow"),
+        "POST",
+        `${method} /mcp must advertise Allow: POST`,
+      );
+      const body = (await response.json()) as { code?: string };
       assert.equal(body.code, "method_not_allowed");
     }
     // Unauthenticated GET /mcp still gets 401 first (auth gate beats method-conformance).
-    const unauth = await fetch(`http://127.0.0.1:${status.port}/mcp`, { method: "GET" });
+    const unauth = await fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      method: "GET",
+    });
     assert.equal(unauth.status, 401);
   } finally {
     await server.stop();
@@ -2046,7 +2376,10 @@ test("HTTP /mcp rejects unknown MCP-Protocol-Version header with 400 JSON-RPC er
       body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping" }),
     });
     assert.equal(response.status, 400);
-    const body = await response.json() as { jsonrpc?: string; error?: { message?: string } };
+    const body = (await response.json()) as {
+      jsonrpc?: string;
+      error?: { message?: string };
+    };
     assert.equal(body.jsonrpc, "2.0");
     assert.match(body.error?.message ?? "", /unsupported MCP-Protocol-Version/);
 
@@ -2067,7 +2400,10 @@ test("HTTP /mcp rejects unknown MCP-Protocol-Version header with 400 JSON-RPC er
     // Absent header is also fine.
     const absent = await fetch(`http://127.0.0.1:${status.port}/mcp`, {
       method: "POST",
-      headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
       body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping" }),
     });
     assert.equal(absent.status, 200);
@@ -2136,7 +2472,10 @@ test("HTTP externalRequestHandler runs pre-auth, can end responses, and falls th
         method: _req.method ?? "",
         authorized: ctx.authorized,
       });
-      if (new URL(_req.url ?? "/", "http://placeholder").pathname === "/probe/handled") {
+      if (
+        new URL(_req.url ?? "/", "http://placeholder").pathname ===
+        "/probe/handled"
+      ) {
         res.writeHead(200, { "content-type": "application/json" });
         res.end(JSON.stringify({ handled: true, authorized: ctx.authorized }));
         return true;
@@ -2147,11 +2486,20 @@ test("HTTP externalRequestHandler runs pre-auth, can end responses, and falls th
   const status = await server.start();
   try {
     // Pre-auth, the handler sees authorized=false (no token sent).
-    const handled = await fetch(`http://127.0.0.1:${status.port}/probe/handled`);
+    const handled = await fetch(
+      `http://127.0.0.1:${status.port}/probe/handled`,
+    );
     assert.equal(handled.status, 200);
-    const handledBody = await handled.json() as { handled?: boolean; authorized?: boolean };
+    const handledBody = (await handled.json()) as {
+      handled?: boolean;
+      authorized?: boolean;
+    };
     assert.equal(handledBody.handled, true);
-    assert.equal(handledBody.authorized, false, "handler must observe authorized=false pre-token");
+    assert.equal(
+      handledBody.authorized,
+      false,
+      "handler must observe authorized=false pre-token",
+    );
 
     // Fall-through path: same handler returns false, request continues to normal
     // routing. Hit a real endpoint so we know the request reached it.
@@ -2159,9 +2507,20 @@ test("HTTP externalRequestHandler runs pre-auth, can end responses, and falls th
       `http://127.0.0.1:${status.port}/engram/v1/health`,
       { headers: { authorization: "Bearer test-token" } },
     );
-    assert.equal(passthrough.status, 200, "fall-through should reach the normal health route");
-    const passthroughBody = await passthrough.json() as { ok?: boolean; memoryDir?: string };
-    assert.equal(passthroughBody.ok, true, "fall-through must return the stubbed health payload");
+    assert.equal(
+      passthrough.status,
+      200,
+      "fall-through should reach the normal health route",
+    );
+    const passthroughBody = (await passthrough.json()) as {
+      ok?: boolean;
+      memoryDir?: string;
+    };
+    assert.equal(
+      passthroughBody.ok,
+      true,
+      "fall-through must return the stubbed health payload",
+    );
     assert.equal(passthroughBody.memoryDir, "/tmp/remnic-test");
 
     // Authorized request: handler sees ctx.authorized=true.
@@ -2170,8 +2529,12 @@ test("HTTP externalRequestHandler runs pre-auth, can end responses, and falls th
       { headers: { authorization: "Bearer test-token" } },
     );
     assert.equal(authed.status, 200);
-    const authedBody = await authed.json() as { authorized?: boolean };
-    assert.equal(authedBody.authorized, true, "handler must observe authorized=true with valid token");
+    const authedBody = (await authed.json()) as { authorized?: boolean };
+    assert.equal(
+      authedBody.authorized,
+      true,
+      "handler must observe authorized=true with valid token",
+    );
 
     assert.deepEqual(seen, [
       { path: "/probe/handled", method: "GET", authorized: false },
@@ -2196,9 +2559,15 @@ test("HTTP externalRequestHandler errors flow through the existing error handler
   });
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/health`);
-    assert.equal(response.status, 500, "thrown errors must produce a 500 via the existing error handler");
-    const body = await response.json() as { code?: string };
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/health`,
+    );
+    assert.equal(
+      response.status,
+      500,
+      "thrown errors must produce a 500 via the existing error handler",
+    );
+    const body = (await response.json()) as { code?: string };
     assert.equal(body.code, "internal_error");
   } finally {
     await server.stop();
@@ -2262,21 +2631,33 @@ test("HTTP authTokenEntriesGetter is authoritative: scope policy binds connector
     // Dangerous shape on purpose: BOTH getters configured, and the string
     // getter is a superset (extra "string_only_token"). The entries getter
     // must decide alone; nothing may leak into the string getter.
-    authTokensGetter: () => [...entries.map((entry) => entry.token), "string_only_token"],
+    authTokensGetter: () => [
+      ...entries.map((entry) => entry.token),
+      "string_only_token",
+    ],
     authTokenEntriesGetter: () => entries,
-    tokenPathPolicy: (connector, pathname) => connector !== "chatgpt" || pathname === "/mcp",
+    tokenPathPolicy: (connector, pathname) =>
+      connector !== "chatgpt" || pathname === "/mcp",
     adminConsoleEnabled: false,
   });
   const status = await server.start();
   const request = (token: string, path: string, method = "GET") =>
     fetch(`http://127.0.0.1:${status.port}${path}`, {
       method,
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
-      ...(method === "POST" ? { body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping" }) } : {}),
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
+      ...(method === "POST"
+        ? { body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping" }) }
+        : {}),
     });
   try {
     // Scoped chatgpt token: /mcp only; health denied.
-    assert.equal((await request("remnic_cg_scoped", "/mcp", "POST")).status, 200);
+    assert.equal(
+      (await request("remnic_cg_scoped", "/mcp", "POST")).status,
+      200,
+    );
     assert.equal(
       (await request("remnic_cg_scoped", "/engram/v1/health")).status,
       401,
@@ -2291,10 +2672,19 @@ test("HTTP authTokenEntriesGetter is authoritative: scope policy binds connector
     assert.equal((await request("remnic_xx_anon", "/mcp", "POST")).status, 401);
     // A token present ONLY in the string getter is NOT honored: the entries
     // getter is authoritative and there is no fall-through.
-    assert.equal((await request("string_only_token", "/mcp", "POST")).status, 401);
-    assert.equal((await request("string_only_token", "/engram/v1/health")).status, 401);
+    assert.equal(
+      (await request("string_only_token", "/mcp", "POST")).status,
+      401,
+    );
+    assert.equal(
+      (await request("string_only_token", "/engram/v1/health")).status,
+      401,
+    );
     // Unknown tokens are rejected everywhere.
-    assert.equal((await request("remnic_zz_unknown", "/mcp", "POST")).status, 401);
+    assert.equal(
+      (await request("remnic_zz_unknown", "/mcp", "POST")).status,
+      401,
+    );
     // Static operator token bypasses the policy entirely: /mcp AND health.
     assert.equal((await request("operator-token", "/mcp", "POST")).status, 200);
     const operatorHealth = await request("operator-token", "/engram/v1/health");
@@ -2336,7 +2726,10 @@ test("HTTP scoped-token namespace allow-list is enforced on every namespace rout
     // Entry-based tokens with a capabilities record. The scoped token carries
     // a namespaces allow-list; the operator token is explicit-unrestricted.
     authTokenEntriesGetter: () => [
-      { token: "scoped-ns-a", capabilities: { version: 1, namespaces: ["ns_a"] } },
+      {
+        token: "scoped-ns-a",
+        capabilities: { version: 1, namespaces: ["ns_a"] },
+      },
       { token: "operator", capabilities: { version: 1 } },
     ],
     adminConsoleEnabled: false,
@@ -2354,13 +2747,25 @@ test("HTTP scoped-token namespace allow-list is enforced on every namespace rout
       "scoped: omitting namespace must be rejected — server default is not in the allow-list",
     );
     assert.equal(
-      (await request("scoped-ns-a", "/engram/v1/memories?namespace=ns_b")).status,
+      (await request("scoped-ns-a", "/engram/v1/memories?namespace=ns_b"))
+        .status,
       403,
       "scoped: an unlisted namespace must be rejected",
     );
-    const okList = await request("scoped-ns-a", "/engram/v1/memories?namespace=ns_a");
-    assert.equal(okList.status, 200, "scoped: an allowed namespace must succeed");
-    assert.equal(browseCalls.at(-1)?.namespace, "ns_a", "scoped: the allowed namespace is forwarded to the service");
+    const okList = await request(
+      "scoped-ns-a",
+      "/engram/v1/memories?namespace=ns_a",
+    );
+    assert.equal(
+      okList.status,
+      200,
+      "scoped: an allowed namespace must succeed",
+    );
+    assert.equal(
+      browseCalls.at(-1)?.namespace,
+      "ns_a",
+      "scoped: the allowed namespace is forwarded to the service",
+    );
 
     // ── memory_get: the other named bypass route (dispatches via the op registry) ──
     assert.equal(
@@ -2369,12 +2774,20 @@ test("HTTP scoped-token namespace allow-list is enforced on every namespace rout
       "scoped memory_get: omitting namespace must be rejected",
     );
     assert.equal(
-      (await request("scoped-ns-a", "/engram/v1/memories/m_1?namespace=ns_b")).status,
+      (await request("scoped-ns-a", "/engram/v1/memories/m_1?namespace=ns_b"))
+        .status,
       403,
       "scoped memory_get: an unlisted namespace must be rejected",
     );
-    const okGet = await request("scoped-ns-a", "/engram/v1/memories/m_1?namespace=ns_a");
-    assert.equal(okGet.status, 200, "scoped memory_get: an allowed namespace must succeed");
+    const okGet = await request(
+      "scoped-ns-a",
+      "/engram/v1/memories/m_1?namespace=ns_a",
+    );
+    assert.equal(
+      okGet.status,
+      200,
+      "scoped memory_get: an allowed namespace must succeed",
+    );
     assert.deepEqual(
       getCalls.at(-1),
       { memoryId: "m_1", namespace: "ns_a" },
@@ -2406,7 +2819,9 @@ test("HTTP scoped-token namespace allow-list gates id-loaded contradiction route
   // knows a pair id in a namespace outside its allow-list must NOT be able to
   // read (GET) or mutate (resolve) it. Fail closed (403) everywhere; the pair
   // in the allowed namespace is reachable.
-  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-http-scoped-contradiction-"));
+  const dir = await mkdtemp(
+    path.join(os.tmpdir(), "remnic-http-scoped-contradiction-"),
+  );
   const allowedPair = writePair(dir, {
     namespace: "ns_a",
     memoryIds: ["a-1", "a-2"],
@@ -2445,20 +2860,29 @@ test("HTTP scoped-token namespace allow-list gates id-loaded contradiction route
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "scoped-ns-a", capabilities: { version: 1, namespaces: ["ns_a"] } },
+      {
+        token: "scoped-ns-a",
+        capabilities: { version: 1, namespaces: ["ns_a"] },
+      },
       { token: "operator", capabilities: { version: 1 } },
     ],
     adminConsoleEnabled: false,
   });
   const status = await server.start();
   const getDetail = (token: string, pairId: string) =>
-    fetch(`http://127.0.0.1:${status.port}/engram/v1/review/contradictions/${pairId}`, {
-      headers: { authorization: `Bearer ${token}` },
-    });
+    fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/review/contradictions/${pairId}`,
+      {
+        headers: { authorization: `Bearer ${token}` },
+      },
+    );
   const resolve = (token: string, pairId: string, verb: string) =>
     fetch(`http://127.0.0.1:${status.port}/engram/v1/review/resolve`, {
       method: "POST",
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
       body: JSON.stringify({ pairId, verb }),
     });
   try {
@@ -2476,7 +2900,11 @@ test("HTTP scoped-token namespace allow-list gates id-loaded contradiction route
     );
 
     // ── review/resolve: scoped token, denied namespace → 403 before any mutation ──
-    const deniedResolve = await resolve("scoped-ns-a", deniedPair.pairId, "both-valid");
+    const deniedResolve = await resolve(
+      "scoped-ns-a",
+      deniedPair.pairId,
+      "both-valid",
+    );
     assert.equal(
       deniedResolve.status,
       403,
@@ -2490,7 +2918,11 @@ test("HTTP scoped-token namespace allow-list gates id-loaded contradiction route
     );
 
     // ── review/resolve: scoped token, allowed namespace → succeeds (not 403) ──
-    const allowedResolve = await resolve("scoped-ns-a", allowedPair.pairId, "both-valid");
+    const allowedResolve = await resolve(
+      "scoped-ns-a",
+      allowedPair.pairId,
+      "both-valid",
+    );
     assert.equal(
       allowedResolve.status,
       200,
@@ -2529,7 +2961,11 @@ test("HTTP-MCP tools/call enforces the token namespace allow-list (issue #1850 f
   // reaches the service.
   const capsuleCalls: Array<Record<string, unknown>> = [];
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-mcp-ns", namespacesEnabled: true, defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-mcp-ns",
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+    }),
     capsuleList: async (args: Record<string, unknown>) => {
       capsuleCalls.push(args);
       return { capsules: [] };
@@ -2539,7 +2975,10 @@ test("HTTP-MCP tools/call enforces the token namespace allow-list (issue #1850 f
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "scoped-ns-a", capabilities: { version: 1, namespaces: ["ns_a"] } },
+      {
+        token: "scoped-ns-a",
+        capabilities: { version: 1, namespaces: ["ns_a"] },
+      },
       { token: "operator", capabilities: { version: 1 } },
     ],
     adminConsoleEnabled: false,
@@ -2548,7 +2987,10 @@ test("HTTP-MCP tools/call enforces the token namespace allow-list (issue #1850 f
   const mcpCall = (token: string, namespace: string) =>
     fetch(`http://127.0.0.1:${status.port}/mcp`, {
       method: "POST",
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
       body: JSON.stringify({
         jsonrpc: "2.0",
         id: 1,
@@ -2563,14 +3005,30 @@ test("HTTP-MCP tools/call enforces the token namespace allow-list (issue #1850 f
       403,
       "scoped MCP: an unlisted namespace must be denied (403) before op.run",
     );
-    assert.equal(capsuleCalls.length, 0, "scoped MCP: the service must NOT be reached for a denied namespace");
+    assert.equal(
+      capsuleCalls.length,
+      0,
+      "scoped MCP: the service must NOT be reached for a denied namespace",
+    );
     // scoped: the allowed namespace proceeds past the gate (200, not 403).
     const allowed = await mcpCall("scoped-ns-a", "ns_a");
-    assert.notEqual(allowed.status, 403, "scoped MCP: the allowed namespace must proceed past the gate");
-    assert.equal(capsuleCalls.at(-1)?.namespace, "ns_a", "scoped MCP: the allowed namespace reaches the service");
+    assert.notEqual(
+      allowed.status,
+      403,
+      "scoped MCP: the allowed namespace must proceed past the gate",
+    );
+    assert.equal(
+      capsuleCalls.at(-1)?.namespace,
+      "ns_a",
+      "scoped MCP: the allowed namespace reaches the service",
+    );
     // unrestricted: an unlisted namespace is a no-op (proceeds, not 403).
     const unrestricted = await mcpCall("operator", "ns_b");
-    assert.notEqual(unrestricted.status, 403, "unrestricted MCP: namespace scoping must be a no-op");
+    assert.notEqual(
+      unrestricted.status,
+      403,
+      "unrestricted MCP: namespace scoping must be a no-op",
+    );
   } finally {
     await server.stop();
   }
@@ -2583,7 +3041,11 @@ test("HTTP coding POST routes gate the body namespace through the allow-list (is
   // routes. 403 before op.run; the allowed namespace reaches the service.
   const decisionCalls: Array<Record<string, unknown>> = [];
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-coding-ns", namespacesEnabled: true, defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-coding-ns",
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+    }),
     codingDecision: async (input: Record<string, unknown>) => {
       decisionCalls.push(input);
       return { subcommand: "list", records: [], count: 0 };
@@ -2593,7 +3055,10 @@ test("HTTP coding POST routes gate the body namespace through the allow-list (is
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "scoped-ns-a", capabilities: { version: 1, namespaces: ["ns_a"] } },
+      {
+        token: "scoped-ns-a",
+        capabilities: { version: 1, namespaces: ["ns_a"] },
+      },
       { token: "operator", capabilities: { version: 1 } },
     ],
     adminConsoleEnabled: false,
@@ -2602,8 +3067,14 @@ test("HTTP coding POST routes gate the body namespace through the allow-list (is
   const postDecision = (token: string, namespace: string | undefined) =>
     fetch(`http://127.0.0.1:${status.port}/engram/v1/coding/decisions`, {
       method: "POST",
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
-      body: JSON.stringify({ subcommand: "list", ...(namespace ? { namespace } : {}) }),
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        subcommand: "list",
+        ...(namespace ? { namespace } : {}),
+      }),
     });
   try {
     // scoped: body.namespace to an unlisted tenant → 403 before op.run.
@@ -2612,11 +3083,23 @@ test("HTTP coding POST routes gate the body namespace through the allow-list (is
       403,
       "scoped coding: body.namespace to an unlisted namespace must be denied (403)",
     );
-    assert.equal(decisionCalls.length, 0, "scoped coding: the service must NOT be reached for a denied namespace");
+    assert.equal(
+      decisionCalls.length,
+      0,
+      "scoped coding: the service must NOT be reached for a denied namespace",
+    );
     // scoped: the allowed body.namespace reaches the service.
     const allowed = await postDecision("scoped-ns-a", "ns_a");
-    assert.notEqual(allowed.status, 403, "scoped coding: the allowed namespace must proceed past the gate");
-    assert.equal(decisionCalls.at(-1)?.namespace, "ns_a", "scoped coding: the allowed namespace reaches the service");
+    assert.notEqual(
+      allowed.status,
+      403,
+      "scoped coding: the allowed namespace must proceed past the gate",
+    );
+    assert.equal(
+      decisionCalls.at(-1)?.namespace,
+      "ns_a",
+      "scoped coding: the allowed namespace reaches the service",
+    );
     // unrestricted: any body.namespace is a no-op.
     assert.notEqual(
       (await postDecision("operator", "ns_b")).status,
@@ -2635,7 +3118,9 @@ test("Legacy undefined-namespace contradiction pair: default-allow-list token re
   // effective-namespace chokepoint maps undefined → default, so:
   //   - namespaces:['default'] (== server default) ⇒ ALLOWED read + resolve;
   //   - namespaces:['ns_a'] (not default) ⇒ DENIED.
-  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-http-scoped-legacy-pair-"));
+  const dir = await mkdtemp(
+    path.join(os.tmpdir(), "remnic-http-scoped-legacy-pair-"),
+  );
   const legacyPair = writePair(dir, {
     memoryIds: ["legacy-x", "legacy-y"],
     verdict: "contradicts",
@@ -2647,7 +3132,11 @@ test("Legacy undefined-namespace contradiction pair: default-allow-list token re
   assert.equal(readPair(dir, legacyPair.pairId)?.namespace, undefined);
   const storage = { dir } as unknown as StorageManager;
   const baseService = {
-    configRef: parseConfig({ memoryDir: dir, namespacesEnabled: true, defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: dir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+    }),
     memoryDir: dir,
     storageRef: storage,
     getReadableStorageForNamespace: async (namespace: string | undefined) => ({
@@ -2664,7 +3153,12 @@ test("Legacy undefined-namespace contradiction pair: default-allow-list token re
     return new EngramAccessHttpServer({
       service,
       port: 0,
-      authTokenEntriesGetter: () => [{ token: scopedToken, capabilities: { version: 1, namespaces: allowList } }],
+      authTokenEntriesGetter: () => [
+        {
+          token: scopedToken,
+          capabilities: { version: 1, namespaces: allowList },
+        },
+      ],
       adminConsoleEnabled: false,
     });
   };
@@ -2677,13 +3171,27 @@ test("Legacy undefined-namespace contradiction pair: default-allow-list token re
       `http://127.0.0.1:${defaultStatus.port}/engram/v1/review/contradictions/${legacyPair.pairId}`,
       { headers: { authorization: "Bearer allow-default" } },
     );
-    assert.equal(detail.status, 200, "default-allow token: legacy undefined pair must be readable (undefined→default)");
-    const resolve = await fetch(`http://127.0.0.1:${defaultStatus.port}/engram/v1/review/resolve`, {
-      method: "POST",
-      headers: { authorization: "Bearer allow-default", "content-type": "application/json" },
-      body: JSON.stringify({ pairId: legacyPair.pairId, verb: "both-valid" }),
-    });
-    assert.equal(resolve.status, 200, "default-allow token: legacy undefined pair must be resolvable");
+    assert.equal(
+      detail.status,
+      200,
+      "default-allow token: legacy undefined pair must be readable (undefined→default)",
+    );
+    const resolve = await fetch(
+      `http://127.0.0.1:${defaultStatus.port}/engram/v1/review/resolve`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer allow-default",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ pairId: legacyPair.pairId, verb: "both-valid" }),
+      },
+    );
+    assert.equal(
+      resolve.status,
+      200,
+      "default-allow token: legacy undefined pair must be resolvable",
+    );
     assert.equal(
       readPair(dir, legacyPair.pairId)?.resolution,
       "both-valid",
@@ -2718,12 +3226,25 @@ test("Legacy undefined-namespace contradiction pair: default-allow-list token re
       403,
       "non-default token: legacy undefined pair must be denied (undefined→default not in allow-list)",
     );
-    const resolve = await fetch(`http://127.0.0.1:${deniedStatus.port}/engram/v1/review/resolve`, {
-      method: "POST",
-      headers: { authorization: "Bearer allow-ns-a", "content-type": "application/json" },
-      body: JSON.stringify({ pairId: deniedLegacyPair.pairId, verb: "both-valid" }),
-    });
-    assert.equal(resolve.status, 403, "non-default token: legacy undefined pair must not be resolvable");
+    const resolve = await fetch(
+      `http://127.0.0.1:${deniedStatus.port}/engram/v1/review/resolve`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer allow-ns-a",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          pairId: deniedLegacyPair.pairId,
+          verb: "both-valid",
+        }),
+      },
+    );
+    assert.equal(
+      resolve.status,
+      403,
+      "non-default token: legacy undefined pair must not be resolvable",
+    );
     assert.notEqual(
       readPair(dir, deniedLegacyPair.pairId)?.resolution,
       "both-valid",
@@ -2744,7 +3265,10 @@ test("HTTP adapters route is op-gated: deny-all → 403, unrestricted → 200 (i
   // NO enforceTokenOp, so a deny-all / narrow-ops token reached it. It now
   // dispatches through the adapters_status op; a scoped token is rejected.
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-adapters-opgate", defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-adapters-opgate",
+      defaultNamespace: "default",
+    }),
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
     service,
@@ -2773,9 +3297,17 @@ test("HTTP adapters route is op-gated: deny-all → 403, unrestricted → 200 (i
       "narrow-ops token without adapters_status must be rejected",
     );
     const ok = await request("operator", "/engram/v1/adapters");
-    assert.equal(ok.status, 200, "unrestricted token must reach adapter metadata");
+    assert.equal(
+      ok.status,
+      200,
+      "unrestricted token must reach adapter metadata",
+    );
     const body = (await ok.json()) as { adaptersEnabled?: boolean };
-    assert.equal(typeof body.adaptersEnabled, "boolean", "adapter metadata body shape preserved");
+    assert.equal(
+      typeof body.adaptersEnabled,
+      "boolean",
+      "adapter metadata body shape preserved",
+    );
   } finally {
     await server.stop();
   }
@@ -2791,53 +3323,93 @@ test("HTTP chat routes gate the resumed session's STORED namespace (issue #1850
   // sessionBelongsToPrincipal, so the namespace gate is the ONLY gate in play).
   const session = await createChatSession(dir, { namespace: "ns_a" });
   const service = {
-    configRef: parseConfig({ memoryDir: dir, namespacesEnabled: true, defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: dir,
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+    }),
     memoryDir: dir,
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "scoped-ns-b", capabilities: { version: 1, namespaces: ["ns_b"] } },
-      { token: "scoped-ns-a", capabilities: { version: 1, namespaces: ["ns_a"] } },
+      {
+        token: "scoped-ns-b",
+        capabilities: { version: 1, namespaces: ["ns_b"] },
+      },
+      {
+        token: "scoped-ns-a",
+        capabilities: { version: 1, namespaces: ["ns_a"] },
+      },
     ],
     adminConsoleEnabled: false,
   });
   const status = await server.start();
-  const authed = (token: string) => ({ headers: { authorization: `Bearer ${token}` } });
+  const authed = (token: string) => ({
+    headers: { authorization: `Bearer ${token}` },
+  });
   try {
     // ── POST chat/message resuming a CROSS-namespace session → 403 ──
-    const cross = await fetch(`http://127.0.0.1:${status.port}/engram/v1/chat/message`, {
-      method: "POST",
-      ...authed("scoped-ns-b"),
-      headers: { ...authed("scoped-ns-b").headers, "content-type": "application/json" },
-      body: JSON.stringify({ message: "hi", chatSessionId: session.id }),
-    });
-    assert.equal(cross.status, 403, "scoped-ns-b must NOT post to a session bound to ns_a");
+    const cross = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/chat/message`,
+      {
+        method: "POST",
+        ...authed("scoped-ns-b"),
+        headers: {
+          ...authed("scoped-ns-b").headers,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ message: "hi", chatSessionId: session.id }),
+      },
+    );
+    assert.equal(
+      cross.status,
+      403,
+      "scoped-ns-b must NOT post to a session bound to ns_a",
+    );
 
     // ── POST chat/message resuming a SAME-namespace session → passes the gate ──
     // (Chat is unconfigured here so the handler returns chat_disabled 404; the
     //  point is it is NOT 403 — the namespace gate let it through.)
-    const same = await fetch(`http://127.0.0.1:${status.port}/engram/v1/chat/message`, {
-      method: "POST",
-      headers: { authorization: "Bearer scoped-ns-a", "content-type": "application/json" },
-      body: JSON.stringify({ message: "hi", chatSessionId: session.id }),
-    });
-    assert.notEqual(same.status, 403, "scoped-ns-a must pass the namespace gate for its own session");
+    const same = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/chat/message`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer scoped-ns-a",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ message: "hi", chatSessionId: session.id }),
+      },
+    );
+    assert.notEqual(
+      same.status,
+      403,
+      "scoped-ns-a must pass the namespace gate for its own session",
+    );
 
     // ── GET chat/events for a CROSS-namespace session → 403 ──
     const crossEvents = await fetch(
       `http://127.0.0.1:${status.port}/engram/v1/chat/events/${session.id}`,
       authed("scoped-ns-b"),
     );
-    assert.equal(crossEvents.status, 403, "scoped-ns-b must NOT stream a session bound to ns_a");
+    assert.equal(
+      crossEvents.status,
+      403,
+      "scoped-ns-b must NOT stream a session bound to ns_a",
+    );
 
     // ── GET chat/events for a SAME-namespace session → passes the gate ──
     const sameEvents = await fetch(
       `http://127.0.0.1:${status.port}/engram/v1/chat/events/${session.id}`,
       authed("scoped-ns-a"),
     );
-    assert.notEqual(sameEvents.status, 403, "scoped-ns-a must pass the namespace gate for its own session");
+    assert.notEqual(
+      sameEvents.status,
+      403,
+      "scoped-ns-a must pass the namespace gate for its own session",
+    );
   } finally {
     await server.stop();
     await rm(dir, { recursive: true, force: true });
@@ -2876,16 +3448,33 @@ test("HTTP per-request token capabilities never bleed across concurrent async re
     port: 0,
     authTokenEntriesGetter: () => [
       { token: "deny-all", capabilities: { version: 1, ops: [] } },
-      { token: "scoped-ns-a", capabilities: { version: 1, ops: ["memory_list"], namespaces: ["ns_a"] } },
-      { token: "scoped-ns-b", capabilities: { version: 1, ops: ["memory_list"], namespaces: ["ns_b"] } },
+      {
+        token: "scoped-ns-a",
+        capabilities: {
+          version: 1,
+          ops: ["memory_list"],
+          namespaces: ["ns_a"],
+        },
+      },
+      {
+        token: "scoped-ns-b",
+        capabilities: {
+          version: 1,
+          ops: ["memory_list"],
+          namespaces: ["ns_b"],
+        },
+      },
     ],
     adminConsoleEnabled: false,
   });
   const status = await server.start();
   const get = (token: string, namespace: string) =>
-    fetch(`http://127.0.0.1:${status.port}/engram/v1/memories?namespace=${namespace}`, {
-      headers: { authorization: `Bearer ${token}` },
-    });
+    fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/memories?namespace=${namespace}`,
+      {
+        headers: { authorization: `Bearer ${token}` },
+      },
+    );
   try {
     const REPEATS = 15;
     const batch: Promise<Response>[] = [];
@@ -2898,26 +3487,54 @@ test("HTTP per-request token capabilities never bleed across concurrent async re
 
     // (1) Op-gate holds under concurrency: every deny-all request is 403, never
     //     fail-open 200 (which would mean its caps bled to unrestricted).
-    const denyAllStatuses = responses.filter((_, i) => i % 3 === 0).map((r) => r.status);
+    const denyAllStatuses = responses
+      .filter((_, i) => i % 3 === 0)
+      .map((r) => r.status);
     assert.ok(
       denyAllStatuses.every((s) => s === 403),
       `deny-all token must always be 403, got: ${JSON.stringify(denyAllStatuses)}`,
     );
 
     // scoped tokens reach the service (200) — op + namespace gates both pass.
-    const nsAStatuses = responses.filter((_, i) => i % 3 === 1).map((r) => r.status);
-    const nsBStatuses = responses.filter((_, i) => i % 3 === 2).map((r) => r.status);
-    assert.ok(nsAStatuses.every((s) => s === 200), `scoped-ns-a should all be 200: ${JSON.stringify(nsAStatuses)}`);
-    assert.ok(nsBStatuses.every((s) => s === 200), `scoped-ns-b should all be 200: ${JSON.stringify(nsBStatuses)}`);
+    const nsAStatuses = responses
+      .filter((_, i) => i % 3 === 1)
+      .map((r) => r.status);
+    const nsBStatuses = responses
+      .filter((_, i) => i % 3 === 2)
+      .map((r) => r.status);
+    assert.ok(
+      nsAStatuses.every((s) => s === 200),
+      `scoped-ns-a should all be 200: ${JSON.stringify(nsAStatuses)}`,
+    );
+    assert.ok(
+      nsBStatuses.every((s) => s === 200),
+      `scoped-ns-b should all be 200: ${JSON.stringify(nsBStatuses)}`,
+    );
 
     // (2) No cross-request bleed: the store read AFTER the async yield carried
     //     the REQUESTING token's namespace on every service call. memoryBrowse
     //     ran once per scoped request (2 * REPEATS).
-    assert.equal(observed.length, 2 * REPEATS, "memoryBrowse called once per scoped request");
-    const nsAObserved = observed.filter((c) => c?.namespaces?.includes("ns_a")).length;
-    const nsBObserved = observed.filter((c) => c?.namespaces?.includes("ns_b")).length;
-    assert.equal(nsAObserved, REPEATS, "every ns_a request observed its own scope — no bleed");
-    assert.equal(nsBObserved, REPEATS, "every ns_b request observed its own scope — no bleed");
+    assert.equal(
+      observed.length,
+      2 * REPEATS,
+      "memoryBrowse called once per scoped request",
+    );
+    const nsAObserved = observed.filter((c) =>
+      c?.namespaces?.includes("ns_a"),
+    ).length;
+    const nsBObserved = observed.filter((c) =>
+      c?.namespaces?.includes("ns_b"),
+    ).length;
+    assert.equal(
+      nsAObserved,
+      REPEATS,
+      "every ns_a request observed its own scope — no bleed",
+    );
+    assert.equal(
+      nsBObserved,
+      REPEATS,
+      "every ns_b request observed its own scope — no bleed",
+    );
   } finally {
     await server.stop();
   }
@@ -2955,22 +3572,39 @@ test("HTTP allow-capability is never inherited by a concurrent deny token across
     port: 0,
     authTokenEntriesGetter: () => [
       // ALLOW: op + namespace both permitted → 200.
-      { token: "allow", capabilities: { version: 1, ops: ["memory_list"], namespaces: ["ns_allow"] } },
+      {
+        token: "allow",
+        capabilities: {
+          version: 1,
+          ops: ["memory_list"],
+          namespaces: ["ns_allow"],
+        },
+      },
       // DENY (op-level): empty ops → 403 at the op-gate.
       { token: "deny-all", capabilities: { version: 1, ops: [] } },
       // DENY (namespace-level): op permitted but scoped to a DIFFERENT
       // namespace ("ns_other") than the request ("ns_allow") → 403 at the
       // namespace-gate. The ONLY way this becomes 200 is by inheriting the
       // allow token's ns_allow cap — exactly the bleed run() prevents.
-      { token: "deny-ns", capabilities: { version: 1, ops: ["memory_list"], namespaces: ["ns_other"] } },
+      {
+        token: "deny-ns",
+        capabilities: {
+          version: 1,
+          ops: ["memory_list"],
+          namespaces: ["ns_other"],
+        },
+      },
     ],
     adminConsoleEnabled: false,
   });
   const status = await server.start();
   const get = (token: string, namespace: string) =>
-    fetch(`http://127.0.0.1:${status.port}/engram/v1/memories?namespace=${namespace}`, {
-      headers: { authorization: `Bearer ${token}` },
-    });
+    fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/memories?namespace=${namespace}`,
+      {
+        headers: { authorization: `Bearer ${token}` },
+      },
+    );
   try {
     const REPEATS = 15;
     const batch: Promise<Response>[] = [];
@@ -2980,13 +3614,22 @@ test("HTTP allow-capability is never inherited by a concurrent deny token across
       batch.push(get("deny-ns", "ns_allow")); // 3i+2 → 403 (namespace-gate)
     }
     const responses = await Promise.all(batch);
-    const allowStatuses = responses.filter((_, i) => i % 3 === 0).map((r) => r.status);
-    const denyAllStatuses = responses.filter((_, i) => i % 3 === 1).map((r) => r.status);
-    const denyNsStatuses = responses.filter((_, i) => i % 3 === 2).map((r) => r.status);
+    const allowStatuses = responses
+      .filter((_, i) => i % 3 === 0)
+      .map((r) => r.status);
+    const denyAllStatuses = responses
+      .filter((_, i) => i % 3 === 1)
+      .map((r) => r.status);
+    const denyNsStatuses = responses
+      .filter((_, i) => i % 3 === 2)
+      .map((r) => r.status);
 
     // ALLOW requests succeed (200) — the caps DID resolve correctly and the
     // service read happened under the allow scope.
-    assert.ok(allowStatuses.every((s) => s === 200), `allow token should all be 200: ${JSON.stringify(allowStatuses)}`);
+    assert.ok(
+      allowStatuses.every((s) => s === 200),
+      `allow token should all be 200: ${JSON.stringify(allowStatuses)}`,
+    );
 
     // NON-INHERITANCE: in the SAME interleaved batch where allow got 200, every
     // deny request stayed 403 — neither deny token ever inherited the allow
@@ -3006,7 +3649,11 @@ test("HTTP allow-capability is never inherited by a concurrent deny token across
 
     // Only allow requests reached the service; the store read after the async
     // yield carried the allow token's namespace every time — zero deny bleed.
-    assert.equal(observed.length, REPEATS, "only allow requests reached the service");
+    assert.equal(
+      observed.length,
+      REPEATS,
+      "only allow requests reached the service",
+    );
     assert.ok(
       observed.every((c) => c?.namespaces?.includes("ns_allow")),
       "every service read carried the allow token's namespace — no deny bleed",
@@ -3033,7 +3680,9 @@ test("HTTP chat/message gates the NEW session's namespace — scoped token canno
         chat: { ...DEFAULT_CHAT_CONFIG, enabled: true },
       }),
       memoryDir: dir,
-      fallbackLlmRef: { chatCompletion: async () => ({ content: "stub reply" }) },
+      fallbackLlmRef: {
+        chatCompletion: async () => ({ content: "stub reply" }),
+      },
       localLlmRef: null,
       memoryGet: () => Promise.resolve(null),
       memoryTimeline: () => Promise.resolve([]),
@@ -3050,9 +3699,23 @@ test("HTTP chat/message gates the NEW session's namespace — scoped token canno
       port: 0,
       authTokenEntriesGetter: () => [
         // scoped to ns_a (NOT the server default) — must be denied a new chat.
-        { token: "scoped-ns-a", capabilities: { version: 1, ops: ["chat_message"], namespaces: ["ns_a"] } },
+        {
+          token: "scoped-ns-a",
+          capabilities: {
+            version: 1,
+            ops: ["chat_message"],
+            namespaces: ["ns_a"],
+          },
+        },
         // scoped to the server default — may start a new chat there.
-        { token: "scoped-default", capabilities: { version: 1, ops: ["chat_message"], namespaces: ["default"] } },
+        {
+          token: "scoped-default",
+          capabilities: {
+            version: 1,
+            ops: ["chat_message"],
+            namespaces: ["default"],
+          },
+        },
       ],
       adminConsoleEnabled: false,
     });
@@ -3060,21 +3723,35 @@ test("HTTP chat/message gates the NEW session's namespace — scoped token canno
     const post = (token: string) =>
       fetch(`http://127.0.0.1:${status.port}/engram/v1/chat/message`, {
         method: "POST",
-        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json",
+        },
         body: JSON.stringify({ message: "hi" }), // no chatSessionId → NEW session
       });
     try {
       // DISALLOWED: token scoped to ns_a; the new session would land in the
       // server default ("default"), which is not in ["ns_a"] → 403.
       const denied = await post("scoped-ns-a");
-      assert.equal(denied.status, 403, "scoped-to-ns_a must not start a new chat in the default namespace");
+      assert.equal(
+        denied.status,
+        403,
+        "scoped-to-ns_a must not start a new chat in the default namespace",
+      );
 
       // ALLOWED: token scoped to the server default → gate passes → chat runs
       // and returns 200 with a reply.
       const allowed = await post("scoped-default");
-      assert.equal(allowed.status, 200, "scoped-to-default may start a new chat in the default namespace");
+      assert.equal(
+        allowed.status,
+        200,
+        "scoped-to-default may start a new chat in the default namespace",
+      );
       const allowedBody = (await allowed.json()) as { reply?: string };
-      assert.ok(allowedBody.reply && allowedBody.reply.length > 0, "allowed new chat returns a reply");
+      assert.ok(
+        allowedBody.reply && allowedBody.reply.length > 0,
+        "allowed new chat returns a reply",
+      );
     } finally {
       await server.stop();
     }
@@ -3088,7 +3765,12 @@ test("HTTP recall forwards the connector from the authorized token entry", async
   const service = {
     recall: (request: EngramAccessRecallRequest) => {
       captured = request;
-      return Promise.resolve({ context: "", count: 0, memoryIds: [], results: [] });
+      return Promise.resolve({
+        context: "",
+        count: 0,
+        memoryIds: [],
+        results: [],
+      });
     },
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
@@ -3166,19 +3848,26 @@ test("PR #1852: token rotation between authorization and write does not stamp th
   });
   const status = await server.start();
   try {
-    const res = await fetch(`http://127.0.0.1:${status.port}/engram/v1/memories`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer race_token",
-        "content-type": "application/json",
+    const res = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/memories`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer race_token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          content: "race-test memory",
+          schemaVersion: 1,
+          idempotencyKey: "race-key-1852",
+        }),
       },
-      body: JSON.stringify({
-        content: "race-test memory",
-        schemaVersion: 1,
-        idempotencyKey: "race-key-1852",
-      }),
-    });
-    assert.equal(res.status, 201, "memory_store must succeed with a valid entry token");
+    );
+    assert.equal(
+      res.status,
+      201,
+      "memory_store must succeed with a valid entry token",
+    );
 
     // The provenance must come from the entry that AUTHORIZED the request
     // ("chatgpt"), not from the rotated store ("codex-cli").
@@ -3189,7 +3878,11 @@ test("PR #1852: token rotation between authorization and write does not stamp th
     );
     // The getter must have been called only once — the matched entry is
     // cached per-request.
-    assert.equal(getterCalls, 1, "authTokenEntriesGetter must be called once (cached per-request)");
+    assert.equal(
+      getterCalls,
+      1,
+      "authTokenEntriesGetter must be called once (cached per-request)",
+    );
   } finally {
     await server.stop();
   }
@@ -3220,23 +3913,28 @@ test("PR #1852: static operator token has no connector provenance under rotation
     service,
     port: 0,
     authToken: "operator-static",
-    authTokenEntriesGetter: () => [{ token: "operator-static", connector: "chatgpt" }],
+    authTokenEntriesGetter: () => [
+      { token: "operator-static", connector: "chatgpt" },
+    ],
     adminConsoleEnabled: false,
   });
   const status = await server.start();
   try {
-    const res = await fetch(`http://127.0.0.1:${status.port}/engram/v1/memories`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer operator-static",
-        "content-type": "application/json",
+    const res = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/memories`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer operator-static",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          content: "operator-token memory",
+          schemaVersion: 1,
+          idempotencyKey: "static-key-1852",
+        }),
       },
-      body: JSON.stringify({
-        content: "operator-token memory",
-        schemaVersion: 1,
-        idempotencyKey: "static-key-1852",
-      }),
-    });
+    );
     assert.equal(res.status, 201);
     assert.equal(
       capturedSourceConnector,
@@ -3253,8 +3951,15 @@ test("HTTP namespace/writable preflight returns the structured writability resul
   // for any principal; a foreign namespace with no policy is not. A rejection
   // is a valid 200 answer (read via `ok`), not an HTTP error.
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-test", defaultNamespace: "default" }),
-    namespaceWritablePreflight: async ({ namespace }: { namespace?: string }) =>
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-preflight-test",
+      defaultNamespace: "default",
+    }),
+    namespaceWritablePreflight: async ({
+      namespace,
+    }: {
+      namespace?: string;
+    }) =>
       namespace && namespace !== "default"
         ? { ok: false as const, reason: "not_writable" as const, namespace }
         : { ok: true as const, namespace: "default" },
@@ -3298,7 +4003,10 @@ test("HTTP namespace/writable forwards project context to the scoped write prefl
       }
     | undefined;
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-context", defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-preflight-context",
+      defaultNamespace: "default",
+    }),
     namespaceWritablePreflight: async (request: {
       namespace?: string;
       sessionKey?: string;
@@ -3322,7 +4030,10 @@ test("HTTP namespace/writable forwards project context to the scoped write prefl
       `http://127.0.0.1:${status.port}/engram/v1/namespace/writable?session=s-1&projectTag=Acme%2FWebshop&cwd=%2Ftmp%2Frepo`,
       { headers: { authorization: "Bearer test-token" } },
     );
-    assert.deepEqual(await response.json(), { ok: true, namespace: "derived-project-namespace" });
+    assert.deepEqual(await response.json(), {
+      ok: true,
+      namespace: "derived-project-namespace",
+    });
     assert.deepEqual(received, {
       namespace: undefined,
       sessionKey: "s-1",
@@ -3337,7 +4048,10 @@ test("HTTP namespace/writable forwards project context to the scoped write prefl
 
 test("HTTP namespace/writable checks token scope against the effective scoped namespace", async () => {
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-effective", defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-preflight-effective",
+      defaultNamespace: "default",
+    }),
     namespaceWritablePreflight: async () => ({
       ok: true as const,
       namespace: "principal-project-derived",
@@ -3347,7 +4061,10 @@ test("HTTP namespace/writable checks token scope against the effective scoped na
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "default-only", capabilities: { version: 1, ops: ["observe"], namespaces: ["default"] } },
+      {
+        token: "default-only",
+        capabilities: { version: 1, ops: ["observe"], namespaces: ["default"] },
+      },
     ],
     adminConsoleEnabled: false,
   });
@@ -3370,16 +4087,31 @@ test("HTTP namespace/writable checks token scope against the effective scoped na
 
 test("HTTP namespace/writable preflight admits write-scoped tokens and rejects read-only ops", async () => {
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-preflight-ops-test", defaultNamespace: "default" }),
-    namespaceWritablePreflight: async () => ({ ok: true as const, namespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-preflight-ops-test",
+      defaultNamespace: "default",
+    }),
+    namespaceWritablePreflight: async () => ({
+      ok: true as const,
+      namespace: "default",
+    }),
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "write-scoped", capabilities: { version: 1, ops: ["observe", "memory_store"] } },
-      { token: "store-only", capabilities: { version: 1, ops: ["memory_store"] } },
-      { token: "diagnostic-only", capabilities: { version: 1, ops: ["namespace_writable"] } },
+      {
+        token: "write-scoped",
+        capabilities: { version: 1, ops: ["observe", "memory_store"] },
+      },
+      {
+        token: "store-only",
+        capabilities: { version: 1, ops: ["memory_store"] },
+      },
+      {
+        token: "diagnostic-only",
+        capabilities: { version: 1, ops: ["namespace_writable"] },
+      },
       { token: "read-only", capabilities: { version: 1, ops: ["recall"] } },
     ],
     adminConsoleEnabled: false,
@@ -3443,16 +4175,31 @@ test("HTTP meetings build enforces the per-principal write rate limit (issue #19
     const build = () =>
       fetch(`http://127.0.0.1:${status.port}/engram/v1/meetings/build`, {
         method: "POST",
-        headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
         body: JSON.stringify({ date: "2026-03-10" }),
       });
     const first = await build();
-    assert.equal(first.status, 200, "the first build is within the write quota");
+    assert.equal(
+      first.status,
+      200,
+      "the first build is within the write quota",
+    );
     const second = await build();
-    assert.equal(second.status, 429, "the second build exceeds the per-principal write quota");
-    const rateLimited = await second.json() as { code?: string };
+    assert.equal(
+      second.status,
+      429,
+      "the second build exceeds the per-principal write quota",
+    );
+    const rateLimited = (await second.json()) as { code?: string };
     assert.equal(rateLimited.code, "write_rate_limited");
-    assert.equal(builds, 1, "the rate-limited build never reached the service (no persist/reindex)");
+    assert.equal(
+      builds,
+      1,
+      "the rate-limited build never reached the service (no persist/reindex)",
+    );
   } finally {
     await server.stop();
   }
@@ -3480,7 +4227,10 @@ test("HTTP-MCP extraction force-flush aliases consume the write quota", async ()
   const status = await server.start();
   try {
     const responses: Response[] = [];
-    for (const name of ["remnic.extraction_force_flush", "engram.extraction_force_flush"]) {
+    for (const name of [
+      "remnic.extraction_force_flush",
+      "engram.extraction_force_flush",
+    ]) {
       responses.push(
         await fetch(`http://127.0.0.1:${status.port}/mcp`, {
           method: "POST",
@@ -3510,9 +4260,214 @@ test("HTTP-MCP extraction force-flush aliases consume the write quota", async ()
     assert.equal(first.status, 200);
     await first.text();
     assert.equal(second.status, 429);
-    const rateLimited = await second.json() as { code?: string };
+    const rateLimited = (await second.json()) as { code?: string };
     assert.equal(rateLimited.code, "write_rate_limited");
-    assert.equal(flushes, 1, "the rate-limited alias must not reach the service");
+    assert.equal(
+      flushes,
+      1,
+      "the rate-limited alias must not reach the service",
+    );
+  } finally {
+    await server.stop();
+  }
+});
+
+test("concurrent support-passport MCP writes reserve quota before dispatch", async () => {
+  const firstStarted = Promise.withResolvers<void>();
+  const secondStarted = Promise.withResolvers<void>();
+  const releaseWrites = Promise.withResolvers<void>();
+  let writes = 0;
+  let requestId = 0;
+  const service = {
+    supportPassportGenerateDrafts: async () => {
+      writes += 1;
+      if (writes === 1) firstStarted.resolve();
+      if (writes === 2) secondStarted.resolve();
+      await releaseWrites.promise;
+      return [];
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+  const status = await server.start();
+  const generate = () =>
+    fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: ++requestId,
+        method: "tools/call",
+        params: {
+          name: "remnic.support_passport_drafts_generate",
+          arguments: {
+            sourceMemoryIds: ["memory-1"],
+            sourceMemoryRevisions: [
+              { memoryId: "memory-1", revision: "a".repeat(64) },
+            ],
+            consent: true,
+          },
+        },
+      }),
+    });
+  try {
+    const firstRequest = generate();
+    await firstStarted.promise;
+    const secondRequest = generate();
+    const secondOutcome = await Promise.race([
+      secondRequest.then(() => "rate-limited" as const),
+      secondStarted.promise.then(() => "dispatched" as const),
+    ]);
+    assert.equal(secondOutcome, "rate-limited");
+    releaseWrites.resolve();
+    const [first, second] = await Promise.all([firstRequest, secondRequest]);
+    assert.equal(first.status, 200);
+    assert.equal(second.status, 429);
+    assert.equal(writes, 1);
+  } finally {
+    releaseWrites.resolve();
+    await server.stop();
+  }
+});
+
+test("support-passport MCP keeps reserved quota when generated drafts commit before failure", async () => {
+  let writes = 0;
+  let requestId = 0;
+  const service = {
+    supportPassportGenerateDrafts: async (
+      _principal: string,
+      input: { onCommitted?: () => void },
+    ) => {
+      writes += 1;
+      input.onCommitted?.();
+      throw new SupportPassportError(
+        "state_conflict",
+        "Draft cleanup failed.",
+        409,
+      );
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+  const status = await server.start();
+  const generate = () =>
+    fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: ++requestId,
+        method: "tools/call",
+        params: {
+          name: "remnic.support_passport_drafts_generate",
+          arguments: {
+            sourceMemoryIds: ["memory-1"],
+            sourceMemoryRevisions: [
+              { memoryId: "memory-1", revision: "a".repeat(64) },
+            ],
+            consent: true,
+          },
+        },
+      }),
+    });
+  try {
+    const first = await generate();
+    assert.equal(first.status, 200);
+    assert.equal(
+      ((await first.json()) as { result?: { isError?: boolean } }).result
+        ?.isError,
+      true,
+    );
+    assert.equal(
+      (await generate()).status,
+      429,
+      "the committed draft keeps its reserved MCP quota slot",
+    );
+    assert.equal(writes, 1);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("support-passport MCP applies the write quota to share-link revocation", async () => {
+  let drafts = 0;
+  let revocations = 0;
+  const service = {
+    supportPassportEnabled: true,
+    supportPassportCreateManualDraft: async () => {
+      drafts += 1;
+      return { cardId: "card-one" };
+    },
+    supportPassportRevokeGrant: async () => {
+      revocations += 1;
+      return {
+        grantId: "grant-one",
+        revokedAt: "2026-08-11T12:05:00.000Z",
+        version: 2,
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+  const status = await server.start();
+  const call = (name: string, args: Record<string, unknown>, id: number) =>
+    fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method: "tools/call",
+        params: { name, arguments: args },
+      }),
+    });
+  try {
+    const draft = await call(
+      "remnic.support_passport_draft_create",
+      {
+        title: "Plan changes",
+        statement: "Tell me before plans change.",
+        category: "transitions",
+        reviewBy: "2027-02-07T12:00:00.000Z",
+      },
+      1,
+    );
+    assert.equal(draft.status, 200);
+    const revoked = await call(
+      "remnic.support_passport_grant_revoke",
+      {
+        grantId: "grant-one",
+        expectedVersion: 1,
+      },
+      2,
+    );
+    assert.equal(revoked.status, 429);
+    assert.equal(drafts, 1);
+    assert.equal(revocations, 0);
   } finally {
     await server.stop();
   }
@@ -3522,9 +4477,7 @@ test("HTTP extraction force-flush records quota after commit when cleanup fails"
   let flushes = 0;
   let committed = 0;
   const service = {
-    extractionForceFlush: async (request: {
-      onCommitted?: () => void;
-    }) => {
+    extractionForceFlush: async (request: { onCommitted?: () => void }) => {
       flushes += 1;
       request.onCommitted?.();
       committed += 1;
@@ -3554,7 +4507,7 @@ test("HTTP extraction force-flush records quota after commit when cleanup fails"
     await first.text();
     const second = await flush();
     assert.equal(second.status, 429);
-    const rateLimited = await second.json() as { code?: string };
+    const rateLimited = (await second.json()) as { code?: string };
     assert.equal(rateLimited.code, "write_rate_limited");
     assert.equal(flushes, 1);
     assert.equal(committed, 1);
@@ -3612,7 +4565,11 @@ test("HTTP-MCP extraction force-flush records quota at the commit boundary", asy
     assert.equal(second.status, 429);
     const rateLimited = (await second.json()) as { code?: string };
     assert.equal(rateLimited.code, "write_rate_limited");
-    assert.equal(flushes, 1, "the rate-limited MCP flush must not reach the service");
+    assert.equal(
+      flushes,
+      1,
+      "the rate-limited MCP flush must not reach the service",
+    );
     assert.equal(committed, 1);
   } finally {
     await server.stop();
@@ -3635,11 +4592,18 @@ test("HTTP meetings get returns 400 (not 500) for a malformed percent-encoded id
   });
   const status = await server.start();
   try {
-    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/meetings/%E0%A4%A`, {
-      headers: { authorization: "Bearer test-token" },
-    });
-    assert.equal(response.status, 400, "a malformed id is a client error, not an internal 500");
-    const errorBody = await response.json() as { code?: string };
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/meetings/%E0%A4%A`,
+      {
+        headers: { authorization: "Bearer test-token" },
+      },
+    );
+    assert.equal(
+      response.status,
+      400,
+      "a malformed id is a client error, not an internal 500",
+    );
+    const errorBody = (await response.json()) as { code?: string };
     assert.equal(errorBody.code, "invalid_request");
     assert.equal(called, 0, "the malformed id never reached the service");
   } finally {
@@ -3649,7 +4613,10 @@ test("HTTP meetings get returns 400 (not 500) for a malformed percent-encoded id
 
 test("HTTP authorization probe verifies requested operation grants without invoking operations (issue #2129)", async () => {
   const service = {
-    configRef: parseConfig({ memoryDir: "/tmp/remnic-http-authorization-probe", defaultNamespace: "default" }),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-authorization-probe",
+      defaultNamespace: "default",
+    }),
   } as unknown as EngramAccessService;
   const implicitNamespaceOperations = [
     "offline_sync_snapshot",
@@ -3668,10 +4635,19 @@ test("HTTP authorization probe verifies requested operation grants without invok
     authTokenEntriesGetter: () => [
       {
         token: "delegate-token",
-        capabilities: { version: 1, ops: ["recall", "observe", "lcm_compaction_flush"] },
+        capabilities: {
+          version: 1,
+          ops: ["recall", "observe", "lcm_compaction_flush"],
+        },
+      },
+      {
+        token: "recall-only-token",
+        capabilities: { version: 1, ops: ["recall"] },
+      },
+      {
+        token: "observe-only-token",
+        capabilities: { version: 1, ops: ["observe"] },
       },
-      { token: "recall-only-token", capabilities: { version: 1, ops: ["recall"] } },
-      { token: "observe-only-token", capabilities: { version: 1, ops: ["observe"] } },
       {
         token: "namespace-scoped-delegate-token",
         capabilities: {
@@ -3720,38 +4696,71 @@ test("HTTP authorization probe verifies requested operation grants without invok
     const query = new URLSearchParams();
     for (const operation of operations) query.append("op", operation);
     if (namespace !== undefined) query.set("namespace", namespace);
-    return fetch(`http://127.0.0.1:${status.port}/engram/v1/authorization?${query}`, {
-      headers: { authorization: `Bearer ${token}` },
-    });
+    return fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/authorization?${query}`,
+      {
+        headers: { authorization: `Bearer ${token}` },
+      },
+    );
   };
   const delegateOperations = ["recall", "observe", "lcm_compaction_flush"];
   try {
-    const authorized = await probe("delegate-token", [...delegateOperations, "recall"]);
+    const authorized = await probe("delegate-token", [
+      ...delegateOperations,
+      "recall",
+    ]);
     assert.equal(authorized.status, 200);
     assert.equal(authorized.headers.get("cache-control"), "no-store");
-    assert.deepEqual(await authorized.json(), { authorized: true, operations: delegateOperations });
+    assert.deepEqual(await authorized.json(), {
+      authorized: true,
+      operations: delegateOperations,
+    });
 
-    const alternateGrant = await probe("observe-only-token", ["namespace_writable"]);
+    const alternateGrant = await probe("observe-only-token", [
+      "namespace_writable",
+    ]);
     assert.equal(alternateGrant.status, 200);
     await alternateGrant.text();
 
-    const namespaceDiagnostic = await probe(
-      "namespace-scoped-delegate-token",
-      ["namespace_writable"],
+    const namespaceDiagnostic = await probe("namespace-scoped-delegate-token", [
+      "namespace_writable",
+    ]);
+    assert.equal(
+      namespaceDiagnostic.status,
+      200,
+      "writability diagnostics report scope in their response",
     );
-    assert.equal(namespaceDiagnostic.status, 200, "writability diagnostics report scope in their response");
     await namespaceDiagnostic.text();
 
-    const namespaceAgnostic = await probe("namespace-scoped-adapters-token", ["adapters_status"]);
-    assert.equal(namespaceAgnostic.status, 200, "namespace-free operations must not use the daemon default");
+    const namespaceAgnostic = await probe("namespace-scoped-adapters-token", [
+      "adapters_status",
+    ]);
+    assert.equal(
+      namespaceAgnostic.status,
+      200,
+      "namespace-free operations must not use the daemon default",
+    );
     await namespaceAgnostic.text();
 
-    const namespaceDenied = await probe("namespace-scoped-delegate-token", delegateOperations);
-    assert.equal(namespaceDenied.status, 403, "a scoped token must cover the daemon default namespace");
+    const namespaceDenied = await probe(
+      "namespace-scoped-delegate-token",
+      delegateOperations,
+    );
+    assert.equal(
+      namespaceDenied.status,
+      403,
+      "a scoped token must cover the daemon default namespace",
+    );
 
     for (const operation of implicitNamespaceOperations) {
-      const implicitNamespace = await probe("implicit-namespace-token", [operation]);
-      assert.equal(implicitNamespace.status, 403, `${operation} must authorize the effective namespace`);
+      const implicitNamespace = await probe("implicit-namespace-token", [
+        operation,
+      ]);
+      assert.equal(
+        implicitNamespace.status,
+        403,
+        `${operation} must authorize the effective namespace`,
+      );
       await implicitNamespace.text();
     }
     await namespaceDenied.text();
@@ -3776,7 +4785,9 @@ test("HTTP authorization probe verifies requested operation grants without invok
     );
     await resourceNamespaceProbe.text();
 
-    const fleetWide = await probe("fleet-scoped-token", ["continuity_audit_generate"]);
+    const fleetWide = await probe("fleet-scoped-token", [
+      "continuity_audit_generate",
+    ]);
     assert.equal(fleetWide.status, 403);
     assert.equal(fleetWide.headers.get("cache-control"), "no-store");
     await fleetWide.text();
@@ -3803,6 +4814,112 @@ test("HTTP authorization probe verifies requested operation grants without invok
     assert.equal(unknown.status, 400);
     assert.equal(unknown.headers.get("cache-control"), "no-store");
     await unknown.text();
+
+    for (const helperOperation of [
+      "support_passport_grant_read",
+      "support_passport_grant_ask",
+    ]) {
+      const helperOnly = await probe("delegate-token", [helperOperation]);
+      assert.equal(
+        helperOnly.status,
+        400,
+        `${helperOperation} cannot use bearer authorization probes`,
+      );
+      assert.equal(helperOnly.headers.get("cache-control"), "no-store");
+      await helperOnly.text();
+    }
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP authorization probe checks the principal-derived support passport namespace", async () => {
+  let namespaceResolutions = 0;
+  const service = {
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-passport-authorization-probe",
+      defaultNamespace: "default",
+      namespacesEnabled: true,
+      namespacePolicies: [
+        {
+          name: "owner:alice",
+          readPrincipals: ["owner:alice"],
+          writePrincipals: ["owner:alice"],
+        },
+      ],
+    }),
+    getWritableStorageForNamespace: async (
+      namespace: string | undefined,
+      principal: string | undefined,
+    ) => {
+      namespaceResolutions += 1;
+      assert.equal(namespace, undefined);
+      assert.equal(principal, "owner:alice");
+      return { namespace: "owner:alice", storage: {} as StorageManager };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    principal: "owner:alice",
+    authTokenEntriesGetter: () => [
+      {
+        token: "passport-token",
+        capabilities: {
+          version: 1,
+          ops: ["support_passport_cards_list"],
+          namespaces: ["other"],
+        },
+      },
+    ],
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/authorization?op=support_passport_cards_list&namespace=other`,
+      { headers: { authorization: "Bearer passport-token" } },
+    );
+
+    assert.equal(response.status, 403);
+    assert.equal(namespaceResolutions, 1);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP authorization probe rejects support passport access without a trusted principal", async () => {
+  let namespaceResolutions = 0;
+  const service = {
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-http-passport-principal-probe",
+      defaultNamespace: "default",
+    }),
+    getWritableStorageForNamespace: async () => {
+      namespaceResolutions += 1;
+      return { namespace: "default", storage: {} as StorageManager };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authTokenEntriesGetter: () => [
+      {
+        token: "passport-token",
+        capabilities: { version: 1, ops: ["support_passport_cards_list"] },
+      },
+    ],
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/authorization?op=support_passport_cards_list`,
+      { headers: { authorization: "Bearer passport-token" } },
+    );
+
+    assert.equal(response.status, 403);
+    assert.equal(namespaceResolutions, 0);
   } finally {
     await server.stop();
   }
@@ -3838,7 +4955,11 @@ test("HTTP capabilities explicitly advertise receiver convergence finalization",
 });
 
 test("HTTP convergence completion forwards one authenticated namespace batch refresh", async () => {
-  const calls: Array<{ namespaces: string[]; principal?: string; sourceId: string }> = [];
+  const calls: Array<{
+    namespaces: string[];
+    principal?: string;
+    sourceId: string;
+  }> = [];
   const service = {
     offlineSyncFinalizeConvergence: async (options: {
       namespaces: string[];
@@ -3856,7 +4977,8 @@ test("HTTP convergence completion forwards one authenticated namespace batch ref
     principal: "writer",
     adminConsoleEnabled: false,
   });
-  const route = "/remnic/v1/offline-sync/convergence-complete?namespace=team&namespace=shared";
+  const route =
+    "/remnic/v1/offline-sync/convergence-complete?namespace=team&namespace=shared";
 
   const status = await server.start();
   try {
@@ -3879,11 +5001,13 @@ test("HTTP convergence completion forwards one authenticated namespace batch ref
       namespaces: ["team", "shared"],
       refreshed: true,
     });
-    assert.deepEqual(calls, [{
-      namespaces: ["team", "shared"],
-      principal: "writer",
-      sourceId: "remnic-converge",
-    }]);
+    assert.deepEqual(calls, [
+      {
+        namespaces: ["team", "shared"],
+        principal: "writer",
+        sourceId: "remnic-converge",
+      },
+    ]);
   } finally {
     await server.stop();
   }
@@ -3901,21 +5025,31 @@ test("HTTP convergence completion accepts either receiver mutation grant", async
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "file-token", capabilities: { version: 1, ops: ["offline_sync_apply_file_content"] } },
-      { token: "delete-token", capabilities: { version: 1, ops: ["offline_sync_apply"] } },
-      { token: "read-token", capabilities: { version: 1, ops: ["offline_sync_snapshot"] } },
+      {
+        token: "file-token",
+        capabilities: { version: 1, ops: ["offline_sync_apply_file_content"] },
+      },
+      {
+        token: "delete-token",
+        capabilities: { version: 1, ops: ["offline_sync_apply"] },
+      },
+      {
+        token: "read-token",
+        capabilities: { version: 1, ops: ["offline_sync_snapshot"] },
+      },
     ],
     adminConsoleEnabled: false,
   });
   const status = await server.start();
   const route = `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/convergence-complete?namespace=team`;
-  const complete = (token: string) => fetch(route, {
-    method: "POST",
-    headers: {
-      authorization: `Bearer ${token}`,
-      "x-remnic-source-id": encodeURIComponent("remnic-converge"),
-    },
-  });
+  const complete = (token: string) =>
+    fetch(route, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "x-remnic-source-id": encodeURIComponent("remnic-converge"),
+      },
+    });
 
   try {
     const fileResponse = await complete("file-token");
@@ -3966,9 +5100,15 @@ test("HTTP convergence completion enforces the per-principal write rate limit",
     const second = await fetch(route, requestOptions);
     assert.equal(second.status, 429);
     const rateLimited: unknown = await second.json();
-    assert.ok(rateLimited && typeof rateLimited === "object" && "code" in rateLimited);
+    assert.ok(
+      rateLimited && typeof rateLimited === "object" && "code" in rateLimited,
+    );
     assert.equal(rateLimited.code, "write_rate_limited");
-    assert.equal(completions, 1, "the rate-limited completion must not reach the service");
+    assert.equal(
+      completions,
+      1,
+      "the rate-limited completion must not reach the service",
+    );
   } finally {
     await server.stop();
   }
@@ -3991,7 +5131,10 @@ test("HTTP convergence completion denies scoped tokens that omit the namespace",
     service,
     port: 0,
     authTokenEntriesGetter: () => [
-      { token: "scoped-token", capabilities: { version: 1, namespaces: ["team"] } },
+      {
+        token: "scoped-token",
+        capabilities: { version: 1, namespaces: ["team"] },
+      },
     ],
     adminConsoleEnabled: false,
   });
@@ -4011,14 +5154,20 @@ test("HTTP convergence completion denies scoped tokens that omit the namespace",
 
     assert.equal(response.status, 403);
     await response.text();
-    assert.equal(completions, 0, "the denied completion must not reach the service");
+    assert.equal(
+      completions,
+      0,
+      "the denied completion must not reach the service",
+    );
   } finally {
     await server.stop();
   }
 });
 
 test("HTTP external wiki search aliases return the same cited result", async () => {
-  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-http-external-wiki-"));
+  const rootDir = await mkdtemp(
+    path.join(os.tmpdir(), "remnic-http-external-wiki-"),
+  );
   await mkdir(path.join(rootDir, "wiki"), { recursive: true });
   await writeFile(
     path.join(rootDir, "INDEX.md"),
@@ -4032,15 +5181,17 @@ test("HTTP external wiki search aliases return the same cited result", async ()
   );
   const service = {
     configRef: {
-      externalWikis: [{
-        id: "planning",
-        rootDir,
-        enabled: true,
-        pagesDir: "wiki",
-        indexFile: "INDEX.md",
-        indexInQmd: false,
-        includeInDefaultRecall: false,
-      }],
+      externalWikis: [
+        {
+          id: "planning",
+          rootDir,
+          enabled: true,
+          pagesDir: "wiki",
+          indexFile: "INDEX.md",
+          indexInQmd: false,
+          includeInDefaultRecall: false,
+        },
+      ],
     },
   } as unknown as EngramAccessService;
   const server = new EngramAccessHttpServer({
@@ -4054,38 +5205,48 @@ test("HTTP external wiki search aliases return the same cited result", async ()
   try {
     let canonicalBody: unknown;
     for (const prefix of ["remnic", "engram"]) {
-      const response = await fetch(`http://127.0.0.1:${status.port}/${prefix}/v1/external-wikis/search`, {
-        method: "POST",
-        headers: {
-          authorization: "Bearer test-token",
-          "content-type": "application/json",
+      const response = await fetch(
+        `http://127.0.0.1:${status.port}/${prefix}/v1/external-wikis/search`,
+        {
+          method: "POST",
+          headers: {
+            authorization: "Bearer test-token",
+            "content-type": "application/json",
+          },
+          body: JSON.stringify({
+            query: "deterministic planner",
+            wikiId: "planning",
+            limit: 2,
+            maxCharsPerHit: 200,
+          }),
         },
-        body: JSON.stringify({
-          query: "deterministic planner",
-          wikiId: "planning",
-          limit: 2,
-          maxCharsPerHit: 200,
-        }),
-      });
+      );
       assert.equal(response.status, 200);
       const body: unknown = await response.json();
       if (canonicalBody === undefined) canonicalBody = body;
       else assert.deepEqual(body, canonicalBody);
     }
-    assert.ok(canonicalBody && typeof canonicalBody === "object" && "hits" in canonicalBody);
+    assert.ok(
+      canonicalBody &&
+        typeof canonicalBody === "object" &&
+        "hits" in canonicalBody,
+    );
     assert.ok(Array.isArray(canonicalBody.hits));
     const firstHit = canonicalBody.hits[0];
     assert.ok(firstHit && typeof firstHit === "object" && "path" in firstHit);
     assert.equal(firstHit.path, "wiki/planning.md");
 
-    const invalid = await fetch(`http://127.0.0.1:${status.port}/remnic/v1/external-wikis/search`, {
-      method: "POST",
-      headers: {
-        authorization: "Bearer test-token",
-        "content-type": "application/json",
+    const invalid = await fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/external-wikis/search`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ query: "  " }),
       },
-      body: JSON.stringify({ query: "  " }),
-    });
+    );
     assert.equal(invalid.status, 400);
   } finally {
     await server.stop();
@@ -4100,7 +5261,13 @@ test("HTTP memory search aliases dispatch the boundary operation identically", a
       calls.push(request);
       return {
         query: request.query,
-        results: [{ path: "facts/alice.md", score: 0.71, snippet: "alice prefers dark mode" }],
+        results: [
+          {
+            path: "facts/alice.md",
+            score: 0.71,
+            snippet: "alice prefers dark mode",
+          },
+        ],
         count: 1,
       };
     },
@@ -4116,22 +5283,36 @@ test("HTTP memory search aliases dispatch the boundary operation identically", a
   try {
     let canonicalBody: unknown;
     for (const prefix of ["engram", "remnic"]) {
-      const response = await fetch(`http://127.0.0.1:${status.port}/${prefix}/v1/memories/search`, {
-        method: "POST",
-        headers: {
-          authorization: "Bearer test-token",
-          "content-type": "application/json",
+      const response = await fetch(
+        `http://127.0.0.1:${status.port}/${prefix}/v1/memories/search`,
+        {
+          method: "POST",
+          headers: {
+            authorization: "Bearer test-token",
+            "content-type": "application/json",
+          },
+          body: JSON.stringify({ query: "dark mode", maxResults: 3 }),
         },
-        body: JSON.stringify({ query: "dark mode", maxResults: 3 }),
-      });
+      );
       assert.equal(response.status, 200);
       const body: unknown = await response.json();
       if (canonicalBody === undefined) canonicalBody = body;
-      else assert.deepEqual(body, canonicalBody, "both prefixes must return one shape");
+      else
+        assert.deepEqual(
+          body,
+          canonicalBody,
+          "both prefixes must return one shape",
+        );
     }
     assert.deepEqual(canonicalBody, {
       query: "dark mode",
-      results: [{ path: "facts/alice.md", score: 0.71, snippet: "alice prefers dark mode" }],
+      results: [
+        {
+          path: "facts/alice.md",
+          score: 0.71,
+          snippet: "alice prefers dark mode",
+        },
+      ],
       count: 1,
     });
     assert.equal(calls.length, 2);
@@ -4174,9 +5355,17 @@ test("HTTP memory search rejects an invalid body before service dispatch", async
       body: JSON.stringify(body),
     });
   try {
-    assert.equal((await post({ query: "   " })).status, 400, "blank query is rejected");
+    assert.equal(
+      (await post({ query: "   " })).status,
+      400,
+      "blank query is rejected",
+    );
     assert.equal((await post({})).status, 400, "a missing query is rejected");
-    assert.equal((await post({ query: "ok", maxResults: 0 })).status, 400, "maxResults must be >= 1");
+    assert.equal(
+      (await post({ query: "ok", maxResults: 0 })).status,
+      400,
+      "maxResults must be >= 1",
+    );
     assert.equal(
       (await post({ query: "ok", namespace: 123 })).status,
       400,
@@ -4212,11 +5401,19 @@ test("HTTP memory search enforces token op and namespace allow-lists", async ()
       { token: "wrong-op", capabilities: { version: 1, ops: ["recall"] } },
       {
         token: "wrong-namespace",
-        capabilities: { version: 1, ops: ["memory_search"], namespaces: ["other"] },
+        capabilities: {
+          version: 1,
+          ops: ["memory_search"],
+          namespaces: ["other"],
+        },
       },
       {
         token: "reader",
-        capabilities: { version: 1, ops: ["memory_search"], namespaces: ["team"] },
+        capabilities: {
+          version: 1,
+          ops: ["memory_search"],
+          namespaces: ["team"],
+        },
       },
     ],
     adminConsoleEnabled: false,
@@ -4232,14 +5429,20 @@ test("HTTP memory search enforces token op and namespace allow-lists", async ()
       body: JSON.stringify(body),
     });
   try {
-    assert.equal((await post("wrong-op", { query: "q", namespace: "team" })).status, 403);
+    assert.equal(
+      (await post("wrong-op", { query: "q", namespace: "team" })).status,
+      403,
+    );
     assert.equal(
       (await post("wrong-namespace", { query: "q", namespace: "team" })).status,
       403,
       "a body namespace outside the token allow-list must fail closed",
     );
     assert.equal(calls.length, 0, "no denied request may reach the service");
-    assert.equal((await post("reader", { query: "q", namespace: "team" })).status, 200);
+    assert.equal(
+      (await post("reader", { query: "q", namespace: "team" })).status,
+      200,
+    );
     assert.equal(calls.length, 1);
     assert.equal(
       (calls[0] as { namespace?: unknown }).namespace,
@@ -4267,9 +5470,16 @@ test("HTTP memory search binds a scoped token to one namespace instead of fannin
     authTokenEntriesGetter: () => [
       {
         token: "scoped",
-        capabilities: { version: 1, ops: ["memory_search"], namespaces: ["generalist"] },
+        capabilities: {
+          version: 1,
+          ops: ["memory_search"],
+          namespaces: ["generalist"],
+        },
+      },
+      {
+        token: "unrestricted",
+        capabilities: { version: 1, ops: ["memory_search"] },
       },
-      { token: "unrestricted", capabilities: { version: 1, ops: ["memory_search"] } },
     ],
     adminConsoleEnabled: false,
   });
@@ -4277,7 +5487,10 @@ test("HTTP memory search binds a scoped token to one namespace instead of fannin
   const post = (token: string) =>
     fetch(`http://127.0.0.1:${status.port}/engram/v1/memories/search`, {
       method: "POST",
-      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
       body: JSON.stringify({ query: "q" }),
     });
   try {
@@ -4312,7 +5525,14 @@ test("HTTP memory search forwards a validated ranking mode and trims the namespa
     port: 0,
     principal: "reader",
     authTokenEntriesGetter: () => [
-      { token: "scoped", capabilities: { version: 1, ops: ["memory_search"], namespaces: ["team"] } },
+      {
+        token: "scoped",
+        capabilities: {
+          version: 1,
+          ops: ["memory_search"],
+          namespaces: ["team"],
+        },
+      },
     ],
     adminConsoleEnabled: false,
   });
@@ -4320,17 +5540,25 @@ test("HTTP memory search forwards a validated ranking mode and trims the namespa
   const post = (body: unknown) =>
     fetch(`http://127.0.0.1:${status.port}/engram/v1/memories/search`, {
       method: "POST",
-      headers: { authorization: "Bearer scoped", "content-type": "application/json" },
+      headers: {
+        authorization: "Bearer scoped",
+        "content-type": "application/json",
+      },
       body: JSON.stringify(body),
     });
   try {
     assert.equal(
-      (await post({ query: "q", namespace: "  team  ", mode: "vector" })).status,
+      (await post({ query: "q", namespace: "  team  ", mode: "vector" }))
+        .status,
       200,
       "surrounding whitespace must not 403 a namespace the token allows",
     );
     assert.equal(calls[0]?.namespace, "team");
-    assert.equal(calls[0]?.mode, "vector", "the ranking mode reaches the service");
+    assert.equal(
+      calls[0]?.mode,
+      "vector",
+      "the ranking mode reaches the service",
+    );
     assert.equal(
       (await post({ query: "q", namespace: "team", mode: "vsearch" })).status,
       400,
@@ -4353,7 +5581,8 @@ test("HTTP memory search excludes artifacts and tops up to a full page", async (
     { path: "facts/one.md", score: 0.5, snippet: "one" },
     { path: "facts/two.md", score: 0.4, snippet: "two" },
   ];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 2,
@@ -4361,6 +5590,7 @@ test("HTTP memory search excludes artifacts and tops up to a full page", async (
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit ?? -1);
       return corpus.slice(0, limit);
@@ -4372,12 +5602,17 @@ test("HTTP memory search excludes artifacts and tops up to a full page", async (
     ["facts/one.md", "facts/two.md"],
     "a full page of real memories",
   );
-  assert.deepEqual(seen, [2, 4, 8], "doubles the candidate request until the budget is met");
+  assert.deepEqual(
+    seen,
+    [2, 4, 8],
+    "doubles the candidate request until the budget is met",
+  );
 });
 
 test("HTTP memory search stops topping up when the corpus is exhausted", async () => {
   const seen: number[] = [];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 5,
@@ -4385,6 +5620,7 @@ test("HTTP memory search stops topping up when the corpus is exhausted", async (
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit ?? -1);
       return [{ path: "facts/only.md", score: 0.5, snippet: "only" }];
@@ -4392,14 +5628,19 @@ test("HTTP memory search stops topping up when the corpus is exhausted", async (
     namespaced: async () => [],
   });
   assert.equal(results.length, 1);
-  assert.deepEqual(seen, [5], "a short page means there is nothing left to fetch");
+  assert.deepEqual(
+    seen,
+    [5],
+    "a short page means there is nothing left to fetch",
+  );
 });
 
 test("HTTP memory search omits maxResults when the caller named no budget", async () => {
   // The wire stays exactly as it was for the default request: the backend's
   // own page size, not a resolved number. Top-up rounds are explicit.
   const seen: Array<number | undefined> = [];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 3,
@@ -4407,6 +5648,7 @@ test("HTTP memory search omits maxResults when the caller named no budget", asyn
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const corpus = [
@@ -4419,12 +5661,15 @@ test("HTTP memory search omits maxResults when the caller named no budget", asyn
     },
     namespaced: async () => [],
   });
-  assert.deepEqual(seen, [undefined, 6], "first request carries no cap, the top-up does");
-  assert.deepEqual(results.map((hit) => hit.path), [
-    "facts/one.md",
-    "facts/two.md",
-    "facts/three.md",
-  ]);
+  assert.deepEqual(
+    seen,
+    [undefined, 6],
+    "first request carries no cap, the top-up does",
+  );
+  assert.deepEqual(
+    results.map((hit) => hit.path),
+    ["facts/one.md", "facts/two.md", "facts/three.md"],
+  );
 });
 
 test("HTTP memory search keeps topping up past four excluded pages", async () => {
@@ -4440,7 +5685,8 @@ test("HTTP memory search keeps topping up past four excluded pages", async () =>
     { path: "facts/two.md", score: 0.09, snippet: "two" },
   ];
   const seen: Array<number | undefined> = [];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 2,
@@ -4448,21 +5694,30 @@ test("HTTP memory search keeps topping up past four excluded pages", async () =>
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       return corpus.slice(0, limit);
     },
     namespaced: async () => [],
   });
-  assert.deepEqual(seen, [2, 4, 8, 16, 32, 64], "doubles past four rounds until the budget is met");
-  assert.deepEqual(results.map((hit) => hit.path), ["facts/one.md", "facts/two.md"]);
+  assert.deepEqual(
+    seen,
+    [2, 4, 8, 16, 32, 64],
+    "doubles past four rounds until the budget is met",
+  );
+  assert.deepEqual(
+    results.map((hit) => hit.path),
+    ["facts/one.md", "facts/two.md"],
+  );
 });
 
 test("HTTP memory search stops at the candidate ceiling", async () => {
   // A backend that always returns a full page of excluded hits must not be
   // asked for an unbounded number of candidates.
   const seen: Array<number | undefined> = [];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 1,
@@ -4470,6 +5725,7 @@ test("HTTP memory search stops at the candidate ceiling", async () => {
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: () => true,
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       return Array.from({ length: limit ?? 0 }, (_, index) => ({
@@ -4484,7 +5740,11 @@ test("HTTP memory search stops at the candidate ceiling", async () => {
   // The cap is ABSOLUTE, not a multiple of the budget: a small request whose
   // hits are all excluded still walks far enough to prove the corpus holds
   // nothing for it, then stops on the backend-safety bound.
-  assert.equal(seen.at(-1), 25_000, "the last request lands exactly on the cap");
+  assert.equal(
+    seen.at(-1),
+    25_000,
+    "the last request lands exactly on the cap",
+  );
   assert.ok(seen.length < 20, "and the loop terminates");
 });
 
@@ -4492,7 +5752,8 @@ test("HTTP memory search scales its ceiling above a large requested budget", asy
   // A fixed 1000 ceiling would stop at or below a 2000-result request, so one
   // excluded hit in the first page could never be replaced.
   const seen: Array<number | undefined> = [];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 2_000,
@@ -4500,6 +5761,7 @@ test("HTTP memory search scales its ceiling above a large requested budget", asy
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath === "artifacts/a.md",
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const size = limit ?? 0;
@@ -4515,7 +5777,11 @@ test("HTTP memory search scales its ceiling above a large requested budget", asy
     namespaced: async () => [],
   });
   assert.deepEqual(seen, [2_000, 4_000], "tops up past the requested budget");
-  assert.equal(results.length, 2_000, "the requested page is delivered in full");
+  assert.equal(
+    results.length,
+    2_000,
+    "the requested page is delivered in full",
+  );
 });
 
 test("HTTP memory search keeps the backend page size when no limit is named", async () => {
@@ -4523,7 +5789,8 @@ test("HTTP memory search keeps the backend page size when no limit is named", as
   // Treating the cap as the target made a FULL page look short and reissued
   // the query, returning 8 where the same request used to return 6.
   const seen: Array<number | undefined> = [];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 8,
@@ -4531,6 +5798,7 @@ test("HTTP memory search keeps the backend page size when no limit is named", as
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: () => false,
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const size = limit ?? 6;
@@ -4550,7 +5818,8 @@ test("HTTP memory search still tops up a thinned default page", async () => {
   // Same shape, but an excluded hit really does shorten the page: the target
   // is the backend page size, so it tops up to restore it.
   const seen: Array<number | undefined> = [];
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 8,
@@ -4558,6 +5827,7 @@ test("HTTP memory search still tops up a thinned default page", async () => {
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async (limit) => {
       seen.push(limit);
       const size = limit ?? 6;
@@ -4572,7 +5842,11 @@ test("HTTP memory search still tops up a thinned default page", async () => {
     },
     namespaced: async () => [],
   });
-  assert.deepEqual(seen, [undefined, 12], "tops up against the backend page size");
+  assert.deepEqual(
+    seen,
+    [undefined, 12],
+    "tops up against the backend page size",
+  );
   assert.equal(results.length, 6);
 });
 
@@ -4580,9 +5854,8 @@ test("search keeps archived memories but still excludes the dedicated surfaces",
   // The lifecycle reserves archived memories for explicit read/search
   // surfaces, so a ranked search must return them - while artifacts, activity
   // digests, and meeting records stay on their own paths.
-  const { isSearchExcludedPath, isGenericRecallExcludedPath } = await import(
-    "./orchestration/generic-recall-paths.js"
-  );
+  const { isSearchExcludedPath, isGenericRecallExcludedPath } =
+    await import("./orchestration/generic-recall-paths.js");
   assert.equal(
     isSearchExcludedPath("archive/2026-01/fact-1.md"),
     false,
@@ -4597,7 +5870,8 @@ test("search keeps archived memories but still excludes the dedicated surfaces",
   assert.equal(isSearchExcludedPath("artifacts/report.md"), true);
   assert.equal(isGenericRecallExcludedPath("artifacts/report.md"), true);
   // And the wiring uses the search predicate, so an archived hit survives.
-  const { runScopedMemorySearch } = await import("./access-memory-search-fanout.js");
+  const { runScopedMemorySearch } =
+    await import("./access-memory-search-fanout.js");
   const results = await runScopedMemorySearch({
     query: "q",
     budget: 5,
@@ -4605,17 +5879,22 @@ test("search keeps archived memories but still excludes the dedicated surfaces",
     authorizeScope: () => {},
     namespacesEnabled: false,
     isExcluded: (memoryPath) => isSearchExcludedPath(memoryPath),
+    filterPrivate: async (hits) => hits,
     flatCorpus: async () => [
       { path: "archive/2026-01/fact-1.md", score: 0.9, snippet: "archived" },
       { path: "artifacts/report.md", score: 0.8, snippet: "artifact" },
     ],
     namespaced: async () => [],
   });
-  assert.deepEqual(results.map((hit) => hit.path), ["archive/2026-01/fact-1.md"]);
+  assert.deepEqual(
+    results.map((hit) => hit.path),
+    ["archive/2026-01/fact-1.md"],
+  );
 });
 
 test("a collection-qualified QMD path still hits the dedicated-surface exclusions", async () => {
-  const { isSearchExcludedPath } = await import("./orchestration/generic-recall-paths.js");
+  const { isSearchExcludedPath } =
+    await import("./orchestration/generic-recall-paths.js");
   // A flat-corpus QMD transport returns `qmd://<collection>/<path>` or
   // `<collection>/<path>`. The activity predicate is root-aware, so an
   // un-stripped prefix reads as a NESTED path and the digest leaks into
@@ -4633,12 +5912,20 @@ test("a collection-qualified QMD path still hits the dedicated-surface exclusion
   // A namespaced search rewrites hits to absolute paths beneath the
   // namespace's own storage root; the digest there must be excluded too.
   assert.equal(
-    isSearchExcludedPath("/memory/namespaces/team/activity/2026-08-02.md", policy, "qmd"),
+    isSearchExcludedPath(
+      "/memory/namespaces/team/activity/2026-08-02.md",
+      policy,
+      "qmd",
+    ),
     true,
     "a digest under a namespace root is still a digest",
   );
   assert.equal(
-    isSearchExcludedPath("/memory/namespaces/team/facts/proj/activity/2026-08-02.md", policy, "qmd"),
+    isSearchExcludedPath(
+      "/memory/namespaces/team/facts/proj/activity/2026-08-02.md",
+      policy,
+      "qmd",
+    ),
     false,
     "and an ordinary nested memory under that root stays searchable",
   );
@@ -4696,10 +5983,15 @@ test("search keeps paging while the backend page is full of excluded hits", asyn
   // indistinguishable from "there is nothing else": a 1,000-row request whose
   // first 4,000 hits are artifacts stopped at 4,000 and answered empty while
   // valid memories sat at rank 4,001.
-  const { searchWithGenericExclusion } = await import("./access-memory-search-fanout.js");
+  const { searchWithGenericExclusion } =
+    await import("./access-memory-search-fanout.js");
   const corpus = [
-    ...Array.from({ length: 4_000 }, (_, index) => ({ path: `artifacts/a-${index}.md` })),
-    ...Array.from({ length: 50, }, (_, index) => ({ path: `facts/f-${index}.md` })),
+    ...Array.from({ length: 4_000 }, (_, index) => ({
+      path: `artifacts/a-${index}.md`,
+    })),
+    ...Array.from({ length: 50 }, (_, index) => ({
+      path: `facts/f-${index}.md`,
+    })),
   ];
   const limits: Array<number | undefined> = [];
   const results = await searchWithGenericExclusion({
@@ -4709,30 +6001,66 @@ test("search keeps paging while the backend page is full of excluded hits", asyn
       limits.push(limit);
       return corpus.slice(0, limit ?? corpus.length);
     },
+    filterPrivate: async (hits) => hits,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
   });
-  assert.equal(results.length, 50, "the memories behind the excluded block are returned");
-  assert.ok(limits.length > 1, "and it took more than the first page to reach them");
+  assert.equal(
+    results.length,
+    50,
+    "the memories behind the excluded block are returned",
+  );
+  assert.ok(
+    limits.length > 1,
+    "and it took more than the first page to reach them",
+  );
   assert.ok(
     limits.every((limit) => (limit ?? 0) <= 25_000),
     "while still respecting the absolute backend cap",
   );
 });
 
+test("search removes excluded paths before private-memory resolution", async () => {
+  const { searchWithGenericExclusion } = await import("./access-memory-search-fanout.js");
+  const resolved: string[] = [];
+  const results = await searchWithGenericExclusion({
+    budget: 1,
+    sendInitialLimit: true,
+    search: async () => [
+      { path: "artifacts/private.md" },
+      { path: "facts/visible.md" },
+    ],
+    filterPrivate: async (hits) => {
+      resolved.push(...hits.map((hit) => hit.path));
+      return hits;
+    },
+    isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
+  });
+  assert.deepEqual(resolved, ["facts/visible.md"]);
+  assert.deepEqual(results, [{ path: "facts/visible.md" }]);
+});
+
 test("a budget above the backend cap still gets the rows it asked for", async () => {
   // The cap protects the backend from an unbounded walk; it must never sit
   // BELOW an explicit request, or a large search returns a short page for a
   // count the operation deliberately supports.
-  const { searchWithGenericExclusion } = await import("./access-memory-search-fanout.js");
+  const { searchWithGenericExclusion } =
+    await import("./access-memory-search-fanout.js");
   const corpus = [
     { path: "artifacts/excluded.md" },
-    ...Array.from({ length: 30_000 }, (_, index) => ({ path: `facts/f-${index}.md` })),
+    ...Array.from({ length: 30_000 }, (_, index) => ({
+      path: `facts/f-${index}.md`,
+    })),
   ];
   const results = await searchWithGenericExclusion({
     budget: 30_000,
     sendInitialLimit: true,
     search: async (limit) => corpus.slice(0, limit ?? corpus.length),
+    filterPrivate: async (hits) => hits,
     isExcluded: (memoryPath) => memoryPath.startsWith("artifacts/"),
   });
-  assert.equal(results.length, 30_000, "the excluded hit was replaced, not subtracted");
+  assert.equal(
+    results.length,
+    30_000,
+    "the excluded hit was replaced, not subtracted",
+  );
 });