@sema-agent/client-core 0.46.0 → 0.48.0

package/dist/hitl/hitlBridge.d.ts

@@ -65,7 +65,7 @@
  * vocabulary, no claude.ai permission-rule destinations, no widget/glyph/keybinding crosses this seam. The
  * backend supplies the SIGNAL; the shell owns the chrome.
  */
-import type { AgentEvent, ApprovalDecision, PendingCheckpoint, CheckpointGate, PlanReviewRequest, AssistantTaskStatus } from '@sema-agent/sdk';
+import type { AgentEvent, ApprovalDecision, ApprovalStaleError, PendingCheckpoint, CheckpointGate, PlanReviewRequest, AssistantTaskStatus } from '@sema-agent/sdk';
 /** durable `/decide` 腿的既有缺省拒因(不带归因时逐字不变 —— 0.27.0 及之前的 wire 字节)。 */
 export declare const DEFAULT_DENY_REASON = "The user rejected this tool use";
 /** server 两条腿共用的 reason 字符上限(超限 413,决断被打回)。 */
@@ -155,6 +155,66 @@ export declare class HitlSafetyError extends Error {
      *  一边加一边不改另一边 = 新码在消费端被静默吞掉(比不加还坏:本地拦住了,判词却丢了)。 */
     code: 'binding_mismatch' | 'no_pending' | 'wrong_gate' | 'bad_plan_edit' | 'empty_answer');
 }
