@sema-agent/client-core 0.77.1 → 0.77.2

package/dist/hitl/parkResolver.js

@@ -1,17 +1,3 @@
-/**
- * parkResolver — HITL gate 桥**外环**的 park 决断(REF-CC-032 / SPLIT-12 第三刀,2026-08-02)。
- *
- * 内环(`frameRouter.ts`)带出一个 `GatePark` 之后,这里回答唯一一个问题:**接着读流,还是
- * fail-soft 收场**。三条出路:
- *   · 决断成功 ⇒ `reattach`(驱动 attach `runs.events`,`lastEventId` 续传);
- *   · 「这个 gate 早就被解决了」(durable re-attach 必然重放已决断的 park)⇒ 同样 `reattach`;
- *   · 其余(overlay 缺席 / pending 蒸发 / decide 409/404 / turn 中断 / hop 预算耗尽)⇒ `failsoft`:
- *     flush HOLD 的毒化帧 + 原样吐 suspended 终帧(durable 腿无终帧则合成一条可见的 failed)。
- *
- * 🔴 本文件不碰流、不 yield:events 以数组交回驱动。`resolvePark` 的**返回值**就是它的全部对外
- *    效果(台账写入除外,且台账写入全经 `GateLedger` 的动词)—— 于是「禁掉某条真臂」这种变异
- *    在驱动的消费点上必然显形,而不是被本文件自己吞掉。
- */
 import { putOwnKey } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
@@ -20,87 +6,21 @@ import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
 import { observeCancelByDeny } from './hitlHostSurface.js';
 import { flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
-// B-070 / L-200(0.65.0):`/decide` 200 回执的单一读面(换挂句柄 + executionOutcome)。
 import { readDecideReceipt } from '../decideReceipt.js';
-/**
- * L-80(2026-09-03,[6215];#357 复发):**连续非进展轮**上限 —— 数的是「壳再附着之后那段流里一个
- * host 推进帧都没有」的轮次,**不是** park 次数。修前这里是 `24` 且按每次 park 递增
- * (askGateWire `hops++` 无条件),于是一个 turn 里模型对同一失败 Edit 重试 24 次、每次真被门真被决,
- * 也会在第 25 次撞成 `gate hop limit (24) exceeded`——一句与真因无关的预算话术。CC 没有这条预算:
- * 模型问 N 次就答 N 次。本闸只留作最后防线:连续 N 轮零进展(坐标失配空转 / reopen 类 re-park /
- * decide 出站恒断)才收场,收场前再呈一次收场卡、终帧带真因与出路。
- */
 export const MAX_GATE_HOPS = 2;
-/** 纯函数:上一轮预算 + 本轮判决 ⇒ 新预算(不就地改入参;`undefined` = 本 turn 第一轮)。 */
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
     return round === 'progress' ? { stalled: 0, total } : { stalled: (prev?.stalled ?? 0) + 1, total };
 }
-/** decide 出站瞬断耗尽臂(retryExhausted)的同因连续上限:第 3 次同因即诚实收场(修前该臂**无闸**)。 */
 const MAX_TRANSPORT_REATTACHES = 2;
-/**
- * 硬兜底(对抗复审 r1 [high]①,r6 [high] 收窄):一 turn 内**解析不出身份**的 park 数上限。连续非进展计数靠
- * 「解析到的 pending 行身份 + host 推进帧」判进展;解析不到行(tool-less park / approvals 恒空)时身份判不出 ⇒
- * 只能靠推进帧,一个每轮先吐一帧文本再原样 park 的病态引擎在那一形下仍可能无限。**只数这一类**:每轮都解析到
- * 新 call 且真推进的门(模型重试同一失败调用 N 次)不吃这格 —— CC 没有此闸,问 65 次就答 65 次。
- * 命中即收场、终帧如实说「本 turn 有 N 次 park 解析不出身份」。
- */
 export const MAX_TOTAL_PARKS = 64;
-/**
- * 「已解决 ⇒ reattach」臂的**同因连续命中上限**(#357,现网 P0;[5522] 定谳 / [5525] server 答复)。
- * 同一判据源连续第 `N+1` 次命中即**不再** reattach。
- *
- * ── 病 ──────────────────────────────────────────────────────────────────────────────────────
- * 用户批完两张卡,第三只门 16 分钟长等,最后吐 `gate hop limit (24) exceeded`,工具 abort,
- * 而引擎侧 run 仍 parked。链:run 仍 parked 但取件当拍读不到本 run 的可决行 ⇒ 每一轮重放的 park
- * 都命中「已解决」⇒ reattach ⇒ 引擎重放同一张 park ⇒ 循环到 hop 预算耗尽。24 轮里只有 debug 级
- * 日志,用户零告知,拿到的还是一句与真因无关的预算话术。
- *
- * ── 两件修的分工(**别合并**)──────────────────────────────────────────────────────────────
- *   · **主修 = 坐标重探**({@link resolvePark} 的 rescan 臂):server [5525] 定谳这不是「状态失配」
- *     而是**坐标失配** —— decide 受理后 resume **消费**掉 checkpoint(token 一次性),下一 turn 再
- *     撞门就是**新 park / 新 token / 新行**;拿旧坐标去查/去决恒得 409 `approval_stale`(体
- *     terminal:"resolved")或 404 no-pending,逐字命中本文件的「已解决」判据集,而 run 真身是
- *     parked、**新行真实存在待决**。⇒ 命中「已解决」时先**重读当前队列**(丢掉这张 park 自带的
- *     陈旧身份,让取件腿按当前拍的坐标选行):有行 ⇒ 这一轮就把**新卡**真呈给用户;确无行 ⇒ 才是
- *     #110 的重放窗,照旧 reattach。
- *   · **兜底 = 本闸**:重探自己也失配/读不动时(网络类、或队列确实空而 run 就是不动),不许再
- *     空转 24 轮 —— 同因连续第 2 次即诚实收场,终帧带真因。
- *
- * 值 = 1 的理由:「已解决」判据的**正当性只覆盖一次重放窗**(#110 成文:`lastEventId` 再准也只能
- * 精确到帧,park 就在重放窗里,而那个窗**只有一次**)。第二次同因命中意味着重探也没能把新坐标
- * 找出来 —— 那时继续 reattach 只是把同一个空转再跑一遍。
- * 🔴 {@link MAX_GATE_HOPS} 总闸**保留**(最后防线):本闸只管「已解决」这一条臂,别的臂
- * (重呈臂每轮真呈卡)仍由总闸兜底。
- *
- * 🔴 键**按语义分不按表征分**(异源复审 finding③):「已解决」在 wire 上有 `no_pending` 码 /
- * 409 体 `resolved` / 404 `not found` 三种长相,它们是同一个真因 —— 按长相分键的话,表征一轮换
- * 计数就重置回 1,闸永远不触发。判据见 {@link alreadyResolvedStreakKey}。
- */
 const MAX_ALREADY_RESOLVED_REATTACHES = 1;
