@sema-agent/server 7.72.0 → 7.73.1

package/dist/http/routes/runs.js

@@ -17,7 +17,7 @@ import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames } from "../../approval-card.js";
 import { ASK_DECISION_CONSUMER_ABSENT, resolveStreamApprovalGate } from "../../tool-approval.js";
 import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
-import { normalizeRunEventType } from "../../trace/project.js";
+import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
 import { sendJson, sendError, httpErrorCode, sseHeaders } from "../send.js";
 import { readTurnActivityMs } from "../../turn-activity.js";
 import { mintCancelledResult } from "../../run-cancel-context.js";
@@ -137,9 +137,10 @@ async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
         retainedFrom: (id) => runStore.retainedFrom(id),
         formatEvent: (ev) => {
             const type = normalizeRunEventType(ev.type);
-            const data = type === "done" && ev.data && typeof ev.data === "object" && ev.data.result && typeof ev.data.result === "object"
+            const redacted = type === "done" && ev.data && typeof ev.data === "object" && ev.data.result && typeof ev.data.result === "object"
                 ? { ...ev.data, result: memoRedactTerminalResult("ev.done.result", ev.data.result) }
                 : type === "failed" ? memoRedactedRead("ev.failed", ev.data, (d) => redactLedgerEventData(type, d)) : redactLedgerEventData(type, ev.data);
+            const data = screenedStoredEventData(type, redacted);
             return { id: ev.seq, event: type, data: { type, ...(data ?? {}) } };
         },
         staleFrame: () => ({ event: "failed", data: { type: "failed", errorMessage: "run stalled (instance lost?)" } }),
@@ -262,6 +263,8 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 error: stale ? "run stalled (instance lost?)" : isTerminalRunStatus(run.status) ? memoRedactedRead("run.error", run.error ?? undefined, redactErrorMessage) : redactErrorMessage(run.error ?? undefined),
                 jobId: run.jobId ?? undefined,
                 source: run.source ?? undefined,
+                heldBy: run.instanceId ?? null,
+                cancelRequested: run.cancelRequested,
             });
         }
         return;
@@ -302,7 +305,7 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
                         else {
-                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" });
+                            sendJson(res, 202, { taskId, status: st ?? "failed", cancelRequested: now?.cancelRequested ?? false, note: "run already terminal — cancel is a no-op" });
                         }
                         return;
                     }
@@ -316,7 +319,7 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
                         else {
-                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" });
+                            sendJson(res, 202, { taskId, status: st ?? "failed", cancelRequested: now?.cancelRequested ?? false, note: "run already terminal — cancel is a no-op" });
                         }
                         return;
                     }
@@ -352,10 +355,10 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             }
             const finalRow = await rs.getRun(taskId).catch(() => undefined);
             if (finalRow && finalRow.errorCode !== "cancelled" && isTerminalRunStatus(finalRow.status)) {
-                sendJson(res, 202, { taskId, status: finalRow.status, errorCode: finalRow.errorCode ?? null, note: `session unlocked; the run was terminalized concurrently (${finalRow.errorCode ?? finalRow.status}) before this cancel's write — reporting the actual ledger state` });
+                sendJson(res, 202, { taskId, status: finalRow.status, errorCode: finalRow.errorCode ?? null, cancelRequested: finalRow.cancelRequested, note: `session unlocked; the run was terminalized concurrently (${finalRow.errorCode ?? finalRow.status}) before this cancel's write — reporting the actual ledger state` });
                 return;
             }
-            sendJson(res, 202, { taskId, status: "failed", errorCode: "cancelled", note });
+            sendJson(res, 202, { taskId, status: "failed", errorCode: "cancelled", cancelRequested: false, note });
         };
         if (run.status === "running") {
             let flagged = await deps.runStore.requestCancel(taskId, run.owner);
@@ -371,23 +374,23 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     continue;
                 }
                 if (now?.status === "running") {
-                    sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: now.status });
+                    sendError(res, 409, "conflict.run_not_running", "the cancel flag could not be set: this run was not in 'running' state at the moment of each attempt (it keeps flipping between running and a park) — retry cancel", { taskId, status: now.status });
                     return;
                 }
-                sendJson(res, 202, { taskId, status: now?.status ?? "failed", note: "run already terminal — cancel is a no-op" });
+                sendJson(res, 202, { taskId, status: now?.status ?? "failed", cancelRequested: now?.cancelRequested ?? false, note: "run already terminal — cancel is a no-op" });
                 return;
             }
             if (inflightRuns.has(taskId)) {
                 cancelledViaVerb.add(taskId);
                 inflightRuns.get(taskId).abort();
             }
-            sendJson(res, 202, { taskId, status: "cancelling" });
+            sendJson(res, 202, { taskId, status: "cancelling", cancelRequested: true });
         }
         else if (isParkedRunStatus(run.status)) {
             await cancelSuspended();
         }
         else {
-            sendJson(res, 202, { taskId, status: run.status, note: "run already terminal — cancel is a no-op" });
+            sendJson(res, 202, { taskId, status: run.status, cancelRequested: run.cancelRequested, note: "run already terminal — cancel is a no-op" });
         }
         return;
     }

package/dist/http/server.js