+/**
+ * decide 409 `approval_stale` 拒体上的 **additive 指路键** `currentPending` —— 本会话**当前**那条
+ * pending 的三件 D-1 坐标(#363,0.47.0;server S-02 ≥7.52)。
+ *
+ * ── 它是什么、不是什么 ────────────────────────────────────────────────────────────────────
+ * 是:「你手上那条已经不是当前的了,**当前**这条长这样」——壳拿它**一跳重定位**再 decide,
+ *     免去整队重拉(`GET /v1/approvals`)。
+ * 不是:放行凭据 / CAS 输入 / resume 凭证。server 自己的 fail-open 登记原话逐字:
+ *     「纯指路/便利面,**不参与任何门/CAS/resume 判定**」。⇒ 缺席的代价 = 退回它到货前的行为
+ *     (重拉列表自行重定位),所以本包对它一律**宽读、诚实缺席**,绝不 fail-closed。
+ * 🔴 **恒不含 `checkpointToken`**(server 侧 resume 凭证不外发纪律)——本形也刻意没有那一位:
+ *     多一个位就是给一个「凭证能过境」的错觉。
+ *
+ * ── 自铸形已退役,本名现在是上游形的**别名**(0.48.0)──────────────────────────────────
+ * 0.47.0 这里是一个**自铸 interface** + 一段记账:`@sema-agent/sdk` 7.3.0 起已有逐字同形的
+ * `ApprovalStaleCurrentPending`,但当时本包 peer 地板是 `>=7.2.0`,那一版上这个名字不存在 ⇒
+ * `import type` 会让装 7.2.0 的端当场编不过。记账段同批写死了退役条件:「peer 地板抬到 `>=7.3.0`
+ * 的那一批,把本形改成 `import type` 的别名并删掉这段记账」。
+ * 本批(0.48.0)peer 地板抬到 **`>=7.4.0`**(四件新投影都吃 7.4.0 的类型面)⇒ 条件满足,兑现。
+ * 🔴 **别名而不是删名**:`GateCurrentPending` 是 `FsApprovalOutcome` / `GateOutcome` 两条腿的**已发布
+ *    导出名**,删它是 BREAKING。别名让上游形成为**唯一真源**(上游改一个位,本包的两条腿当天跟着
+ *    动,不再有第二份可能漂的声明),而本名继续对已接入的端有效。
+ * 🔴 **同名不同源的风险随之消失**:0.47.0 刻意取了个**不同名**(免得地板线下出现一个与上游同名却
+ *    不同源的形,[same-name-different-meaning-crosses-layers]);现在两者是同一个形,那条顾虑不再
+ *    适用 —— 但名字**不回改**成上游名,理由见上一条(已发布导出名)。
+ *
+ * 🔴 **为什么绕道 `ApprovalStaleError['currentPending']` 而不是直接 `import type
+ *    { ApprovalStaleCurrentPending }`(上游缺口,本批亲验实证)**:那个名字在 sdk 7.4.0 里**声明了
+ *    但没有从包入口导出** —— `dist/types.d.ts:2359` 有 `export interface ApprovalStaleCurrentPending`,
+ *    而 `dist/index.d.ts` 的 re-export 名单里**没有它**(同文件只导出了 `ApprovalStaleError`),
+ *    且包 `exports` 映射只开 `.` / `./registry` 两个子路径,深引 `@sema-agent/sdk/dist/types.js`
+ *    这条路根本不通。⇒ 按名 import 是**编译错**,不是风格选择。
+ *    绕道取的是**同一个声明**(`currentPending?: ApprovalStaleCurrentPending | undefined`,
+ *    `NonNullable` 剥掉可选位),所以单源化的目的一字不打折:上游改那个形,本包当天跟着动。
+ *    📋 **上游候件(已登记,不在本批修)**:请 sdk 把 `ApprovalStaleCurrentPending` 加进 `index.d.ts`
+ *    的 `export type {…}` 名单(纯 additive,零行为)。到货后本别名可改回按名 import,
+ *    **但那是等价重构、不是修复** —— 今天这条路已经拿到上游形本身,不存在第二份可能漂的声明。
+ */
+export type GateCurrentPending = Readonly<NonNullable<ApprovalStaleError['currentPending']>>;
+/**
+ * 从一次 decide 失败(任意抛出物)里读出 {@link GateCurrentPending} —— 读不出即 `undefined`。
+ *
+ * 🔴 **结构视图读,不 `instanceof`**(两条理由,都是承重的):
+ *   ① **供给面**:本包的 decide 出站走的是宿主注入的 `HitlClientLike`(见该型)。抛出来的到底是不是
+ *      SDK 的 `ApprovalStaleError` 由**宿主**决定 —— web/desktop 完全可以注入自己的传输层。拿
+ *      `instanceof` 当闸,等于让「宿主用的是哪一份 SDK 实例」决定一个纯读值的位在不在
+ *      (跨 realm / 双实例 = `HitlSafetyError` 判型契约踩过的同一个坑,见 §4e)。
+ *   ② **类型面**(0.48.0 就地订正):0.47.0 这条写的是「`ApprovalStaleError.currentPending` 只在
+ *      sdk ≥7.3.0 上声明,而本包地板是 7.2.0」——**地板已抬到 `>=7.4.0`,那半条不再成立**。
+ *      但本条的**结论不变**,因为承重的从来是 ① 那半:即使类型面现在够得着,抛出来的对象仍由宿主
+ *      的传输层决定,`instanceof` 依旧是错的判据。⇒ 保留宽读,只订正理由。
+ * 🔴 **判据锚在「值本身合不合形」,不锚它骑在哪个类/哪个 errorCode 上**
+ *    ([anchor-on-the-deciding-quantity]):真正决定「壳能不能一跳重定位」的量,是**这个三元组的
+ *    两件必填位在不在且是非空串** —— 而不是错误的类名。宽读在这里是**方向安全**的:本位不参与
+ *    任何裁决(见 {@link GateCurrentPending} 顶注),多读到一次的代价 = 多一条指路;漏读的代价 =
+ *    退回整队重拉。
+ * 🔴 **两件必填位缺一即整只不铸**:半个三元组重定位不了(`decide` 要的是 boundCallId 本体),
+ *    铸一个残形只会让消费点以为「有指路」。`boundInputHash` 是**行上有才带**的可选位,缺席照铸。
+ */
+export declare function readDecideCurrentPending(e: unknown): GateCurrentPending | undefined;
 /** 测试钩:把超时类重试总窗调小(传 undefined 还原缺省)。 */
 export declare function __setDecideTimeoutRetryBudgetForTests(ms?: number): void;
 /**

package/dist/hitl/hitlBridge.js

@@ -53,6 +53,55 @@ export class HitlSafetyError extends Error {
         this.name = 'HitlSafetyError';
     }
 }
+/**
+ * 🔴 **编译期负控**(对抗复审 [medium] 采纳,0.48.0):三位必须**全 `readonly`**。
+ *
+ * 0.47.0 的自铸形三位逐个写着 `readonly`,而上游 `ApprovalStaleCurrentPending` 的成员是**可写**的
+ * —— 首版别名(`NonNullable<…>`,不带 `Readonly<>`)把这条已发布的类型契约悄悄弱了一档:
+ * 消费方从此可以直接改写 `boundCallId` / `boundInputHash`,而那两位的契约恰恰是
+ * **逐字回显、绝不本地重算**(§9.1;本地重算一次就会把一次合法审批 fail-close 掉)。
+ * 🔴 这类退化**没有任何行为门看得见**(它不改变任何运行期字节)—— 名字在、字段在、行为门全绿。
+ *    所以钉必须下在编译期:`Readonly<>` 哪天被顺手摘掉,这一行当场编译错。
+ */
+const _gateCurrentPendingReadonlyPin = true;
+void _gateCurrentPendingReadonlyPin;
+/**
+ * 从一次 decide 失败(任意抛出物)里读出 {@link GateCurrentPending} —— 读不出即 `undefined`。
+ *
+ * 🔴 **结构视图读,不 `instanceof`**(两条理由,都是承重的):
+ *   ① **供给面**:本包的 decide 出站走的是宿主注入的 `HitlClientLike`(见该型)。抛出来的到底是不是
+ *      SDK 的 `ApprovalStaleError` 由**宿主**决定 —— web/desktop 完全可以注入自己的传输层。拿
+ *      `instanceof` 当闸,等于让「宿主用的是哪一份 SDK 实例」决定一个纯读值的位在不在
+ *      (跨 realm / 双实例 = `HitlSafetyError` 判型契约踩过的同一个坑,见 §4e)。
+ *   ② **类型面**(0.48.0 就地订正):0.47.0 这条写的是「`ApprovalStaleError.currentPending` 只在
+ *      sdk ≥7.3.0 上声明,而本包地板是 7.2.0」——**地板已抬到 `>=7.4.0`,那半条不再成立**。
+ *      但本条的**结论不变**,因为承重的从来是 ① 那半:即使类型面现在够得着,抛出来的对象仍由宿主
+ *      的传输层决定,`instanceof` 依旧是错的判据。⇒ 保留宽读,只订正理由。
+ * 🔴 **判据锚在「值本身合不合形」,不锚它骑在哪个类/哪个 errorCode 上**
+ *    ([anchor-on-the-deciding-quantity]):真正决定「壳能不能一跳重定位」的量,是**这个三元组的
+ *    两件必填位在不在且是非空串** —— 而不是错误的类名。宽读在这里是**方向安全**的:本位不参与
+ *    任何裁决(见 {@link GateCurrentPending} 顶注),多读到一次的代价 = 多一条指路;漏读的代价 =
+ *    退回整队重拉。
+ * 🔴 **两件必填位缺一即整只不铸**:半个三元组重定位不了(`decide` 要的是 boundCallId 本体),
+ *    铸一个残形只会让消费点以为「有指路」。`boundInputHash` 是**行上有才带**的可选位,缺席照铸。
+ */
+export function readDecideCurrentPending(e) {
+    const raw = e?.currentPending;
+    if (typeof raw !== 'object' || raw === null)
+        return undefined;
+    const o = raw;
+    if (typeof o.toolName !== 'string' || o.toolName.length === 0)
+        return undefined;
+    if (typeof o.boundCallId !== 'string' || o.boundCallId.length === 0)
+        return undefined;
+    return {
+        toolName: o.toolName,
+        boundCallId: o.boundCallId,
+        ...(typeof o.boundInputHash === 'string' && o.boundInputHash.length > 0
+            ? { boundInputHash: o.boundInputHash }
+            : {}),
+    };
+}
 // ── decide 出站的瞬断分诊与有界重试(Inkglow-1085 P0a,2026-08-19;[4664] server 定谳后对表)────
 //
 // 病形(案卷 INKGLOW-1085 车1 全链):`approvals.decide` 是**非 submit POST** —— SDK transport 对它