-/**
- * REF-CC-033:`GateOutcome` 的 `failed` 分支闭集判别码。来源两处:①本文件自己的
- * 「pending 行取不到」早退(`surfaceGateAndDecide` 里 `!pending` 那条);②`HitlBridge` 抛出的
- * `HitlSafetyError.code`(hitlBridge.ts 契约:`binding_mismatch|no_pending|wrong_gate|bad_plan_edit`
- * ——该属性今天仍是开集 `string`,TYPESHAPE-07/REF-CC-036 候后续车锁死;这里落地前用
- * `isGateFailureCode` 按闭集白名单过滤,不认得的值一律降级成 `undefined`,退回文案兜底,不让
- * 开集腐蚀这个新判别位)。消费点只认 `'no_pending'` 为「已解决」,其余码(binding_mismatch 等)
- * 是真需要重新呈现给人的失败,不能走「继续读流」这条路。
- */
-/**
- * 白名单的**运行期真源**(FIX② 2026-08-07 由三处散落的 `===` 收成一份元组)。
- * 🔴 与 `hitlBridge.HitlSafetyError.code` 的联合是**同一个闭集的两半**:下方 `_gateFailureCodePins`
- * 双向钉住,任何一边加员而另一边不跟 ⇒ 编译红。此前两边靠人肉同步,而不同步的可观测后果是
- * 「新码被 `isGateFailureCode` 降成 undefined 后静默走文案兜底臂」—— 门里长得跟正常一模一样。
- */
 export const GATE_FAILURE_CODES = [
     'no_pending',
     'binding_mismatch',
     'wrong_gate',
     'bad_plan_edit',
-    /** 0.72.13 CC-46:plan-review 的 permissionModeAfter 坏形(非 approve 带这一位 / 词表外)被本地拦下。 */
     'bad_plan_mode',
-    /** FIX②:空作答被本地拦下(空 answers[] / 空 selected[] / 空 header)。 */
     'empty_answer',
 ];
 const _gateFailureCodePins = [true, true];
@@ -108,66 +28,26 @@ void _gateFailureCodePins;
 function isGateFailureCode(v) {
     return typeof v === 'string' && GATE_FAILURE_CODES.includes(v);
 }
-/**
- * decide 的 `failed` 原因是不是「这个 gate 早就被解决了」(#110 缺陷② c 的判据)。
- *
- * REF-CC-033:此前判据**只**锚在文案词(`no pending checkpoint` / `resolved` / `already` 三者
- * 任一在场)——server 原文改一个字,整条命中当场失效(FIX-13 / 域词表-01)。现在消费点(见下方
- * `isAlreadyResolvedFailure`)优先判 `GateOutcome.code`(闭集判别位,见 `GateFailureCode`);
- * 这个函数降级为**文案兜底臂**,只在 outcome 没带 code 的时候才被调用(典型:`FsApprovalOutcome`
- * 来自 `toolApprovalWire.ts`,那份类型今天没有 code 字段——C-bridge 卡的文件域,本卡不改)。
- * 🔴 方向没变:这条判**错**的后果不对称 —— 误判成「已解决」最多让流多读一轮(hop 预算兜底),
- * 误判成「真失败」会把一个已经 completed 的 run 谎报成失败并烧掉整条会话转录。所以宁可宽。
- */
-/** #114/[C68] 单源化提升:desktop 照抄件(durable 双实现审计 P0-1 修)到货换包导入删抄件。
- *  [C106] 收编 `not found` 形(2026-08-05):引擎对已批门的 deny 回 `approval not found`
- *  (desktop 实测——parked 刚批完、decide 未返回的竞态窗内 Stop 走 parked-deny 路),旧词表
- *  判不中 ⇒ 按真失败 log-only 放弃 ⇒ runs.cancel 永不发出=Stop 哑弹。按上方「宁可宽」方向收编。 */
 export function isAlreadyResolvedGateReason(reason) {
     return alreadyResolvedReasonToken(reason) !== undefined;
 }
-/**
- * 文案兜底臂的**词表**(判据本体;`isAlreadyResolvedGateReason` 是它的布尔投影)。
- * 🔴 #357 把它从「四个 `||` 就地写死」抽成词表,**行为一个字节不变**:一处词表,两个消费点
- * (布尔判定 + 诊断串里「是哪个词命中的」),此前后者只能靠人再读一遍那四个 `||`。
- * 🔴 命中的词**不进限次闸的键** —— 键按语义分,理由见 {@link alreadyResolvedStreakKey}。
- */
 const ALREADY_RESOLVED_REASON_TOKENS = ['no pending checkpoint', 'resolved', 'already', 'not found'];
-/** 命中的那个词(没命中 ⇒ `undefined`)。顺序即优先级,只进诊断串,不参与判定强弱。 */
 function alreadyResolvedReasonToken(reason) {
     if (typeof reason !== 'string')
         return undefined;
     const r = reason.toLowerCase();
     return ALREADY_RESOLVED_REASON_TOKENS.find((t) => r.includes(t));
 }
