@remnic/core 9.3.769 → 9.3.770

package/dist/storage.js

@@ -16,19 +16,19 @@ import {
   parseFrontmatter,
   parseFrontmatterStringValue,
   serializeEntityFile
-} from "./chunk-DTTVX6EO.js";
-import "./chunk-M7XQSUBB.js";
+} from "./chunk-STN5KMSS.js";
 import "./chunk-L2B3EE7B.js";
+import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import {
+  stripAttributesSuffix
+} from "./chunk-SVOZFLIQ.js";
 import "./chunk-LTJAMRGI.js";
 import "./chunk-TKZ3AL5V.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-DQC3ZZYM.js";
-import {
-  stripAttributesSuffix
-} from "./chunk-SVOZFLIQ.js";
 import "./chunk-JS2HKKOK.js";
 import "./chunk-AWJ2FHCF.js";
 import "./chunk-42JKGUFJ.js";
@@ -40,9 +40,9 @@ import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-YTU7WKYN.js";
 import "./chunk-AAD2ZS6P.js";
+import "./chunk-G7D6GZ5J.js";
 import "./chunk-VF4XKTX3.js";
 import "./chunk-W5H6ZRPT.js";
-import "./chunk-G7D6GZ5J.js";
 import "./chunk-VUA4S7P6.js";
 import "./chunk-IQVQJJL7.js";
 import "./chunk-L2EXJQJP.js";
@@ -55,13 +55,13 @@ import "./chunk-5GKPFL3S.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";
-import "./chunk-6MKAMLQL.js";
-import "./chunk-JAKIDQB2.js";
 import "./chunk-NU3CSQ4H.js";
 import "./chunk-J2HSAU72.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VS2IYZRU.js";
+import "./chunk-6MKAMLQL.js";
+import "./chunk-JAKIDQB2.js";
 import "./chunk-PZ5AY32C.js";
 export {
   ContentHashIndex,

package/dist/verified-recall.js

@@ -1,19 +1,19 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-N4ZA2I7M.js";
+} from "./chunk-5ACKQLGA.js";
 import "./chunk-7FL4CNPV.js";
-import "./chunk-DTTVX6EO.js";
-import "./chunk-M7XQSUBB.js";
+import "./chunk-STN5KMSS.js";
 import "./chunk-L2B3EE7B.js";
+import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-SVOZFLIQ.js";
 import "./chunk-LTJAMRGI.js";
 import "./chunk-TKZ3AL5V.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-DQC3ZZYM.js";
-import "./chunk-SVOZFLIQ.js";
 import "./chunk-JS2HKKOK.js";
 import "./chunk-AWJ2FHCF.js";
 import "./chunk-42JKGUFJ.js";
@@ -25,9 +25,9 @@ import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-YTU7WKYN.js";
 import "./chunk-AAD2ZS6P.js";
+import "./chunk-G7D6GZ5J.js";
 import "./chunk-VF4XKTX3.js";
 import "./chunk-W5H6ZRPT.js";
-import "./chunk-G7D6GZ5J.js";
 import "./chunk-VUA4S7P6.js";
 import "./chunk-IQVQJJL7.js";
 import "./chunk-L2EXJQJP.js";
@@ -40,14 +40,14 @@ import "./chunk-5GKPFL3S.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";
-import "./chunk-6MKAMLQL.js";
-import "./chunk-JAKIDQB2.js";
-import "./chunk-ZBJMUXZH.js";
 import "./chunk-NU3CSQ4H.js";
 import "./chunk-J2HSAU72.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VS2IYZRU.js";
