@sema-agent/client-core 0.59.2 → 0.60.0

package/dist/gateOutcome.js

@@ -0,0 +1,181 @@
+// 「这次调用没在这里结算」的**第二形**判据(见 {@link isGateParkedToolEnd});与 `frameRouter` 的
+// 连坐/中断判据读同一个常量(单源见该常量顶注)。
+import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
+/** 非空串窄化(空串按缺席归一)。 */
+function str(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+/** `who` 的结构窄读;`party` 读不出 ⇒ 整只结算不成形(见 {@link readSettlement})。 */
+function readWho(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    const w = v;
+    const party = str(w.party);
+    if (party === undefined)
+        return undefined;
+    const approver = str(w.approver);
+    const window = str(w.window);
+    return {
+        party,
+        ...(approver !== undefined ? { approver } : {}),
+        ...(window !== undefined ? { window } : {}),
+    };
+}
+/**
+ * `settlement` 的结构窄读。`kind` 或 `who` 读不出 ⇒ **整只缺席**(不铸半只):一只没有
+ * 「怎么结束的」或「谁结束的」的结算,消费端拿它渲不出任何一句可信的话,而半只会被读成
+ * 「结算过了,只是没说是谁」——那是一句本读面证明不了的断言。
+ */
+function readSettlement(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    const s = v;
+    const kind = str(s.kind);
+    const who = readWho(s.who);
+    if (kind === undefined || who === undefined)
+        return undefined;
+    const when = typeof s.when === 'number' && Number.isFinite(s.when) ? s.when : undefined;
+    const note = str(s.note);
+    return {
+        kind,
+        who,
+        ...(when !== undefined ? { when } : {}),
+        ...(note !== undefined ? { note } : {}),
+    };
+}
+/**
+ * `tool_end` 帧(或本包投影出的 `tool_end_result` 内部臂、耐久行的 resolved outcome)→ 门记录。
+ *
+ * 入参是**帧**而不是 `frame.gate`,刻意如此:端不必知道这条记录挂在哪个键上(那正是下一次形变
+ * 会动的东西),也不必自己判「这一帧带不带门」。
+ *
+ * 🔴 `disposition` 是**唯一的承重座**:它读不出来 ⇒ 整只 `undefined`。一条只有 `settlement` 而
+ *    说不出「放行还是拒了」的记录,消费端能从它得到的只有误导。
+ * 🔴 **不校 I1–I4 那四条不变量**(`settlement` ⇔ `origin` 同在、`ask_resolution` ⇒ 有拒绝类结算……):
+ *    筛子的属主是引擎,server 对过不了筛的记录**整条不投**。包再校一遍,只会在上游合法演进的当天
+ *    把一条真记录判没,而本层给不出比「原样交给端」更好的降级动作(`wiring_manifest.autoMode`
+ *    那一段的反向先例是**同一条帧上的段内自洽**,不是跨系统的不变量,两者刻意不同处置)。
+ */
+export function gateOutcomeOf(frame) {
+    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+        return undefined;
+    const g = frame.gate;
+    if (typeof g !== 'object' || g === null || Array.isArray(g))
+        return undefined;
+    const raw = g;
+    const d = raw.disposition;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const dr = d;
+    const dk = str(dr.kind);
+    let disposition;
+    if (dk === 'allowed') {
+        disposition = { kind: 'allowed' };
+    }
+    else if (dk === 'denied') {
+        const deniedBy = str(dr.deniedBy);
+        // 「拒了但说不出谁拒的」在上游**写不出来**(两臂在类型上就分了家)⇒ 到得了这里的这一形是坏记录。
+        if (deniedBy === undefined)
+            return undefined;
+        disposition = { kind: 'denied', deniedBy };
+    }
+    else {
+        // 处置词本身不认识 ⇒ 整只不成形:`allowed` / `denied` 是这条记录的**判别位**,猜不得。
+        return undefined;
+    }
+    const settlement = readSettlement(raw.settlement);
+    const origin = str(raw.origin);
+    return {
+        disposition,
+        ...(settlement !== undefined ? { settlement } : {}),
+        ...(origin !== undefined ? { origin } : {}),
+    };
+}
+/**
+ * 这次调用是**被门 park 了**吗 —— 「没在这里结算」的**第二形**(engine 7.64.0 真机黑盒直证)。
+ *
+ * 🔴 **为什么非有它不可**:审批窗走完(默认 300s)未决而走 park 路径时,`tool_end` 帧上
+ *    **没有 `gate` 字段** —— 只有 `errorCode: "gate.parked"`。⇒ 单锚 {@link gateOutcomeOf} 的
+ *    消费点在这一形上什么都读不到,而这一形**恰恰是端最想说一句话的那一格**(「已转后台候批」)。
+ * 🔴 **两形合起来才是「这次调用没在这里结算」的完整判据**,端要判这件事写:
+ *    `isApprovalWindowExpiredGate(gateOutcomeOf(f)) || isGateParkedToolEnd(f)`。
+ *    两形语义**不同**、不许互相顶替:前者是「窗走完了,拒了」,后者是「park 了,还没人决」。
+ * 🔴 **入参是整只帧**(与 {@link gateOutcomeOf} 同姿势):端不必知道这一位挂在哪个键上。
+ * 🔴 缺席不带语义:大多数 `tool_end` 都不带这个码,缺席 ≠「已经结算过了」。
+ */
+export function isGateParkedToolEnd(frame) {
+    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+        return false;
+    return frame.errorCode === GATE_PARKED_ERROR_CODE;
+}
+/** 这次门是不是**拒**(缺席 ⇒ `false` —— 缺席不带语义,见模块顶注)。 */
+export function isDeniedGate(g) {
+    return g?.disposition.kind === 'denied';
+}
+/** 拒这次的是**哪一层**(`policy` / `hook` / `org` / …;开集)。非拒 / 缺席 ⇒ `undefined`。 */
+export function gateDeniedBy(g) {
+    return g?.disposition.kind === 'denied' ? g.disposition.deniedBy : undefined;
+}
+/**
+ * 这次结算是**谁**的(审批通道自报的身份串)。UNTRUSTED-for-display。
+ * 🔴 缺席 = 通道没报名字 —— 永不意味「没人批」,也永不意味「有人批」。
+ */
+export function gateApprover(g) {
+    return g?.settlement?.who.approver;
+}
+/**
+ * 这次拒是**审批窗自己走完**的吗 —— 端此前自拼的那个两键合取(`settledBy === 'timeout' &&
+ * resolution === 'window_expired'`)的**继任单源**。
+ *
+ * 判据 = `settlement.kind === 'approval_window_expired'`(引擎自己的审批工厂窗,或同步宿主
+ * approver 报「我的窗到了」)。
+ * 🔴 **刻意不含另外两条窗词**:`denial_limit_window_expired` 是**分类器限额回落**的自动拒窗
+ * (端要渲的是另一句话,见 {@link isDenialLimitAutoDeniedGate}),`park_sla_expired` 是**耐久 park**
+ * 的 SLA 到期(结束它的是宿主的扫,不是这次调用在等的那只审批窗)。旧形上这三件事共用一个
+ * `settledBy:"timeout"`,分不出来正是要靠 `resolution` 补第二个键的原因;形变把它们分成了三个词,
+ * 合并读回去等于把刚修好的判别力扔掉。
+ * 🔴 **正面匹配,绝不写不等式**:不等式对缺席与任何未来新词都为真。
+ */
+export function isApprovalWindowExpiredGate(g) {
+    return g?.settlement?.kind === 'approval_window_expired';
+}
+/**
+ * 这次拒是**引擎的限额回落窗自己拒的**吗(不是人拒的)—— 端此前读的 `tool_end.autoDenied === true`
+ * 的**继任单源**。
+ *
+ * 判据 = `settlement.kind === 'denial_limit_window_expired'`(auto 模式分类器的拒绝上限回落窗:
+ * 那张必须真人批的卡在 `autoDenyAfterMs` 走完之后由**引擎**判 deny)。
+ * 🔴 它答的正是 {@link isApprovalWindowExpiredGate} 答不了的那一问:「这一次到期是**自动拒**收的场,
+ *    还是 park 了等人」。端要渲的两句话(「自动拒(限额回落)」vs「已转后台候批」)卡在这一格上。
+ * 🔴 **不据它自铸第二只定时器/第二张资格表**:窗的执行全在引擎,本位是**事后**的判别位。
+ */
+export function isDenialLimitAutoDeniedGate(g) {
+    return g?.settlement?.kind === 'denial_limit_window_expired';
+}
+/**
+ * 这次结算是**耐久 park 的 SLA 到期**被宿主的扫判成拒的吗。
+ * 🔴 与上面两条并列而不合并:它说的是「那一行在队列里坐过了 deadline」,与「这次调用在等的审批窗
+ *    走完了」是两件不同的事,出路也不同(前者要重新提这一步,后者可以再决一次)。
+ */
+export function isParkSlaExpiredGate(g) {
+    return g?.settlement?.kind === 'park_sla_expired';
+}
+/**
+ * 这次门记录是**人**做的决定吗(`human_allowed` / `human_refused`)。
+ * 🔴 「人批了之后被复查否决」(上游不变量 I3)在这里读作:本谓词为 `true` **且** {@link isDeniedGate}
+ *    也为 `true` —— 那时 `deniedBy` 指的是复查那一层,approver 留在结算上,**不是** approver 的拒。
+ */
+export function isHumanSettledGate(g) {
+    const k = g?.settlement?.kind;
+    return k === 'human_allowed' || k === 'human_refused';
+}
+/**
+ * **编译期对账钉**(不出公面):sdk 的 `GateOutcome` 必须能赋给本视图 —— 上游给记录加位/改形时,
+ * 这一行是本包第一个红的地方。
+ *
+ * 🔴 反向**刻意不钉**(本视图不必能赋给 sdk 形):本视图按开集放宽了三处词表
+ * (`deniedBy` / `settlement.kind` / `origin`),那是**故意比铸点宽**(窄读域只许等于或宽于铸点域,
+ * B-025 的定谳);钉反向会把这条纪律反过来判成错。
+ */
+const _gateOutcomeShapePin = (w) => w;
+void _gateOutcomeShapePin;

package/dist/headlessReconnectWire.js

@@ -17,6 +17,8 @@ function debugLog(msg) {
 }
 /** 引擎终态词表全集(core 1.298 TaskStatus;server runs.js setTerminal(taskId, safe.status, …)
  *  把引擎 status【原样】写进 run row ⇒ row.status 可以是全部 6 词,不只 completed/failed)。
+ *  🔴 **run 行自己的 `status` 列 engine 7.64.0 没动**(BREAKING 帖逐字:变的是引擎结果 blob,
+ *  行的列照旧说五词,只是数据源改成从因由投影一次)⇒ 本表原样有效,不随 `TaskResult` 形变。
  *  [909]B3 复核发现的真缺口:此前只认 completed/failed,timeout/blocked 终局的 run row 永不
  *  合成终帧 → 续收环重试到预算耗尽 → 假判死(终局明明就在 row 里)。 */
 const RUN_ROW_TERMINAL_STATUSES = new Set([
@@ -37,8 +39,13 @@ export function terminalEventFromRunRow(row) {
         return null;
     if (RUN_ROW_TERMINAL_STATUSES.has(row.status)) {
         if (row.result && typeof row.result === 'object') {
-            // sync 腿 setTerminal 存的就是终帧的 TaskResult(status 含 failed/timeout/blocked 形)——
-            // 与 tasks/stream 终帧 done{result} 字节同构,terminalToSdkResult 文案线原样生效。
+            // sync 腿 setTerminal 存的就是终帧的 TaskResult —— 与 tasks/stream 终帧 done{result} 字节同构,
+            // terminalToSdkResult 文案线原样生效。
+            // 🔴 **这是一条读盘面**(0.60.0 起要点名):`GET /v1/runs/:id` 的 `result` 是存储 blob 的**逐字
+            //    透传**,server **不补** `terminal` ⇒ 一台跨 engine 7.64.0 升级过的部署上,升级**之前**落盘
+            //    的那些行读出来仍是**扁平**形(退役的八个平面键)。两代字节由 `runTerminal.readRunTerminal`
+            //    的判别位 `"terminal" in result` 各归各位,所以本函数**照旧原样透传、一个键都不补**:补一个
+            //    `terminal` 出来就是替停产的写者重新裁定一次形状(server 自己也刻意不做)。
             return { type: 'done', result: row.result };
         }
         if (row.status === 'failed') {

package/dist/hitl/askParkRowRouting.d.ts

@@ -81,6 +81,8 @@ export interface AskParkRowIdentity {
 export declare function askParkRowIdentity(taskId: string, row: PendingCheckpoint): AskParkRowIdentity;
 /**
  * ③ 这一行该走哪条臂。判据锚在**决定量**(这行到底有没有问句)上,不锚门种的名字 —— 理由见文件头。
+ *   · **toolName 明说是 ask 工具 ⇒ 问答臂,门种一律不再看**(0.60.0 补的**最先**一条,理由见函数体内注:
+ *     工具臂对这样一行会弹一张没有问句的卡、并送出不带 answer 的 approve —— 一次静默的错动作);
  *   · kind 缺席(pre-3.0.0 旧行)⇒ 维持 toolName 判据(旧行没有别的信号);
  *   · kind 是 ask 门族里 `human` 之外的词(tool_approval / irreversible_ask / policy_ask)⇒ 工具臂;
  *   · kind = `human` ⇒ 三选一命中即问答臂:toolName 明说是 ask 工具 / 行真带问句 payload /

package/dist/hitl/askParkRowRouting.js

@@ -66,6 +66,8 @@ export function askParkRowIdentity(taskId, row) {
 }
 /**
  * ③ 这一行该走哪条臂。判据锚在**决定量**(这行到底有没有问句)上,不锚门种的名字 —— 理由见文件头。
+ *   · **toolName 明说是 ask 工具 ⇒ 问答臂,门种一律不再看**(0.60.0 补的**最先**一条,理由见函数体内注:
+ *     工具臂对这样一行会弹一张没有问句的卡、并送出不带 answer 的 approve —— 一次静默的错动作);
  *   · kind 缺席(pre-3.0.0 旧行)⇒ 维持 toolName 判据(旧行没有别的信号);
  *   · kind 是 ask 门族里 `human` 之外的词(tool_approval / irreversible_ask / policy_ask)⇒ 工具臂;
  *   · kind = `human` ⇒ 三选一命中即问答臂:toolName 明说是 ask 工具 / 行真带问句 payload /
@@ -76,12 +78,22 @@ export function askParkRowIdentity(taskId, row) {
 export function askParkRowArm(row) {
     const rowGateKind = askParkRowGateKind(row);
     const toolNameIsAsk = isAskTool(row.toolName ?? undefined);
+    // 🔴 **ask 工具身份优先于门种**(0.60.0,异源对抗复审 [medium] 采纳,真病):此前 `human` /
+    //    `policy_ask` 之外的门种在读 toolName 之前就早退成工具臂,于是一行
+    //    `gateKind:"irreversible_ask"` + `toolName:"AskUserQuestion"` 会被送进工具臂 —— 那条臂铸的卡
+    //    **没有问句**、decide 送的是**不带 answer 的 approve**:一次静默的错动作(用户从没被问过,
+    //    引擎却收到了「批准」)。而本函数自己的判据就写着「问答臂要的东西是**问句**」——
+    //    一行 toolName 明说是 ask 工具时,那件事已经确定,门种再说什么都改不了它。
+    //    ⚠️ 这也是与 `frameRouter` 那条 park 分流**同一个次序**(那里也是 ask 恒先判);两处次序一旦
+    //    不同,同一行在「谁来接」和「怎么决」两层上会得到相反的答案。
+    if (toolNameIsAsk)
+        return 'question';
     if (rowGateKind === null)
-        return toolNameIsAsk ? 'question' : 'tool-gate';
+        return 'tool-gate';
     if (!GENERIC_DECISION_GATE_KINDS.includes(rowGateKind))
         return 'tool-gate';
     const rowHasToolName = typeof row.toolName === 'string' && row.toolName.trim().length > 0;
-    return toolNameIsAsk || askQuestionsFromPending(row) !== null || !rowHasToolName ? 'question' : 'tool-gate';
+    return askQuestionsFromPending(row) !== null || !rowHasToolName ? 'question' : 'tool-gate';
 }
 /**
  * 「泛化的**要人来决定**」那一族 kind —— 它们**不自带**「这是工具 / 这是问句」的答案,所以必须按
@@ -96,6 +108,9 @@ export function askParkRowArm(row) {
  *     按名字硬判工具臂 = `human` 那一病换个 kind 复发(二次评审 R3 [high] 命中)。
  *   · `irreversible_ask` 的 core 形是 `{kind, reason, toolName}`(toolName **必填**)、`tool_approval`
  *     按定义就是工具审批 ⇒ 两者不进这张表,直接工具臂。
+ * ⚠️ **本表不再是路由的第一道判据**(0.60.0):`askParkRowArm` 现在**先**看 toolName 是不是 ask 工具。
+ *    本表回答的仍是「这个门种自不自带『工具/问句』的答案」,只是它在一行**明说自己是 ask 工具**时
+ *    已经不需要被问到了。
  */
 const GENERIC_DECISION_GATE_KINDS = ['human', 'policy_ask'];
 /**

package/dist/hitl/frameRouter.d.ts

@@ -178,8 +178,8 @@ export interface HeldFlushInterruptEvidence {
  *    两臂 stamp CC REJECT 文案),那两臂排在 hold-poison **之前**、帧根本不进扣留表,本包装够不着。
  *    fail-soft 的其余原因(no_pending / 传输失败 / hop 用尽)三腿全不命中 ⇒ 诚实红照旧。
  *
- * 🔴 **只改 `output` 一个键**:`isError` / `errorCode` / `toolCallId` / `toolName` / `settledBy` /
- * `approver` / `resolution` / `structured` 以及 `flushHeld` 自己盖的
+ * 🔴 **只改 `output` 一个键**:`isError` / `errorCode` / `toolCallId` / `toolName` / `gate` /
+ * `delivered` / `gatedCallId` / `structured` 以及 `flushHeld` 自己盖的
  * `_sema_collateral_abort` 机读位全部原样过境(展开赋值只覆盖 `output`)—— 端侧的连坐折叠锚的是
  * 机读位不是文案,所以折叠语义不受影响,只是被折那一行的正文换成了 CC 中断形。
  */

package/dist/hitl/frameRouter.js

@@ -1,6 +1,9 @@
 import { hostLog } from '../host.js';
 import { isToolApprovalGate, toolNameIsFsWrite, toolNameIsShellExec, isToolApprovalFrame, isFromSubagent, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
 import { classifierDenyFromToolEnd } from '../classifierVerdictWire.js';
+import { GATE_PARKED_ERROR_CODE } from '../engineErrorCodes.js';
+// 0.60.0(engine ≥7.64.0 / sdk 8.4.0):终局/park 读数的单一读器(两代字节 → 一个带标因由)。
+import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateToolName } from '../runTerminal.js';
 import { surfaceForCurrentSession } from './hitlHostSurface.js';
 /**
  * CC `utils/messages.ts` 的 `REJECT_MESSAGE` **逐字**(B7 搬迁差分 2)。deny 后重放 tool_end 的
@@ -128,7 +131,10 @@ function isFsOrShellToolName(name) {
  * 就等于把那几族 park 的连坐帧判成「认不出」。(core 5.55 的 `tool_end.gatedCallId` **顶层键**
  * 到货后可用于「折叠归组」那一面,与本判据是两件事,跟车另批。)
  */
-const ENGINE_GATE_PARKED_ERROR_CODE = 'gate.parked';
+// 🔴 **单源**(0.60.0):字面量收编进 `engineErrorCodes.GATE_PARKED_ERROR_CODE` —— 本文件的连坐/中断
+//    判据与 `gateOutcome.isGateParkedToolEnd`(端的「这次调用没在这里结算」第二形谓词)读同一个常量。
+//    两处各写一份必漂,而漂的那一天两边会对同一帧给出相反的判决。
+const ENGINE_GATE_PARKED_ERROR_CODE = GATE_PARKED_ERROR_CODE;
 /**
  * 「这一帧是**引擎因 gate 而中止**的毒化帧」——双判据 OR(件⑤,2026-08-22,[4970] G1 端到端 RED)。
  *
@@ -211,26 +217,36 @@ function isDenyStampCandidate(ev) {
         return true;
     return toolEndOutputText(ev.output) === ENGINE_ABORT_TOOL_RESULT;
 }
-/** done 帧的 AskUserQuestion park 形状(结构性读;别的终态一律 false)。 */
-function isAskGatePark(result) {
-    const r = result;
-    return (!!r &&
-        r.status === 'suspended' &&
-        isAskToolLoose(r.checkpointGate?.toolName) &&
-        typeof r.taskId === 'string' &&
-        r.taskId.length > 0);
-}
-/** done 帧的工具审批 park 形状([816] 放宽腿 + [2150] Bash 半场):status suspended +
- *  checkpointGate 指 fs 写三件 / Bash / 一等 kind==='tool_approval'(超集谓词 isToolApprovalGate,
- *  decide 腿对两族同构、卡形归壳分发)。Ask gate 恒先判(问答 overlay 原路)。 */
-function isFsApprovalPark(result) {
-    const r = result;
-    return (!!r &&
-        r.status === 'suspended' &&
-        typeof r.taskId === 'string' &&
-        r.taskId.length > 0 &&
-        !isAskToolLoose(r.checkpointGate?.toolName) &&
-        isToolApprovalGate(r.checkpointGate));
+/**
+ * done 帧的 park 门读数(0.60.0:判据从退役的 `status:"suspended"` + `checkpointGate` 两个平面键
+ * 换成带标因由 `terminal.paused` —— 读法单源 {@link readRunTerminal},本文件零平面键直读)。
+ *
+ * 🔴 两条 park 臂共用**一次**读取:此前两个谓词各自把 result 强转一遍再各判一次 `status`,
+ *    两处的窄读域一旦分叉就会出现「ask 臂认得、fs 臂认不得」的半场(paired-mechanisms 病形)。
+ * 返回 `null` = 这一帧不是 park(或连 taskId 都读不出 ⇒ 两条臂本来就都驱动不了)。
+ *
+ * ⚠️ **修前那条 `status === 'suspended'` 前置条件去哪了**(如实交代,不是漏掉):因由形下 park 只带
+ *    门,「哪个 park 读作 suspended、哪个读作 needs_review」由**引擎的 pause registry** 决定、不再
+ *    出现在这条 wire 上。而那条前置条件真正在挡的是**复核族 park**(plan_review / dry_run_review /
+ *    needs_review 门)——它们本来就过不了下面两个门谓词(复核门不带 toolName,`isAskToolLoose`
+ *    与 `isToolApprovalGate` 两条都判 false)⇒ 语义由**更精确的**门种判据原样承接,不是放宽。
+ */
+function parkGateOf(result) {
+    const read = readRunTerminal(result);
+    if (read === null || read.kind !== 'paused')
+        return null;
+    const taskId = result?.taskId;
+    if (typeof taskId !== 'string' || taskId.length === 0)
+        return null;
+    const toolName = runTerminalGateToolName(read);
+    // Ask gate 恒先判(问答 overlay 原路)。
+    if (isAskToolLoose(toolName))
+        return { taskId, gate: 'ask', toolName };
+    // 工具审批 park([816] 放宽腿 + [2150] Bash 半场):门指 fs 写三件 / Bash / 一等
+    // kind==='tool_approval'(超集谓词 isToolApprovalGate,decide 腿对两族同构、卡形归壳分发)。
+    if (isToolApprovalGate({ kind: runTerminalGateKind(read), toolName }))
+        return { taskId, gate: 'fs', toolName };
+    return null;
 }
 /**
  * park 帧上的**待批 call 身份**(server ≥7.41.0;[4914] 施工帖逐字:数据源 = checkpoint 本体的
@@ -288,8 +304,9 @@ function isUserInterruptTerminalOrSignal(ev, signal) {
         return ev.errorCode === RUN_CANCELLED_ERROR_CODE;
     }
     if (ev.type === 'done') {
-        const r = ev.result;
-        return !!r && r.errorCode === RUN_CANCELLED_ERROR_CODE;
+        // 0.60.0:cancel settle 的码在因由形下**结构上属于失败臂**(`terminal.failed.code`);扁平形
+        // 回放的历史行仍把它平铺在 `errorCode` 上 —— 两代都由 `runTerminalCode` 归一。
+        return runTerminalCode(readRunTerminal(ev.result)) === RUN_CANCELLED_ERROR_CODE;
     }
     return false;
 }
@@ -329,8 +346,8 @@ function isUserInterruptRewritable(ev, allowGateParked) {
  *    两臂 stamp CC REJECT 文案),那两臂排在 hold-poison **之前**、帧根本不进扣留表,本包装够不着。
  *    fail-soft 的其余原因(no_pending / 传输失败 / hop 用尽)三腿全不命中 ⇒ 诚实红照旧。
  *
- * 🔴 **只改 `output` 一个键**:`isError` / `errorCode` / `toolCallId` / `toolName` / `settledBy` /
- * `approver` / `resolution` / `structured` 以及 `flushHeld` 自己盖的
+ * 🔴 **只改 `output` 一个键**:`isError` / `errorCode` / `toolCallId` / `toolName` / `gate` /
+ * `delivered` / `gatedCallId` / `structured` 以及 `flushHeld` 自己盖的
  * `_sema_collateral_abort` 机读位全部原样过境(展开赋值只覆盖 `output`)—— 端侧的连坐折叠锚的是
  * 机读位不是文案,所以折叠语义不受影响,只是被折那一行的正文换成了 CC 中断形。
  */
@@ -615,16 +632,13 @@ function routeDone(ev, ctx) {
     // [4914]:sync 腿的待批 call 身份在 `done{suspended}` 的 **result 顶层**(与 checkpointId 同位)。
     const gatedCallId = parkGatedCallId(ev.result);
     // 两条 park 臂都登记(理由同 routeSuspended)。
-    if (isAskGatePark(ev.result)) {
-        ctx.taskId.current = ctx.taskId.current ?? ev.result.taskId;
-        led.noteParkGate({ fsOrShellFamily: false });
-        return { kind: 'park', gate: 'ask', pendingDone: ev, ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
-    }
-    if (isFsApprovalPark(ev.result)) {
-        ctx.taskId.current = ctx.taskId.current ?? ev.result.taskId;
-        // 准入证:主语是 checkpointGate **本体**的 toolName,不是任何 tool_end 帧的。
-        led.noteParkGate({ fsOrShellFamily: isFsOrShellToolName(ev.result.checkpointGate?.toolName) });
-        return { kind: 'park', gate: 'fs', pendingDone: ev, ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
+    const park = parkGateOf(ev.result);
+    if (park !== null) {
+        ctx.taskId.current = ctx.taskId.current ?? park.taskId;
+        // 准入证:主语是**门本体**的 toolName,不是任何 tool_end 帧的(ask 臂恒 false —— 问答门不属
+        // fs/shell 族)。
+        led.noteParkGate({ fsOrShellFamily: park.gate === 'fs' && isFsOrShellToolName(park.toolName) });
+        return { kind: 'park', gate: park.gate, pendingDone: ev, ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     // 真错(非 gate)的 Ask tool_end 此刻诚实渲染;件 B:纯用户中断批在这个出口把文案归一成 CC 中断形。
     const events = [...flushHeldWithInterruptRewrite(led, { terminal: ev, signal: ctx.signal })];

package/dist/hitl/hitlBridge.d.ts

@@ -141,6 +141,34 @@ export interface PlanReviewOutcome {
     editedPlan?: string;
     reason?: string;
 }
+/**
+ * {@link HitlSafetyError.code} 的闭集(0.60.0 抽名,**成员一个没动**)。
+ *
+ * 🔴 抽名的理由是**消费面**:决断腿的失败结局要把「本地安全停」与「引擎的 wire 拒绝」结构分开
+ * (`FsApprovalOutcome.safetyCode` / `GateOutcome.code`),而那两处此前只能各自把这五个词再抄一遍
+ * ——抄一份就是给自己立第二个判官(B-025 的病形)。加员仍必须**同批**改齐
+ * `parkResolver.GATE_FAILURE_CODES` 白名单(见下方原注)。
+ */
+export type HitlSafetyCode = 'binding_mismatch' | 'no_pending' | 'wrong_gate' | 'bad_plan_edit' | 'empty_answer';
+/**
+ * 一次决断链失败**停在哪一段**(0.60.0;异源对抗复审 [medium] 采纳,B-037 候包件 ② 的完整兑现)。
+ *
+ * ── 病 ──────────────────────────────────────────────────────────────────────────────────────
+ * 两条决断腿(fs / ask)的 `failed` 结局把 typed 错**拍平成一个 `reason` 串**,于是四类完全不同的
+ * 失败在消费点**同形**:「取件那一拍没有可决行」「卡口没装」「引擎语义拒绝」「出站瞬断耗尽」——
+ * 分流只能去正则匹配那句拍平文案(里面嵌的是 `String(e)`,上游改一个词就静默空转)。而这四类的
+ * 出路完全不同:重探 / 装口 / 重呈或换参数 / 重呈不判死。
+ *
+ * ── 词与判据 ────────────────────────────────────────────────────────────────────────────────
+ *  · `fetch`         —— 取件腿没给出可决行,或读面自己炸了(**一个字节都没送出去**);
+ *  · `input`         —— 行上没有可呈现的载荷(工具入参 / 问句),卡渲不出来(同样没送出去);
+ *  · `card`          —— 卡口那一段失败(没装卡口 / 卡口自己报失败 / 没有问答 overlay);
+ *  · `decide`        —— 决断**已经发出去了**(引擎语义拒绝,或出站瞬断耗尽);
+ *  · `orchestration` —— 上面四段都不是:编排层在若干轮重挂之后收口(轮数/park 数硬上限、连续零进展)。
+ * 🔴 **只有 `decide` 代表「引擎那一头知道这次决断」** —— 安全停的第一问就是它,前三段一个字节都没送出。
+ * 🔴 **必填**:一个可选的阶段位等于又留了一格「读不出就猜」,而这一位存在的全部理由就是消灭那一格。
+ */
+export type HitlFailureStage = 'fetch' | 'input' | 'card' | 'decide' | 'orchestration';
 /** A safety stop: a contract law was about to be violated (e.g. a binding mismatch, a wrong-gate route).
  *  The caller MUST re-present to the human or surface the error — NEVER silently retry or auto-decide
  *  (contract/04 §9.1 fail-closed law). */
@@ -150,14 +178,14 @@ export declare class HitlSafetyError extends Error {
     /** 🔴 闭集(FIX② 2026-08-07 加 `empty_answer`,第 5 员)。加员必须**同批**改齐
      *  `parkResolver.GATE_FAILURE_CODES` 白名单 —— 那道白名单把不认得的码降成 `undefined`,
      *  一边加一边不改另一边 = 新码在消费端被静默吞掉(比不加还坏:本地拦住了,判词却丢了)。 */
-    readonly code: 'binding_mismatch' | 'no_pending' | 'wrong_gate' | 'bad_plan_edit' | 'empty_answer';
+    readonly code: HitlSafetyCode;
     constructor(message: string, 
     /** A stable code the shell can branch on (REF-CC-036,2026-08-02:闭集联合,不再是开集 string —
      *  与同族兄弟 `controlRouter.ts` 的 `ControlSafetyError.code` 同形)。 */
     /** 🔴 闭集(FIX② 2026-08-07 加 `empty_answer`,第 5 员)。加员必须**同批**改齐
      *  `parkResolver.GATE_FAILURE_CODES` 白名单 —— 那道白名单把不认得的码降成 `undefined`,
      *  一边加一边不改另一边 = 新码在消费端被静默吞掉(比不加还坏:本地拦住了,判词却丢了)。 */
-    code: 'binding_mismatch' | 'no_pending' | 'wrong_gate' | 'bad_plan_edit' | 'empty_answer');
+    code: HitlSafetyCode);
 }
 /**
  * decide 409 `approval_stale` 拒体上的 **additive 指路键** `currentPending` —— 本会话**当前**那条
@@ -219,6 +247,25 @@ export type GateCurrentPending = Readonly<NonNullable<ApprovalStaleError['curren
  *    铸一个残形只会让消费点以为「有指路」。`boundInputHash` 是**行上有才带**的可选位,缺席照铸。
  */
 export declare function readDecideCurrentPending(e: unknown): GateCurrentPending | undefined;
+/**
+ * 从一次 decide / 取件失败(任意抛出物)里读出**引擎的机器码** —— 读不出即 `undefined`。
+ *
+ * 🔴 **为什么这一位非透出不可**(0.60.0;上游候包件 ②,与 0.47.0 补 `currentPending` **同形**):
+ *    本包把 typed 错**拍平成 `reason` 串**交给消费点(`FsApprovalOutcome.failed.reason`),于是
+ *    「只读 outcome 形」的消费者(壳的重开链、迟到决断代理)对机读码**全盲** —— 要分辨
+ *    `resume.preflight_rejected` / `approval_stale` / 传输类失败,只能去正则匹配那句拍平文案,
+ *    而那句文案里嵌的是 `String(e)`(上游一改措辞就静默空转)。上游为此在壳里绕了一整圈
+ *    (把 client 套进代理、站在拍平**之前**读)——那圈本该由这一位省掉。
+ * 🔴 **结构视图读,不 `instanceof`**:理由与 {@link readDecideCurrentPending} 逐字同一条 ——
+ *    抛出来的是不是 SDK 的错误类由**宿主注入的传输层**决定(跨 realm / 双实例)。
+ * 🔴 **键位只认 `errorCode`**([2055] 死键纪律,退役的 `code` 槽不做兼容);非空串才算数,
+ *    其余一律诚实缺席。
+ * 🔴 **只搬运不解释**:本读口不判任何码属于哪一族(词表属主在 server/core,开集)——消费点分支
+ *    已知码、永远带 `default`。
+ * 🔴 **绝不把它当凭证面**:`errorCode` 是机器码,不是错误正文;错误正文(可能含凭据/内部路径)
+ *    照旧**不**经本位外流。
+ */
+export declare function readWireErrorCode(e: unknown): string | undefined;
 /** 测试钩:把超时类重试总窗调小(传 undefined 还原缺省)。 */
 export declare function __setDecideTimeoutRetryBudgetForTests(ms?: number): void;
 /**

package/dist/hitl/hitlBridge.js

@@ -35,7 +35,6 @@ export function denyReasonForWire(reason, tag) {
         `(server caps approval reason at ${MAX_DENY_REASON_CHARS}; over-cap is a 413 reason_too_large that would drop the DECISION, not just the reason)`);
     return cut;
 }
-// ── Errors the bridge surfaces (fail-closed; never auto-retried) ───────────────
 /** A safety stop: a contract law was about to be violated (e.g. a binding mismatch, a wrong-gate route).
  *  The caller MUST re-present to the human or surface the error — NEVER silently retry or auto-decide
  *  (contract/04 §9.1 fail-closed law). */
@@ -102,6 +101,28 @@ export function readDecideCurrentPending(e) {
             : {}),
     };
 }
+/**
+ * 从一次 decide / 取件失败(任意抛出物)里读出**引擎的机器码** —— 读不出即 `undefined`。
+ *
+ * 🔴 **为什么这一位非透出不可**(0.60.0;上游候包件 ②,与 0.47.0 补 `currentPending` **同形**):
+ *    本包把 typed 错**拍平成 `reason` 串**交给消费点(`FsApprovalOutcome.failed.reason`),于是
+ *    「只读 outcome 形」的消费者(壳的重开链、迟到决断代理)对机读码**全盲** —— 要分辨
+ *    `resume.preflight_rejected` / `approval_stale` / 传输类失败,只能去正则匹配那句拍平文案,
+ *    而那句文案里嵌的是 `String(e)`(上游一改措辞就静默空转)。上游为此在壳里绕了一整圈
+ *    (把 client 套进代理、站在拍平**之前**读)——那圈本该由这一位省掉。
+ * 🔴 **结构视图读,不 `instanceof`**:理由与 {@link readDecideCurrentPending} 逐字同一条 ——
+ *    抛出来的是不是 SDK 的错误类由**宿主注入的传输层**决定(跨 realm / 双实例)。
+ * 🔴 **键位只认 `errorCode`**([2055] 死键纪律,退役的 `code` 槽不做兼容);非空串才算数,
+ *    其余一律诚实缺席。
+ * 🔴 **只搬运不解释**:本读口不判任何码属于哪一族(词表属主在 server/core,开集)——消费点分支
+ *    已知码、永远带 `default`。
+ * 🔴 **绝不把它当凭证面**:`errorCode` 是机器码,不是错误正文;错误正文(可能含凭据/内部路径)
+ *    照旧**不**经本位外流。
+ */
+export function readWireErrorCode(e) {
+    const raw = e?.errorCode;
+    return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+}
 // ── decide 出站的瞬断分诊与有界重试(Inkglow-1085 P0a,2026-08-19;[4664] server 定谳后对表)────
 //
 // 病形(案卷 INKGLOW-1085 车1 全链):`approvals.decide` 是**非 submit POST** —— SDK transport 对它

package/dist/hitl/parkResolver.d.ts

@@ -13,7 +13,7 @@
  *    在驱动的消费点上必然显形,而不是被本文件自己吞掉。
  */
 import type { AgentEvent } from '@sema-agent/sdk';
-import { type GateCurrentPending } from './hitlBridge.js';
+import { type GateCurrentPending, type HitlFailureStage } from './hitlBridge.js';
 import { type QuestionAnswer } from '../liveQuestionStore.js';
 import type { AskAnsweredOutput, GateLedger } from './gateLedger.js';
 import { type AskGateWireDeps, type GatePark } from './frameRouter.js';
@@ -69,9 +69,11 @@ export type GateOutcome = {
     gatedCallId?: string | undefined;
 } | {
     kind: 'failed';
+    stage: HitlFailureStage;
     gatedCallId?: string | undefined;
     reason: string;
     code?: GateFailureCode | undefined;
+    errorCode?: string | undefined;
     retryExhausted?: true;
     currentPending?: GateCurrentPending | undefined;
 };

package/dist/hitl/parkResolver.js

@@ -1,4 +1,4 @@
-import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, } from './hitlBridge.js';
+import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -164,7 +164,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal,
  *  与 fs 腿同一条,见 `toolApprovalWire.surfaceFsApprovalAndDecide` 的同名参数头注。 */
 parkGatedCallId, onPresented) {
     if (!hasQuestionOverlay()) {
-        return { kind: 'failed', reason: 'no question overlay mounted (print/non-REPL mode)' };
+        return { kind: 'failed', stage: 'card', reason: 'no question overlay mounted (print/non-REPL mode)' };
     }
     // pending 行 = 问题 payload 的权威源 + D-1 绑定的唯一 surface(PendingCheckpoint.input)。
     // REF-CC-029(单源取件)+ REF-CC-033(no_pending 判别码):findPendingForTask 是唯一取件口
@@ -174,7 +174,7 @@ parkGatedCallId, onPresented) {
     // 本腿的族就是 ask 一族(整行可读闸的 ask 半场,与 fs 腿的 `isToolApprovalGate` 对称)。
     (row) => isAskTool(typeof row.toolName === 'string' ? row.toolName : undefined));
     if (!found.ok)
-        return { kind: 'failed', reason: found.reason, ...(found.code !== undefined ? { code: found.code } : {}) };
+        return { kind: 'failed', stage: 'fetch', reason: found.reason, ...(found.code !== undefined ? { code: found.code } : {}) };
     const { pending, gatedCallId } = found;
     // 问题 payload:优先流上 tool_start.args(零额外语义),缺则 pending.input(service 已 redact + 限长)。
     const fromArgs = gatedCallId
@@ -189,6 +189,7 @@ parkGatedCallId, onPresented) {
         const truncated = pending.input?.truncated === true;
         return {
             kind: 'failed',
+            stage: 'input',
             gatedCallId,
             reason: truncated
                 ? 'question payload exceeded the engine input cap (input={truncated:true}) — dialog cannot be re-rendered; run stays suspended for out-of-band decide'
@@ -268,14 +269,18 @@ parkGatedCallId, onPresented) {
         const code = e instanceof HitlSafetyError && isGateFailureCode(e.code) ? e.code : undefined;
         // #363:S-02 指路键原样透传 —— 与 `toolApprovalWire` 两条 decide 失败腿同形同源。
         const currentPending = readDecideCurrentPending(e);
+        // 0.60.0(候包件 ②):引擎机器码原样透传 —— 与 fs 腿两条 decide 失败腿同形同源。
+        const wireCode = readWireErrorCode(e);
         return {
             kind: 'failed',
+            stage: 'decide',
             gatedCallId,
             reason: `decide failed: ${String(e)}`,
             ...(code !== undefined ? { code } : {}),
             // Inkglow-1085 P0a:ask 腿与 fs 腿同形 —— 瞬断耗尽给判别位,resolvePark 走重呈臂。
             ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
             ...(currentPending !== undefined ? { currentPending } : {}),
+            ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
         };
     }
 }
@@ -369,6 +374,7 @@ export async function resolvePark(park, ctx) {
         closingCardTried = true;
         outcome = {
             kind: 'failed',
+            stage: 'orchestration',
             reason: `${ctx.unverifiableParks ?? 0} parks in this single turn resolved to no identifiable approval (hard cap ${MAX_TOTAL_PARKS}; last: ${ctx.lastStallReason ?? 'the engine kept parking'})`,
         };
     }
@@ -380,14 +386,14 @@ export async function resolvePark(park, ctx) {
             `(last: ${ctx.lastStallReason ?? 'unknown'})`;
         if (ctx.lastRoundPresentedCard === true) {
             // 上一轮已经把卡呈给用户、用户也答了、引擎还是原样 park 回来 —— 再呈一次只是把同一张失效卡再问一遍。
-            outcome = { kind: 'failed', reason: stalledReason };
+            outcome = { kind: 'failed', stage: 'orchestration', reason: stalledReason };
         }
         else {
             const closing = await surfaceParkGate(park, ctx, park.gatedCallId, witness);
             outcome =
                 closing.kind === 'decided' || closing.kind === 'aborted'
                     ? closing
-                    : { kind: 'failed', reason: `${stalledReason}; closing re-read: ${closing.reason}` };
+                    : { kind: 'failed', stage: 'orchestration', reason: `${stalledReason}; closing re-read: ${closing.reason}` };
         }
     }
     else {
@@ -482,6 +488,7 @@ export async function resolvePark(park, ctx) {
                 `[criterion: ${streakKey}${reasonToken !== undefined ? ` via reason token "${reasonToken}"` : ''}]`);
             outcome = {
                 kind: 'failed',
+                stage: 'orchestration',
                 ...(outcome.gatedCallId !== undefined ? { gatedCallId: outcome.gatedCallId } : {}),
                 reason: stalled,
             };
@@ -508,6 +515,9 @@ export async function resolvePark(park, ctx) {
         }
         outcome = {
             kind: 'failed',
+            // 🔴 `orchestration` 而不是 `decide`:这一格是**重呈臂用尽之后**编排层的收口,不是某一次
+            //    decide 的语义结局(那一次的结局在 `outcome.reason` 里被引述)。
+            stage: 'orchestration',
             ...(outcome.gatedCallId !== undefined ? { gatedCallId: outcome.gatedCallId } : {}),
             reason: `the decide call failed on transport ${streak} times in a row while the run stayed parked (${outcome.reason})`,
         };