-/** 已解决判据(REF-CC-033):code 在场就只信 code,不在场才落回文案兜底。
- *  ✅ **记案已销**(#357,0.47.0):原注末句写的是「fs 审批腿的 `FsApprovalOutcome` 今天没有
- *  code 字段——C-bridge 卡域,退役条件 = 那边也补上 code」。那个退役条件已兑现:取件腿的
- *  `no_pending` 码现在由 `toolApprovalWire.surfaceFsApprovalAndDecide` 原样透传(见
- *  `FsApprovalOutcome.code` 头注),两条腿从此同走 code 臂;文案兜底只剩 decide 失败那一类
- *  (引擎的 409/404 语义答复文本)与旧引擎路径。
- *  🔴 入参**已经**是窄化到 `{kind:'failed'}` 的那半:一个「true ⇒ 是 failed」的判定不能反过来
- *  当「false ⇒ 不是 failed」的类型谓词用(TS 的 `outcome is Extract<…>` 负向窄化会把整个
- *  `'failed'` 分支从联合类型里排除,而这个函数对未解决的真失败照样返回 false——那不是「它不是
- *  failed」,是「它是 failed 但没解决」。调用点先用 `outcome.kind === 'failed'` 做真正的判别式
- *  窄化,再把窄化后的值交给这里,本函数只回答布尔,不再兼职类型谓词。 */
 function isAlreadyResolvedFailure(outcome) {
     const code = 'code' in outcome && isGateFailureCode(outcome.code) ? outcome.code : undefined;
     return code !== undefined ? code === 'no_pending' : isAlreadyResolvedGateReason(outcome.reason);
 }
-/** 把 wire 答案({answers:[{header,selected,note?}]})折回 CC 卡片的 Record<question,string> 形状
- *  (multiSelect 与对话框同款 ", " lossy join;note → annotations.notes)。 */
 export function toAnsweredOutput(questions, answer) {
     const answers = {};
     const annotations = {};
     for (const entry of answer.answers ?? []) {
         const q = questions.find(qq => qq.header === entry.header);
         const key = typeof q?.question === 'string' ? q.question : entry.header;
-        // 🔴 0.68.0 / L-246 B2:落键走**单源** `putOwnKey`(`src/ownKey.ts`)。修前这里是一只内联的
-        //    同形实现,与 `adapter/downstream/terminalToSdkResult.ts` 的那一份各写各的 —— 陷阱与取舍
-        //    的完整说明现在只在那个模块的头注里一份。`key` 来自 wire(问题正文 / header),字面等于
-        //    `"__proto__"` 时裸赋值走的是 `Object.prototype` 上那只 accessor:`answers` 那一格(串值)
-        //    整条静默丢失,`annotations` 那一格(对象值)还顺手改了表自己的原型。
         putOwnKey(answers, key, (entry.selected ?? []).join(', '));
         if (entry.note)
             putOwnKey(annotations, key, { notes: entry.note });
@@ -179,37 +59,20 @@ export function toAnsweredOutput(questions, answer) {
         ...(Object.keys(annotations).length > 0 ? { annotations } : {}),
     };
 }
-/**
- * 弹既有 AskUserQuestion overlay → 等作答 → 经 HitlBridge decide(答案/拒答)。
- * decide 成功即引擎已把 run 驱到下一状态(sync);调用方随后 attach runs.events 续流。
- */
-async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, 
-/** 这张 park 的待批 call 身份(server ≥7.41.0;缺席是常态)。语义与不 fail-closed 的理由
- *  与 fs 腿同一条,见 `toolApprovalWire.surfaceFsApprovalAndDecide` 的同名参数头注。 */
-parkGatedCallId, onPresented) {
+async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGatedCallId, onPresented) {
     if (!hasQuestionOverlay()) {
         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 是唯一取件口
-    // (三份近似复刻已收敛),其失败形带 code 判别位,本处原样透传给 GateOutcome ——
-    // 「没有待决 gate」(良性,park 重放常见)与「approvals.list 真失败」自此结构可分。
-    const found = await findPendingForTask(deps.client, taskId, isAskTool, signal ? { signal } : undefined, parkGatedCallId, // 身份在场 ⇒ 逐字命中优先;缺席/不命中 ⇒ 原两腿(不 fail-closed,理由见参数头注)
-    // 本腿的族就是 ask 一族(整行可读闸的 ask 半场,与 fs 腿的 `isToolApprovalGate` 对称)。
-    (row) => isAskTool(typeof row.toolName === 'string' ? row.toolName : undefined));
+    const found = await findPendingForTask(deps.client, taskId, isAskTool, signal ? { signal } : undefined, parkGatedCallId, (row) => isAskTool(typeof row.toolName === 'string' ? row.toolName : undefined));
     if (!found.ok)
         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
         ? askArgsByCall.get(gatedCallId)?.questions
         : undefined;
     const fromPending = pending.input?.questions;
     const questions = Array.isArray(fromArgs) && fromArgs.length > 0 ? fromArgs : fromPending;
     if (!Array.isArray(questions) || questions.length === 0) {
-        // [1543]②:input 超引擎入参帽(MAX_TOOL_INPUT_CHARS,preview 富文本题易中)时 server 降级为
-        // {truncated:true} ——无题可渲不是引擎代差,是 payload 被截。分形出诚实理由(fail-soft 链
-        // 会把 reason 记入 SEMA_DEBUG,别再误导成 pre-CHANNEL[56] 老引擎)。
         const truncated = pending.input?.truncated === true;
         return {
             kind: 'failed',
@@ -220,8 +83,6 @@ parkGatedCallId, onPresented) {
                 : 'gate has no question payload (pre-CHANNEL[56] engine?)',
         };
     }
-    // overlay 往返:合成 frame(id 独占命名空间 hitl-ask:)→ local responder 一次性收答。
-    // A-028.3:id 经 gateIdentity 唯一铸口(呈现台账/壳侧重开腿的键推导同源,字面不再各铸各的)。
     const questionId = askGateQuestionId(approvalCallKey(gatedCallId, taskId));
     const answer = await new Promise(resolve => {
         const unregister = registerLocalQuestionResponder(questionId, async (_id, a) => {
@@ -231,7 +92,6 @@ parkGatedCallId, onPresented) {
         });
         const onAbort = () => {
             cleanup();
-            // 撤下还开着的对话框(question_complete = overlay 的既有 dismiss 语义)
             publishQuestionFrame({ type: 'question_complete', questionId });
             resolve(null);
         };
@@ -244,42 +104,20 @@ parkGatedCallId, onPresented) {
             return;
         }
         signal?.addEventListener('abort', onAbort, { once: true });
-        onPresented?.(); // L-80:ask 腿的呈现回执与 fs 腿同一枚旗(对抗复审 r2 [high]②:此前只数卡口)
+        onPresented?.();
         publishQuestionFrame({ type: 'question', questionId, questions });
     });
     const bridge = new HitlBridge(deps.client, taskId);
     if (answer === null) {
-        // turn 被中断(Esc/Ctrl+C):把这只挂着的 ask 用一次 **TOOL 级 deny** 结算掉,好让 run 不停在
-        // suspended 上(server `ASSISTANT-WIRE-CONTRACT.md` §4a)。
-        // 🔴 **0.42.0 撤稿**:原文写的是「cancel-by-deny(contract/04 §2.4 —— suspended run 不
-        //    runs.cancel)」。那条引用的两个前提都已作废 —— §4a 逐字说 DENY 是 tool 级应答**永远不是**
-        //    run kill;而「suspended run 不能 runs.cancel」自 server [868] 起就不成立(就地取消已实装,
-        //    本仓 fresh-scan B型-5 按真字节证伪)。这里选 deny 不是因为 cancel 不可用,是因为**这一刻
-        //    要处理的就是一只挂着的 ask**:先把它结算掉,run 才走得下去。下方那句「引擎侧解锁腿到货前」
-        //    同批订正:那条腿早就到货了,本臂保留的理由变成「结算 ask 是这一步的正解」,不再是权宜。
-        // 件3(中断事故修复批 G,2026-07-15,症状1 壳侧配套):此前 .catch(()=>{}) 全吞 = deny 丢失时
-        // run 永卡 suspended,session 锁死,用户下一条消息撞 409「active run」还全无线索。改为有界观察
-        // (observeCancelByDeny,2s 预算):abort 仍立即返回用户控制(不 await,交互时序不变),后台
-        // settle 失败/超时上屏一行 warn + SEMA_DEBUG 记失败原因。
-        // 🔴 **0.42.0 订正**:本段原文以「引擎侧解锁腿([866] server:cancel suspended 改语义 +
-        //    reapSuspended TTL)**到货前**,这是壳能做的最诚实半场」收尾 —— 那条腿早已到货
-        //    (server [868] 起 suspended run 就地取消 + `reapSuspended` 实体在,fresh-scan B型-5 已按
-        //    真字节证伪)。本臂**不是**在等一条不存在的上游腿:它保留的理由是「这一刻要处理的就是一只
-        //    挂着的 ask,先结算它 run 才走得下去」。观察器的预算论证前提见 `CANCEL_DENY_BUDGET_MS` 头注
-        //    的重审段(同批 §2.4 撤稿件)。
         observeCancelByDeny(bridge.decideTool({ decision: 'deny', reason: 'Interrupted by user' }, gatedCallId, undefined, pending), taskId);
         return { kind: 'aborted', gatedCallId };
     }
     let declinedReceipt;
     try {
-        // REF-CC-038(2026-08-02):`answer.answers` 已经是 `AskAnswer[]`(liveQuestionStore 的
-        // `QuestionAnswer` 直用 hitlBridge 的 `AskAnswer` 为唯一源)—— 不再需要靠 cast 把两个
-        // 名不同的等价形状缝合。
         const entries = answer.answers ?? [];
         const hasContent = entries.some(a => (a.selected?.length ?? 0) > 0 || (a.note?.length ?? 0) > 0);
         if (hasContent) {
             const raw = await bridge.answerQuestion(entries, gatedCallId, signal ? { signal } : undefined, pending);
-            // B-070:回执原样读一次(缺席即缺席);两条腿同形 —— fs 腿在 `toolApprovalWire` 的三处。
             const receipt = readDecideReceipt(raw);
             return {
                 kind: 'decided',
@@ -289,20 +127,14 @@ parkGatedCallId, onPresented) {
             };
         }
         else {
-            // 用户拒答(overlay reject/dismiss 送空 answers)= 诚实 deny;模型收 denied 结果自续。
             const raw = await bridge.decideTool({ decision: 'deny', reason: 'User declined to answer' }, gatedCallId, signal ? { signal } : undefined, pending);
             declinedReceipt = readDecideReceipt(raw);
         }
         return { kind: 'decided', gatedCallId, ...(declinedReceipt !== undefined ? { receipt: declinedReceipt } : {}) };
     }
     catch (e) {
-        // REF-CC-033:HitlSafetyError.code 是 hitlBridge.ts 自己的闭集契约(见其类型头注),
-        // 这里 instanceof 窄化后再过 isGateFailureCode 白名单——不认得的码(将来 hitlBridge 那边
-        // 万一多加一种)一律降级成 undefined,退回文案兜底,不让开集腐蚀这个新判别位。
         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',
@@ -310,100 +142,45 @@ parkGatedCallId, onPresented) {
             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 } : {}),
         };
     }
 }
