@sema-agent/client-core 0.50.0 → 0.52.0

package/dist/hitl/frameRouter.js

@@ -378,7 +378,16 @@ const TOOL_END_ARMS = [
                 return undefined;
             led.markEnded(callId);
             led.dropHeld(callId);
-            surfaceForCurrentSession()?.surfaceClassifierDeny(typeof ev.toolName === 'string' ? ev.toolName : 'tool', verdict);
+            // L-69⑨(0.52.0):把**这一只 call 的现场**一并交给宿主 —— 修前只给 `toolName`,于是端的
+            // Recent Denials 三行同名(三条被拒的 Bash 一个样)、retry 粒度只能落到「整个工具」。
+            // 🔴 args 是 **UNTRUSTED** wire 值:本层原样搬运(不渲不截不消毒),展示消毒归端。
+            // 🔴 args 取自**在飞表**(`noteStart`,每张 tool_start 都记、有界、收口即删)——`gatedStartArgs`
+            //    在这里读不到:分类器 deny 的工具通常**没被 gate**(引擎侧分类器直接 block,一张
+            //    tool_approval 帧都不出),那张表里根本没有它。
+            // 🔴 缺席不铸键(`exactOptionalPropertyTypes`):台账里没有 ⇒ `ctx` 只带 `toolCallId`,
+            //    端读到的是诚实缺席,不是「args 是 undefined」。
+            const startArgs = led.startArgs().get(callId);
+            surfaceForCurrentSession()?.surfaceClassifierDeny(typeof ev.toolName === 'string' ? ev.toolName : 'tool', verdict, { toolCallId: callId, ...(startArgs !== undefined ? { args: startArgs } : {}) });
             hostLog('debug', `liveHitlAskWire: classifier deny verdict on ${callId} (${String(ev.toolName)}) — labeled render + notice`);
             return { kind: 'yield', events: [{ ...ev, output: verdict.message, structured: undefined }] };
         },