package/dist/hitl/parkResolver.d.ts

@@ -13,6 +13,7 @@
  *    在驱动的消费点上必然显形,而不是被本文件自己吞掉。
  */
 import type { AgentEvent } from '@sema-agent/sdk';
+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';
@@ -46,6 +47,7 @@ export type GateOutcome = {
     reason: string;
     code?: GateFailureCode | undefined;
     retryExhausted?: true;
+    currentPending?: GateCurrentPending | undefined;
 };
 /**
  * decide 的 `failed` 原因是不是「这个 gate 早就被解决了」(#110 缺陷② c 的判据)。

package/dist/hitl/parkResolver.js

@@ -1,4 +1,4 @@
-import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask } from './hitlBridge.js';
+import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, } from './hitlBridge.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -7,6 +7,38 @@ import { flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
 /** 一 turn 内最多循环这么多次 park(防御:引擎/模型病态连环提问时不无限 attach)。 */
 const MAX_GATE_HOPS = 24;
+/**
+ * 「已解决 ⇒ 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` 抛出的
@@ -51,13 +83,28 @@ function isGateFailureCode(v) {
  *  (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 false;
+        return undefined;
     const r = reason.toLowerCase();
-    return r.includes('no pending checkpoint') || r.includes('resolved') || r.includes('already') || r.includes('not found');
+    return ALREADY_RESOLVED_REASON_TOKENS.find((t) => r.includes(t));
 }
-/** 已解决判据(REF-CC-033):code 在场就只信 code,不在场才落回文案兜底(fs 审批腿的
- *  `FsApprovalOutcome` 今天没有 code 字段——C-bridge 卡域,退役条件 = 那边也补上 code)。
+/** 已解决判据(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——那不是「它不是
@@ -196,6 +243,8 @@ parkGatedCallId) {
         // 这里 instanceof 窄化后再过 isGateFailureCode 白名单——不认得的码(将来 hitlBridge 那边
         // 万一多加一种)一律降级成 undefined,退回文案兜底,不让开集腐蚀这个新判别位。
         const code = e instanceof HitlSafetyError && isGateFailureCode(e.code) ? e.code : undefined;
+        // #363:S-02 指路键原样透传 —— 与 `toolApprovalWire` 两条 decide 失败腿同形同源。
+        const currentPending = readDecideCurrentPending(e);
         return {
             kind: 'failed',
             gatedCallId,
@@ -203,6 +252,7 @@ parkGatedCallId) {
             ...(code !== undefined ? { code } : {}),
             // Inkglow-1085 P0a:ask 腿与 fs 腿同形 —— 瞬断耗尽给判别位,resolvePark 走重呈臂。
             ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+            ...(currentPending !== undefined ? { currentPending } : {}),
         };
     }
 }
@@ -210,22 +260,55 @@ parkGatedCallId) {
 function argsByCallOf(led) {
     return new Map(led.gatedStartArgs());
 }
-export async function resolvePark(park, ctx) {
-    const { deps, led, taskId, hops } = 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;
-    if (hops > MAX_GATE_HOPS) {
-        outcome = { kind: 'failed', reason: `gate hop limit (${MAX_GATE_HOPS}) exceeded` };
-    }
-    else if (park.gate === 'fs') {
-        candidateGatedCallId = led.lastFsOrShellGatedCallId();
+/**
+ * 限次闸的**判据源**(键)——「是哪一**条判据**把这一轮判成已解决的」。
+ *
+ * 🔴 键**按语义分,不按表征分**(异源复审 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) {
+    const { deps, led, taskId } = ctx;
+    if (park.gate === 'fs') {
         // [816] 放宽腿:fs 写权限 gate → CC 三选卡(vendored PermissionRequest)→ decide。
-        outcome = await surfaceFsApprovalAndDecide({ client: deps.client }, taskId, argsByCallOf(led), ctx.signal, park.gatedCallId);
+        const outcome = await surfaceFsApprovalAndDecide({ client: deps.client }, 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
@@ -236,9 +319,27 @@ export async function resolvePark(park, ctx) {
         if (outcome.kind === 'decided' && outcomeDenied === true && outcome.gatedCallId) {
             led.markDenied(outcome.gatedCallId); // 重放的报错帧渲 `User rejected …`(见 tool_end 有序臂 ③)
         }
+        return outcome;
+    }
+    return surfaceGateAndDecide(deps, taskId, argsByCallOf(led), ctx.signal, gatedCallId);
+}
+export async function resolvePark(park, ctx) {
+    // `deps` 不在本函数直读:呈卡/决断两族腿统一经 `surfaceParkGate`(#357 单源化,见其头注)。
+    const { led, taskId, hops } = 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;
+    if (hops > MAX_GATE_HOPS) {
+        outcome = { kind: 'failed', reason: `gate hop limit (${MAX_GATE_HOPS}) exceeded` };
     }
     else {
-        outcome = await surfaceGateAndDecide(deps, taskId, argsByCallOf(led), ctx.signal, park.gatedCallId);
+        if (park.gate === 'fs')
+            candidateGatedCallId = led.lastFsOrShellGatedCallId();
+        outcome = await surfaceParkGate(park, ctx, park.gatedCallId);
     }
     // #110 缺陷② b/c —— **重放的、早已决断过的 park 不是失败**。
     // durable re-attach 必然会把 park 帧再送一遍(`lastEventId` 再准也只能精确到帧,park 就在
@@ -250,10 +351,10 @@ export async function resolvePark(park, ctx) {
     // 同 session `--resume` 报 `No conversation found` ⇒ **整个会话废掉**。
     // 无限循环由 `hops > MAX_GATE_HOPS` 兜底(本 reattach 照常吃 hop 预算,不绕过它)。
     //
-    // REF-CC-034:`isAlreadyResolvedFailure` 是首选判据(code/文案双臂),但 fs 腿的
-    // `FsApprovalOutcome` 今天没有 `code`(toolApprovalWire.ts,C-bridge 域),失败原因若不是
-    // 那三个文案子串(例如 `approvals.list` 自身网络失败)就会漏判。已决断身份匹配是独立于
-    // 文案的第二判据 —— 两臂任一命中都按「已解决」处置,方向偏宽(见台账 `markDecided` 处注)。
+    // REF-CC-034:`isAlreadyResolvedFailure` 是首选判据(code/文案双臂;#357 起 fs 腿的取件码也
+    // 走 code 臂,见该函数头注的销案段)。失败原因若两臂都判不出(例如 `approvals.list` 自身网络
+    // 失败),已决断身份匹配是独立于文案的第二判据 —— 两臂任一命中都按「已解决」处置,方向偏宽
+    // (见台账 `markDecided` 处注)。
     //
     // [2393] hitl-F2(2026-08-02):这条身份判据**一次性消费**(`takeDecided` 而不是 `isDecided`)。
     // 它的正当性只覆盖「durable re-attach 把**那一次**已决断的 park 重放一遍」这一个窗口,而它的两个
@@ -261,15 +362,73 @@ export async function resolvePark(park, ctx) {
     // 不消费就等于:本 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);
     if (outcome.kind === 'failed' && (isAlreadyResolvedFailure(outcome) || alreadyDecidedById)) {
-        const seq = led.lastSeq();
-        hostLog('debug', `liveHitlAskWire: gate already resolved (${outcome.reason}) — replayed park, re-attaching runs.events(${taskId})${seq ? ` from seq ${seq}` : ''} instead of failing the turn` +
-            (alreadyDecidedById ? ` [decidedGates id match: ${candidateGatedCallId}]` : '') +
-            (led.decidedCount() > 0 ? ` [decided so far: ${led.decidedCount()}]` : ''));
-        return { kind: 'reattach' };
+        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) && hops <= MAX_GATE_HOPS
+            ? await surfaceParkGate(park, ctx, park.gatedCallId)
+            : undefined;
+        // 🔴 只有**真进展**才采信重探的结果:决断成功 / 用户 Esc / 瞬断耗尽(那一形有自己的重呈臂)。
+        //    重探自己失败(网络类、或队列确实没有可决行)⇒ **不采信**,走限次闸兜底 —— 采信的话,
+        //    一次瞬时读面故障就会把 #110 那条「重放的 park 不是失败」救回腿改判成 fail-soft(会话废掉
+        //    那条路径),代价严重不对称。
+        if (rescan !== undefined &&
+            (rescan.kind === 'decided' ||
+                rescan.kind === 'aborted' ||
+                (rescan.kind === 'failed' && rescan.retryExhausted === true))) {
+            led.resetAlreadyResolvedGate();
+            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`);
+            outcome = rescan;
+        }
+        else {
+            const streak = led.noteAlreadyResolvedGate(streakKey);
+            if (streak <= MAX_ALREADY_RESOLVED_REATTACHES) {
+                const seq = led.lastSeq();
+                hostLog('debug', `liveHitlAskWire: gate already resolved (${firstReason}) — replayed park, re-attaching runs.events(${taskId})${seq ? ` from seq ${seq}` : ''} instead of failing the turn` +
+                    (alreadyDecidedById ? ` [decidedGates id match: ${candidateGatedCallId}]` : '') +
+                    (led.decidedCount() > 0 ? ` [decided so far: ${led.decidedCount()}]` : ''));
+                return { kind: 'reattach' };
+            }
+            // ── 兜底:同因连续第 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})`;
+            hostLog('warn', `liveHitlAskWire: refusing to re-attach runs.events(${taskId}) again — ${stalled} ` +
+                `[criterion: ${streakKey}${reasonToken !== undefined ? ` via reason token "${reasonToken}"` : ''}]`);
+            outcome = {
+                kind: 'failed',
+                ...(outcome.gatedCallId !== undefined ? { gatedCallId: outcome.gatedCallId } : {}),
+                reason: stalled,
+            };
+        }
     }
     // Inkglow-1085 P0a —— **重呈臂**:decide 出站在瞬断类失败上重试一次仍未送达(两发都没拿到引擎的
     // 语义答复)。此刻 run 仍 parked、pending 行仍可决 —— 合成 `hitl_unanswered` 把 turn 判死是三条
@@ -325,6 +484,9 @@ export async function resolvePark(park, ctx) {
     //    `park.gatedCallId`(server ≥7.41.0 的 wire 身份)在场就点名摘,缺席则只在同族唯一时摘。
     //    这一行**刻意排在 `if (outcome.gatedCallId)` 之外**:身份在 wire 上时,摘不摘与 pending
     //    行给没给出 callId 无关(park 有主角,decide 也成功了)。
+    // #357:决断成功 = 判据链上的**真进展**,「已解决」的同因连续计数归零(否则一个 turn 里两只门
+    // 各带一次正当重放,第二只的重放会被第一只的计数顶成「第 2 次」而被闸掉)。
+    led.resetAlreadyResolvedGate();
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
         // 🔴 #324:**刻意不把 pending 行的 callId 当成连坐判别的主角身份**。durable `checkpointGate`

package/dist/hitl/toolApprovalWire.d.ts

@@ -77,7 +77,7 @@
  *    静默截断);真落行与否看 ack 的 `noteRecorded`(缺席 ≠ false)。
  *    🔴 方向纪律:reason/note 只做归因,绝不参与裁决;缺席 ⇒ 现状字节不变。
  */