-/** 台账里那批 gated `tool_start` 当拍 args 快照 → 决断腿要的 `toolCallId → args` 表(UNTRUSTED 原样搬运)。 */
 function argsByCallOf(led) {
     return new Map(led.gatedStartArgs());
 }
-/**
- * 限次闸的**判据源**(键)——「是哪一**条判据**把这一轮判成已解决的」。
- *
- * 🔴 键**按语义分,不按表征分**(异源复审 finding③ 的采纳):「队列里没有本 run 的可决行」这件事
- * 在 wire 上有好几种长相 —— 取件读到空表落 `code:'no_pending'`,server 的 409 `approval_stale`
- * (体 terminal:"resolved")/ 404 落文案臂的 `resolved` / `not found`。它们是**同一个真因的三种
- * 说法**;按长相分键的话,一个卡死的 gate 只要在这几种表征之间轮换,连续计数就一路重置回 1,
- * 闸永远不触发 —— 正是本闸要消灭的那个空转([anchor-on-the-deciding-quantity]:锚真正决定结果
- * 的量,不锚它的表征)。命中的那个词只进诊断串,不进键。
- *
- * 只有身份腿(`decidedGates` 一次性匹配)另占一个键:它与「已解决」是两条独立判据,而且它一次性
- * 消费、连续最多命中一次,天然不会把闸推到跳闸线。
- */
 function alreadyResolvedStreakKey(byDecidedIdOnly) {
     return byDecidedIdOnly ? 'decided-id-match' : 'already-resolved';
 }
