@sema-agent/client-core 0.40.0 → 0.41.0

package/dist/hitl/frameRouter.d.ts

@@ -24,8 +24,16 @@ import type { GateLedger } from './gateLedger.js';
  * 🔴 pure 门 B7 段:包内冻结字面量(无条件)+ 壳树全树扫描「每一处声明都逐字节相同」(壳树缺席=跳过)。
  */
 export declare const HITL_REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
-/** core 对被 gate/连坐 abort 的 call 铸的 tool_end 载体(逐字;desktop session-host 真引擎实测
- *  同款)——HOLD 谓词锚它做**精确等值**,普通工具错的输出是各自错误文案,永不进 HOLD。 */
+/**
+ * core 对**被 gate park 的那个 call**(gate 主角)铸的 tool_end 载体(逐字;desktop session-host
+ * 真引擎实测同款)。HOLD 谓词锚它做**精确等值** —— 普通工具错的输出是各自的错误文案,永不进 HOLD。
+ *
+ * 🔴 **勘误(件⑤,2026-08-22,[4970] 真机取证)**:此处原话是「core 对被 gate/**连坐** abort 的
+ * call **恒**铸这一串」——对连坐的旁观者**不成立**。core 5.52.0 dist 直证两个短路点两种文案:
+ * gate 主角走 abort 早退 = 本串;**执行前被连坐**的旁观者 = `"operation aborted before execution"`
+ * (小写 + 后缀)。所以本串只是判据的**兜底臂**(旧 core 唯一的信号),主锚是机读码
+ * `gate.parked`——见 {@link isEngineAbortToolEnd}。
+ */
 export declare const ENGINE_ABORT_TOOL_RESULT = "Operation aborted";
 /**
  * tool_end.output 的文本归一(P0 案B,2026-08-03,server 6.0.0 wire 实测):sync leg 的毒化帧
@@ -63,6 +71,16 @@ export interface GatePark {
     gate: GateKind;
     /** sync leg 的 `done{suspended}` 终帧 —— fail-soft 回退时原样吐回去(durable leg 的 park 无此帧)。 */
     pendingDone?: AgentEvent | undefined;