@@ -1999,6 +1999,9 @@ export function createHttpServer(rawDeps) {
                 },
             };
         }
+        const windowDenial = await usageWindowDenialFor(principal || GLOBAL_USAGE_KEY);
+        if (windowDenial)
+            return { status: windowDenial.status, body: windowDenial.body };
         const auth = { sessionId, principal, memoryScope: ctx.memoryScope };
         let spec;
         let engineNotices = [];
@@ -2260,27 +2263,32 @@ export function createHttpServer(rawDeps) {
         sendError(res, 429, "quota_exhausted", "budget exhausted (quota lease)", { retryAfterSec: adm.retryAfterSec, ...(adm.detail ?? {}) });
         return true;
     }
-    async function usageWindowDenied(req, res) {
+    async function usageWindowDenialFor(key) {
         const store = deps.usageWindowStore;
         const windows = deps.config.usageWindows;
         if (!store || !windows || windows.length === 0)
-            return false;
-        const key = gatedPrincipal(req, deps.config) || GLOBAL_USAGE_KEY;
+            return undefined;
         let retryAfterMs;
         try {
             retryAfterMs = usageRetryAfterMs(await store.read(key, windows, Date.now()));
         }
         catch (e) {
             deps.logger?.warn?.("usage_window_admission_read_failed", { error: e instanceof Error ? e.message : String(e) });
-            return false;
+            return undefined;
         }
         if (retryAfterMs === undefined)
-            return false;
+            return undefined;
         deps.metrics?.inc("usage_window_rejected_total");
         deps.logger?.info?.("usage_window_exhausted", { hasPrincipal: key !== GLOBAL_USAGE_KEY, retryAfterMs });
         const retryAfterSec = Math.max(1, Math.ceil(retryAfterMs / 1000));
-        res.setHeader("retry-after", String(retryAfterSec));
-        sendError(res, 429, "usage.window_exhausted", "usage window exhausted (deployment token governance)", { retryAfterSec });
+        return { status: 429, body: { error: "usage window exhausted (deployment token governance)", errorCode: "usage.window_exhausted", retryAfterSec }, retryAfterSec };
+    }
+    async function usageWindowDenied(req, res) {
+        const denial = await usageWindowDenialFor(gatedPrincipal(req, deps.config) || GLOBAL_USAGE_KEY);
+        if (!denial)
+            return false;
+        res.setHeader("retry-after", String(denial.retryAfterSec));
+        sendError(res, denial.status, denial.body.errorCode, denial.body.error, { retryAfterSec: denial.retryAfterSec });
         return true;
     }
     function rateLimited(req, res) {

package/dist/main.js

@@ -7,7 +7,8 @@ import { posIntEnv } from "./session-watch.js";
 import { selectEnvironmentTool } from "./capabilities/select-environment-tool.js";
 import { subagentSendUserFileExtraTools } from "./capabilities/send-user-file-tool.js";
 import { brainSummary } from "./brain.js";
-import { buildUnpricedCeilingNotice, loadConfig, logConfigDiagnostics, resolveBindHost, splitLocalRoots, parseCapEnv, parseNumOrFailNonNegative } from "./config.js";
+import { loadConfig, logConfigDiagnostics, resolveBindHost, splitLocalRoots, parseCapEnv, parseNumOrFailNonNegative } from "./config.js";
+import { createUnpricedCeilingVerdict } from "./boot/unpriced-ceiling-verdict.js";
 import { buildWriteProtectionPosture } from "./write-protection.js";
 import { cardRuleScopeRoot } from "./task-cwd.js";
 import { isPricingConfigured } from "./budget.js";
@@ -129,9 +130,8 @@ async function main() {
     }
     const configCenter = await createConfigCenterRuntime({ config, logger, metrics, localRoot });
     await configCenter.applyLocalRemoteExec();
-    const unpricedCeiling = buildUnpricedCeilingNotice(config.models, config);
-    if (unpricedCeiling)
-        logger.warn(unpricedCeiling.event, unpricedCeiling.fields);
+    const ceilingVerdict = createUnpricedCeilingVerdict({ config, logger });
+    ceilingVerdict.judge();
     const { backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngineFacts, } = await openStores({ config, logger, metrics, localRoot });
     const instanceId = uuidv7();
     const sessionCaptureRecords = backend?.sessionCaptureRecords();
@@ -564,7 +564,7 @@ async function main() {
             }
         }
     };