-/**
- * 这一轮的失败是不是「**取件那一步**就没找到本 run 的可决行」—— 即坐标重探唯一有资格跑的那一形。
- *
- * 🔴 判据锚在**结构**上,不锚文案:`code === 'no_pending'`(取件腿的结构化判别位,两条呈卡腿
- * 今天都透传它)**且** `gatedCallId` 缺席。后半条是承重的 —— 两条呈卡腿里,`findPendingForTask`
- * 失败那一条是**唯一**不带 `gatedCallId` 的 failed 出口(行都没选出来,哪来的 call 身份);它之后
- * 的每一个失败出口(卡口缺席 / 无 payload / decide 4xx,包括 `HitlSafetyError.code==='no_pending'`)
- * 都带着 `gatedCallId`。于是这条判据同时证明了一件承重的事:**这一轮没有向用户呈过卡**。
- *
- * 🔴 为什么必须证明「没呈过卡」(异源复审 finding② 的采纳):重探会把整条呈卡腿**再走一遍**。
- * 若允许它在「卡已经呈过、用户答了、decide 回了一句带 resolved 字样的 409」之后跑,用户会在同一轮
- * 里被同一张卡问第二遍(而且可能给出与第一次不同的答案)。把重探限定在取件步失败这一形,
- * 「同一轮重复呈卡」在结构上就不成立。代价:decide 步的 stale 409 不再就地重探 —— 那一形照旧
- * reattach 一次(durable 流本就会把 park 再送一遍),第二次同因命中由限次闸诚实收场。
- */
 function isFetchStepNoPending(outcome) {
     const code = 'code' in outcome && isGateFailureCode(outcome.code) ? outcome.code : undefined;
     return code === 'no_pending' && outcome.gatedCallId === undefined;
 }
