@sema-agent/client-core 0.39.0 → 0.41.0

package/dist/hitl/approvalsFeed.js

@@ -40,6 +40,16 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
     let retryTimer;
     /** [2393] hitl-F5:连续「回调体抛出」的次数(一次跑完就归零)——见 `schedulePoll` 的 catch 臂。 */
     let consecutivePollEscapes = 0;
+    /** [F4957-1] 轮询腿的**代际**:push 腿每重连一次 +1。在途的旧拍完成时凭它认出自己已经过期 ——
+     *  它的成败属于上一条腿,不该改现在这条腿的连续计数,也不该由它来续排(见 `schedulePoll`)。 */
+    let pollLeg = 0;
+    /**
+     * [F4957-1 三审] 取件的**单调发号**与「已观察到的最新一号」。乱序回滚是**取件面的通病**,不是
+     * 轮询腿的私事:`refresh()`(端上的显式刷新)与 push 腿的重取同样可能后发先至。所以提交面的闸
+     * 从「代际」升成请求序号 —— 一次响应只有在「没有更晚发起的请求先落过地」时才允许改视图。
+     */
+    let takeSeq = 0;
+    let lastObservedSeq = 0;
     const stats = {
         pushEvents: 0, heartbeats: 0, polls: 0, listErrors: 0, streamFailures: 0, snapshots: 0,
     };
@@ -73,9 +83,12 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         }
         return verdict;
     }
