@remnic/core 9.69.40 → 9.69.41

package/src/access-mcp.ts

@@ -1,3 +1,4 @@
+import { sharedContextMcpTools } from "./access-mcp-shared-context-tools.js";
 import { randomUUID } from "node:crypto";
 import {
   MCP_ADMIN_OPS_MIGRATED_OPERATIONS, MCP_ADMIN_OPS_TOOLS,
@@ -1301,80 +1302,9 @@ export class EngramMcpServer {
           additionalProperties: false,
         },
       },
-      // ── Shared Context / Compounding tools ────────────────────────────
-      {
-        name: "engram.shared_context_write_output",
-        description: "Write agent work product into shared-context directory for cross-agent coordination.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            agentId: { type: "string", description: "Agent ID producing this output." },
-            title: { type: "string", description: "Short title for the output." },
-            content: { type: "string", description: "Markdown content to write." },
-          },
-          required: ["agentId", "title", "content"],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.shared_feedback_record",
-        description: "Append approval/rejection decision into shared-context feedback inbox for compounding learning.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            agent: { type: "string", description: "Agent name that produced the output." },
-            decision: { type: "string", enum: ["approved", "approved_with_feedback", "rejected"] },
-            reason: { type: "string" },
-            date: { type: "string", description: "ISO timestamp. Defaults to now." },
-            learning: { type: "string" },
-            outcome: { type: "string" },
-            severity: { type: "string", enum: ["low", "medium", "high"] },
-            confidence: { type: "number", description: "Confidence 0-1." },
-            workflow: { type: "string" },
-            tags: { type: "array", items: { type: "string" } },
-            evidenceWindowStart: { type: "string" },
-            evidenceWindowEnd: { type: "string" },
-            refs: { type: "array", items: { type: "string" } },
-          },
-          required: ["agent", "decision", "reason"],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.shared_priorities_append",
-        description: "Append priorities text into shared-context inbox for curator merge.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            agentId: { type: "string" },
-            text: { type: "string", description: "Priority notes (markdown)." },
-          },
-          required: ["agentId", "text"],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.shared_context_cross_signals_run",
-        description: "Generate cross-signal markdown + JSON artifacts from agent outputs and feedback.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            date: { type: "string", description: "YYYY-MM-DD. Defaults to today." },
-          },
-          additionalProperties: false,
-        },
-      },
-      {
-        name: "engram.shared_context_curate_daily",
-        description: "Generate daily roundtable summary (deterministic baseline aggregation).",
-        inputSchema: {
-          type: "object",
-          properties: {
-            date: { type: "string", description: "YYYY-MM-DD. Defaults to today." },
-          },
-          additionalProperties: false,
-        },
-      },
+      // ── Shared Context tools (extracted; access-mcp.ts is at its ratchet
+      // ceiling — issue #2920) ─────────────────────────────────────────
+      ...sharedContextMcpTools,
       {
         name: "engram.compounding_weekly_synthesize",
         description:

package/src/access-operations-batch.ts

@@ -33,7 +33,12 @@ import {
 } from "./access-namespace-preflight.js";
 import { expandTildePath } from "./utils/path.js";
 import { resolvePrincipal } from "./namespaces/principal.js";
+import {
+  parseSharedWriteOutputControls,
+  type SharedWriteOutputControls,
+} from "./shared-context/write-output-controls.js";
 import { getRecallTimingStatus, isRecallTimingsOperator } from "./recall-timings.js";
+import { parseDeepRecallMaxSteps } from "./deep-recall-config.js";
 import { validateBriefingFormat } from "./briefing.js";
 import {
   buildChatGptMemoryInspectorActionRequest,
@@ -195,7 +200,19 @@ defineOperation({ name: "meetings_list", description: "List stored meeting recor
 defineOperation({ name: "meetings_get", description: "Get a stored meeting record by id.", schema: strictSchema({ id: S.str, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.meetingsGet(reqStr(input.id, "id"), { authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }) });
 defineOperation({ name: "meetings_build", description: "Detect + fuse + store a day's meetings.", schema: strictSchema({ date: S.str, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.meetingsBuild(reqStr(input.date, "date"), { authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }) });
 // === DEEP RECALL (issue #2332) — budgeted REFINE/EXPAND/STOP retrieval ===
-defineOperation({ name: "deep_recall", description: "Budgeted multi-hop deep recall over the anchor graph.", schema: strictSchema({ query: S.str, maxSteps: S.flexNum, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => { const q = defStr(input.query, ""); if (q.trim().length === 0) throw new EngramAccessInputError("deep_recall: query is required"); return { result: await ctx.service.deepRecall({ query: q, maxSteps: typeof input.maxSteps === "number" ? input.maxSteps : typeof input.maxSteps === "string" && Number.isFinite(Number(input.maxSteps)) ? Number(input.maxSteps) : undefined, authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey) }) }; } });
+defineOperation({ name: "deep_recall", description: "Budgeted multi-hop deep recall over the anchor graph.", schema: strictSchema({ query: S.str, maxSteps: S.flexNum, namespace: S.str, sessionKey: S.str }), handler: async (input, ctx) => {
+  const q = defStr(input.query, "");
+  if (q.trim().length === 0) throw new EngramAccessInputError("deep_recall: query is required");
+  // Strict boundary parse (issue #2915): `"abc"` must NOT silently become the
+  // configured default and `""` must NOT become 0 — both are rejected.
+  let maxSteps: number | undefined;
+  try {
+    maxSteps = parseDeepRecallMaxSteps(input.maxSteps);
+  } catch (err) {
+    throw new EngramAccessInputError(`deep_recall: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return { result: await ctx.service.deepRecall({ query: q, maxSteps, authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey), ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) }) };
+} });
 
 // === ACTION CONFIDENCE + INSPECTOR + CAPSULE ===
 defineOperation({ name: "action_confidence", description: "Action confidence.", schema: strictSchema({ intendedAction: S.str, confidence: S.num, risk: S.str, contextReadiness: S.str, currentContextScopes: S.strArr, userRules: z.array(z.unknown()).optional(), retrievedMemories: z.array(z.unknown()).optional() }), handler: async (input, ctx) => { const req: Record<string, unknown> = {}; if (input.intendedAction !== undefined) req.intendedAction = optStr(input.intendedAction); if (input.confidence !== undefined) req.confidence = optNum(input.confidence); if (input.risk !== undefined) req.risk = optStr(input.risk) as "low" | "medium" | "high" | "irreversible" | "restricted" | undefined; if (input.contextReadiness !== undefined) req.contextReadiness = optStr(input.contextReadiness) as "none" | "partial" | "sufficient" | undefined; if (input.currentContextScopes !== undefined) req.currentContextScopes = optStrArr(input.currentContextScopes); if (input.userRules !== undefined) req.userRules = input.userRules; if (input.retrievedMemories !== undefined) req.retrievedMemories = input.retrievedMemories; return { result: await ctx.service.actionConfidence(req) }; } });
@@ -306,7 +323,33 @@ defineOperation({ name: "memory_identity", description: "Memory identity.", sche
 defineOperation({ name: "work_task", description: "Manage work task.", schema: strictSchema({ action: S.str, id: S.str, title: S.str, description: S.str, status: S.str, priority: S.str, owner: S.str, assignee: S.str, projectId: S.str, tags: S.strArr, dueAt: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.workTask({ action: (optStr(input.action) as "update" | "list" | "get" | "create" | "delete" | "transition") ?? "list", id: optStr(input.id), title: optStr(input.title), description: optStr(input.description), status: optStr(input.status), priority: optStr(input.priority), owner: optStr(input.owner), assignee: optStr(input.assignee), projectId: optStr(input.projectId), tags: optStrArr(input.tags), dueAt: optStr(input.dueAt) }) }) });
 defineOperation({ name: "work_project", description: "Manage work project.", schema: strictSchema({ action: S.str, id: S.str, name: S.str, description: S.str, status: S.str, owner: S.str, tags: S.strArr, taskId: S.str, projectId: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.workProject({ action: (optStr(input.action) as "update" | "list" | "get" | "create" | "delete" | "link_task") ?? "list", id: optStr(input.id), name: optStr(input.name), description: optStr(input.description), status: optStr(input.status), owner: optStr(input.owner), tags: optStrArr(input.tags), taskId: optStr(input.taskId), projectId: optStr(input.projectId) }) }) });
 defineOperation({ name: "work_board", description: "Manage work board.", schema: strictSchema({ action: S.str, projectId: S.str, snapshotJson: S.str, linkToMemory: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.workBoard({ action: (optStr(input.action) as "export_markdown" | "export_snapshot" | "import_snapshot") ?? "export_markdown", projectId: optStr(input.projectId) ?? "", snapshotJson: optStr(input.snapshotJson) ?? "", linkToMemory: input.linkToMemory === true }) }) });
-defineOperation({ name: "shared_context_write_output", description: "Write shared output.", schema: strictSchema({ agentId: S.str, title: S.str, content: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.sharedContextWriteOutput({ agentId: optStr(input.agentId) ?? "", title: optStr(input.title) ?? "", content: optStr(input.content) ?? "", principal: ctx.authenticatedPrincipal }) }) });
+// Issue #2920: the envelope controls (authority/expiresAt/supersedes) are
+// parsed by the ONE canonical surface module shared with the OpenClaw tool
+// (write-output-controls.ts); semantics stay in composeWriteEnvelope. A
+// client-supplied principal/namespace is rejected here — identity and
+// scoping are server-resolved (ctx.authenticatedPrincipal).
+defineOperation({
+  name: "shared_context_write_output",
+  description: "Write shared output.",
+  schema: strictSchema({ agentId: S.str, title: S.str, content: S.str, authority: S.str, expiresAt: S.str, supersedes: S.str }),
+  handler: async (input, ctx) => {
+    let controls: SharedWriteOutputControls;
+    try {
+      controls = parseSharedWriteOutputControls(input);
+    } catch (error) {
+      throw new EngramAccessInputError(error instanceof Error ? error.message : String(error));
+    }
+    return {
+      result: await ctx.service.sharedContextWriteOutput({
+        agentId: optStr(input.agentId) ?? "",
+        title: optStr(input.title) ?? "",
+        content: optStr(input.content) ?? "",
+        ...controls,
+        principal: ctx.authenticatedPrincipal,
+      }),
+    };
+  },
+});
 defineOperation({ name: "shared_feedback_record", description: "Record shared feedback.", schema: strictSchema({ agent: S.str, decision: S.str, reason: S.str, date: S.str, learning: S.str, outcome: S.str, severity: S.str, confidence: S.num, workflow: S.str, tags: S.strArr, evidenceWindowStart: S.str, evidenceWindowEnd: S.str, refs: S.strArr }), handler: async (input, ctx) => { const sv = optStr(input.severity); return { result: await ctx.service.sharedFeedbackRecord({ agent: optStr(input.agent) ?? "", decision: (optStr(input.decision) as "rejected" | "approved" | "approved_with_feedback") ?? "approved", reason: optStr(input.reason) ?? "", date: optStr(input.date), learning: optStr(input.learning), outcome: optStr(input.outcome), severity: sv === "low" || sv === "medium" || sv === "high" ? sv as "low" | "medium" | "high" : undefined, confidence: optNum(input.confidence), workflow: optStr(input.workflow), tags: optStrArr(input.tags), evidenceWindowStart: optStr(input.evidenceWindowStart), evidenceWindowEnd: optStr(input.evidenceWindowEnd), refs: optStrArr(input.refs) }) }; } });
 defineOperation({ name: "shared_priorities_append", description: "Append priorities.", schema: strictSchema({ agentId: S.str, text: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.sharedPrioritiesAppend({ agentId: optStr(input.agentId) ?? "", text: optStr(input.text) ?? "" }) }) });
 defineOperation({ name: "shared_context_cross_signals_run", description: "Run cross signals.", fleetWide: true, schema: strictSchema({ date: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.sharedContextCrossSignalsRun({ date: optStr(input.date) }) }) });

package/src/access-service.ts

@@ -35,6 +35,7 @@ import { ReplicaDivergenceMonitor } from "./replica-divergence.js";
 import type { ResolveSecretRefFn } from "./resolve-auth-token.js";
 import { buildAccessWriteRequestFingerprint, buildObserveRequestFingerprint } from "./write-envelope.js";
 import { UNATTRIBUTED_ACCESS_WRITE_ORIGIN } from "./shared-context/envelope-io.js";
+import { isSharedContextWriteInputError } from "./shared-context/write-output-controls.js";
 export type { EngramAccessHealthResponse, EngramAccessQmdCollectionState, EngramAccessQmdHealthResponse };
 import { AccessAuditAdapter, type AccessAuditConfig, type AccessAuditResult } from "./access-audit.js";
 import {
@@ -2726,6 +2727,8 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
     sessionKey?: string;
     authenticatedPrincipal?: string;
     maxSteps?: number;
+    /** Transport cancellation (issue #2915): MCP tools/call cancelled, HTTP disconnect. */
+    abortSignal?: AbortSignal;
   }): Promise<DeepRecallResult & { rendered: string }> {
     const cfg = this.orchestrator.config.deepRecall;
     if (!cfg.enabled) {
@@ -2787,14 +2790,18 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
     // (which also decodes the raw collection-qualified path forms the
     // namespaces-disabled fanout returns), so no invocation pre-scans the
     // namespace corpus.
+    // The transport cancellation signal reaches the seed router, the graph
+    // read, and the policy legs (issue #2915).
     const result = await runBudgetedDeepRecall(
       {
         config: effective,
+        ...(request.abortSignal ? { signal: request.abortSignal } : {}),
         searchSeed: createDeepRecallSeedSearch({
           namespace: resolvedNamespace,
           storage,
           router: this.orchestrator,
           resolver: this.orchestrator.qmdResultResolver,
+          ...(request.abortSignal ? { signal: request.abortSignal } : {}),
         }),
         // Nodes and anchors are projected against the namespace's CURRENT
         // active memories through the SAME helper searchHarmonicRetrieval
@@ -2807,6 +2814,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
             memoryDir: storage.dir,
             abstractionNodeStoreDir: graphStoreDir,
             anchorsEnabled: true,
+            ...(request.abortSignal ? { abortSignal: request.abortSignal } : {}),
           }),
         loadMemory: async (memoryId) => {
           const memory = await storage.getMemoryById(memoryId);
@@ -2829,6 +2837,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
             localLlm: this.orchestrator.localLlm ?? null,
             fallbackLlm: this.orchestrator.fastGatewayLlm ?? null,
             timeoutMs,
+            ...(request.abortSignal ? { signal: request.abortSignal } : {}),
           }),
       },
       query
@@ -4595,6 +4604,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
     agentId: string;
     title: string;
     content: string;
+    authority?: string; expiresAt?: string; supersedes?: string;
     /** Authenticated principal resolved by the surface, never client-supplied. */
     principal?: string;
   }): Promise<unknown> {
@@ -4607,19 +4617,16 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
         agentId: request.agentId,
         title: request.title,
         content: request.content,
-        // The origin is server-owned in BOTH cases (issue #1957 review
-        // round 4): the authenticated principal when one resolved, and a
-        // reserved unattributed token otherwise — a principal-less
-        // authenticated request must never stamp the client's `agentId`
-        // as audit metadata. The client label survives only as the
-        // producer, which feeds grouping and display, never authority.
+        authority: request.authority,
+        expiresAt: request.expiresAt,
+        supersedes: request.supersedes,
         ...(request.principal
           ? { authenticatedIdentity: request.principal }
           : { unattributedOrigin: UNATTRIBUTED_ACCESS_WRITE_ORIGIN }),
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (message.startsWith("shared-context write origin mismatch")) {
+      if (isSharedContextWriteInputError(message)) {
         throw new EngramAccessInputError(message);
       }
       throw error;

package/src/activity/timeline/regenerate.test.ts

@@ -386,6 +386,54 @@ test("resolveTimelineLoadDates keeps a bounded window and expands an unbounded o
   assert.deepEqual(empty, ["2026-08-23"]);
 });
 
+test("resolveTimelineLoadDates loads the local day of a lone bound, never today (#2931)", () => {
+  const store = { snapshotCaptureExtent: () => null };
+  const base = { timezone: "UTC" as const, today: "2026-08-23", store, persistedDates: [] as string[] };
+
+  const loneTo = resolveTimelineLoadDates({
+    ...base,
+    window: { to: "2026-05-02T12:00:00.000Z" },
+  });
+  assert.deepEqual(loneTo, ["2026-05-02"], "a lone --to must load the day of the to instant, not today");
+
+  const loneFrom = resolveTimelineLoadDates({
+    ...base,
+    window: { from: "2026-05-02T12:00:00.000Z" },
+  });
+  assert.deepEqual(loneFrom, ["2026-05-02"], "a lone --from keeps loading its own day");
+
+  const futureTo = resolveTimelineLoadDates({
+    ...base,
+    window: { to: "2026-09-01T12:00:00.000Z" },
+  });
+  assert.deepEqual(futureTo, ["2026-09-01"], "a lone future --to loads that future day, not today");
+});
+
+test("resolveTimelineLoadDates resolves a lone --to day through the configured timezone (#2931)", () => {
+  const store = { snapshotCaptureExtent: () => null };
+  // 2026-08-20T23:30Z is 2026-08-21 13:30 in Kiritimati (UTC+14) but still
+  // 2026-08-20 in Adak (UTC-10): the same instant must load different local
+  // days under the two configured zones, proving the configured timezone —
+  // not UTC and not today — drives the resolution.
+  const east = resolveTimelineLoadDates({
+    window: { to: "2026-08-20T23:30:00.000Z" },
+    timezone: "Pacific/Kiritimati",
+    today: "2026-08-23",
+    store,
+    persistedDates: [],
+  });
+  assert.deepEqual(east, ["2026-08-21"]);
+
+  const west = resolveTimelineLoadDates({
+    window: { to: "2026-08-20T23:30:00.000Z" },
+    timezone: "America/Adak",
+    today: "2026-08-23",
+    store,
+    persistedDates: [],
+  });
+  assert.deepEqual(west, ["2026-08-20"]);
+});
+
 test("localDatesForUtcRange covers a multi-year span for unbounded search", () => {
   const dates = localDatesForUtcRange(
     Date.parse("2020-01-01T00:00:00.000Z"),

package/src/activity/timeline/regenerate.ts

@@ -143,9 +143,10 @@ export function listPersistedTimelineDates(memoryDir: string): string[] {
 
 /**
  * Local days a CLI window must load. Bounded windows keep the explicit
- * from/to span. An unbounded search loads every day the snapshot store or a
- * persisted day file covers (plus today), so historical cards enter the
- * search pool instead of only the current day.
+ * from/to span; a window with a single bound loads the local day containing
+ * that instant (never today). An unbounded search loads every day the
+ * snapshot store or a persisted day file covers (plus today), so historical
+ * cards enter the search pool instead of only the current day.
  */
 export function resolveTimelineLoadDates(input: {
   window: { from?: string; to?: string };
@@ -156,8 +157,9 @@ export function resolveTimelineLoadDates(input: {
 }): string[] {
   const { window, timezone, today, store, persistedDates } = input;
   if (window.from !== undefined || window.to !== undefined) {
-    const fromMs = window.from === undefined ? Date.now() : Date.parse(window.from);
-    const toMs = window.to === undefined ? fromMs + 1 : Date.parse(window.to);
+    const parsedTo = window.to === undefined ? Number.NaN : Date.parse(window.to);
+    const fromMs = window.from === undefined ? parsedTo : Date.parse(window.from);
+    const toMs = window.to === undefined ? fromMs + 1 : parsedTo;
     if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) return [];
     return localDatesForUtcRange(fromMs, toMs > fromMs ? toMs : fromMs + 1, timezone);
   }

package/src/cli/deep-recall-commands.ts

@@ -4,20 +4,20 @@
  * meetings-commands.ts). `engram deep-recall <query>` runs the budgeted
  * REFINE/EXPAND/STOP loop through EngramAccessService — the same single
  * implementation MCP and HTTP call.
+ *
+ * Identity (issue #2915): with namespaces enabled the read path requires an
+ * authenticated principal, and this standalone CLI runs without a transport
+ * to authenticate one. It therefore exposes the SAME identity pattern the
+ * access CLI already uses — `--principal` (the authenticated identity) or
+ * `--session-key` (resolved through the configured principal mapping) — so a
+ * namespace-enabled deployment is usable from the CLI instead of refusing
+ * every invocation as unauthenticated.
  */
 
 import type { Orchestrator } from "../orchestrator.js";
 import type { CliCommand } from "../cli.js";
 import { EngramAccessService } from "../access-service.js";
-
-function parseMaxSteps(raw: unknown): number | undefined {
-  if (raw === undefined || raw === null) return undefined;
-  const value = typeof raw === "string" ? Number(raw) : raw;
-  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
-    throw new Error(`--max-steps must be a non-negative integer; got ${JSON.stringify(raw)}`);
-  }
-  return value;
-}
+import { parseDeepRecallMaxSteps } from "../deep-recall-config.js";
 
 export function registerDeepRecallCommands(cmd: CliCommand, orchestrator: Orchestrator): void {
   cmd
@@ -25,18 +25,28 @@ export function registerDeepRecallCommands(cmd: CliCommand, orchestrator: Orches
     .description("Budgeted multi-hop retrieval over the anchor graph (slow, thorough; issue #2332)")
     .option("--max-steps <n>", "Policy-step ceiling (cannot exceed the configured deepRecall.maxSteps)")
     .option("--namespace <ns>", "Namespace to scope the retrieval to")
+    .option("--session-key <key>", "Session key for principal/namespace resolution (namespaces enabled)")
+    .option("--principal <principal>", "Authenticated principal for namespace authorization (namespaces enabled)")
     .option("--json", "JSON output (full entries + trace)")
     .action(async (...args: unknown[]) => {
       const query = String(args[0] ?? "");
       const options = (args[args.length - 1] ?? {}) as Record<string, unknown>;
       let maxSteps: number | undefined;
       try {
-        maxSteps = parseMaxSteps(options.maxSteps);
+        maxSteps = parseDeepRecallMaxSteps(options.maxSteps);
       } catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
         process.exitCode = 1;
         return;
       }
+      const sessionKey =
+        typeof options.sessionKey === "string" && options.sessionKey.trim().length > 0
+          ? options.sessionKey.trim()
+          : undefined;
+      const principal =
+        typeof options.principal === "string" && options.principal.trim().length > 0
+          ? options.principal.trim()
+          : undefined;
       const service = new EngramAccessService(orchestrator);
       try {
         const result = await service.deepRecall({
@@ -45,6 +55,8 @@ export function registerDeepRecallCommands(cmd: CliCommand, orchestrator: Orches
           ...(typeof options.namespace === "string" && options.namespace.length > 0
             ? { namespace: options.namespace }
             : {}),
+          ...(sessionKey !== undefined ? { sessionKey } : {}),
+          ...(principal !== undefined ? { authenticatedPrincipal: principal } : {}),
         });
         if (options.json === true) {
           console.log(JSON.stringify(result, null, 2));

package/src/config.ts

@@ -2796,6 +2796,11 @@ export function parseConfig(
       cfg.inlineSourceAttributionFormat.trim().length > 0
         ? cfg.inlineSourceAttributionFormat
         : "[Source: agent={agent}, session={sessionId}, ts={ts}]",
+    inlineSourceAttributionFormatHistory: Array.isArray(cfg.inlineSourceAttributionFormatHistory)
+      ? (cfg.inlineSourceAttributionFormatHistory as unknown[])
+          .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+          .map((value) => value.trim())
+      : [],
     consolidationRequireNonZeroExtraction: cfg.consolidationRequireNonZeroExtraction !== false,
     // Issue #678 PR 2/4: dreams.phases.rem.minIntervalMs WINS when set.
     consolidationMinIntervalMs: dreamsRem.minIntervalMs,