-/**
- * 「呈这张 park 的卡 → 等人决断 → decide」的**唯一**入口(两族各一条腿;fs 腿的 denied 记账随行)。
- *
- * 🔴 #357 抽成一处的理由不是去重:坐标重探臂要用**当前拍的坐标**再走一次同一条腿,两处各写一份
- *    的话,「第一次走的路」与「重探走的路」会各自漂(记账少一笔 / 族判据不同 ⇒ 决断落到另一行)。
- *
- * @param gatedCallId 交给取件腿的**身份**(wire 给的 park 身份;缺席是常态)。首击与坐标重探
- *   传的是**同一个值** —— 重探要的是读数新鲜,不是判据放宽,理由见调用点的红线注。
- */
 async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
     const { deps, led, taskId } = ctx;
     if (park.gate === 'fs') {
-        // [816] 放宽腿:fs 写权限 gate → CC 三选卡(vendored PermissionRequest)→ decide。
         const outcome = await surfaceFsApprovalAndDecide({ client: deps.client, ...(onPresented ? { onPresented } : {}) }, taskId, argsByCallOf(led), ctx.signal, gatedCallId);
-        // #51: `outcome`'s declared type is the wider `GateOutcome |
-        // FsApprovalOutcome`; both unions share a 'decided' kind with
-        // different optional fields (`answered` vs `denied`), so a plain
-        // `.denied` access doesn't hold for every 'decided' member even
-        // though this branch only ever assigns the FsApprovalOutcome shape.
-        // 'in' narrowing sidesteps it.
         const outcomeDenied = 'denied' in outcome ? outcome.denied : undefined;
         if (outcome.kind === 'decided' && outcomeDenied === true && outcome.gatedCallId) {
-            led.markDenied(outcome.gatedCallId); // 重放的报错帧渲 `User rejected …`(见 tool_end 有序臂 ③)
+            led.markDenied(outcome.gatedCallId);
         }
         return outcome;
     }
     return surfaceGateAndDecide(deps, taskId, argsByCallOf(led), ctx.signal, gatedCallId, onPresented);
 }
 export async function resolvePark(park, ctx) {
-    // `deps` 不在本函数直读:呈卡/决断两族腿统一经 `surfaceParkGate`(#357 单源化,见其头注)。
     const { led, taskId } = ctx;
     let outcome;
-    // REF-CC-034:这次 park 的候选 callId(仅 fs 分支填,已决断身份匹配用)——ask 分支不填,
-    // 因为 `surfaceGateAndDecide` 的 `!pending` 早退已经自带 `code:'no_pending'`(REF-CC-033),
-    // 不需要这条第二判据。用 `lastFsOrShellGatedCallId()` 而非「未收口 fs call 栈」:durable
-    // re-attach 重放的 `suspended` park 没有配套的新 tool_start/tool_end,那个栈在这次重放之前
-    // 早被 tool_end 的 drop 清空了(见台账声明处注),取不到候选。
     let candidateGatedCallId;
     const stalledRounds = ctx.stalledRounds ?? 0;
     let closingCardTried = false;
-    // 呈现回执(对抗复审 r2 [medium]②③):每次 resolvePark 各自一枚旗,fs 腿经 deps.onPresented、ask 腿经
-    // publishQuestionFrame 前的同一枚旗置位;并发会话互不串扰,规则直决/取件失败恒 false。
     let presentedThisRound = false;
     const witness = () => {
         presentedThisRound = true;
     };
     if ((ctx.unverifiableParks ?? 0) > MAX_TOTAL_PARKS) {
-        // 硬兜底:见 MAX_TOTAL_PARKS 头注(只数解析不出身份的 park)。不呈收场卡,终帧如实。
         closingCardTried = true;
         outcome = {
             kind: 'failed',
@@ -412,13 +189,10 @@ export async function resolvePark(park, ctx) {
         };
     }
     else if (stalledRounds > MAX_GATE_HOPS) {
-        // 最后防线:连续 N 轮零进展。收场前**再呈一次收场卡**(现读队列的可决行,用户面能看见能答),
-        // 真呈出来且决了就按决断走;呈不出/仍失败才 failsoft,终帧带真因与出路(不再是预算话术)。
         closingCardTried = true;
         const stalledReason = `the run stayed parked across ${stalledRounds} consecutive re-attach rounds without any host progress ` +
             `(last: ${ctx.lastStallReason ?? 'unknown'})`;
         if (ctx.lastRoundPresentedCard === true) {
-            // 上一轮已经把卡呈给用户、用户也答了、引擎还是原样 park 回来 —— 再呈一次只是把同一张失效卡再问一遍。
             outcome = { kind: 'failed', stage: 'orchestration', reason: stalledReason };
         }
         else {
@@ -434,66 +208,21 @@ export async function resolvePark(park, ctx) {
             candidateGatedCallId = led.lastFsOrShellGatedCallId();
         outcome = await surfaceParkGate(park, ctx, park.gatedCallId, witness);
     }
-    // #110 缺陷② b/c —— **重放的、早已决断过的 park 不是失败**。
-    // durable re-attach 必然会把 park 帧再送一遍(`lastEventId` 再准也只能精确到帧,park 就在
-    // 重放窗口里)。这时 approval 行早已 resolved,`surfaceFsApprovalAndDecide` 取不到 pending,
-    // 返回 `failed: no pending checkpoint for this run (resolved/expired?)` —— 那句话的语义恰恰是
-    // **「这个 gate 已经被解决了」**,正确处置是**继续读流**(引擎那边 run 正常往下跑,实测
-    // `run.json status="completed"`),而不是宣布 turn 失败。旧行为的代价不是一句错文案:
-    // 终帧被投影成 `error_during_execution` ⇒ 壳走失败路径 ⇒ CC 转录**一行都不写** ⇒
-    // 同 session `--resume` 报 `No conversation found` ⇒ **整个会话废掉**。
-    // 无限循环由 `hops > MAX_GATE_HOPS` 兜底(本 reattach 照常吃 hop 预算,不绕过它)。
-    //
-    // REF-CC-034:`isAlreadyResolvedFailure` 是首选判据(code/文案双臂;#357 起 fs 腿的取件码也
-    // 走 code 臂,见该函数头注的销案段)。失败原因若两臂都判不出(例如 `approvals.list` 自身网络
-    // 失败),已决断身份匹配是独立于文案的第二判据 —— 两臂任一命中都按「已解决」处置,方向偏宽
-    // (见台账 `markDecided` 处注)。
-    //
-    // [2393] hitl-F2(2026-08-02):这条身份判据**一次性消费**(`takeDecided` 而不是 `isDecided`)。
-    // 它的正当性只覆盖「durable re-attach 把**那一次**已决断的 park 重放一遍」这一个窗口,而它的两个
-    // 输入都是单调的(`lastFsOrShellGatedCallId()` 故意不随 tool_end 清空 + `decidedGates` 只增),
-    // 不消费就等于:本 turn 只要成功决断过一次,之后**每一次** park 失败都被判「已解决」——
-    // `approvals.list` 网络失败这类真失败会连吃 24 个 hop,最后吐一句与真因无关的 `gate hop limit`。
-    // 消费点写在 `outcome.kind === 'failed'` 之内:决断成功的那一轮压根不该动这个记号。
-    //
-    // 🔴 #357(现网 P0,[5522]/[5525]):上面那条一次性只关掉了**身份腿**的空转;它的孪生腿
-    // (code/文案判据)当时没有任何限次 —— 「run 仍 parked 而取件读到空表」的**坐标失配**态下,
-    // 每一轮重放都命中 code 臂,照样烧满 24 个 hop、16 分钟长等、终帧还是那句与真因无关的预算话术
-    // ([same-shape-residue-constitution]:同一病形的第二处存量)。下面两件按 `MAX_ALREADY_RESOLVED_REATTACHES`
-    // 头注的分工落地:主修 = 坐标重探(拿当前拍的坐标真把新卡呈出去),兜底 = 同因连续限次。
     const alreadyDecidedById = outcome.kind === 'failed' &&
         candidateGatedCallId !== undefined &&
         led.takeDecided(candidateGatedCallId);
-    // L-80:触顶收场的合成失败**不进**「已解决」臂(它的文案判据会把 `(last: no pending …)` 认成同族再续一轮)。
     if (!closingCardTried && outcome.kind === 'failed' && (isAlreadyResolvedFailure(outcome) || alreadyDecidedById)) {
         const firstReason = outcome.reason;
-        // 键按语义分(见 `alreadyResolvedStreakKey` 头注);命中的那个文案词只进诊断串。
         const streakKey = alreadyResolvedStreakKey(!isAlreadyResolvedFailure(outcome) && alreadyDecidedById);
         const reasonToken = alreadyResolvedReasonToken(outcome.reason);
-        // ── 主修:坐标重探 ────────────────────────────────────────────────────────────────────
-        // 🔴 重探 = **按当前拍再读一次队列**(同一条呈卡腿、**同样的入参**)。有可决行 ⇒ 这一轮就把
-        //    新卡真呈给用户(死锁在这里破);无行 ⇒ 它照旧回同一个「已解决」,落下面的限次闸。
-        //    坐标轮换在这里是**自动**发生的:取件腿的身份腿在队列里找不到那张 park 的陈旧 callId 时
-        //    本就回落 taskId + 族谓词两腿,于是选中的正是当前拍的新行(server [5525] 的新 token 新行)。
-        // 🔴 **刻意不把身份入参抹成 `undefined`**(异源门 F10-j 当场证伪的写法):`parkGatedCallId` 在
-        //    `findPendingForTask` 里同时是「优先命中的身份」**和**「身份与本腿族属冲突时把候选池收紧」
-        //    的那把闸。抹掉它就等于把 F10-j 钉住的那条绕道兜底重新打开 —— 身份指着一行反族行、队列里
-        //    又没有别的行时,「任意行」兜底会把那行反族行捞回来呈卡 + decide(卡面全错、决断打在另一个
-        //    checkpoint 上)。重探要的是**读数新鲜**,不是**判据放宽**。
-        const rescan = isFetchStepNoPending(outcome) && stalledRounds <= MAX_GATE_HOPS // L-80:按连续非进展轮判,不按 park 总数
+        const rescan = isFetchStepNoPending(outcome) && stalledRounds <= MAX_GATE_HOPS
             ? await surfaceParkGate(park, ctx, park.gatedCallId, witness)
             : undefined;
-        // 🔴 只有**真进展**才采信重探的结果:决断成功 / 用户 Esc / 瞬断耗尽(那一形有自己的重呈臂)。
-        //    重探自己失败(网络类、或队列确实没有可决行)⇒ **不采信**,走限次闸兜底 —— 采信的话,
-        //    一次瞬时读面故障就会把 #110 那条「重放的 park 不是失败」救回腿改判成 fail-soft(会话废掉
-        //    那条路径),代价严重不对称。
         if (rescan !== undefined &&
             (rescan.kind === 'decided' ||
                 rescan.kind === 'aborted' ||
-                rescan.kind === 'retracted' || // 0.74.1(CC-67):宿主撤卡也是「人那一侧有了处置」,采信,不再重探
+                rescan.kind === 'retracted' ||
                 (rescan.kind === 'failed' && rescan.retryExhausted === true))) {
-            // L-80:**不在这里**复位同因计数 —— 复位只在驱动侧观察到 host 进展帧时发生(#357 的闸曾被这一行
-            // 每轮绕空:坐标失配序下每轮都「找到新行→决成功→引擎原样重放」,计数永远回不到 2)。
             hostLog('debug', `liveHitlAskWire: gate reported already-resolved (${firstReason}) but a fresh approvals re-read for run ` +
                 `${taskId} surfaced a decidable row under the current coordinates — re-presented it (rescan: ${rescan.kind}) ` +
                 `instead of re-attaching on the stale park identity`);
@@ -509,12 +238,6 @@ export async function resolvePark(park, ctx) {
                     (led.decidedCount() > 0 ? ` [decided so far: ${led.decidedCount()}]` : ''));
                 return { kind: 'reattach', progress: false, reason: reasonToken ?? streakKey, presented: presentedThisRound, gatedCallId: outcome.gatedCallId };
             }
-            // ── 兜底:同因连续第 2 次 ⇒ 不再空转,诚实收场 ──────────────────────────────────────
-            // 件B(可见告知):真因走**终帧的 errorMessage**(下面 fail-soft 汇流合成的那一条),不是只落
-            // debug —— 修前用户在 24 轮里什么都看不到,最后拿到的是一句关于 hop 预算的话。
-            // 🔴 如实记边界:`park.pendingDone` 在场(sync leg 的 `done{suspended}`)时,fail-soft 汇流
-            //    按既有语义原样吐那一帧、不合成 failed —— 那一格的告知面仍只有本行日志。durable 腿
-            //    (真实病形所在:`suspended` 事件无 pendingDone)恒走合成帧,真因必然上屏。
             const stalled = `the gate reported already-resolved ${streak} times in a row while the run stayed parked, and a fresh ` +
                 `approvals re-read surfaced no decidable row for it — run/approvals coordinate mismatch ` +
                 `(last gate reason: ${firstReason})`;
@@ -528,16 +251,7 @@ export async function resolvePark(park, ctx) {
             };
         }
     }
-    // Inkglow-1085 P0a —— **重呈臂**:decide 出站在瞬断类失败上重试一次仍未送达(两发都没拿到引擎的
-    // 语义答复)。此刻 run 仍 parked、pending 行仍可决 —— 合成 `hitl_unanswered` 把 turn 判死是三条
-    // 出路里唯一不可逆的那条,只配给「引擎答了且拒了」的语义失败。这里改走 reattach:durable 流对
-    // suspended run 必然把 park 帧再送一遍(#110 已解决重放同一条机械路径),于是**同一张卡重新交给
-    // 用户**(重呈的呈现就是卡本身,归端零新 UI);hop 预算照吃(每轮都要人再答一次,不会空转)。
-    // 引擎真死时失败也尽快显形:下一轮的 approvals.list / runs.events 对死引擎当场失败,walks 既有
-    // 诚实红(reason 是 approvals.list failed,不带 retryExhausted ⇒ 不再进本臂)。
     if (outcome.kind === 'failed' && outcome.retryExhausted === true && !closingCardTried) {
-        // L-80:该臂修前**无次数闸**(头注自认「approvals.list 网络失败这类真失败会连吃 24 个 hop」)——
-        // 现进同一本同因账:连续第 3 次即收场(下方 failsoft),终帧带真因。
         const token = transportReasonToken(outcome.reason);
         const streak = led.noteAlreadyResolvedGate(`transport:${token}`);
         if (streak <= MAX_TRANSPORT_REATTACHES) {
@@ -549,8 +263,6 @@ 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})`,
@@ -558,8 +270,6 @@ export async function resolvePark(park, ctx) {
     }
     if (outcome.kind !== 'decided') {
         hostLog('debug', `liveHitlAskWire: gate not decided (${outcome.kind}${'reason' in outcome ? `: ${outcome.reason}` : ''}) — fail-soft to suspended terminal`);
-        // 0.74.1(CC-67):宿主撤卡(无决断收口)⇒ 零 decide,run 照旧 parked;这一轮按 fail-soft 收口并把真因写进去
-        //    (不是用户中断、不是 decide 失败 —— 是这张卡在这个宿主上已经没有决断口了)。
         const failedReason = outcome.kind === 'failed'
             ? outcome.reason
             : outcome.kind === 'retracted'
@@ -567,44 +277,12 @@ export async function resolvePark(park, ctx) {
                 : undefined;
         return { kind: 'failsoft', events: failsoftEvents(park, ctx, outcome.kind === 'aborted', failedReason) };
     }
-    // decide 成功:丢弃该 call 的毒化 HOLD(续流重放会带 isError:false 的解答帧收口卡片),
-    // 并记下真实答案供该解答帧 stamp `structured`(否则卡片渲成结果不可用)。
-    //
-    // 🔴 件④([4933] 立案的存量,0.41.0 根修):摘扣留帧走 `dropHeldForDecidedPark` 而不是裸
-    //    `dropHeld(outcome.gatedCallId)` —— 后者的入参是 `findPendingForTask` 的**卡面渲染宽口**
-    //    (同 taskId + 谓词命中的第一行),同族多行排队时它可能是旁观者,于是摘掉的是**另一条**
-    //    call 的扣留帧、那一帧再也不吐(「一帧不丢」在这一格上不成立)。新动词的两条腿见其头注:
-    //    `park.gatedCallId`(server ≥7.41.0 的 wire 身份)在场就点名摘,缺席则只在同族唯一时摘。
-    //    这一行**刻意排在 `if (outcome.gatedCallId)` 之外**:身份在 wire 上时,摘不摘与 pending
-    //    行给没给出 callId 无关(park 有主角,decide 也成功了)。
-    // #357:决断成功 = 判据链上的**真进展**,「已解决」的同因连续计数归零(否则一个 turn 里两只门
-    // 各带一次正当重放,第二只的重放会被第一只的计数顶成「第 2 次」而被闸掉)。
-    // L-80:决断成功**不在这里**复位同因计数 —— 「决了」不等于「引擎动了」(reopen 类 re-park / 坐标
-    // 失配都是决了又原样 park 回来);复位归驱动侧的进展观察点。
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
-        // 🔴 #324:**刻意不把 pending 行的 callId 当成连坐判别的主角身份**。durable `checkpointGate`
-        //    不带 callId,`findPendingForTask` 取的是「同 taskId + 谓词命中的**第一行**」(谓词不命中
-        //    时还退「任意行」)—— 那是给**卡面渲染**用的宽口,证明不了这一行就是这张 park 的主角:
-        //    同族两行排队时它可能给出旁观者,于是真主角被挤成「非主角」而 stamp(异源复审实测)。
-        //    连坐判别改由台账按「本批唯一的该族 call」自证(`gateLedger.flushHeld` 头注),
-        //    分不出来就整批不标。下面两行是 gate 生命周期(#110 / REF-CC-034),与判别无关,照旧。
-        //    ✅ **记案已销**(0.41.0 件④):此处原先那句「`dropHeld` 用的也是这个不可信 callId」的
-        //    存量记案,已由上方 `dropHeldForDecidedPark` 收口(wire 身份点名 / 判不出就不摘)。
-        //    🔴 `markDecided` **刻意仍用** `outcome.gatedCallId`:它喂的是 #110 那条「重放的 park 不是
-        //    失败」的承重判据,而那条判据的候选取自 `lastFsOrShellGatedCallId()`(同一条 pending 宽口
-        //    时代的口径),两边必须同源才对得上;换成 wire 身份是**另一件**改动(要连着上方
-        //    `candidateGatedCallId` 一起换,且会改动烧会话那条路径的行为),不搭本批的车。
-        led.markDecided(outcome.gatedCallId); // #110 缺陷② b / REF-CC-034:身份留痕,上方候选匹配消费
+        led.markDecided(outcome.gatedCallId);
         if ('answered' in outcome && outcome.answered)
             led.rememberAnswer(outcome.gatedCallId, outcome.answered);
     }
-    // ── B-070:200 = 投递受理,续跑可能挂在**另一条 run** 上 ────────────────────────────────────
-    // workflow 车道的受理形回执带的是**宿主新铸**的 run id(sdk README §9.0.0:「poll 它,不要盯那张
-    // 卡」)。修前这里恒用原 `taskId` 重挂 `runs.events` ⇒ 旧流上再无推进帧,一路烧到 hop 上限。
-    // 🔴 判据是回执上的**两件合取**(`status:"resuming"` ∧ 非空 taskId,判在 `readDecideReceipt` 里),
-    //    而且**必须与当前 taskId 不同**才算换挂 —— 任务级车道的受理形回执带的就是同一条 run,
-    //    把它当「换挂」会白白丢掉 `lastEventId`(等于从头重放一遍这条流)。
     const handoffTaskId = 'receipt' in outcome && outcome.receipt?.handoffTaskId !== undefined && outcome.receipt.handoffTaskId !== taskId
         ? outcome.receipt.handoffTaskId
         : undefined;
@@ -620,11 +298,6 @@ export async function resolvePark(park, ctx) {
         ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
     };
 }
-/**
- * fail-soft 收场的事件序列:扣留帧一律走中断感知出口(件 B:五个排水出口同一形,零-park 硬门必挡,语义等价 no-op;
- * 常驻门 hitl F13-h 钉 src 下 `flushHeld()` 调用点恰一处)+ sync 终帧原样回吐 / durable 腿合成 `hitl_unanswered` 真因终帧
- * (#87 评审② minor 记案:durable 第二问走 `aborted` 时不吐终帧 —— 下游正在拆流,合成了也没人渲)。
- */
 function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal) {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
@@ -643,27 +316,15 @@ function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal) {
         events.push({
             type: 'failed',
             errorCode: 'hitl_unanswered',
-            // 真因 + 出路(L-80:修前的终帧只有一句预算话术,用户拿不到「run 还 parked、卡还能决」这件事)。
             errorMessage: `${park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion'} gate could not be answered: ${failedReason}` +
                 ' — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.',
         });
     }
     return events;
 }