-    configCenter.startRefreshLoop({ runnerTierFrozen, pricing, limitSync, swapRunnerDeps });
+    configCenter.startRefreshLoop({ runnerTierFrozen, pricing, limitSync, swapRunnerDeps, ceilingVerdict });
     configCenter.initKeyResolver();
     const { ownerAware, sessionAudit, sessionWatchRegistry, purgeSession, instrumentDegenerate, planCacheProbe } = createSessionFaces({
         deviceStore: deviceLane?.store,

package/dist/memory-bundle-engine.d.ts

@@ -53,9 +53,10 @@ export interface MemoryBundleFaces {
 /**
  * 在**已装配的记忆后端**上建 bundle 两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
  *
- * `memoryDir` = `boot/stores.ts` 的 `memoryEngine.root`(该部署的记忆工作根)。见文件头:这两条路径
- * 不读它,传它是为了不发明第二个「引擎根」的概念 —— 万一 core 日后真用上,它拿到的也是本部署唯一的
- * 那个根,而不是一个本模块凭空编出来的路径。
+ * `memoryDir` = 引擎的**挂载平面**(`memoryMountRootOf(backend, root)` 单铸点;全仓自构引擎同一条规则,
+ * 由 `test/memory-layout-plane.test.ts` 的归一门咬住)。见文件头:这两条路径**不读它**(机器钉在
+ * `test/memory-bundle-engine.test.ts`:给一个不存在的 `memoryDir` 也照样工作),传对的那一只是为了
+ * 万一 core 日后真用上时,它拿到的是本部署真正的挂载平面,而不是高一层的配置根。
  */
 export declare function createMemoryBundleFaces(store: {
     backend: MemoryBackend;

package/dist/memory-bundle-engine.js

@@ -1,9 +1,10 @@
 import { MemoryEngine } from "@sema-agent/core";
+import { memoryMountRootOf } from "./memory-scope.js";
 export function createMemoryBundleFaces(store, opts) {
     const b = store.backend;
     if (typeof b.exportSnapshotOf !== "function" || typeof b.importBundleCommit !== "function")
         return undefined;
-    const engine = new MemoryEngine({ backend: store.backend, memoryDir: store.root, ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}) });
+    const engine = new MemoryEngine({ backend: store.backend, memoryDir: memoryMountRootOf(store.backend, store.root), ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}) });
     return {
         exportScopes: (scopes) => engine.exportMemoryScopes(scopes),
         importBundle: (bundle, opts) => engine.importMemoryBundle(bundle, opts),

package/dist/memory-incident-sink.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 记忆引擎 **incident 席**在本仓的唯一落点形。
+ *
+ * ## 为什么要一只共用工厂(而不是每个宿主各写一行 `logger.warn`)
+ * core 的记忆引擎有**两条**到宿主的披露路:
+ *  · **mount 路**——`MemoryEngine` 自己的 `onIncident`,由 core 的 Runner 在 `prepare-memory` 里桥到
+ *    `RunnerDeps.onError(err, { phase: "memory", sessionId })`(亲读 `dist/core/runner/prepare-memory.js`
+ *    的 `const onEngineIncident = (err) => deps.onError?.(err, { phase: "memory", sessionId })`);
+ *  · **无锁公开面路**——`FileMemoryEngineBackend` 的**构造期** `onIncident`,是那条腿上唯一的披露口
+ *    (`adoptLayoutLocked` 取 `onIncident ?? this.onIncident`)。
+ * 同一条事实(例如一次性的目录布局搬家)会按调用路径落到其中**一条**,而本仓有**两个宿主**
+ * (HTTP 服务的 `boot/runner-deps.ts` 与 `run-local.ts`)各自持有 `onError` 座。四个落点各写一行 =
+ * 四份会各自漂移的形;实际已经漂过一次:服务腿把整族印成 `memory_consolidation_failed`(只有一支是
+ * consolidation),run-local 腿把整族印成 `engine_error` 并用 `String(err)` 抹掉 `err.code`。
+ *
+ * ## 形(一处定义,四处引用)
+ * `memory_engine_incident` + `{ sessionId?, code, detail }`,并计 `memory_engine_incident_total{code}`。
+ * 🔴 `code` 是**结构化字段**而不是被折进散文:它是运维唯一能按名告警的那一位,而这一族里最要紧的几条
+ * (一次性布局搬家、无主根内容、控制面写失败)一辈子只发生一次 —— 折平就等于没说。无码的成员
+ * (core 里有大量不带 `.code` 的记忆相 Error)落 `null` / 计数标签 `"none"`,**不编**一个码。
+ *
+ * ⚠️ 与 `main.ts` 三只 **operator 面**引擎座(`memory_compliance_incident` / `memory_origin_incident` /
+ * `memory_consolidation_incident`)**刻意不合并**:那三条的事件名回答「哪一张操作面」,是三个产品面的
+ * 分辨位;本工厂回答「引擎事故席」,是同一件事的四个落点。合并会丢掉前者的分辨位。
+ */
+import type { Logger } from "./observability/logger.js";
+import type { Metrics } from "./observability/metrics.js";
+/** 落点依赖。`metrics` 可缺席(run-local 的 backend 构造期座就没有计数面的消费者)。 */
+export interface MemoryEngineIncidentSinkDeps {
+    logger: Pick<Logger, "warn">;
+    metrics?: Pick<Metrics, "inc">;
+}
+/** 命名照工厂律:返回的是**带行为的闭包** ⇒ `create*`。 */
+export declare function createMemoryEngineIncidentSink(deps: MemoryEngineIncidentSinkDeps): (err: unknown, ctx?: {
+    sessionId?: string;
+}) => void;
+//# sourceMappingURL=memory-incident-sink.d.ts.map

package/dist/memory-incident-sink.js

@@ -0,0 +1,13 @@
+export function createMemoryEngineIncidentSink(deps) {
+    return (err, ctx) => {
+        const code = err?.code;
+        const codeText = typeof code === "string" && code !== "" ? code : undefined;
+        deps.logger.warn("memory_engine_incident", {
+            ...(ctx?.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
+            code: codeText ?? null,
+            detail: String(err),
+        });
+        deps.metrics?.inc("memory_engine_incident_total", { code: codeText ?? "none" });
+    };
+}
+//# sourceMappingURL=memory-incident-sink.js.map

package/dist/memory-operator-faces.d.ts

@@ -104,9 +104,15 @@ export declare function erasureInputSmugglesPrototypeKey(input: unknown): boolea
 /**
  * 在**已装配的记忆后端**上建合规两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
  *
- * `memoryDir` = `boot/stores.ts` 的 `memoryEngine.root`(该部署的记忆工作根)。见文件头 ② 号钉:这两条
- * 路径不读它(erase 的派生索引清扫只在**真有**已删条目的绑定投影时才碰挂载树),传它是为了不发明第二个
- * 「引擎根」的概念 —— 与 `createMemoryBundleFaces` 逐字同一条理由。
+ * `memoryDir` = 引擎的**挂载平面**(`memoryMountRootOf(backend, root)` 单铸点:后端钉了 `directoryRoot`
+ * 就是它 —— file 腿 = `<配置根>/memory`;两只 SQL 孪生不钉 ⇒ 回到配置根,读数逐字节不变)。
+ *
+ * 🔴 **不是 `memoryEngine.root`**(2026 提货批订正,亲读 core 推翻旧注):旧注写着「这两条路径不读它」,
+ * 而实装里 `erase` 的派生索引清扫(`engine.js` 的 `sweepErasedIndexLines`)与 `clearEntryOrigin` 的
+ * 盘上分歧判据(`completeOriginClearance`)都按 `scopeDirFor(this.memoryDir, …)` **真的**去读挂载树 ——
+ * 只是文件头 ② 号钉用的收执里 `erased: []`(清扫提前返回),把这件事测成了恒绿。交配置根的后果是
+ * **静默**:扫一棵不存在的树 ⇒ ENOENT ⇒ 跳过 ⇒ 零残留可报,而真正的 `MEMORY.md` 里还留着被抹条目的
+ * 名字,收执却显示干净。机器钉:`test/memory-operator-faces.test.ts` 的「[ref] 提货」两格。
  */
 export declare function createMemoryComplianceFaces(store: {
     backend: MemoryBackend;

package/dist/memory-operator-faces.js

@@ -1,4 +1,5 @@
 import { MemoryEngine, } from "@sema-agent/core";
+import { memoryMountRootOf } from "./memory-scope.js";
 export function backendOwnsControlPlane(backend) {
     const b = backend;
     return typeof b?.controlPlaneRoot === "string" && b.controlPlaneRoot !== "";
@@ -41,7 +42,7 @@ export function createMemoryComplianceFaces(store, opts) {
         return undefined;
     const engine = new MemoryEngine({
         backend: store.backend,
-        memoryDir: store.root,
+        memoryDir: memoryMountRootOf(store.backend, store.root),
         ...(opts?.onIncident !== undefined ? { onIncident: opts.onIncident } : {}),
         ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}),
     });
@@ -65,7 +66,7 @@ export function createMemoryOriginFaces(store, opts) {
         return undefined;
     const engine = new MemoryEngine({
         backend: store.backend,
-        memoryDir: store.root,
+        memoryDir: memoryMountRootOf(store.backend, store.root),
         ...(opts?.onIncident !== undefined ? { onIncident: opts.onIncident } : {}),
         ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}),
     });
@@ -80,7 +81,7 @@ export function createSessionMemoryStatusFace(store, opts) {
         return undefined;
     const engine = new MemoryEngine({
         backend: store.backend,
-        memoryDir: store.root,
+        memoryDir: memoryMountRootOf(store.backend, store.root),
         ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}),
     });
     return { status: (sessionId) => engine.sessionMemoryStatus(sessionId) };

package/dist/memory-scope.d.ts

@@ -124,11 +124,47 @@ export interface FileMemoryPlane {
  * 返回 `undefined` ⇔ 本部署上 file 记忆引擎**不接线**(多租户 / `MEMORY_ENGINE=off` / 平面分裂车道未 allow)。
  * 门与 `memoryEngineBackendFor` 逐字同源(它就读本函数),所以「有引擎 ⇔ 有控制面 ⇔ 供记录店」三者
  * 在构造上不可能分家。
+ *
+ * 🔴 **core 7.16.0 起每个 scope 的家深一层**(`<memoryDir>/<label>`,缺省 scope `local` ⇒ `memory/local/`),
+ * 而本函数**一个坐标都不用改**:①`memoryDir` 仍是引擎的**平面**(家是它的直接子目录,由引擎自己按注册簿
+ * 铸 —— 本仓绝不自行 `join(memoryDir, scope)`,label 的真源是注册簿,写家的读面是 core 的
+ * `writableRootOf(handle)`);②`controlDir` 的推导键仍是记忆目录本身(亲读 `layout.js` 的
+ * `deriveControlPlaneDir(configRoot, key) = join(configRoot, slugifyPath(resolve(key)), ".engine")`,[ref] 未动),
+ * 所以升级前写下的 capture opt-out 记录、账本、隔离区全部原址可读。升级期的一次性搬家由引擎在 mount 前跑
+ * (`adoptRootScopeLayout`),披露走 incident 座(见 {@link memoryEngineBackendFor} 的 `onIncident`)。
+ * 机器钉:`test/memory-layout-plane.test.ts`。
  */
 export declare function fileMemoryPlaneFor(config: ServiceConfig, fallbackRoot?: string): FileMemoryPlane | undefined;
 /** 控制面目录那一坐标(local 车道 capture 记录店的依托)—— 只是 {@link fileMemoryPlaneFor} 的投影,不是第二条推导。 */
 export declare function fileMemoryControlDirFor(config: ServiceConfig, fallbackRoot?: string): string | undefined;
-export declare function memoryEngineBackendFor(config: ServiceConfig, fallbackRoot?: string): {
+/**
+ * 引擎的**挂载平面**那一坐标 —— 已装配的 backend 钉了就是它(`directoryRoot`;file 腿 = `<root>/memory`),
+ * 没钉就是配置根。
+ *
+ * ## 为什么需要这只谓词(而不是让各处自己 `join(root, "memory")` 或直接用配置根)
+ * 本仓把「引擎根」(`RunnerDeps.memoryEngineDir` = 配置根,core 在它旁边派生控制面与各任务的记忆目录)
+ * 与「挂载平面」(引擎真正读写条目的那棵树)**两只坐标**在装配结果里压成了一只 `root`,于是凡是要后者的
+ * 消费点都拿了前者 —— 差一层。`core 7.16.0` 之前这条差错也在(条目在 `<root>/memory/*.md`,消费点按
+ * `<root>/*.md` 找),只是没有任何一道门看得见;[ref] 把条目再下移一层之后它照样静默。
+ *
+ * 判据与 core **同源**、不是第二条推导:`dist/core/runner/prepare-memory.js` 的
+ * `const pinned = backend.directoryRoot; … typeof pinned === "string" && pinned ? pinned : <派生>`
+ * 逐字同形。鸭子读(`MemoryBackend` 的类型面不声明这一位,core 自己也是鸭子读)与
+ * `backendOwnsControlPlane` 同族 —— 认能力不认后端方言名。
+ *
+ * 两只 SQL 记忆孪生不钉平面(盘上只有每任务的 ephemeral 投影,boot 期没有第二个说得出口的坐标)⇒
+ * 回到配置根,读数与本函数出现之前**逐字节相同**。
+ */
+export declare function memoryMountRootOf(backend: unknown, configRoot: string): string;
+export declare function memoryEngineBackendFor(config: ServiceConfig, fallbackRoot?: string, 
+/** 引擎 backend 的**构造期 incident 座**(core `FileMemoryEngineBackendOptions.onIncident`)。
+ *  接它不是锦上添花:backend 的每个无锁公开面在动注册簿派生的路径前会跑一次布局收编
+ *  (`ensureLayout`),而**那条腿上唯一的披露口就是构造期这只座** —— mount 那条腿拿的是引擎自己的座。
+ *  不接 ⇒ 一次真搬家(`memory.layout_migrated`)或一堆无主根内容(`memory.layout_unowned_root_content`)
+ *  在这条腿上**静默**发生。缺席合法(advisory-silent,与操作面三件套同形)。 */
+onIncident?: (err: Error & {
+    code?: string;
+}) => void): {
     backend: FileMemoryEngineBackend;
     root: string;
 } | undefined;

package/dist/memory-scope.js

@@ -80,11 +80,21 @@ export function fileMemoryPlaneFor(config, fallbackRoot) {
 export function fileMemoryControlDirFor(config, fallbackRoot) {
     return fileMemoryPlaneFor(config, fallbackRoot)?.controlDir;
 }
-export function memoryEngineBackendFor(config, fallbackRoot) {
+export function memoryMountRootOf(backend, configRoot) {
+    const pinned = backend?.directoryRoot;
+    return typeof pinned === "string" && pinned !== "" ? pinned : configRoot;
+}
+export function memoryEngineBackendFor(config, fallbackRoot, onIncident) {
     const plane = fileMemoryPlaneFor(config, fallbackRoot);
     if (plane === undefined)
         return undefined;
-    return { backend: new FileMemoryEngineBackend(plane.memoryDir, { controlDir: plane.controlDir }), root: plane.root };
+    return {
+        backend: new FileMemoryEngineBackend(plane.memoryDir, {
+            controlDir: plane.controlDir,
+            ...(onIncident !== undefined ? { onIncident } : {}),
+        }),
+        root: plane.root,
+    };
 }
 export function memorySpecForRequest(scope, memoryWrite, defaultScopes, originPolicy, memoryCapture) {
     if (!scope)

package/dist/observability/fail-open.d.ts

@@ -19,7 +19,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.trace.gate-outcome-defective": {
         readonly cls: "F";
-        readonly note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`:写腿 `toolEndEventData` 直用;两条耐久读腿(账本回放 `toolResultFieldsOf` / `/decide` 幂等回放 `executionOutcome`)经 `screenedStoredGate` 认过退役词旧拼法后同走这一只筛):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。";
+        readonly note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`:写腿 `toolEndEventData` 直用;**三条**耐久读腿(投影回放 `toolResultFieldsOf`,`GET /v1/tasks/:id/turns` 与 `GET /v1/tasks/:id/stream` 共用 / 账本裸回放 `GET /v1/runs/:id/events`,经 `screenedStoredEventData` / `/decide` 幂等回放 `executionOutcome`)经 `screenedStoredGate` 认过退役词旧拼法后同走这一只筛):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集),**或投影期抛出**(S-239:`settlement.note` / `who.approver` 在 ≥2^23 单段上撞 `redactSecrets` 既有的回溯上界 —— 筛子总函数化后同走这一口,而不是逃出去断掉整条账本流)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。";
     };
     readonly "server.trace.tool-roster-malformed": {
         readonly cls: "F";

package/dist/observability/fail-open.js

@@ -10,7 +10,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.trace.gate-outcome-defective": {
         cls: "F",
-        note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`:写腿 `toolEndEventData` 直用;两条耐久读腿(账本回放 `toolResultFieldsOf` / `/decide` 幂等回放 `executionOutcome`)经 `screenedStoredGate` 认过退役词旧拼法后同走这一只筛):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。",
+        note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`:写腿 `toolEndEventData` 直用;**三条**耐久读腿(投影回放 `toolResultFieldsOf`,`GET /v1/tasks/:id/turns` 与 `GET /v1/tasks/:id/stream` 共用 / 账本裸回放 `GET /v1/runs/:id/events`,经 `screenedStoredEventData` / `/decide` 幂等回放 `executionOutcome`)经 `screenedStoredGate` 认过退役词旧拼法后同走这一只筛):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集),**或投影期抛出**(S-239:`settlement.note` / `who.approver` 在 ≥2^23 单段上撞 `redactSecrets` 既有的回溯上界 —— 筛子总函数化后同走这一口,而不是逃出去断掉整条账本流)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。",
     },
     "server.trace.tool-roster-malformed": {
         cls: "F",

package/dist/plugins/approval-ask-store-memory.js

@@ -1,5 +1,5 @@
 import { canAskTransition } from "../approval-ask-machine.js";
-import { assertIdempotencyKeyShape, ApprovalAskReadAbortedError, projectAskTerminalClaimTruth } from "./approval-ask-store-sql.js";
+import { assertIdempotencyKeyShape, assertIntegralEpochMs, ApprovalAskReadAbortedError, projectAskTerminalClaimTruth } from "./approval-ask-store-sql.js";
 function applyPatch(row, patch) {
     if (patch.decision !== undefined)
         row.decision = patch.decision;
@@ -24,6 +24,8 @@ export class InMemoryApprovalAskStore {
     asks = new Map();
     batches = new Map();
     async ensureAsk(row) {
+        assertIntegralEpochMs("expiresAtMs", row.expiresAtMs);
+        assertIntegralEpochMs("createdAtMs", row.createdAtMs);
         if (!this.batches.has(row.batchId)) {
             this.batches.set(row.batchId, {
                 batchId: row.batchId,

package/dist/plugins/approval-ask-store-sql.d.ts

@@ -226,6 +226,11 @@ export type DecideResult = {
  * `idempotency_conflict`/回放结果。键是调用方铸的 opaque 值,首尾空白没有任何合法语义,
  * 在边界上 fail-loud 拒掉,方言分歧面整个消失(比把列改 VARBINARY 更窄、且对三形同时成立)。
  */
+/** BIGINT 毫秒列的整数守卫(两 twin 同一只):`expires_at_ms` / `created_at_ms` / `updated_at_ms` 落库前必须是
+ *  安全整数。带小数的墙钟(`Date.now() + performance.now()` 派生窗)在 PG 上被 `bigint` 拒收、在 MySQL 协议上被
+ *  隐式截断 —— 两方言不同答;这里改成两方言同一句 TypeError(响亮,点名字段与值),铸点侧(`tool-approval.ts`
+ *  的 deadline 铸点)负责给整数,本守卫只拦漏网。 */
+export declare function assertIntegralEpochMs(field: string, value: number): void;
 export declare function assertIdempotencyKeyShape(key: string): void;
 /**
  * [ref] 车3 刀 3b(§14.2 遗留记账):两条**重放读口**被调用方的 deadline 掐断时抛的具名错误。

package/dist/plugins/approval-ask-store-sql.js

@@ -1,6 +1,11 @@
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { canAskTransition } from "../approval-ask-machine.js";
 import { isDupKeyError, isMissingColumnError } from "./sql-errors.js";
+export function assertIntegralEpochMs(field, value) {
+    if (!Number.isSafeInteger(value)) {
+        throw new TypeError(`approval-ask store: ${field} must be an integer epoch-ms (BIGINT column), got ${String(value)}`);
+    }
+}
 export function assertIdempotencyKeyShape(key) {
     if (key.length === 0 || key.length > 255 || key.trim() !== key) {
         throw new Error(`invalid idempotency key: must be 1-255 chars with no leading/trailing whitespace (got ${JSON.stringify(key.slice(0, 32))}${key.length > 32 ? "…" : ""}, length ${key.length})`);
@@ -314,6 +319,8 @@ export class SqlApprovalAskStore {
         return rows[0] ? mapBatchRow(rows[0]) : null;
     }
     async ensureAsk(row) {
+        assertIntegralEpochMs("expiresAtMs", row.expiresAtMs);
+        assertIntegralEpochMs("createdAtMs", row.createdAtMs);
         const now = row.createdAtMs;
         let insertedRows = 0;
         const conn = await this.db.connect();

package/dist/plugins/file-run-store.js

@@ -88,6 +88,7 @@ export class FileRunStore {
             jobId: r.jobId,
             source: r.source,
             instanceId: r.instanceId,
+            cancelRequested: r.cancelRequested,
             objectivePreview: r.objectivePreview,
             createdAt: r.createdAt.toISOString(),
             updatedAt: r.updatedAt.toISOString(),

package/dist/plugins/memory-run-store.js

@@ -23,6 +23,7 @@ export class MemoryRunStore {
             jobId: r.jobId,
             source: r.source,
             instanceId: r.instanceId,
+            cancelRequested: r.cancelRequested,
             objectivePreview: r.objectivePreview,
             createdAt: r.createdAt.toISOString(),
             updatedAt: r.updatedAt.toISOString(),

package/dist/plugins/run-store-sql.d.ts

@@ -6,7 +6,6 @@ import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult } from ".
 import { type SqlDriver } from "./sql-driver.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
 export type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
-/** Dual-dialect async run registry + event log. See the file header for the dialect-delta ledger. */
 export declare class SqlRunStore {
     protected readonly db: SqlDriver;
     constructor(db: SqlDriver);
@@ -124,7 +123,11 @@ export declare class SqlRunStore {
     /** The active run's taskId for a session (the `task_active` claim) — lets resume find the suspended run row. */
     getActiveTaskId(sessionId: string): Promise<string | undefined>;
     /** Shared row→record mapper — byte-identical between dialects (both drivers hand back the same column
-     *  names + comparable JS types after SqlDriver's result normalization). */
+     *  names + comparable JS types after SqlDriver's result normalization).
+     *  🔴 **读它的每一条查询都必须选 {@link RUN_ROW_COLS}**(S-230):映射器对「没被 SELECT 的列」是
+     *  结构性失明的 —— `undefined ?? null` 与 `Boolean(undefined)` 都会安静地铸出一个**看上去合法的假值**。
+     *  修前 `listRuns` 的两条方言臂就漏选 `instance_id`,于是列表面的每一行 `instanceId` 恒 `null`
+     *  (今天没有消费点,所以没人发现)。列表收成一个常量 = 这类漏选从此不可能发生。 */
     private rowToRun;
     getRun(taskId: string): Promise<RunRecord | undefined>;
     /** Task Trace list (S1): runs newest-first, keyset-paginated on (created_at, task_id). Optional status +

package/dist/plugins/run-store-sql.js

@@ -7,6 +7,7 @@ import { parseJsonLenient as parseJson, toIso as iso } from "./sql-row-helpers.j
 import { notifyRunTerminal, runTerminalLogLevel } from "../observability/run-terminal-log.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
+const RUN_ROW_COLS = "task_id, session_id, owner, status, result, error, error_code, job_id, source, instance_id, cancel_requested, objective_preview, created_at, updated_at";
 export class SqlRunStore {
     db;
     constructor(db) {
@@ -182,13 +183,14 @@ export class SqlRunStore {
             jobId: r.job_id ?? null,
             source: r.source ?? null,
             instanceId: r.instance_id ?? null,
+            cancelRequested: Boolean(r.cancel_requested),
             objectivePreview: r.objective_preview ?? null,
             createdAt: iso(r.created_at),
             updatedAt: iso(r.updated_at),
         };
     }
     async getRun(taskId) {
-        const { rows } = await this.db.query(this.q("SELECT task_id, session_id, owner, status, result, error, error_code, job_id, source, instance_id, objective_preview, created_at, updated_at FROM task_run WHERE task_id = ?", "SELECT task_id, session_id, owner, status, result, error, error_code, job_id, source, instance_id, objective_preview, created_at, updated_at FROM task_run WHERE task_id = $1"), [taskId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${RUN_ROW_COLS} FROM task_run WHERE task_id = ?`, `SELECT ${RUN_ROW_COLS} FROM task_run WHERE task_id = $1`), [taskId]);
         return rows[0] ? this.rowToRun(rows[0]) : undefined;
     }
     async listRuns(opts) {
@@ -217,7 +219,7 @@ export class SqlRunStore {
                 where.push("(created_at < ? OR (created_at = ? AND task_id < ?))");
                 params.push(new Date(opts.cursor.createdAt), new Date(opts.cursor.createdAt), opts.cursor.taskId);
             }
-            const sql = "SELECT task_id, session_id, owner, status, result, error, error_code, job_id, source, objective_preview, created_at, updated_at FROM task_run" +
+            const sql = `SELECT ${RUN_ROW_COLS} FROM task_run` +
                 (where.length ? " WHERE " + where.join(" AND ") : "") +
                 " ORDER BY created_at DESC, task_id DESC LIMIT ?";
             params.push(opts.limit);
@@ -244,7 +246,7 @@ export class SqlRunStore {
             const t = p(opts.cursor.taskId);
             where.push(`(created_at < ${a} OR (created_at = ${b} AND task_id < ${t}))`);
         }
-        const sql = "SELECT task_id, session_id, owner, status, result, error, error_code, job_id, source, objective_preview, created_at, updated_at FROM task_run" +
+        const sql = `SELECT ${RUN_ROW_COLS} FROM task_run` +
             (where.length ? " WHERE " + where.join(" AND ") : "") +
             ` ORDER BY created_at DESC, task_id DESC LIMIT ${p(opts.limit)}`;
         const { rows } = await this.db.query(sql, params);

package/dist/plugins/store-contracts.d.ts

@@ -101,6 +101,20 @@ export interface RunRecord {
      *  MY replica" (consult the in-process inflight/steerable map authoritatively) from "held elsewhere" (fall
      *  back to the durable cross-replica flag). null for pre-column rows. */
     instanceId: string | null;
+    /** 🔴 S-230 P-45 —— 这条 run 上**挂没挂着取消请求**(耐久 `cancel_requested` 列的投影,跨副本)。
+     *
+     *  语义就是那一列的字节:`POST /v1/runs/:id/cancel` 的 running 臂 CAS 成功即置位,持有副本的心跳拍
+     *  poll 到它就 abort;`markResuming`(续跑认领)把它清零 —— 一次撞上 suspend 的取消不许在恢复之后
+     *  再杀一遍(那条 reset 的理由逐字在 run-store-sql `markResuming` 上)。
+     *
+     *  为什么是**行上的一位**而不是读面再查一次:列早就在(三个后端同名),只是行投影没带它 —— 正是
+     *  本仓 L1 键集门盯的那族「投影剥键」。读面每次 poll 再发一条 `isCancelRequested` 查询,是给热路径
+     *  加一次往返去拿一个本来就在同一行里的字节。
+     *
+     *  ⚠️ **终局行上这一位读作「历史」不是「结论」**:取消的终局事实是 `status`+`errorCode:"cancelled"`
+     *  (那条腿不经这一位),而 suspended 臂的取消**根本不置位**(它直接终局化行)。消费端判「这条 run
+     *  被取消了没有」看终局码;判「一条还在跑的 run 上有没有人按过取消」才看这一位。 */
+    cancelRequested: boolean;
     /** First ~120 chars of the objective (secret-redacted at write) — the list's "what is this task" glance.
      *  null for rows predating the column. */
     objectivePreview: string | null;

package/dist/run-local.js

@@ -28,6 +28,7 @@ import { buildScenarios, selectScenario, centerScenarios } from "./capabilities/
 import { createTaskListLane } from "./boot/task-list-lane.js";
 import { pickHandsRunner, withoutExecutionEnv } from "./capabilities/hands-lane.js";
 import { HttpError } from "./security.js";
+import { createMemoryEngineIncidentSink } from "./memory-incident-sink.js";
 import { memoryEngineBackendFor, memorySpecForRequest } from "./memory-scope.js";
 import { createMemorySyncRunner, createMemorySyncTransport } from "./memory-sync-client.js";
 import { buildPricing, cappedCeiling, createTracer } from "./budget.js";
@@ -173,6 +174,7 @@ export async function runLocal(argv, deps = {}) {
     const config = loadConfig();
     const logger = deps.logger ?? createLogger(config.logLevel);
     const metrics = createMetrics();
+    const memoryEngineIncident = createMemoryEngineIncidentSink({ logger, metrics });
     installSecretEnvScrubRecorder({ logger, metrics });
     logConfigDiagnostics(logger);
     const configProvider = createConfigProvider({
@@ -283,7 +285,7 @@ export async function runLocal(argv, deps = {}) {
         })
         : undefined;
     const lspManager = hostRx && config.lspHostEnabled && config.requirePrincipal !== true ? new NodeLspManager({ log: (event, fields) => logger.info(event, fields) }) : undefined;
-    const memoryEngine = memoryEngineBackendFor(config, root);
+    const memoryEngine = memoryEngineBackendFor(config, root, memoryEngineIncident);
     let memorySync;
     if (config.memorySync && memoryEngine) {
         memorySync = createMemorySyncRunner({
@@ -337,12 +339,18 @@ export async function runLocal(argv, deps = {}) {
         askYesNo: deps.askYesNo ?? promptYesNoOnTty,
         printErr,
     });
-    const engineOnError = (err, ctx) => logger.warn("engine_error", {
-        phase: ctx.phase,
-        sessionId: ctx.sessionId,
-        ...(ctx.classification !== undefined ? { classification: ctx.classification } : {}),
-        err: String(err),
-    });
+    const engineOnError = (err, ctx) => {
+        if (ctx.phase === "memory") {
+            memoryEngineIncident(err, ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : undefined);
+            return;
+        }
+        logger.warn("engine_error", {
+            phase: ctx.phase,
+            sessionId: ctx.sessionId,
+            ...(ctx.classification !== undefined ? { classification: ctx.classification } : {}),
+            err: String(err),
+        });
+    };
     let orgMemoryAdmission;
     try {
         orgMemoryAdmission = createOrgMemoryAdmissionWiring({ config, logger, metrics });