@sema-agent/client-core 0.35.0 → 0.37.0

package/dist/hitl/hitlBridge.js

@@ -1,6 +1,7 @@
 import { askParkForeignGateKind } from '../adapter/activeRunSelfHeal.js';
 import { eventSeq } from '../adapter/types.js';
 import { hostLog } from '../host.js';
+import { abortableSleep } from '../abortableSleep.js';
 // ── deny/plan-review 归因的 wire 窄化(0.28.0 发版扫描 F1/F2/F3 收编;单源,三条腿共用)──────
 //
 // server 对 `/decide` 与 plan-review 两条腿的 `reason` 同限 `MAX_APPROVAL_REASON_CHARS`(4096 字符,
@@ -52,6 +53,111 @@ export class HitlSafetyError extends Error {
         this.name = 'HitlSafetyError';
     }
 }
+// ── decide 出站的瞬断分诊与有界重试(Inkglow-1085 P0a,2026-08-19;[4664] server 定谳后对表)────
+//
+// 病形(案卷 INKGLOW-1085 车1 全链):`approvals.decide` 是**非 submit POST** —— SDK transport 对它
+// `maxAttempts = 1`(「a decide must not double-act」),且每发带显式 `AbortSignal.timeout(timeoutMs)`
+// (缺省 60s;per-call opts 只有 `signal`,调用方 signal 与之**合流取先**,只能收短、不能放长 ——
+// timeoutMs 是 client 构造级旋钮,本包对已构造的注入 client 不可配)。于是一次网络瞬断/超时 =
+// decide 单发即死 → 上层拼 `failed` → parkResolver 合成 `hitl_unanswered` 终帧 → ask 死局。
+//
+// 🔴 [4664] server 定谳的真因与过渡期口径(2026-08-19):60s 超时**结构性必炸** —— legacy 任务级
+// decide 腿(`/v1/approvals/:sessionId/decide`)在响应前**同步跑整条 resume**(模型往返,无上限);
+// server 立件 #316 改快速 ack,过渡期口径 = **壳把这条腿当长调用处理(预期上限无界)**。SDK 的
+// per-attempt 60s 帽对注入 client 不可配(调用面只有 signal,合流只能收短)⇒ 本层的消化形:
+//   · **超时类**(TimeoutError = 60s 帽掐断,server 多半仍在跑 resume)⇒ 带退避**继续重试**,
+//     总窗 {@link DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS}(10 分钟级 —— 长调用口径);
+//   · **网络断类**(ECONNREFUSED / fetch failed 等:连语义答复都没拿到,引擎多半真死)⇒ 重试
+//     **恰一次**,让真死尽快显形;
+//   · 语义答复类(带 HTTP status 的 4xx/5xx —— 引擎收到并回答了)⇒ 零重试,原样上抛;
+//   · `HitlSafetyError`(binding mismatch 等安全信号)⇒ 恒零重试(§9.1 铁律,原有行为不动);
+//   · 调用方已中止(用户 Esc)⇒ 零重试(AbortError 是人按的,不是瞬断)。
+//
+// 🔴 为什么重试不违反「decide 绝不 double-act」:①[4664] 原话 —— **重复 decide 不双跑,server CAS
+// 保证**(重试幂等安全,放心重试);②D-1 绑定回显(boundCallId+boundInputHash 逐字回显,server
+// fail-closed on mismatch)—— 第一发其实送达时,重发只能撞 4xx(approval not found / conflict),
+// 绝不可能批掉**另一件**事;那个 4xx 原样上抛,parkResolver 的「已解决重放救回」判据照认。
+// 重试耗尽(超时类窗尽 / 网络断类第二发仍断)⇒ 抛 {@link DecideTransportRetryExhaustedError}
+// (typed 判别位)—— 消费方(toolApprovalWire / parkResolver)据此走**重呈臂**而不是把 turn 判死。
+// 引擎真死时失败也会尽快显形:重呈臂的下一步(approvals.list / runs.events)对死引擎当场失败,
+// 走既有诚实红。
+// 🔴 请托半场(候黑板):SDK decide 若开 per-call timeoutMs(或对 HITL 面单列长缺省),本层的
+// 超时类重试环可整段收敛成一发长等待;#316 落地(快速 ack)后总窗也可回收。
+/** 瞬断重试的起始退避(×2 递增,封顶 {@link DECIDE_RETRY_BACKOFF_MAX_MS};别把 decide 打成连发)。 */
+const DECIDE_TRANSPORT_RETRY_BACKOFF_MS = 750;
+const DECIDE_RETRY_BACKOFF_MAX_MS = 5_000;
+/** 超时类重试的总窗([4664] 长调用口径:legacy decide 腿同步跑整条 resume,60s 帽结构性必炸;
+ *  每发本身就要跑满 SDK 的 60s 帽,10 分钟 ≈ 9 发 —— 覆盖长 resume 而不至于无限吊死)。
+ *  🔴 窗的语义是**不再起新发**,刻意不掐在飞那一发(codex 复审议题,驳回后成文):给一发可能已被
+ *  server 受理的 decide 塞截止 signal 换不来任何安全 —— server 侧照跑,客户端只多制造一个「送达
+ *  未知」;上冲上界 = 一发(SDK 60s 帽)+ 一拍退避,可预算。 */
+const DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS = 10 * 60_000;
+let decideTimeoutRetryBudgetOverrideMs;
+/** 测试钩:把超时类重试总窗调小(传 undefined 还原缺省)。 */
+export function __setDecideTimeoutRetryBudgetForTests(ms) {
+    decideTimeoutRetryBudgetOverrideMs = ms;
+}
+function decideTimeoutRetryBudgetMs() {
+    return decideTimeoutRetryBudgetOverrideMs ?? DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS;
+}
+/** 超时类判别(自身或 cause 链上的 TimeoutError —— SDK per-attempt `AbortSignal.timeout` 的产物;
+ *  [4664] 口径下它多半意味着 server 仍在同步跑 resume,不是引擎死了)。 */
+function isDecideAttemptTimeout(e, depth = 0) {
+    if (depth > 3 || e === null || typeof e !== 'object')
+        return false;
+    const o = e;
+    if (o.name === 'TimeoutError')
+        return true;
+    return isDecideAttemptTimeout(o.cause, depth + 1);
+}
+/** 瞬断类网络错误码(自身或 cause 链上;undici 的 fetch failed 把真因挂在 cause)。 */
+const TRANSIENT_NETWORK_CODES = new Set([
+    'ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN',
+    'ENETUNREACH', 'EHOSTUNREACH', 'ECONNABORTED',
+    'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT', 'UND_ERR_SOCKET',
+]);
+/**
+ * decide 出站失败的瞬断判别(module 私有 —— 唯一消费点是 {@link HitlBridge} 的 decide choke point)。
+ * 🔴 方向:判不出一律**非瞬断**(fail 到「不重试」侧 —— 语义拒绝被误判成瞬断才是真事故:那会把
+ * 一次已被拒绝的决断再发一遍)。带数字 `status` 的错误 = 引擎**答了**,无论 4xx/5xx 都不是瞬断。
+ */
+function isTransientDecideTransportFailure(e, depth = 0) {
+    if (depth > 3 || e === null || typeof e !== 'object')
+        return false;
+    if (e instanceof HitlSafetyError)
+        return false;
+    const o = e;
+    if (typeof o.status === 'number')
+        return false;
+    if (o.name === 'TimeoutError' || o.name === 'AbortError')
+        return true;
+    if (typeof o.code === 'string' && TRANSIENT_NETWORK_CODES.has(o.code))
+        return true;
+    if (typeof o.message === 'string' && o.message.toLowerCase().includes('fetch failed'))
+        return true;
+    return isTransientDecideTransportFailure(o.cause, depth + 1);
+}
+/**
+ * decide 出站在瞬断类失败上重试一次**仍未送达**(两发都没拿到引擎的语义答复)。
+ *
+ * 🔴 判别位契约:消费方(`toolApprovalWire` 的 catch 臂 / `parkResolver.surfaceGateAndDecide`)
+ * 据 `instanceof` 在 outcome 上 stamp `retryExhausted: true`,parkResolver 对该位走**重呈臂**
+ * (re-attach ⇒ durable 流重放 park ⇒ 同一张卡重新交给用户),不再合成 `hitl_unanswered` 把 turn
+ * 判死 —— run 仍 parked、pending 行仍可决,判死是三条出路里唯一不可逆的那条。
+ * 🔴 message 刻意避开 `isAlreadyResolvedGateReason` 的词表(no pending checkpoint / resolved /
+ * already / not found):被那把兜底尺误判成「已解决」会走成静默 reattach,判别位就白铸了 ——
+ * pure 门(hitl-gate-honesty F6-d)有常驻负控钉着这一条。
+ */
+export class DecideTransportRetryExhaustedError extends Error {
+    attempts;
+    constructor(
+    /** 实际发出的次数(网络断类 = 2:首发 + 单次重试;超时类 = 总窗内发出的全部)。 */
+    attempts, lastFailureText) {
+        super(`decide did not reach the engine after ${attempts} attempts (transient transport failure): ${lastFailureText}`);
+        this.attempts = attempts;
+        this.name = 'DecideTransportRetryExhaustedError';
+    }
+}
 /**
  * The single source for "which `PendingCheckpoint` row is the human about to decide on", used by the two
  * decision wires (`toolApprovalWire.surfaceFsApprovalAndDecide` / `askGateWire.surfaceGateAndDecide`)
@@ -323,19 +429,57 @@ export class HitlBridge {
     }
     // ── decide transport (the single choke point; maps 409 binding mismatch → safety stop) ──
     async decideRaw(sessionId, decision, opts) {
-        try {
-            const r = await this.client.approvals.decide(sessionId, decision, opts);
-            // A successful decide resumes the SAME durable stream; the gate clears on the next running arm.
-            this.active = null;
-            return r;
-        }
-        catch (e) {
-            if (isBindingMismatch(e)) {
-                // contract/04 §2.2 / §9.1: a binding mismatch means the pending action changed under the human.
-                // SAFETY signal — re-present to the human, NEVER auto-retry / auto-re-decide.
-                throw new HitlSafetyError('approval_binding_mismatch — the pending action changed under the human; refetch + re-present', 'binding_mismatch');
+        // Inkglow-1085 P0a([4664] 对表后形):瞬断类失败带退避有界重试 —— 超时类按长调用总窗,
+        // 网络断类恰一次;为什么重试不违反「decide 绝不 double-act」、哪些失败绝不重试,见文件上方
+        // DECIDE_TRANSPORT_RETRY 段总注。
+        // 🔴 经函数读 aborted(waitForClaimRelease.isAborted 同注):它在 await 两侧会变,直接读两次
+        // 会被 tsc 控制流分析把第二次窄成恒假比较(TS2367)。
+        const callerAborted = () => opts?.signal?.aborted === true;
+        const startedAt = Date.now();
+        let attempts = 0;
+        let netRetriesUsed = 0;
+        let backoff = DECIDE_TRANSPORT_RETRY_BACKOFF_MS;
+        for (;;) {
+            attempts++;
+            try {
+                const r = await this.client.approvals.decide(sessionId, decision, opts);
+                // A successful decide resumes the SAME durable stream; the gate clears on the next running arm.
+                this.active = null;
+                return r;
+            }
+            catch (e) {
+                if (isBindingMismatch(e)) {
+                    // contract/04 §2.2 / §9.1: a binding mismatch means the pending action changed under the human.
+                    // SAFETY signal — re-present to the human, NEVER auto-retry / auto-re-decide.
+                    throw new HitlSafetyError('approval_binding_mismatch — the pending action changed under the human; refetch + re-present', 'binding_mismatch');
+                }
+                // 调用方已中止(用户 Esc)⇒ 这个 AbortError 是人按的,不是瞬断 —— 原错上抛,零重试。
+                if (!isTransientDecideTransportFailure(e) || callerAborted())
+                    throw e;
+                if (isDecideAttemptTimeout(e)) {
+                    // [4664] 长调用口径:60s 帽掐断 ≠ 引擎死了 —— legacy decide 腿在响应前同步跑整条 resume。
+                    // 重复 decide 由 server CAS 保证不双跑:server 已受理时,下一发要么等到快速答复(conflict/
+                    // not-found ⇒ 上抛,已解决判据接手),要么继续被长调用吃满 60s —— 总窗兜底。
+                    if (Date.now() - startedAt >= decideTimeoutRetryBudgetMs()) {
+                        throw new DecideTransportRetryExhaustedError(attempts, String(e));
+                    }
+                }
+                else if (netRetriesUsed >= 1) {
+                    // 网络断类(连语义答复都没有)重试恰一次 —— 引擎真死时让失败尽快显形。
+                    throw new DecideTransportRetryExhaustedError(attempts, String(e));
+                }
+                else {
+                    netRetriesUsed++;
+                }
+                hostLog('debug', `hitlBridge: decide transport failure (transient: ${String(e)}) — retrying after ${backoff}ms ` +
+                    `(attempt ${attempts}; duplicate decide is CAS-safe per [4664] and the D-1 binding echo makes it ` +
+                    'at-most-once-effective: a landed first shot turns the retry into a 4xx, never a second act)');
+                await abortableSleep(backoff, opts?.signal ?? new AbortController().signal);
+                backoff = Math.min(backoff * 2, DECIDE_RETRY_BACKOFF_MAX_MS);
+                // 退避期间被中止 ⇒ 不再补发(abortableSleep 对 abort 是提前 resolve,不抛)。
+                if (callerAborted())
+                    throw e;
             }
-            throw e;
         }
     }
 }

package/dist/hitl/parkResolver.d.ts

@@ -45,6 +45,7 @@ export type GateOutcome = {
     gatedCallId?: string | undefined;
     reason: string;
     code?: GateFailureCode | undefined;
+    retryExhausted?: true;
 };
 /**
  * decide 的 `failed` 原因是不是「这个 gate 早就被解决了」(#110 缺陷② c 的判据)。

package/dist/hitl/parkResolver.js

@@ -1,4 +1,4 @@
-import { HitlBridge, HitlSafetyError, findPendingForTask } from './hitlBridge.js';
+import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask } from './hitlBridge.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -179,7 +179,14 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal) {
         // 这里 instanceof 窄化后再过 isGateFailureCode 白名单——不认得的码(将来 hitlBridge 那边
         // 万一多加一种)一律降级成 undefined,退回文案兜底,不让开集腐蚀这个新判别位。
         const code = e instanceof HitlSafetyError && isGateFailureCode(e.code) ? e.code : undefined;
-        return { kind: 'failed', gatedCallId, reason: `decide failed: ${String(e)}`, ...(code !== undefined ? { code } : {}) };
+        return {
+            kind: 'failed',
+            gatedCallId,
+            reason: `decide failed: ${String(e)}`,
+            ...(code !== undefined ? { code } : {}),
+            // Inkglow-1085 P0a:ask 腿与 fs 腿同形 —— 瞬断耗尽给判别位,resolvePark 走重呈臂。
+            ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+        };
     }
 }
 /** 台账里那批 gated `tool_start` 当拍 args 快照 → 决断腿要的 `toolCallId → args` 表(UNTRUSTED 原样搬运)。 */
