@remnic/core 9.69.39 → 9.69.41

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { u as MemoryCategory, N as MemorySubject } from './types-Cyr32ABj.js';
+import { u as MemoryCategory, N as MemorySubject } from './types-cK5LydjL.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.39",
+  "version": "9.69.41",
   "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.39"
+    "@remnic/coding-graph": "^9.69.41"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-category-alias.test.ts

@@ -151,6 +151,18 @@ test("#2829 retainedCategoryAlias reads the transform-minted spelling from a raw
   assert.equal(categoryAliasCoercion(undefined), undefined);
 });
 
+test("#2889 retainedCategoryAlias recovers the spelling from a single-parse envelope's category", () => {
+  // Single-parse callers (CLI store command, direct op.run) hand the op the
+  // raw envelope: the alias sits on `category`, no `rawCategory` exists yet.
+  assert.equal(retainedCategoryAlias({ content: "x", category: "project_state" }), "project_state");
+  assert.equal(retainedCategoryAlias({ content: "x", category: "project-state" }), "project-state");
+  // Canonical and near-miss categories never mint a retained spelling.
+  assert.equal(retainedCategoryAlias({ content: "x", category: "fact" }), undefined);
+  assert.equal(retainedCategoryAlias({ content: "x", category: "projection" }), undefined);
+  assert.equal(retainedCategoryAlias({ content: "x" }), undefined);
+  // A transform-minted rawCategory outranks the raw category spelling.
+  assert.equal(retainedCategoryAlias({ category: "project_update", rawCategory: "project" }), "project");
+});
 // ---------------------------------------------------------------------------
 // Type-level regressions (enforced by tsc via check-types)
 // ---------------------------------------------------------------------------
@@ -303,6 +315,10 @@ function makePersistService(memoryDir: string): PersistProbe {
       writes.push({ category, content });
       return { id: `mem-${writes.length}`, duplicateOf: undefined };
     },
+    // The suggestion review-queue path re-reads and re-stamps the queued
+    // memory (explicit-capture.ts queueExplicitCaptureForReview).
+    getMemoryById: async (id: string) => ({ id, status: "active" }),
+    writeMemoryFrontmatter: async () => {},
   });
   return { service: new EngramAccessService(orch), writes };
 }
@@ -410,6 +426,83 @@ test("#2829 peek idempotency ignores the retained spelling", async () => {
   });
 });
 