-/**
- * 驱动侧在**预算提交之后**判定触顶时的收场(对抗复审 r4 [high]①:有推进帧的轮次触顶必须等权威身份解析完 ——
- * 先呈 B、决 B,提交后仍是同一只 call 才收场;这一轮已经呈过卡,不再呈收场卡)。
- */
-export function stalledTerminal(park, ctx, stalledRounds, lastStallReason, 
-/** 这一轮的决断有没有落地(r5 [medium]③):落地了就**不许**说「could not be answered」「still parked」—— 那是谎报。 */
-decidedThisRound, 
-/** 这一轮决断落在哪只 call(解析到的行身份):收场排水前先把**它**的扣留帧摘掉(r6 [medium]:两只同族 call 都在
- *  扣留、park 帧无可信身份时,决断臂刻意保守不摘,排水会把刚批准的那只当 abort 吐出)。 */
-decidedGatedCallId) {
+export function stalledTerminal(park, ctx, stalledRounds, lastStallReason, decidedThisRound, decidedGatedCallId) {
     const gate = park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion';
     if (decidedThisRound) {
-        // r7 [high]:第二参必须是 **park 帧上的**可信身份(GateLedger 契约),不能拿候选身份自证 —— 无可信身份且同族
-        // 不唯一时保守不摘、由排水按中断语义吐出(一帧不丢),与决断臂同一条纪律。
         if (decidedGatedCallId !== undefined)
             ctx.led.dropHeldForDecidedPark(decidedGatedCallId, park.gatedCallId);
         const errorMessage = `${gate} was decided, but the engine parked the same call again after each of the last ${stalledRounds} decisions, so sema ` +
@@ -677,7 +338,6 @@ decidedGatedCallId) {
     hostLog('debug', `liveHitlAskWire: ${reason} — fail-soft after the round committed`);
     return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, reason) };
 }
-/** 非进展 reattach 的用户面告知(deps 口缺席 = 只留 debug;口抛错不许炸续流)。 */
 function notifyParkReattach(ctx, attempt, max, reason) {
     const cb = ctx.deps.onParkReattach;
     if (typeof cb !== 'function')
@@ -689,7 +349,6 @@ function notifyParkReattach(ctx, attempt, max, reason) {
         hostLog('debug', `liveHitlAskWire: onParkReattach threw (${String(e)}) — ignored`);
     }
 }
-/** 传输失败的同因键:只留错误类词(同一类连断才算同因;数字/id 每次都变,不能进键)。 */
 function transportReasonToken(reason) {
     const m = /(ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|EAI_AGAIN|TimeoutError|AbortError|fetch failed|network)/i.exec(reason);
     return (m?.[1] ?? reason.split(/\s+/).slice(0, 4).join(' ')).toLowerCase();