@remnic/core 9.69.40 → 9.69.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.40",
+  "version": "9.69.42",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -2680,6 +2680,16 @@
       "remnic-source": "./src/shared-context/manager.ts",
       "import": "./dist/shared-context/manager.js"
     },
+    "./shared-context/write-output-controls": {
+      "types": "./dist/shared-context/write-output-controls.d.ts",
+      "remnic-source": "./src/shared-context/write-output-controls.ts",
+      "import": "./dist/shared-context/write-output-controls.js"
+    },
+    "./shared-context/write-output-controls.js": {
+      "types": "./dist/shared-context/write-output-controls.d.ts",
+      "remnic-source": "./src/shared-context/write-output-controls.ts",
+      "import": "./dist/shared-context/write-output-controls.js"
+    },
     "./signal": {
       "types": "./dist/signal.d.ts",
       "remnic-source": "./src/signal.ts",
@@ -3297,7 +3307,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.69.40"
+    "@remnic/coding-graph": "^9.69.42"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-http.test.ts

@@ -861,6 +861,7 @@ test("HTTP briefing endpoint dispatches through the briefing operation", async (
       {
         since: "24h",
         focus: undefined,
+        includeLocation: undefined,
         namespace: "team",
         format: "markdown",
         maxFollowups: 5,

package/src/access-http.ts

@@ -1753,7 +1753,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
     if (req.method === "GET" && meetingGetEngram) { this.enforceTokenOp("meetings_get"); await respondMeetingsGet(res, this.respondJson.bind(this), this.service, meetingGetEngram[1] ?? "", this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined)); return; }
     const meetingGetRemnic = /^\/remnic\/v1\/meetings\/([^/]+)$/.exec(pathname); if (req.method === "GET" && meetingGetRemnic) { this.enforceTokenOp("meetings_get"); await respondMeetingsGet(res, this.respondJson.bind(this), this.service, meetingGetRemnic[1] ?? "", this.wearablesScope(req, parsed.searchParams.get("namespace") ?? undefined, parsed.searchParams.get("sessionKey") ?? undefined)); return; }
     if (req.method === "POST" && (pathname === "/engram/v1/recall/deep" || pathname === "/remnic/v1/recall/deep")) {
-      this.enforceTokenOp("deep_recall"); await respondDeepRecall(req, res, this.respondJson.bind(this), this.readJsonBody.bind(this), this.service, (ns, sk) => this.wearablesScope(req, ns ?? parsed.searchParams.get("namespace") ?? undefined, sk ?? parsed.searchParams.get("sessionKey") ?? undefined)); return; }
+      this.enforceTokenOp("deep_recall"); await respondDeepRecall(req, res, this.respondJson.bind(this), this.readJsonBody.bind(this), this.service, (ns, sk) => this.wearablesScope(req, ns ?? parsed.searchParams.get("namespace") ?? undefined, sk ?? parsed.searchParams.get("sessionKey") ?? undefined), abortSignal); return; }
     // Location sync surfaces (issue #2047): thin branches; bodies + boundary dispatch live in location/http-glue.ts.
     if (req.method === "GET" && (pathname === "/engram/v1/location/status" || pathname === "/remnic/v1/location/status")) {
       this.enforceTokenOp("location_status"); await respondLocationStatus(res, this.respondJson.bind(this), this.service); return; }

package/src/access-mcp-shared-context-tools.ts

@@ -0,0 +1,103 @@
+/**
+ * Shared-context MCP tool descriptors (issue #2920).
+ *
+ * Extracted from access-mcp.ts (at its fileSizeGrandfather ceiling) so the
+ * write-output tool could gain the governed envelope controls without
+ * growing the god file. Content is identical to the previously inline
+ * entries except for the new `authority`/`expiresAt`/`supersedes` properties
+ * on `engram.shared_context_write_output`, which mirror the canonical
+ * validation in shared-context/write-output-controls.ts and
+ * composeWriteEnvelope.
+ */
+import type { McpTool } from "./access-mcp.js";
+
+export const sharedContextMcpTools: McpTool[] = [
+  {
+    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." },
+        authority: {
+          type: "string",
+          enum: ["informational", "advisory", "binding"],
+          description:
+            "Envelope authority class. `binding` additionally requires the operator config `sharedContextAllowBindingAuthority: true`.",
+        },
+        expiresAt: {
+          type: "string",
+          description:
+            "ISO-8601 instant strictly after the write time and at most 10 years out. Past, invalid, or over-bound values are rejected.",
+        },
+        supersedes: {
+          type: "string",
+          description: "Id of the shared item this output supersedes (non-empty, single line).",
+        },
+      },
+      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,
+    },
+  },
+];

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,
@@ -260,7 +261,7 @@ function resolveChatGptInspectorRecallSessionKey(
 }
 
 const STRICT_MCP_SCHEMA_KEYS: Partial<Record<SchemaName, readonly string[]>> = {
-  daySummary: ["memories", "sessionKey", "namespace", "timeZone", "cwd", "projectTag"],
+  daySummary: ["memories", "includeLocation", "sessionKey", "namespace", "timeZone", "cwd", "projectTag"],
   memoryStore: [
     "schemaVersion",
     "idempotencyKey",
@@ -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:
@@ -1654,12 +1584,9 @@ export class EngramMcpServer {
                 type: "object",
                 properties: {
                   since: { type: "string", description: "Lookback window (e.g. 'yesterday', '3d', '1w', '24h')." },
-                  focus: {
-                    type: "string",
-                    description:
-                      "Optional focus filter (e.g. 'person:Jane Doe', 'project:remnic-core', 'topic:retrieval').",
-                  },
+                  focus: { type: "string", description: "Optional focus filter (e.g. 'person:Jane Doe', 'project:remnic-core', 'topic:retrieval')." },
                   namespace: { type: "string" },
+                  includeLocation: { type: "boolean", description: "Opt-in: append matched location place names (location gates apply)." },
                   format: { type: "string", enum: ["markdown", "json"] },
                   maxFollowups: {
                     type: "number",

package/src/access-observe-write-category.ts

@@ -13,6 +13,7 @@ import {
 } from "./access-schema.js";
 
 export { reapplyCategoryCoercion };
+export { applyBriefingLocationContext } from "./location/tagging.js";
 
 export function splitCanonicalWriteRequest<T extends { rawCategory?: string }>(
   request: T,

package/src/access-observe-write-surface.ts

@@ -29,7 +29,7 @@ import {
   type MemoryScopePlan,
   NamespaceNotWritableError,
 } from "./access-service.js";
-import { reapplyCategoryCoercion, splitCanonicalWriteRequest } from "./access-observe-write-category.js";
+import { applyBriefingLocationContext, reapplyCategoryCoercion, splitCanonicalWriteRequest } from "./access-observe-write-category.js";
 import { extractionForceFlush } from "./access-extraction-force-flush.js";
 import { ObserveTranscriptPersister, observeTranscriptSessionKey } from "./access-observe-transcript.js";
 import { FileCalendarSource, buildBriefing, parseBriefingFocus, parseBriefingWindow } from "./briefing.js";
@@ -454,7 +454,7 @@ export class AccessObserveWriteSurface {
       ? new FileCalendarSource(config.briefing.calendarSource)
       : undefined;
 
-    const result = await buildBriefing({
+    const result = await applyBriefingLocationContext(await buildBriefing({
       storage,
       namespace,
       window,
@@ -470,7 +470,7 @@ export class AccessObserveWriteSurface {
       // other LLM feature uses. A configured key keeps its precedence so
       // existing deployments are unchanged.
       followupGenerator: config.openaiApiKey ? undefined : this.deps.orchestrator.briefingChainFollowupGenerator,
-    });
+    }), request.includeLocation, storage.dir, window.from.toISOString(), config.location);
 
     return {
       format,

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) }; } });
@@ -216,7 +233,7 @@ defineOperation({ name: "chatgpt_memory_inspector", description: "Memory inspect
     return { result: buildChatGptMemoryInspectorResult(ii, r, x, ac) };
   },
 });
-defineOperation({ name: "day_summary", description: "Day summary.", schema: strictSchema({ memories: S.str, sessionKey: S.str, namespace: S.str, timeZone: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => { const req: Record<string, unknown> = {}; if (input.memories !== undefined) req.memories = optStr(input.memories); if (input.sessionKey !== undefined) req.sessionKey = optStr(input.sessionKey); if (input.namespace !== undefined) req.namespace = optStr(input.namespace); if (input.timeZone !== undefined) req.timeZone = optStr(input.timeZone); const summary = await ctx.service.daySummary(req); return { result: summary ?? {} }; } });
+defineOperation({ name: "day_summary", description: "Day summary.", schema: strictSchema({ memories: S.str, includeLocation: S.bool, sessionKey: S.str, namespace: S.str, timeZone: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => { const req: Record<string, unknown> = {}; if (input.memories !== undefined) req.memories = optStr(input.memories); if (input.includeLocation !== undefined) req.includeLocation = optBool(input.includeLocation); if (input.sessionKey !== undefined) req.sessionKey = optStr(input.sessionKey); if (input.namespace !== undefined) req.namespace = optStr(input.namespace); if (input.timeZone !== undefined) req.timeZone = optStr(input.timeZone); const summary = await ctx.service.daySummary(req); return { result: summary ?? {} }; } });
 defineOperation({ name: "capsule_export", description: "Export capsule.", schema: strictSchema({ name: S.str, namespace: S.str, since: S.str, includeKinds: S.strArr, peerIds: S.strArr, includeTranscripts: S.bool, encrypt: S.bool, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.capsuleExport({ name: optStr(input.name) ?? "", namespace: optStr(input.namespace), since: optStr(input.since), includeKinds: optStrArr(input.includeKinds), peerIds: optStrArr(input.peerIds), includeTranscripts: optBool(input.includeTranscripts as unknown), encrypt: optBool(input.encrypt as unknown), principal: ctx.authenticatedPrincipal } as unknown as Parameters<EngramAccessService["capsuleExport"]>[0]) }) });
 defineOperation({ name: "capsule_import", description: "Import capsule.", schema: strictSchema({ archivePath: S.str, namespace: S.str, mode: S.str, passphrase: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.capsuleImport({ archivePath: expandTildePath(optStr(input.archivePath) ?? ""), namespace: optStr(input.namespace), mode: optStr(input.mode) as "skip" | "overwrite" | "fork" | undefined, passphrase: optStr(input.passphrase), principal: ctx.authenticatedPrincipal }) }) });
 defineOperation({ name: "capsule_list", description: "List capsules.", schema: strictSchema({ namespace: S.str, sessionKey: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => {
@@ -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) }) }) });
@@ -330,7 +373,7 @@ defineOperation({ name: "memory_promote", description: "Promote memory.", schema
 defineOperation({ name: "memory_outcome", description: "Record outcome.", schema: strictSchema({ memoryId: S.str, outcome: S.str, namespace: S.str, sessionKey: S.str, timestamp: S.str }), handler: async (input, ctx) => { const o = optStr(input.outcome); if (o !== "success" && o !== "failure") throw new EngramAccessInputError("memory_outcome: outcome must be \"success\" or \"failure\"; got " + JSON.stringify(o)); return { result: await ctx.service.memoryOutcome({ memoryId: optStr(input.memoryId) ?? "", outcome: o, namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey), timestamp: optStr(input.timestamp), principal: ctx.authenticatedPrincipal }) }; } });
 defineOperation({ name: "memory_action_apply", description: "Apply action.", schema: strictSchema({ action: S.str, outcome: S.str, reason: S.str, memoryId: S.str, namespace: S.str, sessionKey: S.str, content: S.str, category: S.str, linkTargetId: S.str, linkType: S.str, linkStrength: S.num, artifactType: S.str, execute: S.bool, sourcePrompt: S.str, dryRun: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.memoryActionApply({ action: optStr(input.action) ?? "", outcome: optStr(input.outcome), reason: optStr(input.reason), memoryId: optStr(input.memoryId) ?? "", namespace: optStr(input.namespace), sessionKey: optStr(input.sessionKey), content: optStr(input.content), category: optStr(input.category), linkTargetId: optStr(input.linkTargetId), linkType: optStr(input.linkType), linkStrength: optNum(input.linkStrength), artifactType: optStr(input.artifactType), execute: optBool(input.execute), sourcePrompt: optStr(input.sourcePrompt), dryRun: input.dryRun === true, principal: ctx.authenticatedPrincipal }) }) });
 defineOperation({ name: "context_checkpoint", description: "Context checkpoint.", schema: strictSchema({ sessionKey: S.str, context: S.str, namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.contextCheckpoint({ sessionKey: optStr(input.sessionKey) ?? "", context: optStr(input.context) ?? "", namespace: optStr(input.namespace), principal: ctx.authenticatedPrincipal }) }) });
-defineOperation({ name: "briefing", description: "Daily briefing.", schema: strictSchema({ since: S.str, focus: S.str, namespace: S.str, format: S.str, maxFollowups: S.num }), handler: async (input, ctx) => { const rf = optStr(input.format); const fe = validateBriefingFormat(rf); if (fe) throw new EngramAccessInputError(fe); return { result: await ctx.service.briefing({ since: optStr(input.since), focus: optStr(input.focus), namespace: optStr(input.namespace), format: rf as "json" | "markdown" | undefined, maxFollowups: optNum(input.maxFollowups), principal: ctx.authenticatedPrincipal }) }; } });
+defineOperation({ name: "briefing", description: "Daily briefing.", schema: strictSchema({ since: S.str, focus: S.str, namespace: S.str, includeLocation: S.bool, format: S.str, maxFollowups: S.num }), handler: async (input, ctx) => { const rf = optStr(input.format); const fe = validateBriefingFormat(rf); if (fe) throw new EngramAccessInputError(fe); return { result: await ctx.service.briefing({ since: optStr(input.since), focus: optStr(input.focus), namespace: optStr(input.namespace), includeLocation: optBool(input.includeLocation), format: rf as "json" | "markdown" | undefined, maxFollowups: optNum(input.maxFollowups), principal: ctx.authenticatedPrincipal }) }; } });
 
 // === CONTRADICTION/REVIEW ===
 defineOperation({ name: "review_list", description: "List review pairs.", schema: strictSchema({ filter: S.str, namespace: S.str, limit: S.num }),

package/src/access-schema.ts

@@ -529,6 +529,7 @@ export const lcmCompactionRecordRequestSchema = z.object({
 
 export const daySummaryRequestSchema = z.object({
   memories: z.string().max(100000).optional(),
+  includeLocation: z.boolean().optional(),
   sessionKey: sessionKeySchema,
   namespace: namespaceSchema,
   timeZone: timeZoneSchema.optional(),

package/src/access-service.ts

@@ -35,6 +35,8 @@ 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";
+import { daySummaryAutoOptions, type LocationContextRequestOptions } from "./location/tagging.js";
 export type { EngramAccessHealthResponse, EngramAccessQmdCollectionState, EngramAccessQmdHealthResponse };
 import { AccessAuditAdapter, type AccessAuditConfig, type AccessAuditResult } from "./access-audit.js";
 import {
@@ -480,7 +482,7 @@ export interface EngramAccessRecallExplainResponse {
   graph?: GraphRecallSnapshot | null;
 }
 
-export interface EngramAccessDaySummaryRequest {
+export interface EngramAccessDaySummaryRequest extends LocationContextRequestOptions {
   memories?: string;
   sessionKey?: string;
   namespace?: string;
@@ -488,7 +490,7 @@ export interface EngramAccessDaySummaryRequest {
 }
 
 /** Inputs accepted by the `remnic_briefing` MCP tool. */
-export interface EngramAccessBriefingRequest {
+export interface EngramAccessBriefingRequest extends LocationContextRequestOptions {
   since?: string;
   focus?: string;
   namespace?: string;
@@ -2475,9 +2477,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
 
     if (memories.length === 0) {
       // Auto-gather today's facts from the resolved namespace
-      return this.orchestrator.generateDaySummaryAuto(namespace, {
-        timeZone: request.timeZone,
-      });
+      return this.orchestrator.generateDaySummaryAuto(namespace, daySummaryAutoOptions(request));
     }
     return this.orchestrator.generateDaySummary(memories);
   }
@@ -2726,6 +2726,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 +2789,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 +2813,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 +2836,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 +4603,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 +4616,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);
   }