-import { type HitlClientLike } from './hitlBridge.js';
+import { type GateCurrentPending, type HitlClientLike } from './hitlBridge.js';
 import type { RuleSuggestion, ToolApprovalRespondAck } from '@sema-agent/sdk';
 /** fs 写权限 gate 判定:未来的一等 kind(tool_approval)或按 toolName(server 桥首批=fs 写三件,
  *  [820] 表)。AskUserQuestion 永不进这里(ask 桥先判)。 */
@@ -108,12 +108,26 @@ export type FsApprovalOutcome = {
 /** `retryExhausted`(Inkglow-1085 P0a,0.37.0):decide 出站在**瞬断类**失败上重试一次仍未送达
  *  (两发都没拿到引擎的语义答复)—— 在场即真。消费方(parkResolver)据此走**重呈臂**(re-attach
  *  重放 park ⇒ 同一张卡重新交给用户),不合成 `hitl_unanswered` 判死 turn。缺席 = 语义类失败
- *  (引擎答了且拒了)或卡面失败,既有 fail-soft 语义逐字节不变。 */
+ *  (引擎答了且拒了)或卡面失败,既有 fail-soft 语义逐字节不变。
+ *  `code`(#357,0.47.0):**取件当拍队列里没有本 run 的可决行** —— `findPendingForTask` 的
+ *  结构化判别位原样透传(此前本类型没有这个位,消费点只能拿 `reason` 的文案子串猜,而
+ *  `parkResolver.isAlreadyResolvedFailure` 的头注把「fs 腿没有 code」记成了已知缺口)。
+ *  🔴 只透传取件腿那一个码:decide 失败(409/404 语义答复)不落这个位 —— 那两件事对消费点
+ *  是不同处置(前者「这一拍没有行」可以重探,后者是引擎的语义答复)。 */
+/** `currentPending`(#363,0.47.0):**decide 失败**那一类才可能带 —— server S-02(≥7.52)在
+ *  409 `approval_stale` 拒体上铸的 additive **指路键**,说的是「你手上那条已经不是当前的了,
+ *  **当前**这条长这样」。壳据此**一跳重定位**再 decide,免整队重拉。
+ *  🔴 缺席是常态,而且缺席**什么都不证明**:老 server / 非工具门 / 行读失败 / 本次失败根本
+ *     不是 stale 臂,四种情形在 wire 上同形(server 自己的 F 类留痕账逐字如此)。
+ *  🔴 它**不参与任何裁决** —— 见 `GateCurrentPending` 顶注;消费方拿它当指路,不当放行凭据。
+ *  🔴 **取件腿的 `no_pending` 恒不带这一位**:那一腿连 decide 都没发,谈不上「你决的那条过期了」。 */
  | {
     kind: 'failed';
     gatedCallId?: string | undefined;
     reason: string;
+    code?: 'no_pending' | undefined;
     retryExhausted?: true;
+    currentPending?: GateCurrentPending | undefined;
 };
 /** 本桥消费的 wire 面(liveHitlAskWire 的 AskGateWireDeps 同形切片,mock 可注入)。 */
 export interface FsApprovalWireDeps {
@@ -401,6 +415,26 @@ export interface ApprovalCardRequest {
      *    `renderUntrustedCommandText`(core 导出的展示基线)。本包只保证这一位到得了卡口。
      */
     inputHasBidi?: true;
+    /**
+     * **S-30①(0.48.0;server ≥7.53 / core 5.60.0 #438;sdk 7.4.0 起在 `PendingCheckpoint` 上声明)**
+     * —— 原样来自 **durable park 行** `PendingCheckpoint.hasBidiControls`:这条 park 行的**执行载荷**里
+     * 含至少一个 DIRECTIONAL 格式控制符(Trojan Source:人眼读到的顺序 ≠ 真正执行的字节顺序)。
+     *
+     * 🔴 **与 {@link inputHasBidi} 刻意分键不合流**(上游把名字取得不同,正是为了不让人合并):
+     *   · {@link inputHasBidi} = **同步腿**(`tool_approval` 活卡帧),server 对**帧自身序列化后的 args**
+     *     现算(E-14);
+     *   · 本键 = **durable 腿**,值**完全由 core 供**(park mint 时 `PendingAction.hasBidiControls`,
+     *     反范式成 durable 行的 `has_bidi_controls` 列;server `listPending` 读列 `=== 1` 才铸,**不重算**)。
+     *   两者是**同语义、不同源、不同算点**的两个量 ⇒ 同一只 ask 的两条腿在场性**可以不一致**,合成一位
+     *   就是拿一个量冒充另一个([same-name-different-meaning-crosses-layers])。端要渲一个徽标的话,
+     *   读**两位的并**是允许的(那是端的呈现决定),但两位在本层必须各自到货。
+     * 🔴 **缺席绝不折成 `false`**(类型 `true`,与 {@link governanceForced} / {@link inputHasBidi} 同族):
+     *   缺席 = **没检出**(干净 / core 有界扫描没够着 / 列诞生前 park 的老行),消费端**禁**读成
+     *   「已确认干净」—— 那是对用户下一个证不出的断言。
+     * 🔴 **披露位,不是清洗位;本包字节零改**:清洗会改掉即将被执行的那串字节(卡上显示的与真跑的不是
+     *   同一个东西),比不披露更坏。显形(转义/高亮/加标记)归端。
+     */
+    hasBidiControls?: true;
     /**
      * 被越级的持久 allow 规则**原文**(#144,原样来自 {@link ToolApprovalFrame.persistedRuleShadowed}
      * 的合形值)——壳据此渲「你的规则仍在,只是这次调用被要求逐次确认」;缺席 = 卡形与 0.27.0

package/dist/hitl/toolApprovalWire.js

@@ -77,7 +77,7 @@
  *    静默截断);真落行与否看 ack 的 `noteRecorded`(缺席 ≠ false)。
  *    🔴 方向纪律:reason/note 只做归因,绝不参与裁决;缺席 ⇒ 现状字节不变。
  */
-import { DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, denyReasonForWire, findPendingForTask, } from './hitlBridge.js';
+import { DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, denyReasonForWire, findPendingForTask, readDecideCurrentPending, } from './hitlBridge.js';
 import { hostLog } from '../host.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
@@ -251,8 +251,10 @@ parkGatedCallId) {
     // toolName + fs/shell 名字腿),而上面那个 `matches` 只有名字腿那半 —— 拿它当身份闸会把合法的
     // kind-only 行判出局(五审 finding①)。gateKind = 行上的扁平投影,与 gate.kind 同一权威。
     (row) => isToolApprovalGate({ kind: row.gateKind, toolName: row.toolName }));
+    // #357:取件腿的结构化判别位原样透传(见 `FsApprovalOutcome.code` 头注)——「这一拍队列里没有
+    // 本 run 的可决行」与「approvals.list 自身炸了」自此对消费点结构可分,不再靠文案子串猜。
     if (!found.ok)
-        return { kind: 'failed', reason: found.reason };
+        return { kind: 'failed', reason: found.reason, ...(found.code !== undefined ? { code: found.code } : {}) };
     const { pending, gatedCallId } = found;
     const toolName = typeof pending.toolName === 'string' ? pending.toolName : '';
     // 工具入参:优先流上 tool_start.args(完整、零额外语义);缺则 pending.input(service 已 redact+限长
@@ -293,6 +295,13 @@ parkGatedCallId) {
         callKey,
         ...(signal ? { signal } : {}),
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
+        // S-30①(0.48.0):durable 行的 bidi 披露位随卡透传。**同一个病形的第 N 例** —— 这处「行 → 卡」
+        // 重铸是闭形的,server ≥7.53 起行上就有的这一位在这里整键丢失([C170] 那次 ruleSuggestions /
+        // governanceForced 逐字同一个坐标)。本批由 durable-card 门 ⑦ 段的**富行键集普查**当天抓出
+        // (红文逐字:「无账:hasBidiControls」),不是人眼发现的。
+        // 🔴 条件 stamp **只认严格 true**,与 governanceForced / inputHasBidi 同族:上游契约是
+        //    「`true` 或缺席,恒不写 false/null」,这里认宽了就会把一个 falsy 值渲成披露。
+        ...(pending.hasBidiControls === true ? { hasBidiControls: true } : {}),
         ...(ruleOffersReadOnly !== undefined ? { ruleOffersReadOnly } : {}),
         ...(isWireRecordCarrier(durableProbeCause) ? { probeCause: durableProbeCause } : {}),
         // #348(0.44.0)durable 腿的对偶:行上**本来就存着**这个值(server `parked-decide.ts`;SDK
@@ -337,8 +346,20 @@ parkGatedCallId) {
                         // Inkglow-1085 P0a:瞬断耗尽同样**不许**回退纯 approve —— 引擎此刻根本够不着,再补一发
                         // 纯 approve 只是再烧一轮超时,还把「传输断了」错标成「老 server 不识别 remember」。
                         // 上抛给外层 catch ⇒ retryExhausted 判别位 ⇒ parkResolver 走重呈臂。
+                        // 🔴 **第三条再抛(#363,0.47.0;异源复审 [high] 采纳,真病)**:拒体带 `currentPending`
+                        // ⇒ 引擎**结构化地告诉我们**「你决的那一行已经不是当前的了,当前是这一条」——
+                        // 那和 `binding_mismatch` 是同一件事的另一种说法(人看见的那一行在他决断期间被换掉了),
+                        // 只是走的是 stale 那条码。修前它落进这条 catch-all,被当成「老 server 不识别 remember」
+                        // **并立刻用人对旧卡给的答案再发一次纯 approve** —— 正是本臂上方那条铁律禁的动作;
+                        // 而且顺带把这枚指路键吞掉(第二发若也失败,外层拍平拿到的是**第二个**错误,首发的
+                        // `currentPending` 从此不存在)。⇒ 上抛,由外层拍平臂原样带上指路键,人重新决断。
+                        // ⚠️ 边界如实说:本条只收「引擎给了指路键」这一格;「回退臂是不是应该收窄成**只**兜
+                        //    400 未知键」是**本批之前就在的**分类问题(见 §7b 登记),不在本批射程内 ——
+                        //    在一个 additive 批里悄悄改掉老引擎兼容腿的宽度,是另一种越界。
                         if (e instanceof HitlSafetyError || e instanceof DecideTransportRetryExhaustedError)
                             throw e;
+                        if (readDecideCurrentPending(e) !== undefined)
+                            throw e;
                         hostLog('debug', `liveToolApprovalWire: decide(approve+remember) failed (${String(e)}) — falling back to plain approve`);
                     }
                 }
@@ -346,12 +367,15 @@ parkGatedCallId) {
                 return { kind: 'decided', gatedCallId };
             }
             catch (e) {
+                // #363:S-02 指路键原样透传(读不出 ⇒ 键不铸,形状逐字节不变)。见 FsApprovalOutcome 同名位。
+                const currentPending = readDecideCurrentPending(e);
                 return {
                     kind: 'failed',
                     gatedCallId,
                     reason: `decide(approve) failed: ${String(e)}`,
                     // Inkglow-1085 P0a:瞬断耗尽的判别位(在场即真)—— 语义失败缺席,reason 字节不变。
                     ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                    ...(currentPending !== undefined ? { currentPending } : {}),
                 };
             }
         case 'deny':