@@ -247,6 +254,19 @@ export async function resolvePark(park, ctx) {
             (led.decidedCount() > 0 ? ` [decided so far: ${led.decidedCount()}]` : ''));
         return { kind: 'reattach' };
     }
+    // Inkglow-1085 P0a —— **重呈臂**:decide 出站在瞬断类失败上重试一次仍未送达(两发都没拿到引擎的
+    // 语义答复)。此刻 run 仍 parked、pending 行仍可决 —— 合成 `hitl_unanswered` 把 turn 判死是三条
+    // 出路里唯一不可逆的那条,只配给「引擎答了且拒了」的语义失败。这里改走 reattach:durable 流对
+    // suspended run 必然把 park 帧再送一遍(#110 已解决重放同一条机械路径),于是**同一张卡重新交给
+    // 用户**(重呈的呈现就是卡本身,归端零新 UI);hop 预算照吃(每轮都要人再答一次,不会空转)。
+    // 引擎真死时失败也尽快显形:下一轮的 approvals.list / runs.events 对死引擎当场失败,walks 既有
+    // 诚实红(reason 是 approvals.list failed,不带 retryExhausted ⇒ 不再进本臂)。
+    if (outcome.kind === 'failed' && outcome.retryExhausted === true) {
+        const seq = led.lastSeq();
+        hostLog('debug', `liveHitlAskWire: decide transport retries exhausted (${outcome.reason}) — re-presenting the gate via ` +
+            `re-attach runs.events(${taskId})${seq ? ` from seq ${seq}` : ''} instead of failing the turn (the run is still parked and the pending row is still decidable)`);
+        return { kind: 'reattach' };
+    }
     if (outcome.kind !== 'decided') {
         hostLog('debug', `liveHitlAskWire: gate not decided (${outcome.kind}${'reason' in outcome ? `: ${outcome.reason}` : ''}) — fail-soft to suspended terminal`);
         const events = [...led.flushHeld()]; // 回退:毒化帧照旧渲染(= 修复前的诚实红)

package/dist/hitl/toolApprovalWire.d.ts

@@ -104,10 +104,16 @@ export type FsApprovalOutcome = {
 } | {
     kind: 'aborted';
     gatedCallId?: string | undefined;
-} | {
+}
+/** `retryExhausted`(Inkglow-1085 P0a,0.37.0):decide 出站在**瞬断类**失败上重试一次仍未送达
+ *  (两发都没拿到引擎的语义答复)—— 在场即真。消费方(parkResolver)据此走**重呈臂**(re-attach
+ *  重放 park ⇒ 同一张卡重新交给用户),不合成 `hitl_unanswered` 判死 turn。缺席 = 语义类失败
+ *  (引擎答了且拒了)或卡面失败,既有 fail-soft 语义逐字节不变。 */
+ | {
     kind: 'failed';
     gatedCallId?: string | undefined;
     reason: string;
+    retryExhausted?: true;
 };
 /** 本桥消费的 wire 面(liveHitlAskWire 的 AskGateWireDeps 同形切片,mock 可注入)。 */
 export interface FsApprovalWireDeps {
@@ -268,6 +274,28 @@ export interface ApprovalCardRequest {
      * UNTRUSTED-for-display:只渲染,绝不回喂模型/工具入参。
      */
     ruleEvidence?: unknown;
+    /**
+     * 安全类 ask 出身位(#283,0.36.0;server ≥7.33.0 / core 5.37)——原样来自
+     * {@link ToolApprovalFrame.requiresRealApproval}(**单源:活卡帧腿**;durable 行腿今天无对偶,
+     * 见帧上同名键的 JSDoc 末段)。在场 = 这只 ask **拒绝 blanket-allow**:一切自动放行必须让位
+     * (含记住的规则、`allow_session`、bypass 姿态)——那正是[4390]③ 预埋壳侧读器时写死的消费语义。
+     * 缺席 = 这不是一次安全类 ask / 老 server(两者同形,不猜),卡形与 0.35.0 字节不变。
+     *
+     * 🔴 **缺席绝不折成 `false`**(类型 `true` 而非 `boolean`,与 {@link governanceForced} 同族纪律):
+     * 折成 false 会把「没有证据」渲成「已确认这是普通 ask」,而这一位的整个存在理由就是不让自动放行
+     * 在安全类门上悄悄生效。
+     * 🔴 **与 {@link governanceForced} 分键不合流**:那位答「门是运维治理层下的」,本位答「引擎侧安全
+     * 策略/hook 判这门必须真人过目」。两句话对用户的下一步建议不同(改不改 permissionMode),
+     * 合并即谎报出身。
+     * 🔴 **展示 + 放行闸,不是裁决输入**:它不改变本次决断的任何字节,只约束宿主**自动**决断的资格;
+     * 人真按下的 allow 仍是 allow。
+     * 🔴 **分工写死,别把「包搬运了」读成「包挡住了」**:本包只保证这一位**到得了卡口**,
+     * 它**不**改写、不否决、也不收窄你回给 wire 的决断动词 —— `surfaceToolApprovalFrameAndRespond`
+     * 对 {@link ApprovalCardDecision} 的映射与 0.35.0 逐字节相同。⇒ 「在场时不要走自动放行」「在场时
+     * 卡上要不要还给人一个会话级选项」这两条策略**属于宿主**,包不替你执行;要它变成包级强制,是一次
+     * **行为面**改动(会改到人已按下的决断的字节),按宪法三问单独立项,不在本过境批内。
+     */
+    requiresRealApproval?: true;
 }
 /**
  * 🔴 **拆缝口** —— 弹「三选卡」并等人的决断。壳 = vendored CC `PermissionRequest`;
@@ -325,9 +353,18 @@ export interface ToolApprovalFrame {
      *  lane 的 ask 出此键(宿主自身 ask 的 sourceTaskId=sessionId 已在 server 侧收口不上帧)。
      *  ⚠️ 值=子代 sessionId 非 a… handle(fence 实测 2026-07-23)——不是 fleet 台账键。 */
     sourceTaskId?: string;
-    /** core 1.378 RB-39②([1550]):Runner 填充的只读显式判别键——委派子代 gate 的 ask 恒带,
-     *  受信 internals 事实不可伪造。在场即子代(优先于 sourceTaskId 权宜式);候 server 帧透传班车。 */
-    fromSubagent?: boolean;
+    /**
+     * core 1.378 RB-39②([1550]):Runner 填充的只读显式判别键——委派子代 gate 的 ask 恒带,
+     * 受信 internals 事实不可伪造。在场即子代(优先于 sourceTaskId 权宜式)。
+     *
+     * 🔴 **字面 `true` 不是 `boolean`**(#307 双扫 S47,2026-08-19;SDK 7.1.0/7.2.0
+     * `dist/resources/tool-approvals.d.ts` 的 `fromSubagent?: true` 逐字)——与本 interface 上
+     * `governanceForced?: true` / `requiresRealApproval?: true` 同族的**在场即真**键:
+     * wire 上只有「在场」与「缺席」两态,`false` 根本不是合法取值。此前这里写 `boolean` 是本仓
+     * 自铸的宽形,把一个不存在的第三态写进了契约。
+     * 缺席 = **没有显式判别证据**(不是「明确不是子代」),读法见 {@link isFromSubagent}。
+     */
+    fromSubagent?: true;
     /** core 1.378 RB-39②:展示身份(UNTRUSTED-for-display,server redact 后上帧)——徽章名一手源。 */
     sourceAgentName?: string;
     /**
@@ -433,6 +470,30 @@ export interface ToolApprovalFrame {
      * 端呈前消毒,只渲染绝不回喂模型/工具入参。
      */
     ruleEvidence?: unknown;
+    /**
+     * server ≥7.33.0(#283,core 5.37 起铸;**ADDITIVE**,`"tool_approval"` only。来源锚 = engine fixture
+     * `@sema-agent/server/dist/tool-approval.d.ts` 的同名键)——这只 ask 是一次**安全类** ask:
+     * 它**拒绝 blanket-allow**。出身是 core 自己的两条安全策略(`createUnverifiableDeletePolicy` /
+     * `createTranscriptIntegrityPolicy`)与 PreToolUse hook 族在 `AskRequest.requiresRealApproval` 上铸的位。
+     *
+     * 🔴 **契约 = 真才带,缺席绝不编 `false`**({@link governanceForced} 同形,故类型是 `true` 而不是
+     * `boolean`):缺席 = 这不是一次安全类 ask —— 那是**正常的否定形**,不是坏形、也不是「老 server」的
+     * 同义词(两者今天同形,不猜)。
+     * 🔴 **与卡内那一位的在场契约刻意不同、别混**(server `ApprovalCardSchema` 顶注逐字):durable
+     * `ApprovalCard.risk.requiresRealApproval` 是**恒在布尔**(投影层已把缺席按 `=== true` 归一化),
+     * 而本键走帧顶层、只在为真时在场。⇒ 「帧上没有」与「卡上是 false」是两条不同的陈述,别互相推导。
+     * 🔴 **与 {@link governanceForced} 刻意分列不合并**:那个键答「门是谁下的」(运维治理层
+     * AUTONOMY/commandPolicy/守卫集),本键答「这门为什么掀不掉」(引擎侧安全类策略/hook 出身)。
+     * 合并会让任一方谎报出身 —— 而消费端对这两句话的正确反应不同:治理位该劝「别去改
+     * permissionMode」,本位该劝「这一次必须真人过目,记住的规则与 bypass 姿态都让位」。
+     * 🔴 本键**领先** SDK 运行期锚一代(sdk 7.1.0 的 `TOOL_APPROVAL_FRAME_KEYS` 尚无)⇒ 对账门
+     * (run-approval-frame-keys-test.mjs)AHEAD_OF_ANCHOR 带退出条件登记,#144 `persistedRuleShadowed`
+     * 与 #280 `probeCause` 同形先例:SDK 锚补上当天登记自红逼删。
+     * 耐久路今天**无对偶**(sdk 7.1.0 的 `PendingCheckpoint` / `riskDescriptor` 均未声明本键;server 侧
+     * 那份在**卡内** `risk` 子树,不是行上的键)⇒ durable 行 → 卡那条腿不 stamp,行为钉在
+     * run-durable-card-display-keys-test.mjs ⑨ 段;上游补位后按 {@link probeCause} 的双源合流形跟批。
+     */
+    requiresRealApproval?: true;
 }
 /** {@link ToolApprovalFrame.delegation} 的形(命名形,不用内联匿名 —— typeshape 门 B4 棘轮口径)。 */
 export interface ToolApprovalDelegation {
@@ -448,9 +509,29 @@ export interface ToolApprovalDelegation {
  * `TOOL_APPROVAL_FRAME_KEYS` 比对——SDK additive 增键时对账当天红,不再人肉追平。
  * 下面两个类型钉保证镜像与 interface 本身不可能漂移(少键/多键都是编译错)。
  */
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleSuggestions", "persistedRuleShadowed", "probeCause", "ruleEvidence", "delegation", "outcome"];
-/** 子代帧判别:显式键 fromSubagent(core 1.378 RB-39②)优先;缺席退 sourceTaskId 在场性权宜式
- *  (server 1.258 [1549]①3,旧代际兼容)。 */
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleSuggestions", "persistedRuleShadowed", "probeCause", "ruleEvidence", "requiresRealApproval", "delegation", "outcome"];
+/**
+ * 子代帧判别:显式键 fromSubagent(core 1.378 RB-39②)优先;缺席退 sourceTaskId 在场性权宜式
+ * (server 1.258 [1549]①3,旧代际兼容)。
+ *
+ * 🔴 **`=== true` 是在场判别,不是布尔求值**(#307 S47 复核结论,2026-08-19)。`fromSubagent`
+ * 的 wire 形是 `?: true`(见上方声明),所以运行期只可能是 `true` 或缺席;一个**显式 `false`**
+ * 只能来自注入面或不合契约的实现,它承载的信息是「这个载体不合契约」,**不是**「引擎明确判定不是
+ * 子代」。故这里刻意**不**把 `false` 当成否定证据:它与缺席同档 —— 落回 `sourceTaskId` 在场性
+ * 那条旧代际权宜臂。
+ *
+ * 为什么这个方向是对的(而不是「显式 false ⇒ 直接 return false」):
+ *   · 本判据的**唯一消费面是展示归属**(`workerBadge` 徽章 + `delegation` 出处链,见下方卡口),
+ *     不参与任何放行/收窄决策 —— 两个方向的代价不对称:多一枚徽章只是噪声,少一枚徽章是把
+ *     「这是子代发起的」这条事实对用户藏起来;
+ *   · `sourceTaskId` 本身就是 server 只对后台子代 lane 才出的键(见其声明),它在场是**独立的**
+ *     子代证据。让一个不合契约的 `false` 去否决一条独立成立的证据,等于让注入面拿到一个
+ *     「隐藏子代身份」的开关;
+ *   · 与本文件 `governanceForced` 的「缺席 ≠ false」同族纪律:在场即真的键上,非 `true` 一律读作
+ *     「没有这条证据」,而不是「有一条相反的证据」。
+ * 反漂移:类型侧 `?: true` 已让**编译期**的显式 false 不可能构造;本臂守的是运行期(wire/注入面)
+ * 的越界载体,pure 门有对应负控(`fromSubagent:false` + sourceTaskId 在场 ⇒ 仍判子代)。
+ */
 export declare function isFromSubagent(frame: ToolApprovalFrame): boolean;
 /** 三选卡决断 → respond 端点的 wire 枚举(server parseToolApprovalDecision)。 */
 export type ToolApprovalRespondDecision = 'allow' | 'allow_session' | 'deny';

package/dist/hitl/toolApprovalWire.js

@@ -77,7 +77,7 @@
  *    静默截断);真落行与否看 ack 的 `noteRecorded`(缺席 ≠ false)。
  *    🔴 方向纪律:reason/note 只做归因,绝不参与裁决;缺席 ⇒ 现状字节不变。
  */
-import { DEFAULT_DENY_REASON, HitlBridge, HitlSafetyError, denyReasonForWire, findPendingForTask, } from './hitlBridge.js';
+import { DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, denyReasonForWire, findPendingForTask, } from './hitlBridge.js';
 import { hostLog } from '../host.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
@@ -305,7 +305,10 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                         // binding 不匹配意味着「人看见的那一行在他决断期间被换掉了」,自动重试等于替人对一件
                         // 他没看过的事按了 Yes。`no_pending` 同族(那一行已经没了,重试同样只会再失败一次)。
                         // 上抛给外层 catch ⇒ typed `failed` ⇒ 调用方走 fail-soft 诚实红,由人重新决断。
-                        if (e instanceof HitlSafetyError)
+                        // Inkglow-1085 P0a:瞬断耗尽同样**不许**回退纯 approve —— 引擎此刻根本够不着,再补一发
+                        // 纯 approve 只是再烧一轮超时,还把「传输断了」错标成「老 server 不识别 remember」。
+                        // 上抛给外层 catch ⇒ retryExhausted 判别位 ⇒ parkResolver 走重呈臂。
+                        if (e instanceof HitlSafetyError || e instanceof DecideTransportRetryExhaustedError)
                             throw e;
                         hostLog('debug', `liveToolApprovalWire: decide(approve+remember) failed (${String(e)}) — falling back to plain approve`);
                     }
@@ -314,7 +317,13 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                 return { kind: 'decided', gatedCallId };
             }
             catch (e) {
-                return { kind: 'failed', gatedCallId, reason: `decide(approve) failed: ${String(e)}` };
+                return {
+                    kind: 'failed',
+                    gatedCallId,
+                    reason: `decide(approve) failed: ${String(e)}`,
+                    // Inkglow-1085 P0a:瞬断耗尽的判别位(在场即真)—— 语义失败缺席,reason 字节不变。
+                    ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                };
             }
         case 'deny':
             try {
@@ -326,7 +335,12 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                 return { kind: 'decided', gatedCallId, denied: true };
             }
             catch (e) {
-                return { kind: 'failed', gatedCallId, reason: `decide(deny) failed: ${String(e)}` };
+                return {
+                    kind: 'failed',
+                    gatedCallId,
+                    reason: `decide(deny) failed: ${String(e)}`,
+                    ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                };
             }
     }
 }
