@sema-agent/server 7.56.0 → 7.58.0

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

@@ -1,7 +1,9 @@
+import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal-log.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { escapeLike } from "./sql-escape.js";
 import { pgSanitizeText } from "./pg-safe-json.js";
 import { parseJsonLenient as parseJson, toIso as iso } from "./sql-row-helpers.js";
+import { notifyRunTerminal, runTerminalLogLevel } from "../observability/run-terminal-log.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
 export class SqlRunStore {
@@ -105,6 +107,7 @@ export class SqlRunStore {
         await this.db.query(this.q("UPDATE task_run SET updated_at = ? WHERE task_id = ? AND owner <=> ? AND status = 'running'", "UPDATE task_run SET updated_at = $1 WHERE task_id = $2 AND owner IS NOT DISTINCT FROM $3 AND status = 'running'"), [new Date(), taskId, owner]);
     }
     async appendEvent(taskId, seq, type, data) {
+        data = redactLedgerEventData(type, data);
         await this.db.query(this.q("INSERT INTO task_event (task_id, seq, type, data, ts) VALUES (?,?,?,?,?)", "INSERT INTO task_event (task_id, seq, type, data, ts) VALUES ($1,$2,$3,$4::jsonb,$5)"), [taskId, seq, type, data == null ? null : this.json(data), new Date()]);
     }
     async maxSeq(taskId) {
@@ -113,9 +116,12 @@ export class SqlRunStore {
         return m == null ? 0 : Number(m);
     }
     async setTerminal(taskId, status, result, error) {
+        result = redactTerminalResult(result);
+        error = error === null ? null : (redactErrorMessage(error) ?? null);
         const errorCode = result?.errorCode ?? null;
+        let observed;
         await this.tx(async (conn) => {
-            await conn.query(this.q("UPDATE task_run SET status = ?, result = ?, error = ?, error_code = ?, updated_at = ? WHERE task_id = ? AND status IN ('running','suspended','needs_review')", "UPDATE task_run SET status = $1, result = $2::jsonb, error = $3, error_code = $4, updated_at = $5 WHERE task_id = $6 AND status IN ('running','suspended','needs_review')"), [
+            const w = await conn.query(this.q("UPDATE task_run SET status = ?, result = ?, error = ?, error_code = ?, updated_at = ? WHERE task_id = ? AND status IN ('running','suspended','needs_review')", "UPDATE task_run SET status = $1, result = $2::jsonb, error = $3, error_code = $4, updated_at = $5 WHERE task_id = $6 AND status IN ('running','suspended','needs_review')"), [
                 status,
                 result == null ? null : this.json(result),
                 this.db.dialect === "tidb" ? error : error == null ? null : pgSanitizeText(error),
@@ -123,8 +129,31 @@ export class SqlRunStore {
                 new Date(),
                 taskId,
             ]);
+            if (w.affected > 0 && runTerminalLogLevel(status, errorCode ?? undefined) !== undefined) {
+                const { rows } = await conn.query(this.q("SELECT owner, session_id, created_at FROM task_run WHERE task_id = ?", "SELECT owner, session_id, created_at FROM task_run WHERE task_id = $1"), [taskId]);
+                const row = rows[0];
+                const createdAt = row ? Date.parse(iso(row.created_at)) : NaN;
+                observed = {
+                    owner: row?.owner ?? null,
+                    sessionId: String(row?.session_id ?? result?.sessionId ?? ""),
+                    createdAt: Number.isFinite(createdAt) ? createdAt : undefined,
+                };
+            }
             await conn.query(this.q("DELETE FROM task_active WHERE task_id = ?", "DELETE FROM task_active WHERE task_id = $1"), [taskId]);
         });
+        if (observed) {
+            notifyRunTerminal({
+                runId: taskId,
+                sessionId: observed.sessionId,
+                owner: observed.owner,
+                status,
+                resultTaskId: result?.taskId,
+                model: result?.model,
+                errorCode: errorCode ?? undefined,
+                errorMessage: result?.errorMessage ?? error ?? undefined,
+                elapsedMs: observed.createdAt === undefined ? undefined : Math.max(0, Date.now() - observed.createdAt),
+            });
+        }
     }
     async setSuspended(taskId) {
         await this.db.query(this.q("UPDATE task_run SET status = 'suspended', updated_at = ? WHERE task_id = ? AND status IN ('running','suspended')", "UPDATE task_run SET status = 'suspended', updated_at = $1 WHERE task_id = $2 AND status IN ('running','suspended')"), [new Date(), taskId]);

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

@@ -95,7 +95,7 @@ export type ImageBake = TiDBImageBake | PgImageBake;
 /** [ref] 车4 件1:durable leader-run 登记表的双方言孪生(union 同族——TS 私有字段让具体类名义上不同)。 */
 export type LeaderRunStore = TiDBLeaderRunStore | PgLeaderRunStore;
 /** The FULL checkpoint store (core CheckpointStore + the service operator-queue/ctx methods listPending/
- *  listByScope/findPendingTokenBySession/peekPendingScope/putCtx/getCtx/reapCtx) — the SQL twins carry them,
+ *  listByScope/findPendingTokenBySession/peekPendingScope/peekScopeByToken/putCtx/getCtx/reapCtx) — the SQL twins carry them,
  *  and the LOCAL lane now does too (core FileCheckpointStore + the service half — TOC plan-mode /
  *  durable HITL work on one box). */
 export type CheckpointStoreFull = TiDBCheckpointStore | PgCheckpointStore | LocalCheckpointStore;

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;

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.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}]`);
@@ -241,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,
                 });
             }

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);
             }
         }