+test("#2889 single-pass op.run retains the alias through canonical validation and replay", async () => {
+  // The CLI store command's path (PR #2866 review): the raw envelope carries
+  // the alias on `category` and op.run performs the ONLY schema parse. The
+  // boundary must still retain the spelling, and a same-key replay with a
+  // different accepted spelling must report THIS caller's alias while the
+  // stored result stays canonical and untouched.
+  await withPersistService(async ({ service, writes }) => {
+    const base = {
+      content: "single-pass aliased idempotent write",
+      confidence: 0.9,
+      tags: [] as string[],
+      idempotencyKey: "k-2889",
+    };
+    const first = await memoryStoreOperation.run(
+      { ...base, category: "project_state" },
+      { service },
+    );
+    assert.equal(first.result.status, "stored");
+    assert.deepEqual(first.result.categoryCoercion, { from: "project_state", to: "fact" });
+    assert.equal(writes.length, 1);
+    assert.equal(writes[0]?.category, "fact", "the persisted memory stays canonical");
+
+    const second = await memoryStoreOperation.run(
+      { ...base, category: "project-state" },
+      { service },
+    );
+    assert.equal(second.result.idempotencyReplay, true, "alias spellings share the canonical fingerprint");
+    assert.deepEqual(second.result.categoryCoercion, { from: "project-state", to: "fact" });
+    assert.equal(first.result.categoryCoercion?.from, "project_state", "the replay never mutates the stored note");
+    assert.equal(writes.length, 1, "the replay persists nothing");
+
+    const third = await memoryStoreOperation.run(
+      { ...base, category: "fact" },
+      { service },
+    );
+    assert.equal(third.result.idempotencyReplay, true);
+    assert.equal("categoryCoercion" in third.result, false, "a canonical replay reports no coercion");
+    assert.equal(writes.length, 1);
+  });
+});
+
+test("#2889 a single-pass dry run reports the coercion note and persists nothing", async () => {
+  await withPersistService(async ({ service, writes }) => {
+    const output = await memoryStoreOperation.run(
+      { content: "single-pass dry-run alias", category: "project_update", confidence: 0.9, tags: [], dryRun: true },
+      { service },
+    );
+    assert.equal(output.result.status, "validated");
+    assert.deepEqual(output.result.categoryCoercion, { from: "project_update", to: "fact" });
+    assert.equal(writes.length, 0);
+  });
+});
+
+test("#2889 suggestion_submit reports the coercion and queues the canonical category", async () => {
+  await withPersistService(async ({ service, writes }) => {
+    const aliased = await service.suggestionSubmit({
+      content: "suggested aliased fact",
+      category: "fact",
+      confidence: 0.9,
+      tags: [],
+      rawCategory: "project_update",
+    });
+    assert.equal(aliased.status, "queued_for_review");
+    assert.deepEqual(aliased.categoryCoercion, { from: "project_update", to: "fact" });
+    assert.equal(writes.length, 1);
+    assert.equal(writes[0]?.category, "fact", "the queued review memory stays canonical");
+
+    const canonical = await service.suggestionSubmit({
+      content: "suggested canonical fact",
+      category: "preference",
+      confidence: 0.9,
+      tags: [],
+    });
+    assert.equal(canonical.status, "queued_for_review");
+    assert.equal("categoryCoercion" in canonical, false, "a no-alias submit reports no coercion");
+  });
+});
 // ---------------------------------------------------------------------------
 // Quarantine — the parked payload keeps the raw spelling for replay
 // ---------------------------------------------------------------------------

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,
@@ -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-offline-manifest.ts

@@ -57,11 +57,17 @@ export interface ServerIdentityCacheEntry {
 export function planServerIdentityCacheWrite(input: {
   persisted: ReadonlyMap<string, ServerIdentityCacheEntry>;
   yieldedPaths: ReadonlySet<string>;
+  /** Paths the walk saw but never yielded (removed by the exclusion
+   * callback). Not deleted — pruning them would drop their persisted
+   * classification and force a re-classify on every later cycle. */
+  retainedPaths?: ReadonlySet<string>;
   streamCompleted: boolean;
   cacheDirty: boolean;
 }): { shouldWrite: boolean; entries: ServerIdentityCacheEntry[] } {
   const entries = input.streamCompleted
-    ? [...input.persisted.values()].filter((entry) => input.yieldedPaths.has(entry.path))
+    ? [...input.persisted.values()].filter(
+        (entry) => input.yieldedPaths.has(entry.path) || input.retainedPaths?.has(entry.path)
+      )
     : [...input.persisted.values()];
   return { shouldWrite: input.cacheDirty || entries.length !== input.persisted.size, entries };
 }
@@ -147,7 +153,7 @@ async function withServerIdentityCacheWriteLock(cachePath: string, write: () =>
 
 /** Union of the entries being written and the current on-disk set; on conflict
  * the write wins (it reflects the newer run). Callers hold the write lock. */
-async function mergeServerIdentityCacheEntries(
+export async function mergeServerIdentityCacheEntries(
   fs: typeof import("node:fs/promises"),
   cachePath: string,
   entries: readonly ServerIdentityCacheEntry[],
@@ -178,6 +184,9 @@ async function mergeServerIdentityCacheEntries(
                   ? { identityResolutionVersion: entry.identityResolutionVersion }
                   : {}),
               }),
+          ...(entry.statIdentity !== undefined && entry.excluded !== undefined
+            ? { statIdentity: entry.statIdentity, excluded: entry.excluded }
+            : {}),
         });
       }
     }