-    async function take(via) {
+    async function take(via, 
+    /** [F4957-1 二审] 发起这次取件时的轮询代际(只有轮询腿传;push/refresh 不受代际管)。 */
+    leg) {
         if (stopped)
             return;
+        const seq = ++takeSeq;
         let rows;
         try {
             rows = (await client.approvals.list({ signal: ac.signal })).pending;
@@ -88,6 +101,23 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         if (stopped)
             return;
         const d = digestOf(rows);
+        // 🔴 [F4957-1 二审 finding②] 代际闸必须排在**提交之前**:下面四行(lastDigest / revision /
+        // last / onSnapshot)一落,视图就已经被改了 —— 守卫排在 take() 之外只挡得住计数与续排,挡不住
+        // 回滚。乱序是真的会发生的:旧 poll 在途 → push 重连并发布新快照 → 旧 poll 才带着**更老**的
+        // 结果返回 ⇒ 端拿到一张 revision 更高、内容更旧的 `mode:'poll'` 快照(刚出现的待审批被抹掉,
+        // 或刚解决的又冒回来)。过期的结论一个字节都不提交。
+        if (leg !== undefined && leg !== pollLeg) {
+            hostLog('debug', `approvalsFeed: dropping stale poll snapshot from leg ${leg} (current ${pollLeg})`);
+            return;
+        }
+        // 🔴 [F4957-1 三审 finding②] 乱序闸(三条取件路径共用):比「已观察到的最新一号」更早发起的
+        // 响应,其结论已经被后发者的结论取代 —— 一个字节都不提交。`refresh()` 不带代际,单靠上面那道
+        // 闸盖不住它(端上「用户点了刷新」正是最容易与 push 重取撞车的那一发)。
+        if (seq < lastObservedSeq) {
+            hostLog('debug', `approvalsFeed: dropping out-of-order take #${seq} (newest observed #${lastObservedSeq})`);
+            return;
+        }
+        lastObservedSeq = seq;
         if (d === lastDigest)
             return; // 内容没变 ⇒ 不打扰订阅者
         lastDigest = d;
@@ -118,6 +148,11 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             return;
         pollTimer = arm(setTimeout(() => {
             pollTimer = undefined;
+            // 🔴 [F4957-1 二审] 这一拍属于**哪一代**轮询腿。`take('poll')` 是可以挂很久的(慢 list /
+            // 挂死读面),期间 push 腿完全可能重连成功并把连续计数清零 —— 那一拍的结论此时已经是
+            // **上一条腿**的历史,回写到新计数里就等于把「被健康 push 窗隔开的失败」又算回连续
+            // (回落之后只需 4 拍就转 idle),而这正是本批要修掉的那条语义。代际在重连处 +1。
+            const leg = pollLeg;
             // [C77]② 跳拍:消费方说这一拍不用查 ⇒ 不取件、不计 `stats.polls`(没取件却计数 = 谎报流量)、
             // **不动** `consecutivePollEscapes`(跳拍不是失败,连着跳一万拍也不该被 F5 判成腿挂了),
             // 但下一拍照排 —— 这是「腿活着但闲着」,不是停摆。
@@ -128,7 +163,11 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             }
             void (async () => {
                 stats.polls++;
-                await take('poll');
+                await take('poll', leg); // 代际随取件一路带进去(提交面的闸在 take 内,见其头注)
+                // 代际已翻篇 ⇒ 这一拍的成败都不属于现在这条腿:既不清零(会掩盖新腿真正的连续失败),
+                // 也不续排(当代那条链由 degradeToPoll 自己排,这里再排一次纯属两条腿并行的种子)。
+                if (leg !== pollLeg)
+                    return;
                 consecutivePollEscapes = 0; // 跑完一整拍 ⇒ 之前的逃逸不再连续
                 if (mode === 'poll')
                     schedulePoll();
@@ -149,6 +188,11 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 // ② **连续失败上限转 idle** —— 一直抛就是真的挂了,那时 `mode` 必须说真话,让端的自检
                 // 看得见([honest-absence-not-fabricated-zero]:诚实缺席优先于一个还在报活的假象)。
                 hostLog('debug', `approvalsFeed: poll leg threw unexpectedly (take() should have self-caught): ${String(e)}`);
+                // 🔴 [F4957-1 二审] 同上:上一代的逃逸不喂现在这条腿的连续计数,也不由它来续排。
+                if (leg !== pollLeg) {
+                    hostLog('debug', `approvalsFeed: stale poll completion from leg ${leg} (current ${pollLeg}) — not counted as a consecutive escape`);
+                    return;
+                }
                 consecutivePollEscapes++;
                 if (consecutivePollEscapes >= MAX_CONSECUTIVE_POLL_ESCAPES) {
                     mode = 'idle';
@@ -216,6 +260,17 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                         clearTimeout(pollTimer);
                         pollTimer = undefined;
                     }
+                    // 🔴 [F4957-1](0.41.0):**同批清零 F5 的连续逃逸计数**。这一拍与 `schedulePoll` 里
+                    // 「跑完一整拍 ⇒ 之前的逃逸不再连续」是同等强度的健康证据 —— 端真的从服务端收到了一个
+                    // 事件。不清零的后果不是多算几次:被一整段健康 push 窗**隔开**的两批逃逸会被当成连续
+                    // 累加(3 次 → 重连 → 再 2 次 = 5),于是刚从 push 回落的轮询腿才逃逸两拍就撞上限,
+                    // `mode()` 谎报 idle —— 而文件头 38-42 卖的正是「mode 不是 idle」这条端自检,
+                    // 它会指着一条刚活过来的腿说它停摆了([honest-absence-not-fabricated-zero] 的反面:
+                    // 把「活着」渲成「死了」同样是撒谎)。计数的语义是**连续**,那就只能被真正连续的失败喂大。
+                    consecutivePollEscapes = 0;
+                    // 与清零**同一拍**翻代际:清零只管已经落地的计数,代际管的是那些还挂在 `take()` 里、
+                    // 稍后才回写的在途拍(二审 finding③ —— 少了这一半,清零会被一个旧拍当场推回 1)。
+                    pollLeg++;
                     hostLog('debug', 'approvalsFeed: push leg re-established — polling leg stopped');
                 }
                 if (ev?.type === 'heartbeat') {

package/dist/hitl/askGateWire.d.ts

@@ -73,6 +73,7 @@ import { type AskGateWireDeps } from './frameRouter.js';
 export { HITL_REJECT_MESSAGE, ENGINE_ABORT_TOOL_RESULT } from './frameRouter.js';
 export type { AskGateWireDeps } from './frameRouter.js';
 export type { AskAnsweredOutput } from './gateLedger.js';
+export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
 /**

package/dist/hitl/askGateWire.js

@@ -19,6 +19,12 @@ import { resolvePark } from './parkResolver.js';
 //    `toAnsweredOutput` / 下方 `bridgeAskUserQuestionGates`)、类型四个。定义搬去了实现所在的
 //    那一刀,本文件是它们对外的**唯一门牌**——下游 import 路径不变,public-export 基线不变。
 export { HITL_REJECT_MESSAGE, ENGINE_ABORT_TOOL_RESULT } from './frameRouter.js';
+// #324 / [4907]:连坐 abort 机读位的**单一真源**导出([C93] `toolEndOutputText` 同款理由 ——
+// 三端各自手抄键名 = 漂移温床)。壳/web/desktop 认这个常量,不认文案。
+export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
+// 🔴 `HoldOrigin` 随 #324 换锚删除(2026-08-22):出身不再在入表当拍冻结成两值枚举,改在
+//    `flushHeld` 当拍按已登记的 gate 主角身份求值 —— 那个枚举没有对外语义了。干净切:它只在
+//    未发布的 0.40.0 窗里存在过,零已发布消费者([clean-cut-no-legacy-compat])。
 export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES } from './parkResolver.js';
 /**
  * 包一层 AgentEvent 流:把 AskUserQuestion 的 suspended park 变成「对话框 → decide → 续流」闭环。
@@ -70,6 +76,8 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             park = {
                 gate: action.gate,
                 ...(action.pendingDone !== undefined ? { pendingDone: action.pendingDone } : {}),
+                // [4914] 请托①到货件:park 的待批 call 身份(server ≥7.41.0)——缺席是常态,见 GatePark 头注。
+                ...(action.gatedCallId !== undefined ? { gatedCallId: action.gatedCallId } : {}),
             };
             break;
         }

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 的毒化帧
@@ -76,6 +84,62 @@ function isGatedToolName(name) {
         return false;
     return toolNameIsFsWrite(name) || toolNameIsShellExec(name);
 }
+/** 这个 gate 的**主角属 fs 写 / shell 执行族**吗(`gateLedger.noteParkGate` 的准入判据)。
+ *  🔴 主语是 **gate 本体**的 toolName(park 的 `checkpointGate`/`gate`),不是某张 tool_end
+ *  帧的 —— 拿「本 turn 有哪些 gate-capable 工具」当准入证正是 v1 名字锚那条病的同形残留。 */
+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)。
@@ -90,9 +154,10 @@ function isGatedToolName(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)。方向是有意的,且不对称成立 —— 多盖一帧的代价是那一帧
@@ -102,6 +167,26 @@ function isGatedToolName(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;
@@ -127,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)
@@ -191,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;
@@ -223,11 +323,19 @@ 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;
-            led.hold(callId, ev); // park 毒化帧,先 HOLD(gate 定性前不渲 Error 卡)
-            return { kind: 'skip' };
+            // #324 换锚(2026-08-22):这一拍**不判出身**。durable park 腿的帧序是
+            // `tool_start → tool_end(毒化) → done{suspended}` —— gate 身份晚于本帧到达,此刻任何判词
+            // 都是猜的(名字腿猜法被双向证伪:一等 kind gate 的主角判成连坐、同族兄弟两个都判成主角)。
+            // 出身改在 `flushHeld` 当拍按**已登记的主角身份**求值,判据供给见 `gateLedger.noteGateSubject`。
+            led.hold(callId, ev);
+            return { kind: 'skip' }; // park 毒化帧,先 HOLD(gate 定性前不渲 Error 卡)
         },
     },
     {
@@ -266,6 +374,12 @@ async function routeToolApprovalFrame(ev, ctx) {
     const { led, deps } = ctx;
     if (ev.type === 'tool_approval_complete')
         return { kind: 'skip' }; // 收口帧:卡已由决断路径撤下,吞掉
+    // 🔴 #324:本臂**刻意不给连坐判别子供证**(异源对抗复审四轮的收口,2026-08-22)。
+    //    帧只证明「本 turn 出现过一张 gate」,证明不了「**这一批** abort 帧属于它」—— 那张 gate
+    //    可能早已正常收口(零毒化帧 ⇒ 零扣留表 ⇒ 一次 flush 都不跑),证却会活到下一批派错判词。
+    //    三条实测假阳(旧 server 双主角 / 零 HOLD 审批证跨批 / 历史身份跨批)都出自帧腿取证。
+    //    判别子只认 park(归属可结构性证明,见 `gateLedger.noteParkGate` 头注);同步帧腿一律
+    //    不标 —— 诚实缺席,登记在 §3z 已知局限。
     if (!deps.respondToolApproval) {
         hostLog('debug', `liveHitlAskWire: tool_approval frame ${ev.approvalId} but no respond wire — engine self-settles (TTL deny)`);
         return { kind: 'skip' };
@@ -345,12 +459,21 @@ function routeToolEnd(ev, callId, led) {
 function routeSuspended(ev, ctx) {
     // durable leg 的 park arm(续流中模型再次提问/再次撞写权限)。gate 只带 kind/toolName,
     // payload 走 approvals。
-    if (ev.gate && isAskToolLoose(ev.gate.toolName) && ctx.taskId.current)
-        return { kind: 'park', gate: 'ask' };
+    // 🔴 两条 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', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
+    }
     if (ev.gate &&
         isToolApprovalGate(ev.gate) &&
         ctx.taskId.current) {
-        return { kind: 'park', gate: 'fs' };
+        // 准入证:park 的 gate 本体属 fs/shell 族(kind-only gate 的 toolName 在族外 ⇒ 不发证)。
+        ctx.led.noteParkGate({ fsOrShellFamily: isFsOrShellToolName(ev.gate.toolName) });
+        return { kind: 'park', gate: 'fs', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     // 其余 gate:透传。⚠️ ADAPTER-F8 注纠(2026-08-02):原文写「eventToSdkMessage 出 null」——
     // 那个返回形已随 REF-CC-058 退役,今天它出的是 `EventProjection` 三态,永不是 null;本臂的
@@ -359,13 +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;
-        return { kind: 'park', gate: 'ask', pendingDone: ev };
+        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;
-        return { kind: 'park', gate: 'fs', pendingDone: ev };
+        // 准入证:主语是 checkpointGate **本体**的 toolName,不是任何 tool_end 帧的。
+        led.noteParkGate({ fsOrShellFamily: isFsOrShellToolName(ev.result.checkpointGate?.toolName) });
+        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

@@ -19,6 +19,17 @@
  *    台账要能自描述,值类型必须与台账同层或更低。`askGateWire.ts` 原样 re-export 它,对外类型面不变。
  */
 import type { AgentEvent } from '@sema-agent/sdk';
+/**
+ * 连坐 abort 帧的 additive 超集机读位(#324 / [4907] 裁定;登记见 `docs/type-superset.json`)。
+ *
+ * `flushHeld` 对**已知不是 gate 主角**的帧 stamp `true`,别的帧一个字节不改。消费方(壳 / web /
+ * desktop)据此把连坐簇按 repeated-error 族软化折叠,**不猜文案**。
+ *
+ * 🔴 刻意**不动** `isError` 与 `output`:core 5.51 的 `[DEFERRED]` / `gate.batch_halted` 词汇
+ *    ([4826]③)尚未到货,那一面的定形归 core;本键只是机读位,到货后与官方形对表,
+ *    additive 键保留兼容(裁定原文)。
+ */
+export declare const SEMA_COLLATERAL_ABORT_KEY = "_sema_collateral_abort";
 /** CC AskUserQuestion outputSchema 形状(答过的问题卡):toolResult 的 `ask-user-question` arm
  *  消费它渲真实答案卡(否则「诚实缺席」路径会把这张卡渲成结果不可用)。 */
 export interface AskAnsweredOutput {
@@ -52,12 +63,71 @@ export interface GateLedger {
     gatedStartArgs(): ReadonlyMap<string, unknown>;
     isEnded(callId: string): boolean;
     markEnded(callId: string): void;
-    /** park 毒化的 gated tool_end(isError:true "Operation aborted")——HOLD 到 gate 定性
-     *  (AskUserQuestion + [816] 放宽后的 fs 写工具 + [2150] Bash)。 */
+    /**
+     * park 毒化的 gated tool_end(isError:true "Operation aborted")——HOLD 到 gate 定性
+     * (AskUserQuestion + [816] 放宽后的 fs 写工具 + [2150] Bash)。
+     *
+     * 🔴 **入表当拍不判出身**(#324 换锚,2026-08-22):durable park 腿的帧序是
+     * `tool_start → tool_end(毒化) → done{suspended}` —— gate 身份**晚于**毒化帧到达,入表那一拍
+     * 包层根本还不知道谁是主角。出身改在 {@link flushHeld} 当拍求值(五个 flush 出口全部晚于 park
+     * 被看见),判据见 {@link noteParkGate}。
+     */
     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 回退路径与终帧路径共用的唯一出口)。 */
+    /**
+     * drain:逐帧吐出并**同批记 ended**(fail-soft 回退路径与终帧路径共用的唯一出口)。
+     *
+     * 🔴 **一帧不丢**(frameRouter:185 的不变量,#324 车实测确证它是刻意的):HOLD 过的帧在这里
+     * 全部吐出去 —— 丢帧的后果是永久假排队(dim 圆点永远等不到结果行),比多渲一行红字更坏。
+     * 本出口做的唯一一件事是给**已知不是 gate 主角**的帧 stamp {@link SEMA_COLLATERAL_ABORT_KEY}
+     * 机读位(additive 超集键;`isError` / `output` / 帧序一律不动),让消费端能把连坐簇与主角帧
+     * 分开呈现。
+     *
+     * 🔴 判词方向(fail-safe):**判不出本批主角 ⇒ 一个都不 stamp**(诚实缺席,与本键出现之前
+     * 逐字节相同);判得出 ⇒ 主角走原路零改动、其余一律 stamp。绝不按到达顺序编判词。
+     *
+     * 主角怎么判(实现见 `resolveGateSubjects`,判据全部**批级**、一批一套):
+     *   ① **硬门:本批恰好一张 park**({@link noteParkGate})。零张 = 归属无从证明(同步帧腿 /
+     *      纯取消批都落这里);两张以上 = 这批扣留帧混了两次 gate 的 abort,谁属谁无解。一律不标。
+     *   ② **主角 = 本批(扣留帧 ∪ 本批已出批的帧)里唯一属该 park 族的 call**。并上「已出批的帧」
+     *      是因为决断成功那一下会把主角的毒化帧 `dropHeld` 掉,只看扣留帧的话主角就「不在这一批」,
+     *      整批判据当场失效。族外 park(kind-only / ask)不发准入证 ⇒ 整批不标。
+     *   ③ 前置:**每一条扣留帧的 `tool_start` 本连接都得见过** —— 族成员判据取自 tool_start 当拍
+     *      记的集合,没见过 start 的 call 在「唯一」这件事上是隐形的;续流只消费 `runs.events` 的
+     *      一段,主角的 start 完全可能落在这次连接之外,那时表里剩下的唯一族成员是**旁观者**。
+     *
+     * 🔴 **pending 队列一概不参与判别**:`durable checkpointGate` 不带 callId,`findPendingForTask`
+     * 取的是「同 taskId + 谓词命中的第一行」(不命中时退「任意行」)—— 那是给**卡面渲染**用的宽口,
+     * **不是身份**。同族两行排队时它会给出旁观者,拿它当主角就把真主角挤成「非主角」而 stamp。
+     */
     flushHeld(): Generator<AgentEvent>;
     /** 三选卡 deny 过的 call:重放 tool_end 的 render 面 stamp REJECT_MESSAGE(vendored
      *  renderToolUseRejectedMessage 渲 `User rejected <op> to <path>`,CC 逐字)。 */
@@ -81,6 +151,28 @@ export interface GateLedger {
      *  时前进,天然把「这次 park 到底是哪个 call」的身份带过 decide→重放两轮。 */
     noteFsOrShellGate(callId: string): void;
     lastFsOrShellGatedCallId(): string | undefined;
+    /**
+     * 登记「**这一批**的 park」——判别子唯一认的归属证据。写者 = 四条 park 臂:`routeDone` 的
+     * ask/fs 两条、`routeSuspended` 的 ask/fs 两条。`fsOrShellFamily` = 这张 park 的 gate **本体**
+     * `toolName` 属 fs 写 / shell 执行族吗(唯一性兜底腿的准入证)。
+     *
+     * 🔴 **为什么只认 park、不认 `tool_approval` 帧**(异源对抗复审四轮的收口,2026-08-22):
+     * 判别子要回答的是「**这一批** abort 帧属于哪张 gate」,而 wire 上**没有**任何位做这个关联 ——
+     * 包层能算的都是推断。park 是唯一**归属可结构性证明**的证据:`flushHeld` 的出口就长在那张 park
+     * 自己的决断/回退路径上(`parkResolver` fail-soft / decide 成功后的续流放行 / 终帧),
+     * 「这一批是这张 park 的 abort 批」是结构事实,不是猜的。
+     * 审批帧腿不具备这个性质:帧只证明「本 turn 出现过一张 gate」,那张 gate 可能**早已正常收口**
+     * (零毒化帧 ⇒ 零扣留表 ⇒ 一次 flush 都不跑),它的证却会活到下一批去派判词。四轮实测里
+     * 三条「假阳打回主角」都出自帧腿证据(旧 server 双主角 / 零 HOLD 审批证跨批 / 历史身份跨批),
+     * 故本版**刻意**不从帧腿取证 —— 代价是同步帧腿整条不标(已知局限,见 §3z)。
+     *
+     * 🔴 **重放同一张 park 不算新的一张**:#110 成文「durable re-attach 必然把已决断的 park 再送
+     * 一遍」。判据 = 自上一次 park 登记以来**有没有新的帧进过扣留表**;没有就是同一张 park 被重放,
+     * 计数不动(否则本批会被自己的重放判成「多 park」而整批失效,真连坐帧拿不到位)。
+     */
+    noteParkGate(evidence: {
+        fsOrShellFamily: boolean;
+    }): void;
     /** 续流重放的解答 tool_end 无 output,不补就会渲成结果不可用;这里记下真实答案供该帧 stamp
      *  `structured` 让卡片渲真实选择。 */
     rememberAnswer(callId: string, answered: AskAnsweredOutput): void;