+    /**
+     * 这张 park 的**待批 call 身份**(server ≥7.41.0,[4913]/[4914] 请托① 到货件)。
+     * 供给见 {@link parkGatedCallId};消费者今天只有一个:`parkResolver` 决断成功臂的
+     * `dropHeldForDecidedPark` —— 它此前只能拿 `findPendingForTask` 那个**卡面渲染宽口**当身份,
+     * 同族多行排队时会摘错 call 的扣留帧([4933] 立案的存量)。
+     * 🔴 缺席是**常态**(旧引擎 / tool-less park / 键畸形),消费方必须自带无身份也能走的臂。
+     * 🔴 刻意**不**喂给 `#324` 的连坐判别子:那条判据的换锚是独立一件事(S3/S33 的「已知局限锁」
+     *    断言到时会翻红 = 点亮信号),两件事混在一起改就分不清谁引入了假阳。
+     */
+    gatedCallId?: string | undefined;
 }
 /** 帧路由的产物:驱动只认这四种,自己不再判帧型。 */
 export type FrameAction = {
@@ -74,6 +92,7 @@ export type FrameAction = {
     kind: 'park';
     gate: GateKind;
     pendingDone?: AgentEvent | undefined;
+    gatedCallId?: string | undefined;
 } | {
     kind: 'end';
     events: readonly AgentEvent[];

package/dist/hitl/frameRouter.js

@@ -11,8 +11,16 @@ export const HITL_REJECT_MESSAGE = "The user doesn't want to proceed with this t
 function rejectMessageForRender() {
     return HITL_REJECT_MESSAGE;
 }
-/** core 对被 gate/连坐 abort 的 call 铸的 tool_end 载体(逐字;desktop session-host 真引擎实测
- *  同款)——HOLD 谓词锚它做**精确等值**,普通工具错的输出是各自错误文案,永不进 HOLD。 */
+/**
+ * core 对**被 gate park 的那个 call**(gate 主角)铸的 tool_end 载体(逐字;desktop session-host
+ * 真引擎实测同款)。HOLD 谓词锚它做**精确等值** —— 普通工具错的输出是各自的错误文案,永不进 HOLD。
+ *
+ * 🔴 **勘误(件⑤,2026-08-22,[4970] 真机取证)**:此处原话是「core 对被 gate/**连坐** abort 的
+ * call **恒**铸这一串」——对连坐的旁观者**不成立**。core 5.52.0 dist 直证两个短路点两种文案:
+ * gate 主角走 abort 早退 = 本串;**执行前被连坐**的旁观者 = `"operation aborted before execution"`
+ * (小写 + 后缀)。所以本串只是判据的**兜底臂**(旧 core 唯一的信号),主锚是机读码
+ * `gate.parked`——见 {@link isEngineAbortToolEnd}。
+ */
 export const ENGINE_ABORT_TOOL_RESULT = 'Operation aborted';
 /**
  * tool_end.output 的文本归一(P0 案B,2026-08-03,server 6.0.0 wire 实测):sync leg 的毒化帧
@@ -82,6 +90,56 @@ function isGatedToolName(name) {
 function isFsOrShellToolName(name) {
     return typeof name === 'string' && (toolNameIsFsWrite(name) || toolNameIsShellExec(name));
 }
+/**
+ * core 对**因 gate park 而中止**的 call 铸的机读短码(`tool_end.errorCode`,core ≥5.9.0)。
+ *
+ * 🔴 **契约,不是巧合**(core 官方答复 [4973]):两个 abort 短路点(gate 主角 / 执行前被连坐的
+ * 旁观者)**消费同一个分类席**,而 park 提交**先于** abort 发射 —— 铸点读那一席时无竞态,
+ * 于是主角与旁观者**恒**同席同码。所以本码可以当**主锚**用,而不是「我们在消费侧观察到它总在」
+ * 那种推断。SDK 的 `Event_tool_end.errorCode` 声明处也逐字点名这个码 =「门把这次调用 park 了」;
+ * 供给点见 core 5.52.0 dist `prepare-task` 的 `abortResultDetails: () => ({ code: "gate.parked" })`。
+ *
+ * 🔴 开集里的**具名一员**,不是前缀族:判据只认这一个码。放宽成「有 errorCode 就算」会把
+ * `path_not_in_root` 这类普通工具错拖进 HOLD —— 那正是 [2084]①-b 收窄掉的病(真错迟到上屏)。
+ * 常驻反证:hitl 门 F11-d(表外码的普通工具错必须**零滞后**上屏,判据锚在帧的**位置**上)。
+ *
+ * 🔴 **在场 ≠ 这次 park 有 call 身份**([4973]③):plan-review / resource-slice 这类不持有 call
+ * 的 park 照样带本码,但诚实缺席 call id。所以本判据只锚 errorCode,**不**顺手去锚任何 id —— 锚了
+ * 就等于把那几族 park 的连坐帧判成「认不出」。(core 5.55 的 `tool_end.gatedCallId` **顶层键**
+ * 到货后可用于「折叠归组」那一面,与本判据是两件事,跟车另批。)
+ */
+const ENGINE_GATE_PARKED_ERROR_CODE = 'gate.parked';
+/**
+ * 「这一帧是**引擎因 gate 而中止**的毒化帧」——双判据 OR(件⑤,2026-08-22,[4970] G1 端到端 RED)。
+ *
+ * 🔴 病形(test 线真机取证:真 server 7.41.0 + 真 Postgres,1 Bash 待审批 + 2 并行 WebFetch):
+ * 判据原来只有下面第②条(精确串),而 core 的**两个短路点产两种串**——
+ *   · gate 主角(`agent-loop` abort 早退,dist 两处)= `"Operation aborted"`(精确);
+ *   · **同批被连坐的旁观者**(执行前短路)= `"operation aborted before execution"`(小写 + 后缀)。
+ * ⇒ 判据对旁观者**恰好全不命中**:它们的毒化帧根本没进 HOLD(当场上屏 + 被 generic-close 记
+ * `markEnded`,resume 后重放的真结果被静默去重),而 #324 的连坐机读位在真实现网**一次都没出现过**。
+ * 本文件旧注写的「core 对被 gate/连坐 abort 的 call **恒**铸这一串」对旁观者不成立,已按实证撤回。
+ *
+ * 两臂各自的适用域(都**不**放宽成模糊匹配):
+ *   ① **主锚** `errorCode === "gate.parked"`([4973] 契约:双短路点同席恒铸)—— 机读位,
+ *      两种文案都覆盖,core ≥5.9.0 起在场;
+ *   ② **兜底** 输出等于 {@link ENGINE_ABORT_TOOL_RESULT} —— 覆盖两类:老 core(还没有 errorCode
+ *      这个位)**以及** core 现役唯一**不铸**本码的那一条臂 —— **post-hook signal re-check**
+ *      ([4973]②:工具**已经执行完**、hook 之后签核那一拍才发现 abort,历来铸的 abort 结果
+ *      不带 details ⇒ 无 errorCode)。这条臂正是双判据设计成立的理由:少了兜底臂,它整条落空。
+ * 🔴 缺席不反推:两臂都不命中 = 这一帧没有「因 gate 中止」的任何证据,照旧走普通收口
+ * (老 core + 变体串就落在这一格 —— 诚实缺席,不靠猜文案家族把普通工具错也收进来)。
+ *
+ * 🔴 **两串族不会被上游合并**([4973],core 显式拒绝改串向,**不是**「core 待修」):两条串各自
+ * 承的是真语义 —— `"Operation aborted"` = **执行中被中止**,`"operation aborted before execution"`
+ * = **从未执行**。消费端要的是「归不归 gate 管」这个判定,那件事归机读码;文案面归 core 的语义面,
+ * 两者不该互相迁就。
+ */
+function isEngineAbortToolEnd(ev) {
+    if (ev.errorCode === ENGINE_GATE_PARKED_ERROR_CODE)
+        return true;
+    return toolEndOutputText(ev.output) === ENGINE_ABORT_TOOL_RESULT;
+}
 /**
  * 「这一帧 tool_end 归 gate 管」的判据 —— 上面那条**名字腿**加一条 kind 腿的替身([2393] hitl-F1,
  * 2026-08-02)。
@@ -96,9 +154,10 @@ function isFsOrShellToolName(name) {
  * 🔴 为什么不能在名字腿里补 kind:`tool_end` 帧上**根本没有 kind 位** —— gate 的 kind 只在
  * `done{suspended}.checkpointGate` / `suspended.gate` 上,而那两帧**晚于**毒化 tool_end 到达
  * (park 帧序:tool_start → tool_end(毒化)→ done{suspended})。「park 时按 callId 打标、
- * tool_end 时读台账」这条路对**这一帧**来得太晚。帧面上唯一可读的信号是引擎铸的**确切 abort
- * 标记** `ENGINE_ABORT_TOOL_RESULT`(见下方 ④ 臂头注:core 对被 gate/连坐 abort 的 call 恒铸
- * 这一串),所以本判据 = 名字腿 ∪ abort 标记腿。
+ * tool_end 时读台账」这条路对**这一帧**来得太晚。帧面上唯一可读的信号是引擎铸的 abort 标记
+ * ({@link isEngineAbortToolEnd} 的**双判据**:机读码 `gate.parked` ∪ 那条确切串 —— 件⑤ 之前
+ * 这里只有后者,而 core 对**旁观者**铸的是另一种文案,见该函数头注),所以本判据 =
+ * 名字腿 ∪ abort 标记腿。
  *
  * 🔴 集合关系(说清楚,别让下一棒再以为两边逐字相等):本判据是 park 判定的**超集**(它还会盖到
  * 被同 turn 连坐 abort 的非 gate call)。方向是有意的,且不对称成立 —— 多盖一帧的代价是那一帧
@@ -108,6 +167,26 @@ function isFsOrShellToolName(name) {
  * ⚠️ 普通工具错(非 abort 标记)照旧**不进** HOLD —— [2084]①-b 的收窄没有被放宽,负控 F1-c 钉着。
  */
 function isGatedToolEnd(ev) {
+    if (isGatedToolName(ev.toolName))
+        return true;
+    return isEngineAbortToolEnd(ev); // 件⑤:abort 标记腿单源(机读码 ∪ 确切串)
+}
+/**
+ * 上者的**窄口**,只给 ②`deny-stamp-next` 那条**位置性**判据用(件⑤ 的臂间掩蔽面,异源复审四审
+ * finding①)。
+ *
+ * 🔴 为什么这一条不能用超集谓词:deny stamp 是**一次性的全局记号**(同步审批帧腿 deny 且 callId
+ * 关联不上时才武装),语义是「**下一张** gated 报错帧就是那张门的收口帧」——**谁先到谁消费**。
+ * 件⑤ 把 abort 标记腿放宽到认 `gate.parked` 之后,同批被连坐的**旁观者**(WebFetch 之流)也成了
+ * 「gated 报错帧」:它先到就把记号吃掉、被改写成「用户拒绝了」并记 ended(它 resume 后的真结果
+ * 还会被去重),而真正被拒的那个 call 拿到的是引擎原文 —— 正是 [2393] hitl-F1 要修的那个用户面,
+ * 方向还反了。连坐帧带的是「我被 gate 连累中止」,**不是**「我就是那张被拒的门」,所以它没资格
+ * 认领一个**位置性**的身份记号。
+ * ⇒ 本判据 = 件⑤ **之前**的那一版(名字腿 ∪ 确切串),逐字保留;新加的连坐码臂**刻意不进来**。
+ * (确切串腿理论上也可能是一条正在执行中被连坐的帧 —— 那是本记号自带的既有近似,与件⑤ 无关,
+ * 不在本批放宽也不在本批收紧。)
+ */
+function isDenyStampCandidate(ev) {
     if (isGatedToolName(ev.toolName))
         return true;
     return toolEndOutputText(ev.output) === ENGINE_ABORT_TOOL_RESULT;
@@ -133,6 +212,19 @@ function isFsApprovalPark(result) {
         !isAskToolLoose(r.checkpointGate?.toolName) &&
         isToolApprovalGate(r.checkpointGate));
 }
+/**
+ * park 帧上的**待批 call 身份**(server ≥7.41.0;[4914] 施工帖逐字:数据源 = checkpoint 本体的
+ * `pendingAction.toolCallId`,投影到 **`done{suspended}` 的 result 顶层**与 durable **`suspended`
+ * 事件**的 `gate` **旁**,两处同键同义)。两个 park 腿各读各的载体,判据是同一只。
+ *
+ * 🔴 UNTRUSTED wire 值:只认**非空串**,其余(缺席 / 非串 / 空串)一律诚实缺席 —— tool-less park
+ *    (resource_limit / plan_review / task_done)按契约本来就没有这个键,而一个坏值被当成身份用
+ *    会去摘一条不存在的扣留帧(等于什么都没摘,但把「判不出」的保守臂骗过去了)。
+ */
+function parkGatedCallId(src) {
+    const v = src?.toolCallId;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
 /** 台账里那份 gated `tool_start` 当拍的 args 快照(UNTRUSTED,只搬运不解释)。 */
 function argsOfGatedStart(led, callId) {
     if (callId === undefined)
@@ -197,7 +289,9 @@ const TOOL_END_ARMS = [
         //    收口帧名字腿认不出,不盖它 = 用户按了 No 却看到引擎原文。
         id: 'deny-stamp-next',
         run(ev, callId, led) {
-            if (ev.isError !== true || !isGatedToolEnd(ev) || led.isDenied(callId))
+            // 🔴 窄口(件⑤/四审 finding①):这条记号是**一次性 + 位置性**的,超集谓词会让连坐旁观者
+            //    抢走它 —— 理由见 `isDenyStampCandidate` 头注。
+            if (ev.isError !== true || !isDenyStampCandidate(ev) || led.isDenied(callId))
                 return undefined;
             if (!led.takeDenyStamp())
                 return undefined;
@@ -229,8 +323,12 @@ const TOOL_END_ARMS = [
         run(ev, callId, led) {
             if (ev.isError !== true || !isGatedToolEnd(ev))
                 return undefined;
-            // 6.0.0 wire:output 可为 content-block 数组形(见 toolEndOutputText 头注)—— 归一后仍做精确等值。
-            if (toolEndOutputText(ev.output) !== ENGINE_ABORT_TOOL_RESULT)
+            // 件⑤(2026-08-22,[4970] 真机 RED):判据 = `isEngineAbortToolEnd` 的**双判据**(机读码
+            // `gate.parked` ∪ 那条确切串)。此前只有后者,而 core 对**被连坐的旁观者**铸的是
+            // `"operation aborted before execution"` —— 于是连坐帧恰好全不进 HOLD(当场上屏 + 被 ⑤ 臂
+            // 记 ended 吃掉重放的真结果),#324 的机读位在现网一次都没出现过。适用域与不放宽的理由
+            // 见该函数头注;6.0.0 wire 的 content-block 数组形由 `toolEndOutputText` 归一后仍做精确等值。
+            if (!isEngineAbortToolEnd(ev))
                 return undefined;
             // #324 换锚(2026-08-22):这一拍**不判出身**。durable park 腿的帧序是
             // `tool_start → tool_end(毒化) → done{suspended}` —— gate 身份晚于本帧到达,此刻任何判词
@@ -364,16 +462,18 @@ function routeSuspended(ev, ctx) {
     // 🔴 两条 park 臂都要登记(判别子的归属证据只认 park)—— ask park 自己用不到兜底腿,
     //    但它必须把**上一张** gate 的准入证清掉,否则旧证会让兜底把一个 Bash 连坐帧反认成主角、
     //    再把真正的 ask 主角 stamp 掉(对抗复审实测 `ask-main=STAMP`)。
+    // [4914]:durable `suspended` 事件的待批 call 身份就挂在 `gate` **旁**(不是 gate 里)。
+    const gatedCallId = parkGatedCallId(ev);
     if (ev.gate && isAskToolLoose(ev.gate.toolName) && ctx.taskId.current) {
         ctx.led.noteParkGate({ fsOrShellFamily: false });
-        return { kind: 'park', gate: 'ask' };
+        return { kind: 'park', gate: 'ask', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     if (ev.gate &&
         isToolApprovalGate(ev.gate) &&
         ctx.taskId.current) {
         // 准入证:park 的 gate 本体属 fs/shell 族(kind-only gate 的 toolName 在族外 ⇒ 不发证)。
         ctx.led.noteParkGate({ fsOrShellFamily: isFsOrShellToolName(ev.gate.toolName) });
-        return { kind: 'park', gate: 'fs' };
+        return { kind: 'park', gate: 'fs', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     // 其余 gate:透传。⚠️ ADAPTER-F8 注纠(2026-08-02):原文写「eventToSdkMessage 出 null」——
     // 那个返回形已随 REF-CC-058 退役,今天它出的是 `EventProjection` 三态,永不是 null;本臂的
@@ -382,17 +482,19 @@ function routeSuspended(ev, ctx) {
 }
 function routeDone(ev, ctx) {
     const { led } = 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 };
+        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 };
+        return { kind: 'park', gate: 'fs', pendingDone: ev, ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     const events = [...led.flushHeld()]; // 真错(非 gate)的 Ask tool_end 此刻诚实渲染
     // durable 终帧的 result.taskId === sessionId(引擎 durable quirk)会让 captureSessionId 跳过

package/dist/hitl/gateLedger.d.ts

@@ -74,6 +74,33 @@ export interface GateLedger {
      */
     hold(callId: string, ev: AgentEvent): void;
     dropHeld(callId: string): void;
+    /**
+     * 件④([4933] 立案的存量根修,0.41.0):**决断成功**之后摘掉这张 park 主角的扣留帧。
+     *
+     * 🔴 与裸 {@link dropHeld} 的差别只有一个:**入参可信度**。内环那四个调用点摘的是**帧自己的**
+     * `toolCallId`(帧在手,身份无疑);而决断成功那一下,外环手上只有 `findPendingForTask` 给的
+     * callId —— 那是给**卡面渲染**用的宽口(同 taskId + 族谓词命中的**第一行**,谓词不命中还退
+     * 「任意行」),不是身份。同族多行排队时它可能指向旁观者,于是被摘掉的是**另一条** call 的
+     * 扣留帧,而那一帧从此不再吐:{@link flushHeld} 的「一帧不丢」在这一格上不成立
+     * (用户面 = dim 圆点永远等不到结果行)。
+     *
+     * 🔴 摘的**永远是真被决断的那一行**(`candidateCallId`);`trustedCallId` 的角色是**确证**,
+     * 不是第二个摘取目标 —— 两边指向不同 call 时摘谁都是 split-brain(决断绑一行、摘另一行的帧)。
+     *
+     * 两条腿:
+     *  ① `trustedCallId`(server ≥7.41.0 的 park 身份:`done{suspended}.result.toolCallId` /
+     *     durable `suspended` 事件 `gate` 旁同键,[4914])与 `candidateCallId` **相等** ⇒ 身份确证,
+     *     点名摘。取件腿今天已优先按同一个身份选行,所以正常路径上两者恒等;
+     *  ② 身份缺席(旧引擎 / tool-less park / 键畸形)或两者不等(身份在场但队列没有那一行 ⇒ 决断
+     *     落在别的行上)⇒ 只在 `candidateCallId` 于扣留表里**同族唯一**
+     *     时才摘;同族多条 = 判不出谁是主角 ⇒ **一条都不摘**,帧照走 flush 的连坐判别
+     *     (与 {@link flushHeld}「判不出整表不标」同轴的 fail-safe:宁可多渲一行 abort,
+     *     也不许让一帧永久消失)。
+     *
+     * 🔴 两条腿都要走「摘完看表空不空」那一步(见 {@link dropHeld} 尾注的批级退休不变量),
+     *    包括**什么都没摘**那条路 —— 零 HOLD 批正是每次 delete 都落空的形状。
+     */
+    dropHeldForDecidedPark(candidateCallId: string | undefined, trustedCallId?: string): void;
     heldCount(): number;
     /**
      * drain:逐帧吐出并**同批记 ended**(fail-soft 回退路径与终帧路径共用的唯一出口)。

package/dist/hitl/gateLedger.js

@@ -62,6 +62,49 @@ export function createGateLedger() {
         const family = [...new Set([...heldAskEnds.keys(), ...droppedFromBatch])].filter((id) => fsOrShellGatedCalls.has(id));
         return family.length === 1 ? new Set(family) : undefined;
     };
+    /**
+     * `dropHeld` / `dropHeldForDecidedPark` 的**唯一**实现(两个动词共用一份,批级退休那条不变量
+     * 只写一处 —— 两份写法各自漂正是本模块存在的理由)。
+     * `callId === undefined` = 「这次什么都不摘」:退休检查照跑,别的一律不动。
+     */
+    const dropHeldImpl = (callId) => {
+        if (callId !== undefined && heldAskEnds.delete(callId))
+            droppedFromBatch.add(callId);
+        // 🔴 扣留表空 = 这一批没有(或不再有)任何待判的帧,批级判据当场退休 —— 不能等下一次
+        //    flush:「决断成功但本批压根没有毒化帧」的路径上 `flushHeld` 一次都不会跑,判据会就这么
+        //    活到下一批去把那一批的**真主角**判成连坐(实测 `new-main=STAMP`)。
+        // 🔴 「摘的那个不在表里」也要走这一步(不能早退):零 HOLD 批正是**每次** delete 都落空的
+        //    形状,早退就等于那种批永远不退休 —— 上一版的漏洞就在这里。
+        if (heldAskEnds.size === 0)
+            retireBatchState();
+    };
+    /**
+     * 件④ 保守臂的判据:候选在扣留表里**同族唯一**吗。
+     *
+     * 「族」的口径与**取件谓词**同轴(那才是可能撞车的那一层 —— `findPendingForTask` 是按族选行的):
+     *   · 候选属 fs 写 / shell 执行族(`fsOrShellGatedCalls`,tool_start 当拍记)⇒ 数扣留表里同属
+     *     该族的条数(两个 Bash / 一个 Write 一个 Edit 都算同族,因为取件谓词对它们不可分);
+     *   · 否则(ask / kind-only 等)⇒ 数扣留表里 `toolName` 逐字相同的条数。
+     * 不在扣留表里 ⇒ `false`(没有可摘的帧,也就谈不上「唯一」)。
+     */
+    const soleOfItsFamilyInHold = (callId) => {
+        const ev = heldAskEnds.get(callId);
+        if (ev === undefined)
+            return false;
+        let n = 0;
+        if (fsOrShellGatedCalls.has(callId)) {
+            for (const id of heldAskEnds.keys())
+                if (fsOrShellGatedCalls.has(id))
+                    n++;
+        }
+        else {
+            const name = ev.toolName;
+            for (const held of heldAskEnds.values())
+                if (held.toolName === name)
+                    n++;
+        }
+        return n === 1;
+    };
     /** 一批判完(或整批被摘空)⇒ 四样批级判据同批退休:下一批从零证起。 */
     const retireBatchState = () => {
         fsOrShellFamilyGate = false;
@@ -109,15 +152,27 @@ export function createGateLedger() {
             heldAskEnds.set(callId, ev);
         },
         dropHeld(callId) {
-            if (heldAskEnds.delete(callId))
-                droppedFromBatch.add(callId);
-            // 🔴 扣留表空 = 这一批没有(或不再有)任何待判的帧,批级判据当场退休 —— 不能等下一次
-            //    flush:「决断成功但本批压根没有毒化帧」的路径上 `flushHeld` 一次都不会跑,判据会就这么
-            //    活到下一批去把那一批的**真主角**判成连坐(实测 `new-main=STAMP`)。
-            // 🔴 「摘的那个不在表里」也要走这一步(不能早退):零 HOLD 批正是**每次** delete 都落空的
-            //    形状,早退就等于那种批永远不退休 —— 上一版的漏洞就在这里。
-            if (heldAskEnds.size === 0)
-                retireBatchState();
+            dropHeldImpl(callId);
+        },
+        dropHeldForDecidedPark(candidateCallId, trustedCallId) {
+            // ① wire 身份**对上了这次真被决断的那一行** ⇒ 身份确证,点名摘。
+            //    🔴 摘的永远是「真的被决断的那一行」(`candidateCallId`),wire 身份在这里的角色是**确证**
+            //    而不是另一个独立的摘取目标 —— 异源复审 finding①:决断腿按队列首行选行、这里却按 wire
+            //    身份摘帧,两边指向不同 call 时就是 split-brain(用户批的是旁观者,被摘的是主角帧)。
+            //    取件腿今天已经优先按同一个身份选行(见 `surfaceFsApprovalAndDecide` 的 parkGatedCallId),
+            //    所以正常路径上两者恒相等;不相等只发生在「身份在场但队列里没有那一行」的回落形 ——
+            //    那时决断落在别的行上,任何一帧都证明不了自己已过时,走②/③ 的保守判。
+            if (trustedCallId !== undefined && trustedCallId === candidateCallId) {
+                dropHeldImpl(trustedCallId);
+                return;
+            }
+            // ② 无可信身份:候选同族唯一才摘 —— 同族多条时任何选择都是猜,而猜错的代价是一帧永久消失。
+            if (candidateCallId !== undefined && soleOfItsFamilyInHold(candidateCallId)) {
+                dropHeldImpl(candidateCallId);
+                return;
+            }
+            // ③ 判不出 ⇒ 一条都不摘(退休检查仍照跑,见 dropHeldImpl 头注)。
+            dropHeldImpl(undefined);
         },
         heldCount() {
             return heldAskEnds.size;

package/dist/hitl/hitlBridge.d.ts

@@ -213,6 +213,14 @@ export type FindPendingOutcome = {
  * whose toolName the predicate doesn't recognize, but which still belongs to this run). Never `pending[0]`
  * — a typed failure when nothing for this taskId is queued.
  *
+ * F4947-1(2026-08-22,0.41.0):`callId` 是**更强的身份腿**,在场时先于上面两条跑。它来自
+ * `HitlBridge.decideTool`/`answerQuestion` 的 `toolUseID`(CC 的 tool_use id)—— 那两处此前走的是
+ * 本类里一个**同名私有** `findPending`,REF-CC-029 的收编没覆盖到它、P-30 的门种闸也没加到它,
+ * 于是真实生产入口(`makeHitlCanUseTool` → `decideTool`,从不传 `preResolvedPending`)一直在一条
+ * **没有闸**的复刻上跑(test 线 P0-KPI 复现)。收口方式是把私有件删掉改调本函数,而不是给它补第二
+ * 份过滤 —— 复刻正是这条缺陷的成因。身份腿同样只在**过完门种闸的行**里找:一个 `plan_review` 行
+ * 哪怕 callId 逐字命中也不该被工具审批 decide 掉(server 那边照样 409 `gate_not_tool_approval`)。
+ *
  * P-30(2026-08-14):both legs only consider rows whose `gateKind` belongs to the ask/approval family
  * ({@link askParkForeignGateKind} — the same single-source guard `classifyAskParkRows` uses). Without it
  * the ANY-row fallback would hand a `plan_review`/`resource_limit` row to the tool-approval wire — an
@@ -222,7 +230,34 @@ export type FindPendingOutcome = {
  */
 export declare function findPendingForTask(client: HitlClientLike, taskId: string, matches: (toolName: string | undefined) => boolean, opts?: {
     signal?: AbortSignal;
-}): Promise<FindPendingOutcome>;
+}, 
+/**
+ * F4947-1:调用方手上的**更强身份** —— CC 的 `toolUseID`(`HitlBridge`),或这张 park 的
+ * wire 身份(server ≥7.41.0,两条决断腿)。在场 ⇒ 先在**本 taskId** 的行里按
+ * `boundCallId`/`toolCallId` 逐字命中(仍在门种闸之内);不命中再走下面两条 taskId 腿。
+ *
+ * 🔴 **刻意不 fail-closed**(异源复审二审 finding① 的部分驳回,理由成文):身份在场而队列里
+ * 没有那一行时**照旧回落**,不铸「身份不匹配」的硬拒。两条理由:
+ *   · 回落的失效面 = 与本参数出现之前**逐字节相同**(那时压根没有身份腿);fail-closed 的失效面
+ *     = **每一次审批都决断不了**(用户点了 Yes 也过不去)。代价严重不对称;
+ *   · 这个 join(checkpoint 的 `pendingAction.toolCallId` ↔ `/v1/approvals` 富行的
+ *     `toolCallId`/`boundCallId`)本仓**没有对真 server 的实证**,只有上游帖面的口径。拿一个
+ *     没实证的键去关整条 HITL 的门,是把「可能对不上」赌成「一定对得上」。
+ * 跨 run 那一半的风险由上面的 taskId 约束关掉;「决断落在同 task 的另一行」这一格与本参数出现
+ * 之前同形,且下游 `dropHeldForDecidedPark` 对这一格自带保守判(身份对不上 ⇒ 一帧都不摘)。
+ */
+callId?: string, 
+/**
+ * 身份腿的**族闸**(整行可读)。缺省 = 退回 `matches(toolName)`。
+ *
+ * 🔴 为什么必须能读**整行**而不是只读 toolName(五审 finding①):工具审批族有**两条腿** ——
+ * 一等 `kind === 'tool_approval'`(放行**任意** toolName)与 fs 写 / shell 名字腿。而 wire 模块
+ * 传下来的 `matches` 只有名字腿那半(它服务的是「同族第一行」那条 leg 2)。拿它当身份闸,一个
+ * **合法的 kind-only 行**即使 taskId+callId 逐字命中也会被判出局 ⇒ 回落挑了同 task 的另一行,
+ * 卡面与决断全落在别的审批上、真 gate 继续 suspended。⇒ 调用方按自己那条腿的**完整**族判据
+ * 供给本闸(fs 腿 = `isToolApprovalGate({kind: row.gateKind, toolName})`,ask 腿 = `isAskTool`)。
+ */
+identityAccepts?: (row: PendingCheckpoint) => boolean): Promise<FindPendingOutcome>;
 /**
  * The bridge state. One per run/session. The shell feeds it `suspended` events (observe) and the human's
  * outcome (decide / answer / planReview); it owns the `approvals.list()` join + the verbatim binding echo.
@@ -240,17 +275,24 @@ export declare class HitlBridge {
     /** The gate currently awaiting a human, if any. The shell branches on `gate.kind` to pick the chrome. */
     currentGate(): CheckpointGate | null;
     /**
-     * Find the `PendingCheckpoint` the human is about to decide on. Joins by `toolCallId` when CC hands a
-     * `toolUseID`; otherwise falls back to the single pending row for this run's `taskId`. Returns null when
-     * the queue is empty (e.g. resolved/expired under the human → the caller must refetch + re-present).
+     * Fetch the `PendingCheckpoint` this decide/answer is about to resolve, for the callers that do NOT
+     * already have one in hand (see `decideTool`/`answerQuestion`'s `preResolvedPending` param — the wire
+     * modules that surface a card/overlay BEFORE deciding fetch the row themselves and pass it straight
+     * through, closing the TOCTOU window between "the row the human saw" and "the row decide resolves",
+     * REF-CC-029/hitl2-08).
+     *
+     * 🔴 F4947-1(2026-08-22,0.41.0):本方法**没有自己的查找逻辑** —— 它是 {@link findPendingForTask}
+     * 的一层出参映射,一个字节的行过滤都不在这里。上一版是一个与那个单源导出**撞名**的私有复刻
+     * (`findPending`),REF-CC-029 的三合一没覆盖到它、P-30 的门种闸也只加在导出那一份上,于是
+     * `makeHitlCanUseTool` → `decideTool`(真实用户点 Yes/No 那条路,从不传 `preResolvedPending`)
+     * 一直在没有闸的老复刻上跑:同 task 停着 `plan_review` 行时,它被当成「这个 run 的 pending」
+     * 交给工具审批 decide(空 toolName 卡 / 409 `gate_not_tool_approval`)。
+     * 名字也一并换掉:撞名正是「看起来只有一份实现」的成因。
      *
-     * Used only as the fallback when a caller does NOT already have the pending row in hand (see
-     * `decideTool`/`answerQuestion`'s `preResolvedPending` param) — the wire modules that surface a card/
-     * overlay BEFORE calling decide/answer fetch the row themselves via `findPendingForTask` (below) and
-     * pass it straight through, closing the TOCTOU window between "the row the human saw" and "the row
-     * decide resolves" (REF-CC-029/hitl2-08).
+     * 谓词传 {@link ANY_TOOL_FAMILY}:桥这一层对工具族**没有意见**(人刚刚决断的是哪张门就是哪张),
+     * 与旧私有件的 taskId 兜底逐字同语义;身份腿(`toolUseID`)由单源函数的 `callId` 参数承接。
      */
-    private findPending;
+    private pendingForDecide;
     /**
      * Build the D-1 binding off the pending row the human SAW. Echo VERBATIM — NEVER recompute the hash
      * (contract/04 §2.2). `checkpointToken` is DELIBERATELY never set (deprecated legacy path;
@@ -288,7 +330,7 @@ export declare class HitlBridge {
      *  its own `approvals.list()` — closing the TOCTOU window between "the row the human saw" and "the
      *  row decide resolves" (two independent fetches could otherwise land on different rows if the
      *  first one got resolved/expired in between, hitl2-01/hitl2-08). Omit only when the caller has no
-     *  such row in hand (falls back to `findPending`). */
+     *  such row in hand(缺省回落 `pendingForDecide` — 见其头注,那是单源 `findPendingForTask` 的一层出参映射). */
     preResolvedPending?: PendingCheckpoint): Promise<unknown>;
     /**
      * Answer an `AskUserQuestion` gate (contract/04 §4; 08 CS-16). Same suspended → decide loop as a