@@ -364,11 +388,14 @@ parkGatedCallId) {
                 return { kind: 'decided', gatedCallId, denied: true };
             }
             catch (e) {
+                // #363:与 allow 臂**同形同源**(同形存量清剿:两条 decide 失败腿一次改齐,不许只修当格)。
+                const currentPending = readDecideCurrentPending(e);
                 return {
                     kind: 'failed',
                     gatedCallId,
                     reason: `decide(deny) failed: ${String(e)}`,
                     ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                    ...(currentPending !== undefined ? { currentPending } : {}),
                 };
             }
     }

package/dist/index.d.ts

@@ -138,6 +138,7 @@ export * from './notifications.js';
 export * from './steering.js';
 export * from './diagnostics.js';
 export * from './retryStatus.js';
+export * from './sessionMemoryStatus.js';
 export * from './adapt.js';
 export * from './subagentContentStore.js';
 export * from './engineAgentPanelStore.js';
@@ -237,6 +238,7 @@ export * from './hitl/resumeRunningCard.js';
 export * from './hitl/persistedRulesWire.js';
 export * from './hitl/localAllowRule.js';
 export * from './hitl/approvalsFeed.js';
+export * from './interactiveHalt.js';
 export * from './compensations.js';
 export * from './request/printNotification.js';
 export * from './seatContract.js';