@@ -370,6 +384,11 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     // ⚠️ 与上面两例**不同形**:sdk 7.1.0 的运行期锚**已经含**本键(node 直读实证)⇒ 这是一次**追平**,
     // 不是领先,故**不**进 AHEAD_OF_ANCHOR(往那张表里塞一个锚已有的键,它的第二条退出条件当场红)。
     'ruleEvidence',
+    // #283(client-core 0.36.0):server 7.33.0 起真发 `requiresRealApproval`(core 5.37 铸的安全类 ask
+    // 出身位,投到帧顶层)。⚠️ 与 `ruleEvidence` **不同形**、与 `persistedRuleShadowed`/`probeCause` 同形:
+    // sdk 7.1.0 的运行期锚**尚无**本键(node 直读实证:锚 17 项)⇒ 这是一次**领先**,进对账门的
+    // AHEAD_OF_ANCHOR 带退出条件登记(SDK 追平当天那条登记自红逼删,回到逐元素相等)。
+    'requiresRealApproval',
     'delegation',
     'outcome',
 ];
@@ -398,8 +417,28 @@ function isToolApprovalDelegation(v) {
         return false;
     return d.agentName === undefined || typeof d.agentName === 'string';
 }
-/** 子代帧判别:显式键 fromSubagent(core 1.378 RB-39②)优先;缺席退 sourceTaskId 在场性权宜式
- *  (server 1.258 [1549]①3,旧代际兼容)。 */
+/**
+ * 子代帧判别:显式键 fromSubagent(core 1.378 RB-39②)优先;缺席退 sourceTaskId 在场性权宜式
+ * (server 1.258 [1549]①3,旧代际兼容)。
+ *
+ * 🔴 **`=== true` 是在场判别,不是布尔求值**(#307 S47 复核结论,2026-08-19)。`fromSubagent`
+ * 的 wire 形是 `?: true`(见上方声明),所以运行期只可能是 `true` 或缺席;一个**显式 `false`**
+ * 只能来自注入面或不合契约的实现,它承载的信息是「这个载体不合契约」,**不是**「引擎明确判定不是
+ * 子代」。故这里刻意**不**把 `false` 当成否定证据:它与缺席同档 —— 落回 `sourceTaskId` 在场性
+ * 那条旧代际权宜臂。
+ *
+ * 为什么这个方向是对的(而不是「显式 false ⇒ 直接 return false」):
+ *   · 本判据的**唯一消费面是展示归属**(`workerBadge` 徽章 + `delegation` 出处链,见下方卡口),
+ *     不参与任何放行/收窄决策 —— 两个方向的代价不对称:多一枚徽章只是噪声,少一枚徽章是把
+ *     「这是子代发起的」这条事实对用户藏起来;
+ *   · `sourceTaskId` 本身就是 server 只对后台子代 lane 才出的键(见其声明),它在场是**独立的**
+ *     子代证据。让一个不合契约的 `false` 去否决一条独立成立的证据,等于让注入面拿到一个
+ *     「隐藏子代身份」的开关;
+ *   · 与本文件 `governanceForced` 的「缺席 ≠ false」同族纪律:在场即真的键上,非 `true` 一律读作
+ *     「没有这条证据」,而不是「有一条相反的证据」。
+ * 反漂移:类型侧 `?: true` 已让**编译期**的显式 false 不可能构造;本臂守的是运行期(wire/注入面)
+ * 的越界载体,pure 门有对应负控(`fromSubagent:false` + sourceTaskId 在场 ⇒ 仍判子代)。
+ */
 export function isFromSubagent(frame) {
     if (frame.fromSubagent === true)
         return true;
@@ -617,6 +656,11 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         // 🔴 呈现谓词归端(无治理部署下每只 ask 都带全具名缺席,[4050] live 实测 / [4051] 定性);
         //    本层若替端做「全 not_wired 就别给了」的过滤,就是替引擎把一条真事实湮灭掉。
         ...(isWireRecordCarrier(frame.ruleEvidence) ? { ruleEvidence: frame.ruleEvidence } : {}),
+        // #283(0.36.0):安全类 ask 出身位透传([4390]③ 请托的正位解 —— 壳侧读器早已预埋,缺的一直是
+        // 包边界这一格)。条件 stamp **只认严格 true**,与 governanceForced 同一条纪律:缺席的语义是
+        // 「这不是一次安全类 ask」,把它折成显式 false 会让宿主把「没有证据」读成「已确认可自动放行」,
+        // 而本键存在的全部理由正是在这种门上把自动放行(记住的规则 / allow_session / bypass 姿态)拦下。
+        ...(frame.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
     });
     const decision = card.kind === 'allow' ? (card.allowSession ? 'allow_session' : 'allow') : 'deny';
     if (card.kind === 'failed') {

package/dist/request/taskRequest.js

@@ -59,7 +59,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'reasoningEffort', lanes: ['interactive'], live: false, why: '`/effort` 拨盘存在 AppState,print 无 AppState', gap: true },
     { field: 'model', lanes: ['interactive'], live: false, why: '`/model` 中途换模型读 toolUseContext.options.mainLoopModel;print 的模型走 MODEL_ID/--model 另一条路', gap: true },
     { field: 'images', lanes: ['interactive'], live: false, why: '贴图提交是交互动作,`-p` 的 stdin 没有图片块' },