@@ -187,6 +196,34 @@ async function mergeServerIdentityCacheEntries(
   return [...merged.values()];
 }
 
+/** Record classifications for files the walk excluded (the exclusion callback
+ * returned true, so they were never yielded): they were seen this walk, so
+ * their entries must persist and must not be pruned as deleted. Mirrors the
+ * per-yield classification application for never-yielded paths. */
+export function retainExcludedClassifications(input: {
+  persisted: Map<string, ServerIdentityCacheEntry>;
+  classifications: ReadonlyMap<string, { statIdentity: string; excluded: boolean }>;
+  yieldedPaths: ReadonlySet<string>;
+}): { retained: Set<string>; changed: boolean } {
+  const retained = new Set<string>();
+  let changed = false;
+  for (const [pathName, classification] of input.classifications) {
+    if (input.yieldedPaths.has(pathName)) continue;
+    retained.add(pathName);
+    const entry = input.persisted.get(pathName) ?? { path: pathName, sha256: "" };
+    if (entry.statIdentity === classification.statIdentity && entry.excluded === classification.excluded) {
+      continue;
+    }
+    input.persisted.set(pathName, {
+      ...entry,
+      statIdentity: classification.statIdentity,
+      excluded: classification.excluded,
+    });
+    changed = true;
+  }
+  return { retained, changed };
+}
+
 export async function createOfflineSyncManifestStream(
   orchestrator: Orchestrator,
   namespace: string,
@@ -227,10 +264,12 @@ export async function createOfflineSyncManifestStream(
       // near-cold rebuild on the next request.
       const persistedEntries = new Map(identityCache);
       const yieldedPaths = new Set<string>();
+      const retainedPaths = new Set<string>();
       const flush = async (): Promise<void> => {
         const { shouldWrite, entries } = planServerIdentityCacheWrite({
           persisted: persistedEntries,
           yieldedPaths,
+          retainedPaths,
           streamCompleted,
           cacheDirty,
         });
@@ -334,6 +373,17 @@ export async function createOfflineSyncManifestStream(
         }
         streamCompleted = true;
       } finally {
+        // Files the exclusion callback removed from the snapshot were seen
+        // this walk but never yielded: persist their classifications so the
+        // next cycle skips the read+parse, and keep them out of the
+        // deleted-path prune.
+        const retained = retainExcludedClassifications({
+          persisted: persistedEntries,
+          classifications: classificationUpdates,
+          yieldedPaths,
+        });
+        for (const pathName of retained.retained) retainedPaths.add(pathName);
+        if (retained.changed) cacheDirty = true;
         await flush();
       }
     })(),

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-schema.ts

@@ -323,13 +323,18 @@ export function categoryAliasCoercion(rawCategory: string | undefined): Category
 /**
  * Recover the retained alias spelling from a pre-parse raw envelope: the
  * `rawCategory` minted by a previous parse of the same schema (the HTTP/MCP
- * validate-then-dispatch double pass) or an as-yet-untransformed alias
- * `category` (single-parse callers like the CLI store command).
+ * validate-then-dispatch double pass), or — for single-parse callers like the
+ * CLI store command — the as-yet-untransformed alias still sitting on
+ * `category` (issue #2889). A minted `rawCategory` always wins: it names the
+ * spelling the transform actually canonicalized.
  */
 export function retainedCategoryAlias(rawInput: unknown): MemoryCategoryAlias | undefined {
   if (!rawInput || typeof rawInput !== "object") return undefined;
-  const spelling = (rawInput as Record<string, unknown>).rawCategory;
-  return typeof spelling === "string" && isMemoryCategoryAlias(spelling) ? spelling : undefined;
+  const envelope = rawInput as Record<string, unknown>;
+  const minted = envelope.rawCategory;
+  if (typeof minted === "string" && isMemoryCategoryAlias(minted)) return minted;
+  const category = envelope.category;
+  return typeof category === "string" && isMemoryCategoryAlias(category) ? category : undefined;
 }
 
 /**

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;