+import "./chunk-6MKAMLQL.js";
+import "./chunk-JAKIDQB2.js";
+import "./chunk-ZBJMUXZH.js";
 import "./chunk-PZ5AY32C.js";
 export {
   compareVerifiedEpisodeResults,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.769",
+  "version": "9.3.770",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3000,7 +3000,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.769"
+    "@remnic/coding-graph": "^9.3.770"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-boundary.ts

@@ -147,6 +147,7 @@ export type OperationName =
   | "offline_sync_apply"
   | "lcm_status"
   | "memory_list"
+  | "recall_timings"
   | "entity_list"
   | "maintenance_status"
   | "quality_status"
@@ -178,6 +179,7 @@ export type OperationName =
 export interface OperationContext {
   readonly service: EngramAccessService;
   readonly authenticatedPrincipal?: string;
+  readonly operatorPrincipal?: string;
   readonly hooks?: OperationHooks;
 }
 

package/src/access-errors.ts

@@ -0,0 +1,2 @@
+/** Authenticated caller lacks the required authorization (HTTP 403). */
+export class EngramAccessForbiddenError extends Error {}

package/src/access-http.ts

@@ -8,7 +8,13 @@ import { fileURLToPath, URL } from "node:url";
 import { gunzipSync } from "node:zlib";
 import { log } from "./logger.js";
 import { abortError, isAbortError } from "./abort-error.js";
-import { EngramAccessInputError, type EngramAccessService, type EngramAccessMemoryResponse, type EngramAccessWriteResponse } from "./access-service.js";
+import { EngramAccessForbiddenError } from "./access-errors.js";
+import {
+  EngramAccessInputError,
+  type EngramAccessService,
+  type EngramAccessMemoryResponse,
+  type EngramAccessWriteResponse,
+} from "./access-service.js";
 import { CorrectionContractError } from "./correction/correction-contract.js";
 import { WearablesInputError } from "./wearables/errors.js";
 import { EngramMcpServer, MCP_SUPPORTED_PROTOCOL_VERSIONS } from "./access-mcp.js";
@@ -451,6 +457,10 @@ export class EngramAccessHttpServer {
             this.respondJson(res, 400, { error: err.message, code: "input_error" });
             return;
           }
+          if (err instanceof EngramAccessForbiddenError) {
+            this.respondJson(res, 403, { error: err.message, code: "forbidden" });
+            return;
+          }
           if (err instanceof CorrectionContractError) {
             this.respondJson(res, 400, { error: err.message, code: "correction_contract_error" });
             return;
@@ -1769,6 +1779,27 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    if (req.method === "GET" && pathname === "/engram/v1/recall/timings") {
+      const op = getOperation("recall_timings"); // boundary dispatch (issue #1830)
+      if (!op) {
+        throw new Error("access-boundary: operation not registered: recall_timings");
+      }
+      // Live diagnostic route; no response (success or denial) is cacheable.
+      // Set before dispatch so the 403 path carries the header too.
+      res.setHeader("cache-control", "no-store");
+      // Dispatch through the registered operation so the HTTP route and the
+      // boundary registration share one gate. The server's own principal is
+      // the transport-level operator fallback; a configured
+      // agentAccessHttp.principal outranks it.
+      const output = (await op.run({}, {
+        service: this.service,
+        authenticatedPrincipal: this.resolveRequestPrincipal(req),
+        operatorPrincipal: this.authenticatedPrincipal,
+      })) as { result: unknown };
+      this.respondJson(res, 200, output.result);
+      return;
+    }
+
     const memoryMatch = pathname.match(/^\/engram\/v1\/memories\/([^/]+)$/);
     if (req.method === "GET" && memoryMatch) {
       const memoryId = decodeURIComponent(memoryMatch[1] ?? "");

package/src/access-operations-batch.ts

@@ -14,10 +14,12 @@ import { z } from "zod";
 import type { DreamsPhase, RecallDisclosure, RecallPlanMode } from "./types.js";
 import type { RemnicChatGptMemoryInspectorInput } from "./mcp-memory-inspector-app.js";
 import { defineOperation } from "./access-boundary.js";
+import { EngramAccessForbiddenError } from "./access-errors.js";
 import { EngramAccessInputError, type EngramAccessService } from "./access-service.js";
 import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { expandTildePath } from "./utils/path.js";
 import { resolvePrincipal } from "./namespaces/principal.js";
+import { getRecallTimingStatus, isRecallTimingsOperator } from "./recall-timings.js";
 import { validateBriefingFormat } from "./briefing.js";
 import {
   buildChatGptMemoryInspectorActionRequest,
@@ -254,6 +256,23 @@ defineOperation({ name: "offline_sync_apply_file_content", description: "Apply f
 defineOperation({ name: "offline_sync_apply", description: "Apply sync.", schema: strictSchema({ changeset: z.unknown().optional(), namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.offlineSyncApply({ changeset: input.changeset, namespace: optStr(input.namespace), principal: ctx.authenticatedPrincipal }) }) });
 defineOperation({ name: "lcm_status", description: "LCM status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.lcmStatus() }) });
 defineOperation({ name: "memory_list", description: "List memories.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.memoryBrowse() }) });
+defineOperation({
+  name: "recall_timings",
+  description: "List recent recall timings.",
+  schema: strictSchema({}),
+  handler: async (_input, ctx) => {
+    if (
+      !isRecallTimingsOperator(
+        ctx.service.configRef,
+        ctx.authenticatedPrincipal,
+        ctx.operatorPrincipal,
+      )
+    ) {
+      throw new EngramAccessForbiddenError("recall timings require the configured operator principal");
+    }
+    return { result: getRecallTimingStatus(ctx.service.configRef) };
+  },
+});
 defineOperation({ name: "entity_list", description: "List entities.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.entityList() }) });
 defineOperation({ name: "maintenance_status", description: "Maintenance status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.maintenance() }) });
 defineOperation({ name: "quality_status", description: "Quality status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.quality() }) });

package/src/access-surface-catalog.ts

@@ -200,6 +200,7 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "POST", pathname: "/engram/v1/coding/delta", operation: "coding_delta" },
   { method: "POST", pathname: "/engram/v1/suggestions", operation: "suggestion_submit" },
   { method: "GET", pathname: "/engram/v1/memories", operation: "memory_list" },
+  { method: "GET", pathname: "/engram/v1/recall/timings", operation: "recall_timings" },
   { method: "GET", pathname: "/engram/v1/memories/:id", operation: "memory_get" },
   { method: "GET", pathname: "/engram/v1/memories/:id/timeline", operation: "memory_timeline" },
   { method: "GET", pathname: "/engram/v1/entities", operation: "entity_list" },

package/src/orchestration/recall-internal.ts

@@ -51,6 +51,7 @@ import { createRecallSectionMetricRecorder } from "../recall-qos.js";
 import { buildRecallQueryPolicy } from "../recall-query-policy.js";
 import { type GraphRecallExpandedEntry, type LastRecallBudgetSummary, type LastRecallSnapshot, LastRecallStore, RecallHandleHistoryStore } from "../recall-state.js";
 import { type RecallFilterTrace, type RecallXrayResult, type RecallXrayScoreDecomposition, type RecallXraySnapshot, buildXraySnapshot } from "../recall-xray.js";
+import { recordRecallTiming } from "../recall-timings.js";
 import { findUnresolvedEntityRefs } from "../reconstruct.js";
 import { RerankCache, rerankLocalOrNoop } from "../rerank.js";
 import { buildResponseGuidanceRecallSection, shouldRecallResponseGuidance } from "../response-guidance-recall.js";
@@ -752,6 +753,9 @@ export class RecallInternalCoordinator {
     // Catalog read touch (issue #1499) is recorded LATER — after the Phase 1
     // abort gate — so it fires only when retrieval actually runs, not for
     // aborted / short-circuited recalls.
+    const codingContext = sessionKey
+      ? this.deps.getCodingContextForSession(sessionKey)
+      : null;
     const scopePlan = resolveScopePlan({
       config: this.deps.config,
       sessionKey,
@@ -761,9 +765,7 @@ export class RecallInternalCoordinator {
           && options.principalOverride.length > 0
           ? options.principalOverride
           : undefined,
-      codingContext: sessionKey
-        ? this.deps.getCodingContextForSession(sessionKey)
-        : null,
+      codingContext,
       namespacesEnabled,
     });
     const {
@@ -867,6 +869,14 @@ export class RecallInternalCoordinator {
       const earlySessionKey = sessionKey ?? "default";
       this.deps._recallWorkspaceOverrides.delete(earlySessionKey);
       timings.total = `${Date.now() - recallStart}ms`;
+      recordRecallTiming(this.deps.config, {
+        ...timings,
+        timestamp: new Date().toISOString(),
+        namespace: selfNamespace,
+        total: timings.total,
+        recallPlan: timings.recallPlan,
+        queryPolicy: timings.queryPolicy,
+      });
       // X-ray capture for the `no_recall` early-return path
       // (issue #570 PR 1).  `no_recall` skips retrieval entirely, so
       // the snapshot carries zero results and an empty-budget accounting
@@ -5146,6 +5156,14 @@ export class RecallInternalCoordinator {
       .map(([k, v]) => `${k}=${v}`)
       .join(", ");
     log.info(`recall timings: ${timingParts}`);
+    recordRecallTiming(this.deps.config, {
+      ...timings,
+      timestamp: new Date().toISOString(),
+      namespace: selfNamespace,
+      total: timings.total,
+      recallPlan: timings.recallPlan,
+      queryPolicy: timings.queryPolicy,
+    });
 
     const assembledRecall = this.deps.assembleRecallSections(
       sectionBuckets,

package/src/recall-timings-access.test.ts

@@ -0,0 +1,301 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { getOperation } from "./access-boundary.js";
+import { EngramAccessHttpServer } from "./access-http.js";
+import { EngramAccessService } from "./access-service.js";
+import { parseConfig } from "./config.js";
+import { Orchestrator } from "./orchestrator.js";
+import {
+  getRecallTimings,
+  getRecallTimingStatus,
+  recordRecallTiming,
+  resolveRecallTimingsOperatorPrincipal,
+  type RecallTimingRecord,
+} from "./recall-timings.js";
+
+function makeConfig(memoryDir: string, overrides: Record<string, unknown> = {}) {
+  return parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    qmdEnabled: false,
+    embeddingFallbackEnabled: false,
+    recallPlannerEnabled: false,
+    sharedContextEnabled: false,
+    initGateTimeoutMs: 1000,
+    ...overrides,
+  });
+}
+
+test("authenticated recall timings route returns two recalls without user-correlatable inputs", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-recall-timings-"));
+  const config = makeConfig(memoryDir);
+  const orchestrator = new Orchestrator(config);
+  const service = new EngramAccessService(orchestrator);
+  const server = new EngramAccessHttpServer({
+    service,
+    host: "127.0.0.1",
+    port: 0,
+    authToken: "secret-token",
+    principal: "operator",
+    trustPrincipalHeader: true,
+    maxBodyBytes: 1024,
+  });
+  const started = await server.start();
+  const url = `http://${started.host}:${started.port}/engram/v1/recall/timings`;
+  try {
+    await orchestrator.recall("private first query", "private:first:session");
+    await orchestrator.recall("private second query", "private:second:session", { mode: "no_recall" });
+
+    const denied = await fetch(url);
+    assert.equal(denied.status, 401);
+
+    const nonOperator = await fetch(url, {
+      headers: {
+        Authorization: "Bearer secret-token",
+        "X-Engram-Principal": "reader",
+      },
+    });
+    assert.equal(nonOperator.status, 403);
+    assert.equal(nonOperator.headers.get("cache-control"), "no-store");
+
+    const response = await fetch(url, {
+      headers: {
+        Authorization: "Bearer secret-token",
+        "X-Engram-Principal": "operator",
+      },
+    });
+    assert.equal(response.status, 200);
+    assert.equal(response.headers.get("cache-control"), "no-store");
+    const payload = await response.json() as {
+      generatedAt: string;
+      processStartedAt: string;
+      capacity: number;
+      count: number;
+      order: string;
+      records: RecallTimingRecord[];
+    };
+    assert.ok(Number.isFinite(Date.parse(payload.generatedAt)));
+    assert.ok(Number.isFinite(Date.parse(payload.processStartedAt)));
+    assert.ok(Date.parse(payload.processStartedAt) <= Date.parse(payload.generatedAt));
+    assert.equal(payload.capacity, 50);
+    assert.equal(payload.order, "newest-first");
+    assert.equal(payload.count, 2);
+    assert.equal(payload.records.length, 2);
+    const operation = getOperation("recall_timings");
+    assert.ok(operation);
+    await assert.rejects(
+      operation.run({}, {
+        service,
+        authenticatedPrincipal: "reader",
+        operatorPrincipal: "operator",
+      }),
+      /configured operator principal/,
+    );
+    const operationOutput = await operation.run({}, {
+      service,
+      authenticatedPrincipal: "operator",
+      operatorPrincipal: "operator",
+    }) as { result: { count: number; records: RecallTimingRecord[] } };
+    // generatedAt legitimately differs between the two calls; the data must not.
+    assert.equal(operationOutput.result.count, payload.count);
+    assert.deepEqual(operationOutput.result.records, payload.records);
+    for (const record of payload.records) {
+      assert.equal(record.namespace, "default");
+      assert.ok(Number.isFinite(Date.parse(record.timestamp)));
+      assert.equal(typeof record.timingsMs.total, "number");
+      assert.ok(record.timingsMs.total >= 0);
+      assert.equal(typeof record.recallPlan, "string");
+      assert.equal(typeof record.queryPolicy, "string");
+      assert.equal("query" in record, false);
+      assert.equal("prompt" in record, false);
+      assert.equal("sessionKey" in record, false);
+      assert.equal("retrievalQuery" in record, false);
+      assert.equal("query" in record.timingsMs, false);
+      assert.equal("prompt" in record.timingsMs, false);
+    }
+  } finally {
+    await server.stop();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("recall timing history keeps only the newest 50 records", () => {
+  const config = makeConfig(path.join(os.tmpdir(), "remnic-recall-timing-ring"));
+  for (let index = 0; index < 51; index += 1) {
+    recordRecallTiming(config, {
+      timestamp: new Date(index * 1000).toISOString(),
+      namespace: "default",
+      total: index,
+      recallPlan: "full",
+      queryPolicy: "general/full",
+    });
+  }
+
+  const records = getRecallTimings(config);
+  assert.equal(records.length, 50);
+  assert.equal(records[0]?.timingsMs.total, 50);
+  assert.equal(records[49]?.timingsMs.total, 1);
+});
+
+test("operator principal resolution agrees for standalone and embedded access", () => {
+  const standaloneConfig = makeConfig(path.join(os.tmpdir(), "remnic-recall-timing-standalone"));
+  assert.equal(
+    resolveRecallTimingsOperatorPrincipal(standaloneConfig, "standalone-operator"),
+    "standalone-operator",
+  );
+
+  const embeddedConfig = makeConfig(path.join(os.tmpdir(), "remnic-recall-timing-embedded"), {
+    agentAccessHttp: {
+      enabled: true,
+      host: "127.0.0.1",
+      port: 0,
+      principal: "embedded-operator",
+      maxBodyBytes: 1024,
+    },
+  });
+  assert.equal(
+    resolveRecallTimingsOperatorPrincipal(embeddedConfig),
+    "embedded-operator",
+  );
+  assert.equal(
+    resolveRecallTimingsOperatorPrincipal(
+      embeddedConfig,
+      "fallback-transport-principal",
+    ),
+    "embedded-operator",
+  );
+});
+
+test("recall timing records expose only the fixed telemetry schema", () => {
+  const config = makeConfig(path.join(os.tmpdir(), "remnic-recall-timing-schema"));
+  recordRecallTiming(config, {
+    timestamp: new Date(0).toISOString(),
+    namespace: "default",
+    total: "7ms",
+    qmd: "3ms",
+    qmdPost: "2ms-cache",
+    recallPlan: "full",
+    queryPolicy: "general/full",
+    queryAware: "1ms;helped=private prompt detail",
+    prompt: "private prompt",
+    sessionKey: "user-session",
+    unknownTiming: "9ms",
+  });
+
+  const record = getRecallTimings(config)[0];
+  assert.deepEqual(record, {
+    timestamp: new Date(0).toISOString(),
+    namespace: "default",
+    recallPlan: "full",
+    queryPolicy: "general/full",
+    timingsMs: {
+      total: 7,
+      qmd: 3,
+      qmdPost: 2,
+    },
+  });
+});
+
+test("phases that did not run are omitted while measured zeros survive", () => {
+  const config = makeConfig(path.join(os.tmpdir(), "remnic-recall-timing-phases"));
+  recordRecallTiming(config, {
+    timestamp: new Date(0).toISOString(),
+    namespace: "default",
+    total: "5ms",
+    qmd: "0ms",
+    recallPlan: "full",
+    queryPolicy: "general/full",
+  });
+
+  const record = getRecallTimings(config)[0];
+  assert.ok(record);
+  assert.equal(record.timingsMs.qmd, 0);
+  assert.equal("qmdPost" in record.timingsMs, false);
+  assert.equal("ki" in record.timingsMs, false);
+});
+
+test("status envelope reports a stable process start and live generation time", () => {
+  const config = makeConfig(path.join(os.tmpdir(), "remnic-recall-timing-envelope"));
+  const first = getRecallTimingStatus(config);
+  const second = getRecallTimingStatus(config);
+  assert.equal(first.processStartedAt, second.processStartedAt);
+  assert.ok(Number.isFinite(Date.parse(first.processStartedAt)));
+  assert.ok(Date.parse(first.processStartedAt) <= Date.now());
+  assert.equal(first.capacity, 50);
+  assert.equal(first.order, "newest-first");
+  assert.equal(first.count, 0);
+  assert.deepEqual(first.records, []);
+});
+
+test("configured operator principal outranks a divergent server principal override", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-recall-timings-div-"));
+  const config = makeConfig(memoryDir, {
+    agentAccessHttp: {
+      enabled: true,
+      host: "127.0.0.1",
+      port: 0,
+      principal: "config-operator",
+      maxBodyBytes: 1024,
+    },
+  });
+  const orchestrator = new Orchestrator(config);
+  const service = new EngramAccessService(orchestrator);
+  const server = new EngramAccessHttpServer({
+    service,
+    host: "127.0.0.1",
+    port: 0,
+    authToken: "secret-token",
+    principal: "cli-override",
+    trustPrincipalHeader: true,
+    maxBodyBytes: 1024,
+  });
+  const started = await server.start();
+  const url = `http://${started.host}:${started.port}/engram/v1/recall/timings`;
+  try {
+    // The server's own default identity is NOT the operator when the config
+    // explicitly names a different one. Settled precedence: config first.
+    const overrideOnly = await fetch(url, {
+      headers: { Authorization: "Bearer secret-token" },
+    });
+    assert.equal(overrideOnly.status, 403);
+
+    const configOperator = await fetch(url, {
+      headers: {
+        Authorization: "Bearer secret-token",
+        "X-Engram-Principal": "config-operator",
+      },
+    });
+    assert.equal(configOperator.status, 200);
+  } finally {
+    await server.stop();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("batch context without transport operator fails closed when config names no operator", async () => {
+  const config = makeConfig(path.join(os.tmpdir(), "remnic-recall-timing-batch-closed"));
+  const orchestrator = new Orchestrator(config);
+  const service = new EngramAccessService(orchestrator);
+  const operation = getOperation("recall_timings");
+  assert.ok(operation);
+  // No config principal and no transport operator: nobody can pass the gate,
+  // not even a caller whose authenticated principal would match elsewhere.
+  await assert.rejects(
+    operation.run({}, { service, authenticatedPrincipal: "operator" }),
+    /configured operator principal/,
+  );
+  // The same caller passes once the transport supplies the operator context,
+  // as the HTTP route does by dispatching with operatorPrincipal set to the
+  // server's own principal.
+  const output = await operation.run({}, {
+    service,
+    authenticatedPrincipal: "operator",
+    operatorPrincipal: "operator",
+  }) as { result: { count: number } };
+  assert.equal(output.result.count, 0);
+});