@sema-agent/server 7.55.0 → 7.57.0

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

@@ -15,12 +15,77 @@
  *    code should import from this file.
  */
 import type { TaskResult, TaskStatus } from "@sema-agent/core";
+/**
+ * 取消便签里的**大脑相位**快照 —— core `BrainStatus` 帧经 `brainStatusEventData` 投影后的五键子集。
+ *
+ * 刻意**不含** `detail`(provider 自由文本,宽面)与 `retryInMs`/`retryInSec`(相对量,过期即失真;
+ * 绝对量 `retryAtMs` 才是可跨进程读的那个,core 顶注已裁)。`phase` 是这只快照的存在理由:没有它
+ * 就没有快照(不铸半只)。
+ */
+export interface RunBrainStatusSnapshot {
+    phase: string;
+    attempt?: number;
+    maxRetries?: number;
+    /** 等待结束的**墙钟**时刻(发端进程钟域,非单调)—— 只当近似,别与本地单调计时器比。 */
+    retryAtMs?: number;
+    errClass?: string;
+}
+/**
+ * [ref] 件3(cli [ref] sema-bug4 (d) / server [ref]):**用户取消时的现场快照**。
+ *
+ * 病(取证 `audits/evidence/2026-09-03-model-failure-visibility/`):模型挂起 7 分 26 秒后用户放弃,
+ * 账本把这条 run 记成 `failed` + `errorCode:"cancelled"` + 「stream client disconnected before
+ * completion」—— 与「用户看了一眼不想跑了,秒按 Esc」**同形**。历史 314 条里 96 条 failed、其中 63 条
+ * 是 `user_disconnect`,「其中有多少条其实是模型挂死」在数据面**不可考**。
+ *
+ * 本结构是那一维判别材料:取消发生时,距离**本 run 上一条引擎事件**过了多久。
+ *
+ * 【语义边界(勿漂)】
+ * - 它**不**描述模型调用相位(首字节/重试在 core 的 stream-engine/with-retry 里,server 结构上看不见
+ *   ——那半场是 [ref] 的 core 钩,别在这里编造)。它只说「server 这一侧多久没收到这条 run 的动静了」。
+ * - `lastEventKind`/`lastEventAgeMs` 的数据源是**同副本进程内**的 turn 活性登记(`turn-activity.ts`)。
+ *   跨副本 / 本副本重启后读不到 ⇒ 两键**诚实缺席**(缺席 = 「证不出」,不是「0ms 前刚活过」)。
+ * - `elapsedMs` 恒在场:run 起跑到取消的墙钟毫秒。
+ * - 分诊材料,不是状态机输入:任何门 / CAS / resume 判定都不许读它。
+ *
+ * 落点 = 终局 `result` blob 里的一个 additive 可缺席键({@link PersistedTaskResult}),**零新列**
+ * ——run 行的 `result` 本来就是整只 JSON 存(SQL 双方言同形),所以两个孪生都不需要 DDL 变更。
+ */
+export interface RunCancelContext {
+    /** 最后一条进本 run durable 账本的事件类型(`text` / `tool_start` / `status` / …)。
+     *  🔴 它比 {@link RunCancelContext.lastEventAgeMs} **更容易缺席**(codex 交叉复审 R1-[medium],验真后
+     *  改的正是这条契约):打点方里有几席拿不到事件类型(core 的 `onActivity` 第五席、resume 腿的手动
+     *  打点),它们只推进「时刻」不带「词」。所以两键**不是**同在同缺 —— 有 age 无 kind 是合法读数,
+     *  意思是「本副本知道那一刻,但说不出那是条什么事件」。 */
+    lastEventKind?: string;
+    /** 距最后一条 durable 事件过了多久(ms,≥0)。同副本有活性登记就在场。 */
+    lastEventAgeMs?: number;
+    /** 本 run 账本尾**最后一条** `status`(BrainStatus)帧的五键快照([ref]/[ref])——「已重试几次 /
+     *  在等什么 / 什么错类」。这条帧 server 早就在透传与落账(`trace/project.ts` 的 `brainStatusEventData`),
+     *  取消时把最后一条摘下来当便签,**不需要 core 新钩**。sticky:后续 text/tool 事件不清它。
+     *  这条 run 从没出过 status 帧(或跨副本读不到)⇒ 缺席,恒不铸 null。 */
+    lastBrainStatus?: RunBrainStatusSnapshot;
+    /** run 起跑到本次取消的墙钟毫秒(≥0)。常态在场;行的 `createdAt` 坏到解析不出时缺席
+     *  ——**绝不折成 0**(0 会被读成「刚起跑就取消」,与本结构要判别的那件事正好相反)。 */
+    elapsedMs?: number;
+}
+/**
+ * 落库/上 wire 的终局结果 = core 的 `TaskResult` **加上** server 自铸的可缺席侧记键。
+ *
+ * 今天只有一个成员({@link RunCancelContext});additive 且可缺席,所以旧行、旧消费端逐字不受影响
+ * (`TaskResult` 仍可原样赋给本型)。⚠️ 这不是给「往 core 结果里塞私货」开的口子:每加一个键都要能
+ * 回答「为什么它属于 run 账本而不属于 core 的任务结果」——`cancelContext` 的答案是它描述的是
+ * **server 侧的取消现场**,core 那一侧根本不知道有人按了取消。
+ */
+export type PersistedTaskResult = TaskResult & {
+    cancelContext?: RunCancelContext;
+};
 export interface RunRecord {
     taskId: string;
     sessionId: string;
     owner: string | null;
     status: "running" | TaskStatus;
-    result: TaskResult | null;
+    result: PersistedTaskResult | null;
     error: string | null;
     /** Structured failure code (1.36/1.37) denormalized from the result for SQL queryability. */
     errorCode: string | null;
@@ -94,6 +159,10 @@ export interface SessionSummary {
     /** K-5c (shell §K): the LATEST run's task_id — the anchor the shell uses to re-attach the live event tail in ONE
      *  hop (`GET /v1/runs/:lastRunId/events`) when resuming a picked session, instead of a second lookup. */
     lastRunId: string | null;
+    /** [ref]([ref]/[ref]):latest 终局 run 的 engine runId(`TaskResult.runId`,latest.result JSON 提取的
+     *  零迁移路线 —— result 终局才写 ⇒ 在跑 run 键诚实缺席);OMIT-when-absent,恒不铸 null。轴辨析与
+     *  wire 半场见 `security.ts SessionListItem.lastTaskRunId`(同名同义)。 */
+    lastTaskRunId?: string;
     /** The auto-generated session title (cheap-model one-liner, write-once). null = not (yet)
      *  titled OR the lister face has no session_meta (the legacy task_run aggregate / memory twins — honest degrade). */
     title: string | null;

package/dist/plugins/tidb-session-store.js

@@ -144,28 +144,32 @@ export class TiDBSessionStore {
             params.push(new Date(opts.cursor.lastActivityAt), new Date(opts.cursor.lastActivityAt), opts.cursor.sessionId);
         }
         const sql = "SELECT sm.session_id, sm.owner, sm.updated_at AS last_activity, sm.created_at AS first_activity, sm.title, " +
-            "  COALESCE(r.run_count, 0) AS run_count, latest.objective_preview, latest.status, latest.task_id AS last_run_id " +
+            "  COALESCE(r.run_count, 0) AS run_count, latest.objective_preview, latest.status, latest.task_id AS last_run_id, latest.last_task_run_id " +
             "FROM session_meta sm " +
             "LEFT JOIN (SELECT session_id, COUNT(*) AS run_count FROM task_run GROUP BY session_id) r ON r.session_id = sm.session_id " +
-            "LEFT JOIN (SELECT session_id, objective_preview, status, task_id FROM (" +
-            "    SELECT session_id, objective_preview, status, task_id, " +
+            "LEFT JOIN (SELECT session_id, objective_preview, status, task_id, last_task_run_id FROM (" +
+            "    SELECT session_id, objective_preview, status, task_id, JSON_UNQUOTE(JSON_EXTRACT(result, '$.runId')) AS last_task_run_id, " +
             "      ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY created_at DESC, task_id DESC) AS rn FROM task_run" +
             "  ) lr WHERE rn = 1) latest ON latest.session_id = sm.session_id " +
             (where.length ? "WHERE " + where.join(" AND ") + " " : "") +
             "ORDER BY sm.updated_at DESC, sm.session_id DESC LIMIT ?";
         params.push(opts.limit);
         const [rows] = await this.pool.query(sql, params);
-        return rows.map((r) => ({
-            sessionId: String(r.session_id),
-            owner: r.owner ?? null,
-            lastActivityAt: r.last_activity instanceof Date ? r.last_activity.toISOString() : String(r.last_activity),
-            firstActivityAt: r.first_activity instanceof Date ? r.first_activity.toISOString() : String(r.first_activity),
-            runCount: Number(r.run_count),
-            objectivePreview: r.objective_preview ?? null,
-            lastStatus: r.status == null ? "" : String(r.status),
-            lastRunId: r.last_run_id ?? null,
-            title: r.title ?? null,
-        }));
+        return rows.map((r) => {
+            const runId = r.last_task_run_id;
+            return {
+                sessionId: String(r.session_id),
+                owner: r.owner ?? null,
+                lastActivityAt: r.last_activity instanceof Date ? r.last_activity.toISOString() : String(r.last_activity),
+                firstActivityAt: r.first_activity instanceof Date ? r.first_activity.toISOString() : String(r.first_activity),
+                runCount: Number(r.run_count),
+                objectivePreview: r.objective_preview ?? null,
+                lastStatus: r.status == null ? "" : String(r.status),
+                lastRunId: r.last_run_id ?? null,
+                ...(typeof runId === "string" && runId !== "" ? { lastTaskRunId: runId } : {}),
+                title: r.title ?? null,
+            };
+        });
     }
     async probeTitle(sessionId) {
         const [rows] = await this.pool.query("SELECT title FROM session_meta WHERE session_id = ?", [sessionId]);

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

@@ -75,6 +75,11 @@ export type InboxWarn = typeof onWarnType;
  *  with an explicit marker. Returns null only when even the skeleton is oversize (physics — caller keeps the
  *  prior revision, matching the old behavior for that corner). Dialect-neutral (pure JS, no SQL) — shared
  *  verbatim by both twins. */
+/** S-107:workflow_run 行的 `error`(脚本抛出的 `err.message`,core 源头不脱)在**两条写腿**(put / update 常态 + oversize 降级)
+ *  同一口脱;`result` 由 core 完成时源头脱。幂等,不抛(超大 ⇒ 占位)。 */
+export declare function withRedactedError<T extends {
+    error?: string | undefined;
+}>(run: T): T;
 export declare function slimOversizeRun(run: WorkflowRun & {
     id: string;
     scope: string;

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

@@ -1,16 +1,23 @@
+import { redactErrorMessage, redactHead } from "../observability/run-terminal-log.js";
 import { summarizeWorkflowRun, isTerminalWorkflowStatus, WorkflowRunStoreError } from "@sema-agent/core";
 import { foldKeyFamily, MAX_PENDING_PER_SESSION, PURGE_FENCE_MS, SERVED_FENCE_MS, } from "../orchestration/workflow-completion-inbox.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
 export const MAX_RUN_BLOB_BYTES = 4 * 1024 * 1024;
 const onWarnType = (msg, meta) => void [msg, meta];
+export function withRedactedError(run) {
+    if (typeof run.error !== "string")
+        return run;
+    const error = redactErrorMessage(run.error) ?? "";
+    return error === run.error ? run : { ...run, error };
+}
 export function slimOversizeRun(run, maxBytes) {
     const MARK = "…[truncated: run blob exceeded the store cap]";
     const cut = (s) => s.slice(0, 4000) + MARK;
     const step1 = {
         ...run,
         ...(typeof run.result === "string" && run.result.length > 4000 ? { result: cut(run.result) } : {}),
-        ...(typeof run.error === "string" && run.error.length > 4000 ? { error: cut(run.error) } : {}),
+        ...(typeof run.error === "string" && run.error.length > 4000 ? { error: redactHead(run.error, 4000) + MARK } : {}),
     };
     let blob = JSON.stringify(step1);
     if (Buffer.byteLength(blob) <= maxBytes)
@@ -30,7 +37,7 @@ export class SqlWorkflowRunStore {
         return this.db.dialect === "tidb" ? tidb : pg;
     }
     async put(id, run) {
-        const stored = { ...run, id, rev: run.rev ?? 0 };
+        const stored = { ...withRedactedError(run), id, rev: run.rev ?? 0 };
         try {
             await this.db.query(this.q("INSERT INTO workflow_run (id, scope, status, run, rev, created_at_ms, ended_at_ms) VALUES (?,?,?,?,?,?,?)", "INSERT INTO workflow_run (id, scope, status, run, rev, created_at_ms, ended_at_ms) VALUES ($1,$2,$3,$4,$5,$6,$7)"), [id, run.scope, run.status, JSON.stringify(stored), stored.rev, run.createdAt, run.endedAt ?? null]);
         }
@@ -51,6 +58,7 @@ export class SqlWorkflowRunStore {
         return run;
     }
     async update(id, scope, run, expect) {
+        run = withRedactedError(run);
         let blob = JSON.stringify({ ...run, id, scope });
         if (Buffer.byteLength(blob) > MAX_RUN_BLOB_BYTES) {
             this.onWarn?.("workflow_run_blob_oversize_slimmed", { id, scope, fullBytes: Buffer.byteLength(blob), capBytes: MAX_RUN_BLOB_BYTES });

package/dist/rules-consent.d.ts

@@ -1,6 +1,6 @@
 import { type RuleOwner, type ImportPreview, type RedeemedBatchMember, type ImportedSettingsLayer, type PersistedAllowRule, type RemoveResult, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
 import type { PermissionRuleStoreProvider, RuleApprovalRecordStore } from "@sema-agent/core";
-import { type RuleImportTicket, type RuleTicketDecisionClock, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./plugins/permission-rule-store-sql.js";
+import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./plugins/permission-rule-store-sql.js";
 /**
  * 本车道**真正**依赖的三面(**结构**接口,不是 SQL 类)。
  *
@@ -31,12 +31,13 @@ export interface RuleConsentStores {
         }): Promise<RuleImportTicket>;
         /** 一次**认领**(不是「已完成」)。语义与「认领之后怎么办」见 {@link RuleConsentStores.tickets.release}。
          *  `purpose` = 车道绑定(A7 R1-F2):一条车道的口只认它自己铸的票,不符与「票不存在」同形。
-         *  `opts.decisionNowMs` = [ref]③ 的判定钟覆写(记账列不受影响),见 {@link RuleTicketDecisionClock}。 */
-        consume(ticketId: string, principal: string, purpose: RuleTicketPurpose, opts?: RuleTicketDecisionClock): Promise<RuleTicketRedeemResult>;
+         *  🔴 **不收任何时刻量**([ref]):过期判定是店自己的事,由店那口钟(SQL=数据库的钟 / local=本进程的
+         *  墙钟)在**语句执行的那一刻**答。车道递一个时刻进来,就等于让副本的钟参与授权判决。 */
+        consume(ticketId: string, principal: string, purpose: RuleTicketPurpose): Promise<RuleTicketRedeemResult>;
         /** 把认领**放回去**(认领之后遇到不确定/瞬时失败时)。`claimId` = 本次认领的代次(A7 R1-F1 围栏:
          *  被顶替的旧持有者动不了现持有者的认领);`mustRemainValidMs` = 放回之后这张票至少还要能用多久
          *  —— 撑不过就**不算放回成功**(理由逐字见 store 侧 `release` 的头注)。 */
-        release(ticketId: string, principal: string, claimId: string, mustRemainValidMs?: number, opts?: RuleTicketDecisionClock): Promise<boolean>;
+        release(ticketId: string, principal: string, claimId: string, mustRemainValidMs?: number): Promise<boolean>;
         /**
          * [ref] A7 三态协议的三条口(CLAIMED → SETTLED / 三态快照 / 崩溃窗抢认领)。
          *

package/dist/rules-consent.js

@@ -80,7 +80,10 @@ function isSupportedRuleMatch(match) {
     switch (match) {
         case "exact":
         case "prefix":
+        case "wildcard":
             return true;
+        case "subpath":
+            return false;
         default: {
             const unknown = match;
             void unknown;
@@ -166,25 +169,28 @@ function screenLocalImportRow(row) {
             detail: "this project root carries control bytes (C0/DEL) — it is not a path, one SQL dialect refuses to store it at all, and it breaks the separator assumption this lane's comparison keys rest on",
         };
     }
+    const consistent = (derived) => {
+        if (derived.tool !== row.tool || derived.match !== row.match || derived.command !== row.command) {
+            return {
+                reason: "row_inconsistent",
+                detail: `this row's tool/match/command are derived facts of its rule text, and they disagree: the rule reads as ` +
+                    `${derived.tool}/${derived.match}/${JSON.stringify(derived.command)} but the row says ${String(row.tool)}/${String(row.match)}/${JSON.stringify(row.command)}`,
+            };
+        }
+        return { rule: derived.rule, scope };
+    };
+    const written = parseAllowRuleText(row.rule);
+    if ("reject" in written)
+        return { reason: "rule_rejected", detail: `${written.reject.code}: ${written.reject.message}` };
+    if (written.rule.tool === "Read")
+        return consistent(written.rule);
     const pre = precheckCardRuleText(row.rule, row.command);
     if (pre === undefined) {
         return { reason: "rule_uncheckable", detail: "the rule text gate could not be asked about this row (its command is absent or not a string) — the row itself is malformed" };
     }
     if (!pre.ok)
         return { reason: "rule_rejected", detail: pre.message };
-    const canonical = parseAllowRuleText(pre.canonicalRule);
-    if ("reject" in canonical) {
-        return { reason: "rule_rejected", detail: `the canonical spelling the engine minted does not re-parse: ${canonical.reject.message}` };
-    }
-    const derived = canonical.rule;
-    if (derived.tool !== row.tool || derived.match !== row.match || derived.command !== row.command) {
-        return {
-            reason: "row_inconsistent",
-            detail: `this row's tool/match/command are derived facts of its rule text, and they disagree: the rule reads as ` +
-                `${derived.tool}/${derived.match}/${JSON.stringify(derived.command)} but the row says ${String(row.tool)}/${String(row.match)}/${JSON.stringify(row.command)}`,
-        };
-    }
-    return { rule: derived.rule, scope };
+    return consistent(written.rule);
 }
 const LOCAL_IMPORT_LAYER_PATH = "local-import:rules";
 const CONTROL_AND_BIDI_DETECT_RE = new RegExp(`[${CONTROL_AND_BIDI_CHARS}]`);
@@ -230,27 +236,6 @@ export function createRuleConsentLane(stores, opts) {
     const monotonic = opts?.monotonic ?? (() => performance.now());
     const sleep = opts?.sleep ?? (async (ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const localImportLogger = createLogger();
-    const anchors = new Map();
-    const ANCHOR_CAP = 4096;
-    const pruneAnchors = (nowMono) => {
-        for (const [id, a] of anchors) {
-            if (nowMono - a.mintedAtMono > ticketTtlMs)
-                anchors.delete(id);
-        }
-        if (anchors.size <= ANCHOR_CAP)
-            return;
-        const excess = anchors.size - ANCHOR_CAP;
-        let dropped = 0;
-        for (const id of anchors.keys()) {
-            if (dropped++ >= excess)
-                break;
-            anchors.delete(id);
-        }
-    };
-    const decisionClock = (ticketId) => {
-        const a = anchors.get(ticketId);
-        return a === undefined ? undefined : { decisionNowMs: Math.ceil(a.mintedAtWall + (monotonic() - a.mintedAtMono)) };
-    };
     return {
         async persistCardRule(input) {
             let prepared;
@@ -262,6 +247,7 @@ export function createRuleConsentLane(stores, opts) {
                     ...(input.toolCallId !== undefined ? { toolCallId: input.toolCallId } : {}),
                     ...(input.boundInputHash !== undefined ? { boundInputHash: input.boundInputHash } : {}),
                     ...(input.scope !== undefined ? { scope: input.scope } : {}),
+                    ...(input.scope?.kind === "project" ? { cwd: input.scope.root } : {}),
                     deps,
                 });
             }
@@ -360,14 +346,10 @@ export function createRuleConsentLane(stores, opts) {
                 }
                 return { ok: false, reason: "too-many-candidates", candidates: preview.candidates.length };
             }
-            const mintedAtMono = monotonic();
             const minted = await stores.tickets.mint({ ticketId: newTicketId(), principal, approvalId, purpose: "cc-import", candidates: preview.candidates, ttlMs: ticketTtlMs });
-            pruneAnchors(mintedAtMono);
-            anchors.set(minted.ticketId, { mintedAtWall: minted.expiresAtMs - ticketTtlMs, mintedAtMono });
             return { ok: true, preview, ticket: minted.ticketId, expiresAtMs: minted.expiresAtMs };
         },
         async redeemImport(principal, ticket) {
-            const clock = decisionClock(ticket);
             const consumeOutcomeAfterThrow = async (err) => {
                 localImportLogger.warn("cc_import_claim_write_failed", {
                     err: err instanceof Error ? err.message : String(err),
@@ -398,7 +380,7 @@ export function createRuleConsentLane(stores, opts) {
             };
             let consumed;
             try {
-                consumed = await stores.tickets.consume(ticket, principal, "cc-import", clock);
+                consumed = await stores.tickets.consume(ticket, principal, "cc-import");
             }
             catch (err) {
                 return await consumeOutcomeAfterThrow(err);
@@ -407,7 +389,7 @@ export function createRuleConsentLane(stores, opts) {
                 return { ok: false, reason: "ticket-unusable", detail: consumed.reason };
             const releaseClaim = async () => {
                 try {
-                    return await stores.tickets.release(ticket, principal, consumed.claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000, decisionClock(ticket));
+                    return await stores.tickets.release(ticket, principal, consumed.claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000);
                 }
                 catch (err) {
                     recordFailOpen("server.rules.ticket-claim-release-failed", err instanceof Error ? err.message : String(err));
@@ -496,10 +478,7 @@ export function createRuleConsentLane(stores, opts) {
             }
             if (approvalId === undefined)
                 return { ok: true, preview: { members } };
-            const mintedAtMono = monotonic();
             const minted = await stores.tickets.mint({ ticketId: newTicketId(), principal, approvalId, purpose: "local-import", candidates: preview.candidates, ttlMs: ticketTtlMs });
-            pruneAnchors(mintedAtMono);
-            anchors.set(minted.ticketId, { mintedAtWall: minted.expiresAtMs - ticketTtlMs, mintedAtMono });
             return { ok: true, preview: { members }, ticket: minted.ticketId, expiresAtMs: minted.expiresAtMs };
         },
         async redeemLocalImport(principal, ticket) {
@@ -530,7 +509,7 @@ export function createRuleConsentLane(stores, opts) {
             const driveAndSettle = async (approvalId, payloadHash, claimId) => {
                 const tryRelease = async () => {
                     try {
-                        return await stores.tickets.release(ticket, principal, claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000, decisionClock(ticket));
+                        return await stores.tickets.release(ticket, principal, claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000);
                     }
                     catch (err) {
                         recordFailOpen("server.rules.ticket-claim-release-failed", err instanceof Error ? err.message : String(err));
@@ -638,7 +617,7 @@ export function createRuleConsentLane(stores, opts) {
             };
             let consumed;
             try {
-                consumed = await stores.tickets.consume(ticket, principal, "local-import", decisionClock(ticket));
+                consumed = await stores.tickets.consume(ticket, principal, "local-import");
             }
             catch (err) {
                 return await claimOutcomeAfterThrow(err, "consume");
@@ -660,7 +639,7 @@ export function createRuleConsentLane(stores, opts) {
                     case "minted": {
                         let again;
                         try {
-                            again = await stores.tickets.consume(ticket, principal, "local-import", decisionClock(ticket));
+                            again = await stores.tickets.consume(ticket, principal, "local-import");
                         }
                         catch (err) {
                             return await claimOutcomeAfterThrow(err, "consume");

package/dist/run-cancel-context.d.ts

@@ -0,0 +1,13 @@
+import type { RunCancelContext } from "./plugins/store-contracts.js";
+/**
+ * @param taskId  这条 run 的账本 id(turn 活性登记的键)。
+ * @param startedAtMs 这条 run 起跑的墙钟时刻(epoch ms):取消腿手上有行就用行的 `createdAt`,
+ *                    只有本腿起点时用本腿起点(两者在同一条 run 上相差 ms 级)。**非有限值**
+ *                    (坏 `createdAt` 解析出的 NaN)⇒ `elapsedMs` 诚实缺席,绝不折成 0
+ *                    ——0 会被读成「刚起跑就取消了」,与「模型挂死 8 分钟后用户放弃」正好相反。
+ * @param nowMs 取样时刻(缺省 `Date.now()`;测试注入用)。
+ * @returns 三键至少有一键可证时的快照;**一键都证不出** ⇒ `undefined`(写一只空对象等于在 wire 上
+ *          断言「我看过现场,什么都没有」,而事实是「我什么都没看见」)。
+ */
+export declare function buildCancelContext(taskId: string, startedAtMs: number, nowMs?: number): RunCancelContext | undefined;
+//# sourceMappingURL=run-cancel-context.d.ts.map

package/dist/run-cancel-context.js

@@ -0,0 +1,15 @@
+import { readTurnActivity } from "./turn-activity.js";
+export function buildCancelContext(taskId, startedAtMs, nowMs = Date.now()) {
+    const activity = readTurnActivity(taskId);
+    const age = activity === undefined ? undefined : Math.max(0, nowMs - activity.at);
+    const elapsedMs = Number.isFinite(startedAtMs) ? Math.max(0, nowMs - startedAtMs) : undefined;
+    if (age === undefined && elapsedMs === undefined)
+        return undefined;
+    return {
+        ...(activity?.kind !== undefined ? { lastEventKind: activity.kind } : {}),
+        ...(age !== undefined ? { lastEventAgeMs: age } : {}),
+        ...(activity?.brainStatus !== undefined ? { lastBrainStatus: activity.brainStatus } : {}),
+        ...(elapsedMs !== undefined ? { elapsedMs } : {}),
+    };
+}
+//# sourceMappingURL=run-cancel-context.js.map

package/dist/run-local.js

@@ -14,7 +14,7 @@ import { ForkRoutingSessionStore } from "./plugins/fork-routing-session-store.js
 import { taskWallClockSec } from "./task-workflow.js";
 import { applyCatalogToSource } from "./capabilities/center-prompts.js";
 import { validatePromptsDomain, CORE_ENGINE_VERSION } from "./prompts-domain-validate.js";
-import { loadConfig, logConfigDiagnostics, numEnv } from "./config.js";
+import { loadConfig, logConfigDiagnostics, parseNumOrFailNonNegative } from "./config.js";
 import { createConfigProvider } from "./config-provider.js";
 import { applyEffective, applyCenterReadFace, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./config-center/facade.js";
 import { hostExecutionEnvFactory } from "./plugins/remote-env-host.js";
@@ -445,7 +445,7 @@ export async function runLocal(argv, deps = {}) {
     }
     const mention = parseModelMention(args.objective, Object.keys(config.models));
     const scope = args.user ?? "local";
-    const taskTimeoutSec = Math.max(0, Math.floor(numEnv("TASK_TIMEOUT_SEC", "0")));
+    const taskTimeoutSec = Math.floor(parseNumOrFailNonNegative("TASK_TIMEOUT_SEC", process.env.TASK_TIMEOUT_SEC || "0"));
     const timeoutSec = taskWallClockSec(taskTimeoutSec, false, scenarioName === "discuss");
     const mcp = mcpForScenario(config.mcpServers, scenarioName);
     const a2a = a2aForScenario(config.a2aPeers, scenarioName);

package/dist/runs.d.ts

@@ -308,10 +308,13 @@ promptManifests?: PromptManifestTracker,
  * `streamApprovalOn` = 协议上场判据(`resolveStreamApprovalGate`,由路由层求值后传进来 —— 本函数是纯
  * 执行腿,不该自己读 backend/config)。为假 ⇒ 只接既有四键 ctx(呈卡口/腿轴都不接),本腿字节逐字不变。
  */
+/** `windowMs` 收成 `number | undefined`([ref] + codex r1-[medium]):`undefined` = **这份装配没有
+ *  `streamApproval` 段**(stub-harness),不是「运维显式关窗」—— 两者自 [ref] 起结局不同(后者即答
+ *  无人值守终局),路由层因此不许再折算,见 `resolveApprovalLeg` 的 `windowMs` 域注。 */
 approval?: {
     coordinator: ToolApprovalCoordinator;
     streamApprovalOn: boolean;
-    windowMs: number;
+    windowMs: number | undefined;
     windowMarginMs: number;
 }, 
 /** [ref]:park 投影腿的 checkpoint 读口(`deps.checkpointStore`)。在场时,durable park 的

package/dist/runs.js

@@ -1,15 +1,18 @@
 import { runWithVerification, runCascade, defaultTaskRegistry, DURABLE_AGENT_HANDLE_RE } from "@sema-agent/core";
+import { redactErrorMessage } from "./observability/run-terminal-log.js";
 import { withPrincipal } from "./observability/principal-context.js";
 import { redactSecrets } from "./trace/redact.js";
 import { taskNotificationEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "./trace/project.js";
 import { createLedgerSink } from "./trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "./trace/engine-notice-wire.js";
 import { recordTurnActivity } from "./turn-activity.js";
+import { buildCancelContext } from "./run-cancel-context.js";
 import { createApprovalCardEmitter, resolveApprovalLeg } from "./tool-approval.js";
 import { fleetRunResiduals, isFleetAgentTerminalNotification } from "./fleet/fleet-bus.js";
 import { defaultSubagentTailBus, projectTailFrame } from "./fleet/subagent-tail-bus.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKey, NotifiedKeys } from "./orchestration/workflow-completion-inbox.js";
 import { recordFailOpen } from "./observability/fail-open.js";
+import { errorText as errText } from "./observability/err-text.js";
 import { LIVENESS_HEARTBEAT_MS } from "./config-invariants.js";
 export async function backgroundAgentOutput(registry, handle, access, agentStore) {
     const row = registry.getAccessibleTask(handle, access);
@@ -162,7 +165,10 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     const preemptCtrl = new AbortController();
     if (preemptEligible)
         preemptable?.set(taskId, preemptCtrl);
-    const cancelledResult = () => ({ taskId, sessionId: spec.sessionId, status: "failed", errorCode: "cancelled", errorMessage: "cancelled by user", stats: { turns: 0, tokens: 0 } });
+    const cancelledResult = () => {
+        const ctx = buildCancelContext(taskId, startedAt);
+        return { taskId, sessionId: spec.sessionId, status: "failed", errorCode: "cancelled", errorMessage: "cancelled by user", stats: { turns: 0, tokens: 0 }, ...(ctx ? { cancelContext: ctx } : {}) };
+    };
     const recordDone = (result, status) => {
         metrics?.addGauge("runs_active", -1);
         metrics?.inc("tasks_total", { status });
@@ -178,7 +184,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     const owner = principal ?? null;
     const approvalLeg = resolveApprovalLeg({
         streamApprovalOn: approval?.streamApprovalOn === true,
-        windowMs: approval?.windowMs ?? 0,
+        windowMs: approval?.windowMs,
         windowMarginMs: approval?.windowMarginMs ?? 0,
         ...(typeof spec.limits?.maxWalltimeMs === "number" ? { legWalltimeMs: spec.limits.maxWalltimeMs } : {}),
         nowMonotonicMs: performance.now(),
@@ -221,7 +227,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
         metrics?.addGauge("runs_active", -1);
         metrics?.inc("tasks_total", { status: "needs_review" });
     };
-    const sink = createLedgerSink({ appendEvent: (seq, type, data) => runStore.appendEvent(taskId, seq, type, data), persistThinking, notifiedKeys, onActivity: () => recordTurnActivity(taskId) });
+    const sink = createLedgerSink({ appendEvent: (seq, type, data) => runStore.appendEvent(taskId, seq, type, data), persistThinking, notifiedKeys, onActivity: (kind, statusData) => recordTurnActivity(taskId, kind, statusData) });
     const append = (type, data) => sink.append(type, data);
     const flush = () => sink.flush();
     const flushModelUsage = () => appendModelUsageDelta(append, modelUsage, taskId);
@@ -410,18 +416,33 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 : withApproval();
         });
         if (!reached && cancelCtrl.signal.aborted) {
-            await flush();
+            try {
+                await flush();
+            }
+            catch (e) {
+                recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=flush-clean-cancel ${errText(e)}`);
+            }
             const c = cancelledResult();
-            await append("failed", { errorMessage: c.errorMessage ?? "cancelled by user", errorCode: "cancelled" });
+            try {
+                await append("failed", { errorMessage: c.errorMessage ?? "cancelled by user", errorCode: "cancelled" });
+            }
+            catch (e) {
+                recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=append-clean-cancel ${errText(e)}`);
+            }
             reached = { kind: "done", result: c };
             await runStore.setTerminal(taskId, "failed", c, c.errorMessage ?? null);
             recordDone(c, "cancelled");
         }
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+        const message = errText(err);
         try {
-            await flush();
+            try {
+                await flush();
+            }
+            catch (e) {
+                recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=flush-catch ${errText(e)}`);
+            }
             if (reached?.kind === "done") {
                 await runStore.setTerminal(taskId, reached.result.status, reached.result, reached.result.errorMessage ?? null);
             }
@@ -433,12 +454,22 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
             }
             else if (cancelCtrl.signal.aborted) {
                 const c = cancelledResult();
-                await append("failed", { errorMessage: c.errorMessage ?? "cancelled by user", errorCode: "cancelled" });
+                try {
+                    await append("failed", { errorMessage: c.errorMessage ?? "cancelled by user", errorCode: "cancelled" });
+                }
+                catch (e) {
+                    recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=append-thrown-cancel ${errText(e)}`);
+                }
                 await runStore.setTerminal(taskId, "failed", c, c.errorMessage ?? null);
             }
             else {
-                const safeMsg = redactSecrets(message);
-                await append("failed", { errorMessage: safeMsg });
+                const safeMsg = redactErrorMessage(message) ?? message;
+                try {
+                    await append("failed", { errorMessage: safeMsg });
+                }
+                catch (e) {
+                    recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=append-failed ${errText(e)}`);
+                }
                 await runStore.setTerminal(taskId, "failed", null, safeMsg);
             }
         }