-    // ⚠️ 四键一条(0.34.1 补第四键 `resumeAtMode`):它是 `rewindWireCaps` 的 `SeamRewindSpec` 真 wire 键,
+    // ⚠️ 四键一条(0.35.0 补第四键 `resumeAtMode`):它是 `rewindWireCaps` 的 `SeamRewindSpec` 真 wire 键,
     //    且 `rewindSpecForMode` 的 `both` / `conversation` 两臂**恒返**它(排他截语义 —— 回到目标消息
     //    **之前**)。修前合写项只列三键 ⇒ 真 `/rewind` 还原 turn 上 `unregisteredRequestKeys` 会点名
     //    `resumeAtMode`,而那正是「本层不许有未登记键」这条判据的误报,会教端去白名单化真键。
@@ -129,7 +129,7 @@ const shapeTag = (v) => {
 /**
  * plain object 判别 —— 按 **prototype** 判,不按 `Object.prototype.toString` 的标签判。
  *
- * 🔴 标签判法是**假的**(0.34.1 codex 对抗复审 [high] 采纳):`[object Object]` 对**普通类实例**同样
+ * 🔴 标签判法是**假的**(0.35.0 codex 对抗复审 [high] 采纳):`[object Object]` 对**普通类实例**同样
  * 成立,而 `Symbol.toStringTag` 还能让任意载体自报这个标签。放它过去之后,下面的摊开用的是
  * `Object.entries`(**只取自有可枚举键**)—— 于是一个把 `permissions.deny/ask` 挂在**原型 getter**
  * 上的载体会摊出一个**空快照**,请求照发 = 权限静默变宽,正是本节要堵的那个 fail-open 形。
@@ -139,7 +139,7 @@ const shapeTag = (v) => {
  * `Map` / `Date` / boxed 包装对象 / 数组一律拒 —— 它们要么内容不在自有键上,要么摊开就是垃圾键;
  * 「上游产出坏了」比「悄悄发一个更宽的权限面」更该被人看见。
  *
- * 🔴 判据 **realm 无关**(0.34.1 codex 对抗复审第八轮 [medium] 采纳):不拿「**本** realm 的
+ * 🔴 判据 **realm 无关**(0.35.0 codex 对抗复审第八轮 [medium] 采纳):不拿「**本** realm 的
  * `Object.prototype`」做身份比较 —— iframe / `node:vm` / 另一个渲染进程里的对象字面量各有**自己的**
  * `Object.prototype`,身份比较会把这些**完全合法、JSON 忠实**的载体误判成异形,在 web / desktop 宿主
  * 上变成提交前的硬失败。
@@ -242,7 +242,7 @@ const materializeJsonFaithful = (v, path, seen = new Set()) => {
             }
             return { value: items }; // 重建:原数组(可能是子类/带访问器/带覆盖方法)不出门
         }
-        // 🔴 重建成**无原型**记录(0.34.1 codex 对抗复审第七轮 [high] 的可采半场):
+        // 🔴 重建成**无原型**记录(0.35.0 codex 对抗复审第七轮 [high] 的可采半场):
         //   ① 忠实 —— 源本来就允许 `Object.create(null)` 字典,重建成 `{}` 等于把载体形换掉了;
         //   ② 少一条改写面 —— 无原型记录不会继承任何**事后**装到 `Object.prototype` 上的 `toJSON`。
         //   ⚠️ 但这只关掉了 record 那一半:重建出来的**数组**必须是真数组(`Array.isArray` / 序列化成
@@ -264,7 +264,7 @@ const materializeJsonFaithful = (v, path, seen = new Set()) => {
             //    `Object.prototype` 的 setter 上:键整个丢掉、还顺手换了目标对象的原型。
             Object.defineProperty(rec, k, { value: r.value, enumerable: true, writable: true, configurable: true });
         }
-        // 🔴 判据的读法**一律排在捕获之后**(0.34.1 codex 对抗复审第十二轮 [high] 采纳):`toJSON` 走属性
+        // 🔴 判据的读法**一律排在捕获之后**(0.35.0 codex 对抗复审第十二轮 [high] 采纳):`toJSON` 走属性
         //    查找、`isPlainRecord` 走 `getPrototypeOf`/`constructor` —— 这三种读法**都可以带副作用**
         //    (`getPrototypeOf` 陷阱在被问的那一刻把 `deny` 清空),而**原生 `JSON.stringify` 从不问原型**。
         //    校在捕获之前 = 本层自己的读法成了丢内容的那一环(比被动撒谎更糟:那是我们引入的丢失面)。
@@ -281,7 +281,7 @@ const materializeJsonFaithful = (v, path, seen = new Set()) => {
 /**
  * 快照 → 摊开成 `settings` 子键前的两道处理:**具名通道让位** + **畸形响亮拒**。
  *
- * ## ① 具名通道管着的键一律让位(0.34.1)
+ * ## ① 具名通道管着的键一律让位(0.35.0)
  *
  * 快照是**开放集 spread**(子键原样就是 wire 键),所以它天生是一条**第二通道**。0.34.0 只剥了
  * 「车道异名」键(表里那行的 lanes 不含本车道),于是**两条车道都登记**的具名键剥不到 ——
@@ -296,7 +296,7 @@ const materializeJsonFaithful = (v, path, seen = new Set()) => {
  * 🔴 剥得**窄**:只剥表里点名的具名子键。快照**表外**的子键(permissions / env / model / …)
  * 原样摊开 —— 那是开放集的全部意义;`outputStyle` 没有车道行(它是 live 兜底层的位)故不受影响。
  *
- * ## ② 畸形快照响亮拒(0.34.1,fail-closed)
+ * ## ② 畸形快照响亮拒(0.35.0,fail-closed)
  *
  * `undefined` / `null` = **合法缺席**(端没解析出快照;老写法拿 null 当空快照传),照旧降空对象。
  * 其余非 plain-object 形(数组 / 原始值 / boxed 包装对象 / Map / **类实例**…)= **上游产出坏了**:
@@ -305,11 +305,11 @@ const materializeJsonFaithful = (v, path, seen = new Set()) => {
  * `TypeError` 带形状描述(合法载体的判据见 {@link isPlainRecord} —— 「摊得全」是它的全部理由)。
  * (本包是发出去的 npm 公开面:JS 调用方与版本偏斜的宿主都到得了这里,型面拦不住。)
  *
- * ## ③ 权限面**子树**同样要摊得全(0.34.1 codex 对抗复审第二轮 [high] 采纳)
+ * ## ③ 权限面**子树**同样要摊得全(0.35.0 codex 对抗复审第二轮 [high] 采纳)
  *
  * 只校最外层是不够的:`{ permissions: new Map([['deny',['Write']]]) }` 的外层是合法字面量,可
  * `JSON.stringify` 把那只 Map 序列化成 `"permissions":{}` —— deny 规则**静默消失**,与 ② 要堵的
- * 是同一个权限变宽形,只是深了一层。所以 `permissions` 子树递归过 {@link jsonFaithfulPath}:
+ * 是同一个权限变宽形,只是深了一层。所以 `permissions` 子树递归过 {@link materializeJsonFaithful}:
  * plain record / 数组 / JSON 原始值才算摊得全,`Map`/`Set`/类实例/boxed/环一律拒。
  *
  * 🔴 **射程刻意只到 `permissions`**,不做整份请求体的深净化:那是「包级 wire 载荷 JSON-safe
@@ -335,7 +335,7 @@ const resolvedSnapshotForWire = (resolved) => {
     //    当场物化成脱钩副本),原件的形状判据留到最后;校不过就整体拒,拒绝面一字未变。
     const named = namedSettingsSubKeys();
     const out = {};
-    // 🔴 **键先捕获、值逐个即读即处理**(0.34.1 codex 对抗复审第六轮 [high]):`Object.entries(resolved)`
+    // 🔴 **键先捕获、值逐个即读即处理**(0.35.0 codex 对抗复审第六轮 [high]):`Object.entries(resolved)`
     //    会把**所有兄弟键**的值先读齐 —— 于是一个 `env`/`model` 位上的 getter 能在 `permissions` 被
     //    重建**之前**把它的 deny 数组清空(拿到的是同一个引用)。这与内层那条(见
     //    {@link materializeJsonFaithful} 第五条)是同一个病、只是高一层:两层都必须按 stringify 的
@@ -410,7 +410,7 @@ export function buildTaskRequest(input, lane) {
     // resolved 两车道都进表(#292 P1)——它是**开放集 spread**(子键即 wire 键),所以走
     // `laneHas + live` 而不是 `on()`:`on()` 判的是「这个键值非空」,而这里要判的是「这份快照要不要
     // 摊开」。
-    // 🔴 具名通道**赢过快照**这件事不靠下面的合并序(0.34.1):合并序只在具名通道**有值**时管用,
+    // 🔴 具名通道**赢过快照**这件事不靠下面的合并序(0.35.0):合并序只在具名通道**有值**时管用,
     //    而具名门否决时的表现恰恰是**没值**(端不给这个键)。让位改由 `resolvedSnapshotForWire`
     //    做**结构剥离** —— 具名通道管着的子键快照一概不产,顺序此后只是可读性,不再是安全依据。
     const s = input.settings ?? {};