@@ -528,6 +537,15 @@ async function routeToolApprovalFrame(ev, ctx) {
     return { kind: 'skip' };
 }
 function routeToolStart(ev, callId, led) {
+    // L-69⑨(0.52.0):**所有** tool_start 都留一份 args 快照(有界在飞表,收口即删)。
+    // 🔴 与下面那张 gated 表刻意**不合表**:「表里有」绝不等于「被 gate 过」——两张表的成员关系、
+    //    生命周期、容量纪律都不同(逐条理由见 `gateLedger.ts` 的 `noteStart` 头注)。
+    //    这一份服务的是分类器 deny 这类**没走 gate**的收口现场(gated 表里根本没有它们)。
+    // 🔴 **必须排在 `markStarted` 闸之前**(异源对抗复审 R1 finding② 采纳):那道闸是**渲染**去重
+    //    (durable 重放的已渲 call 不再上屏),而记账不是渲染。排在闸之后 ⇒ 重放帧一律早退 ⇒
+    //    `noteStart` 的「先删再写」刷新在**生产路径上永远走不到**,只有直调台账的测试碰得着;
+    //    而重放恰恰是被有界表淘汰过的那些 call 唯一一次把快照拿回来的机会。
+    led.noteStart(callId, ev);
     if (!led.markStarted(callId))
         return { kind: 'skip' }; // durable 重放的已渲 call
     if (isGatedToolName(ev.toolName)) {
@@ -545,13 +563,24 @@ function routeToolStart(ev, callId, led) {
     return { kind: 'yield', events: [ev] };
 }
 function routeToolEnd(ev, callId, led) {
-    if (led.isEnded(callId))
+    if (led.isEnded(callId)) {
+        // L-69⑨(0.52.0):已收口的 call **无论走哪条路**都不该留在在飞表里。这一行是上面
+        // 「noteStart 排在渲染去重闸之前」的对偶:durable 重放会把 start 再送一遍(于是快照被重新
+        // 加回来),而重放的 end 在这里早退 ⇒ 少了这一行,那一条就要一直挂到被容量淘汰为止。
+        led.dropStartArgs(callId);
         return { kind: 'skip' }; // durable 重放/park 复写的已收口 call
+    }
     led.dropFsCall(callId);
     for (const arm of TOOL_END_ARMS) {
         const action = arm.run(ev, callId, led);
-        if (action)
+        if (action) {
+            // L-69⑨(0.52.0):在飞窗到此为止 —— 收口帧已经判完(臂**在这一行之前**跑,分类器 deny 臂
+            // 因此还读得到 args),这一条快照从此没有消费者。
+            // 🔴 释放点必须在**臂之后**:挪到循环之前 ⇒ deny 臂拿到的恒是缺席(修前形);挪到 `return`
+            //    的调用方 ⇒ 五条臂各自 return,释放就要抄五遍(而漏抄的那条就是泄漏点)。
+            led.dropStartArgs(callId);
             return action;
+        }
     }
     // 不可达:兜底臂 generic-close 无条件命中。真走到这里 = 有人给它加了早退条件,
     // 那样 tool_end 会被整帧静默丢弃(用户看不到任何收口),必须当场喊出来而不是 `skip`。

package/dist/hitl/gateLedger.d.ts

@@ -61,6 +61,29 @@ export interface GateLedger {
      *  审批 payload,且台账持帧延长了整帧生命周期。载荷仍是 UNTRUSTED unknown,台账只搬运不解释。 */
     noteGatedStart(callId: string, ev: AgentEvent): void;
     gatedStartArgs(): ReadonlyMap<string, unknown>;
+    /**
+     * 每一张 `tool_start` 的 `args` 快照,**不论这只工具有没有被 gate**。
+     *
+     * 🔴 为什么必须与 {@link gatedStartArgs} **分成两张表**(而不是「合表 + 用有没有 args 判 gated」):
+     *    「被 gate 过」是**另一个集合**,两者的成员关系没有任何蕴含 —— 分类器 deny 的工具通常
+     *    **没有**被 gate(引擎侧分类器直接 block,一张 `tool_approval` 帧都不出),而 gate 过的工具
+     *    也可能整场没有 args。把「表里有这一条」读成「它被 gate 过」,等于拿一个搬运位当身份位
+     *    ([provenance-needs-wire-fact-not-inference] 同族);合表之后总有人会这么读,所以不合。
+     *    两表的**生命周期**也刻意不同,见下:
+     *      · {@link gatedStartArgs}:审批 payload 的一手源,**整个 turn 不删**(park / durable 重放
+     *        之后卡面还要读它),条目数被「真被 gate 的工具数」天然约束;
+     *      · 本表:每一张 tool_start 都进,所以**必须有界**(见 {@link START_ARGS_MAX_ENTRIES}),
+     *        且 `tool_end` 收口当拍就删(见 {@link dropStartArgs})—— 它只服务「这只 call 还没收口」
+     *        那段窗口内的消费者(今天唯一一个:分类器 deny 臂给宿主的 `ctx.args`)。
+     *
+     * 🔴 存的是 **tool_start 当拍的 `args` 快照**而非帧引用,理由与 {@link noteGatedStart} 逐字同款。
+     *    载荷是 **UNTRUSTED** wire 值:台账只搬运,不解释、不渲染、不截断。
+     */
+    noteStart(callId: string, ev: AgentEvent): void;
+    /** 本 call 的 tool_start args 快照;没记过 / 已收口 / 已被有界淘汰 ⇒ 表里读不到。 */
+    startArgs(): ReadonlyMap<string, unknown>;
+    /** `tool_end` 收口当拍释放这一条(在飞窗结束)。不在表里 ⇒ no-op。 */
+    dropStartArgs(callId: string): void;
     isEnded(callId: string): boolean;
     markEnded(callId: string): void;
     /**
@@ -237,5 +260,36 @@ export interface GateLedger {
     /** 判据链上出现了真进展(park 真被决断 / 重探把新坐标的卡呈出去了)⇒ 连续计数归零。 */
     resetAlreadyResolvedGate(): void;
 }
+/**
+ * {@link GateLedger.noteStart} 那张在飞表的**容量上限**(L-69⑨,0.52.0)。
+ *
+ * 🔴 为什么必须有界:本表的写口是**每一张** `tool_start`,而它的删口(`tool_end` 收口)在两种真实
+ *    形态下不会来 —— ①一个 turn 里 `tool_end` 先于本连接开始(durable re-attach 只消费 `runs.events`
+ *    的一段);②run 被中止 / 连接断掉,在飞 call 的收口帧永远不到。无界表在长流多工具的 turn 上
+ *    条目数会一直涨。
+ *
+ * 🔴 **上限量的是条目数(= 保留的引用数),不是字节数**(异源对抗复审 R1 finding① 采纳的措辞订正)。
+ *    本表存的是 `ev.args` 的**引用**,不是拷贝 —— 而同一个 `ev` 在这一拍**照常 yield 下去**
+ *    (`frameRouter.routeToolStart` 返回 `{kind:'yield', events:[ev]}`),投影成 `SDKMessage` 之后
+ *    那份入参在端的转录面上本来就活着。所以本表对**驻留字节**的增量是「一个指针 × 条目数」,
+ *    它不复制载荷、也不是这条链上第一个持有它的容器:同文件的 {@link GateLedger.noteGatedStart}
+ *    从本批之前就持着同一形的引用,而且**整个 turn 不删、连条目数都不设上限**。
+ *    ⚠️ 仍然如实说清**没有**守住的那一格:单条载荷本身**没有**字节预算(一次 `Write` 的
+ *    `content` 有多大,这里就跟着多引用多大一份多久)。真要按字节记账得先定义「多大算大」并同批给出
+ *    超限时的降级形(截断 = 交出一份假入参,不许;整条不留 = 那只 call 的 deny 现场退回诚实缺席),
+ *    属独立一件;本批**不做单边近似**,如实登记在此。
+ * 🔴 为什么是 **256** 而不是更小:上限守的是「条目数无界增长」,而它必须**远大于**同一时刻真正在飞的
+ *    call 数,否则淘汰会打到还没收口的 call 身上(那正是本表要服务的对象)。引擎侧同一 turn 的并发
+ *    工具批今天是个位数量级,单批 `tool_start` 连发也在两位数以内;256 给出的是两个数量级的余量。
+ * 🔴 淘汰**按 FIFO 丢最早**(`Map` 的插入序):最早入表的那一条是**最久没有收口**的,它要么已经因为
+ *    上面两种形态永远不会收口,要么它的消费窗(收口当拍)早就过去了 —— 丢它的代价最小。绝不按
+ *    「随便丢一个」或整表清空(整表清空会把同批在飞的兄弟一起打掉)。
+ * 🔴 **淘汰打到仍在飞的 call 时会怎样(成文的取舍,不是漏)**:那只 call 后来被分类器拒绝的话,
+ *    宿主拿到的 `ctx` 只有 `toolCallId`、没有 `args` —— 即**诚实缺席**,端按可选处理照常降级渲
+ *    (契约见 `docs/INTEGRATION-CLIENTS.md` §15c 第 3 条)。这条路上唯一的替代品是「不淘汰」,
+ *    而那就是无界表。durable 重放会把 `tool_start` 再送一遍,那是被淘汰项**拿回快照**的机会 ——
+ *    所以 `frameRouter.routeToolStart` 把本动词排在渲染去重闸**之前**(见该站点注)。
+ */
+export declare const START_ARGS_MAX_ENTRIES = 256;
 /** 造一份 turn 级 gate 台账(**不是单例**,见文件头注)。 */
 export declare function createGateLedger(): GateLedger;

package/dist/hitl/gateLedger.js

@@ -9,6 +9,37 @@
  *    additive 键保留兼容(裁定原文)。
  */
 export const SEMA_COLLATERAL_ABORT_KEY = '_sema_collateral_abort';
+/**
+ * {@link GateLedger.noteStart} 那张在飞表的**容量上限**(L-69⑨,0.52.0)。
+ *
+ * 🔴 为什么必须有界:本表的写口是**每一张** `tool_start`,而它的删口(`tool_end` 收口)在两种真实
+ *    形态下不会来 —— ①一个 turn 里 `tool_end` 先于本连接开始(durable re-attach 只消费 `runs.events`
+ *    的一段);②run 被中止 / 连接断掉,在飞 call 的收口帧永远不到。无界表在长流多工具的 turn 上
+ *    条目数会一直涨。
+ *
+ * 🔴 **上限量的是条目数(= 保留的引用数),不是字节数**(异源对抗复审 R1 finding① 采纳的措辞订正)。
+ *    本表存的是 `ev.args` 的**引用**,不是拷贝 —— 而同一个 `ev` 在这一拍**照常 yield 下去**
+ *    (`frameRouter.routeToolStart` 返回 `{kind:'yield', events:[ev]}`),投影成 `SDKMessage` 之后
+ *    那份入参在端的转录面上本来就活着。所以本表对**驻留字节**的增量是「一个指针 × 条目数」,
+ *    它不复制载荷、也不是这条链上第一个持有它的容器:同文件的 {@link GateLedger.noteGatedStart}
+ *    从本批之前就持着同一形的引用,而且**整个 turn 不删、连条目数都不设上限**。
+ *    ⚠️ 仍然如实说清**没有**守住的那一格:单条载荷本身**没有**字节预算(一次 `Write` 的
+ *    `content` 有多大,这里就跟着多引用多大一份多久)。真要按字节记账得先定义「多大算大」并同批给出
+ *    超限时的降级形(截断 = 交出一份假入参,不许;整条不留 = 那只 call 的 deny 现场退回诚实缺席),
+ *    属独立一件;本批**不做单边近似**,如实登记在此。
+ * 🔴 为什么是 **256** 而不是更小:上限守的是「条目数无界增长」,而它必须**远大于**同一时刻真正在飞的
+ *    call 数,否则淘汰会打到还没收口的 call 身上(那正是本表要服务的对象)。引擎侧同一 turn 的并发
+ *    工具批今天是个位数量级,单批 `tool_start` 连发也在两位数以内;256 给出的是两个数量级的余量。
+ * 🔴 淘汰**按 FIFO 丢最早**(`Map` 的插入序):最早入表的那一条是**最久没有收口**的,它要么已经因为
+ *    上面两种形态永远不会收口,要么它的消费窗(收口当拍)早就过去了 —— 丢它的代价最小。绝不按
+ *    「随便丢一个」或整表清空(整表清空会把同批在飞的兄弟一起打掉)。
+ * 🔴 **淘汰打到仍在飞的 call 时会怎样(成文的取舍,不是漏)**:那只 call 后来被分类器拒绝的话,
+ *    宿主拿到的 `ctx` 只有 `toolCallId`、没有 `args` —— 即**诚实缺席**,端按可选处理照常降级渲
+ *    (契约见 `docs/INTEGRATION-CLIENTS.md` §15c 第 3 条)。这条路上唯一的替代品是「不淘汰」,
+ *    而那就是无界表。durable 重放会把 `tool_start` 再送一遍,那是被淘汰项**拿回快照**的机会 ——
+ *    所以 `frameRouter.routeToolStart` 把本动词排在渲染去重闸**之前**(见该站点注)。
+ */
+export const START_ARGS_MAX_ENTRIES = 256;
 /** 造一份 turn 级 gate 台账(**不是单例**,见文件头注)。 */
 export function createGateLedger() {
     const startedCalls = new Set();
@@ -16,6 +47,8 @@ export function createGateLedger() {
     /** 只存帧:出身不在入表当拍冻结(那一拍 gate 身份还没到),改在 `flushHeld` 当拍求值。 */
     const heldAskEnds = new Map();
     const gatedStartArgsByCall = new Map();
+    /** 每一张 tool_start 的 args 快照(在飞窗;有界 FIFO,见 {@link START_ARGS_MAX_ENTRIES})。 */
+    const startArgsByCall = new Map();
     const deniedCalls = new Set();
     const pendingFsCalls = [];
     const resolvedAnswers = new Map();
@@ -140,6 +173,27 @@ export function createGateLedger() {
         gatedStartArgs() {
             return gatedStartArgsByCall;
         },
+        noteStart(callId, ev) {
+            // 🔴 **先删再写**:同一 callId 重放(durable 重放的 tool_start 在别的入口被 markStarted 挡掉,
+            //    但本动词不依赖那道闸)必须刷新它在 FIFO 里的位置,否则「覆盖」会让它保持旧的插入序、
+            //    在还活着的时候被当成最老的一条淘汰掉。`Map.set` 对已有键**不**改插入序,这一行是承重的。
+            startArgsByCall.delete(callId);
+            startArgsByCall.set(callId, ev.args);
+            // 有界:超容量丢**最早**入表的那一条(`Map` 迭代序 = 插入序)。while 而不是 if —— 上限被
+            // 调小时(或将来某次批量写入)一次要淘汰多条,if 会让表永久停在超限状态。
+            while (startArgsByCall.size > START_ARGS_MAX_ENTRIES) {
+                const oldest = startArgsByCall.keys().next();
+                if (oldest.done === true)
+                    break;
+                startArgsByCall.delete(oldest.value);
+            }
+        },
+        startArgs() {
+            return startArgsByCall;
+        },
+        dropStartArgs(callId) {
+            startArgsByCall.delete(callId);
+        },
         isEnded(callId) {
             return endedCalls.has(callId);
         },

package/dist/hitl/hitlHostSurface.d.ts

@@ -7,14 +7,41 @@ export interface HitlNotice {
     priority: 'immediate';
     timeoutMs: number;
 }
+/**
+ * 分类器 deny 裁决的**这一只 call 的现场**(L-69⑨,0.52.0;{@link HitlHostSurface.surfaceClassifierDeny}
+ * 的 **additive 可选**第三参)。
+ *
+ * 🔴 为什么要有它:修前宿主只拿到 `toolName`,于是端的 Recent Denials 面板三行同名(三条被拒的
+ *    `Bash` 长一个样),而端要做的两件事 —— **行文案**(这一行说的是哪条命令 / 哪个文件)与
+ *    **retry 粒度**(重试这一只调用,而不是「整个 Bash 工具」)—— 都需要这一只 call 的身份与入参。
+ * 🔴 `args` 是 **UNTRUSTED** wire 值(模型产出的工具入参):本包**原样**交给宿主,不渲染、不截断、
+ *    不消毒 —— 展示消毒是端的事(cli 有 `cleanUntrustedForDisplay`)。要拿它铸**行文案**请用
+ *    `classifierDenyDisplay(toolName, args)`(`src/classifierVerdictWire.ts`,三端同形的判定)。
+ * 🔴 `args` **可缺席**:分类器拒绝的工具通常没被 gate,而在飞 args 表是**有界**的(见
+ *    `gateLedger.START_ARGS_MAX_ENTRIES`),长流上早期 call 的快照可能已被淘汰。缺席 = 诚实缺席,
+ *    端按「只有工具名」降级渲,**绝不**据此编一个空 args 出来。
+ */
+export interface ClassifierDenyContext {
+    /** 这一只被拒调用的 wire `toolCallId`(retry 粒度的锚;帧上取,恒在场)。 */
+    toolCallId: string;
+    /** 这一只调用的 `tool_start` 入参快照;**UNTRUSTED**,缺席 = 台账里没有(见上)。 */
+    args?: unknown;
+}
 /** HITL 的宿主副作用面 —— 通知上屏 + 分类器 deny 的端侧记账。 */
 export interface HitlHostSurface {
     /** 立即顶到 current(壳:`notifications.current = notice`,queue 不动)。 */
     showNotice(notice: HitlNotice): void;
     /** **仅当** current 仍是这个 key 时清掉(壳原文的 if-still-mine 语义 —— 否则会误清别人的通知)。 */
     clearNoticeIfCurrent(key: string): void;
-    /** 分类器 deny 裁决的宿主副作用:footer 通知 + /permissions Recent Denials 记账(壳资产)。 */
-    surfaceClassifierDeny(toolName: string, verdict: ClassifierDenyVerdict): void;
+    /**
+     * 分类器 deny 裁决的宿主副作用:footer 通知 + /permissions Recent Denials 记账(壳资产)。
+     *
+     * 🔴 `ctx` 是 **additive 可选**第三参(0.52.0,L-69⑨):老宿主的两参实现**零改动照跑**
+     *    —— JS 里多传一个实参不影响两参函数,TS 里「参数少的函数可赋给参数多的签名」是语言规则
+     *    (函数参数双变/协变),desktop/web 现有 `surfaceClassifierDeny(t, v)` 实现不需要跟车。
+     *    ⚠️ 反过来**不成立**:端一旦读了 `ctx`,就必须按可选处理(库对老路径/缺席场景不承诺在场)。
+     */
+    surfaceClassifierDeny(toolName: string, verdict: ClassifierDenyVerdict, ctx?: ClassifierDenyContext): void;
 }
 /** 装 HITL 宿主面(传 null 卸)。返回还原函数。 */
 export declare function installHitlHostSurface(surface: HitlHostSurface | null): () => void;

package/dist/hitl/parkResolver.d.ts

@@ -17,6 +17,32 @@ import { type GateCurrentPending } from './hitlBridge.js';
 import { type QuestionAnswer } from '../liveQuestionStore.js';
 import type { AskAnsweredOutput, GateLedger } from './gateLedger.js';
 import { type AskGateWireDeps, type GatePark } from './frameRouter.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 declare const MAX_GATE_HOPS = 2;
+/** 一轮 park 的进展判决(驱动侧按 `isHostProgressFrame` 观察,见 askGateWire)。 */
+export type HopRound = 'progress' | 'stalled';
+/** hop 预算状态:`stalled` = 连续非进展轮数(进展即清零);`total` = 本 turn park 总数(只用于日志)。 */
+export interface HopBudget {
+    readonly stalled: number;
+    readonly total: number;
+}
+/** 纯函数:上一轮预算 + 本轮判决 ⇒ 新预算(不就地改入参;`undefined` = 本 turn 第一轮)。 */
+export declare function nextHopBudget(prev: HopBudget | undefined, round: HopRound): HopBudget;
+/**
+ * 硬兜底(对抗复审 r1 [high]①,r6 [high] 收窄):一 turn 内**解析不出身份**的 park 数上限。连续非进展计数靠
+ * 「解析到的 pending 行身份 + host 推进帧」判进展;解析不到行(tool-less park / approvals 恒空)时身份判不出 ⇒
+ * 只能靠推进帧,一个每轮先吐一帧文本再原样 park 的病态引擎在那一形下仍可能无限。**只数这一类**:每轮都解析到
+ * 新 call 且真推进的门(模型重试同一失败调用 N 次)不吃这格 —— CC 没有此闸,问 65 次就答 65 次。
+ * 命中即收场、终帧如实说「本 turn 有 N 次 park 解析不出身份」。
+ */
+export declare const MAX_TOTAL_PARKS = 64;
 /**
  * REF-CC-033:`GateOutcome` 的 `failed` 分支闭集判别码。来源两处:①本文件自己的
  * 「pending 行取不到」早退(`surfaceGateAndDecide` 里 `!pending` 那条);②`HitlBridge` 抛出的
@@ -69,8 +95,19 @@ export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
  *  (multiSelect 与对话框同款 ", " lossy join;note → annotations.notes)。 */
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;
 /** 外环决断的两种出路(见文件头注)。 */
+/** resolvePark 的续流判决:`progress` 位 = 这一轮决断真落地了一次(驱动侧不据此复位计数 —— 复位只看
+ *  下一段流有没有 host 推进帧);非进展轮携 `reason`(收场文案用)。 */
 export type ParkResolution = {
     kind: 'reattach';
+    progress: true;
+    presented: boolean;
+    gatedCallId?: string | undefined;
+} | {
+    kind: 'reattach';
+    progress: false;
+    reason: string;
+    presented: boolean;
+    gatedCallId?: string | undefined;
 } | {
     kind: 'failsoft';
     events: readonly AgentEvent[];
@@ -80,8 +117,26 @@ export interface ParkResolveCtx {
     led: GateLedger;
     /** sync leg 捕获的真 run handle(内环 `TaskIdRef` 的当前值)。 */
     taskId: string;
-    /** 本 turn 内这是第几次 park(hop 预算的唯一计量;由驱动累加,本函数只读)。 */
+    /** 本 turn park 总数(日志用;**不再**是预算计量,见 {@link MAX_GATE_HOPS})。 */
     hops: number;
+    /** 本 turn 内**解析不出身份**的 park 数(驱动侧累计;超过 {@link MAX_TOTAL_PARKS} 即硬兜底收场)。 */
+    unverifiableParks?: number;
+    /** 连续非进展轮数(驱动侧 {@link nextHopBudget} 算出;超过 {@link MAX_GATE_HOPS} 即收场)。 */
+    stalledRounds?: number;
+    /** 上一轮非进展的真因 token(收场文案用)。 */
+    lastStallReason?: string | undefined;
+    /** 上一轮有没有真呈过卡(收场卡只在**没呈过**时才呈 —— 呈过再呈 = 把同一张失效卡再问一遍,F15-e② 禁)。 */
+    lastRoundPresentedCard?: boolean | undefined;
     signal?: AbortSignal | undefined;
 }
 export declare function resolvePark(park: GatePark, ctx: ParkResolveCtx): Promise<ParkResolution>;
+/**
+ * 驱动侧在**预算提交之后**判定触顶时的收场(对抗复审 r4 [high]①:有推进帧的轮次触顶必须等权威身份解析完 ——
+ * 先呈 B、决 B,提交后仍是同一只 call 才收场;这一轮已经呈过卡,不再呈收场卡)。
+ */
+export declare function stalledTerminal(park: GatePark, ctx: ParkResolveCtx, stalledRounds: number, lastStallReason: string | undefined, 
+/** 这一轮的决断有没有落地(r5 [medium]③):落地了就**不许**说「could not be answered」「still parked」—— 那是谎报。 */
+decidedThisRound: boolean, 
+/** 这一轮决断落在哪只 call(解析到的行身份):收场排水前先把**它**的扣留帧摘掉(r6 [medium]:两只同族 call 都在
+ *  扣留、park 帧无可信身份时,决断臂刻意保守不摘,排水会把刚批准的那只当 abort 吐出)。 */
+decidedGatedCallId?: string | undefined): ParkResolution;