@sema-agent/client-core 0.64.1 → 0.65.0

package/dist/engineErrorCodes.js

@@ -338,6 +338,48 @@ export const RESUME_RETRY_LATER_CODES = Object.freeze([
     RESUME_USAGE_WINDOW_EXHAUSTED,
     RESUME_PREFLIGHT_REJECTED,
 ]);
+// ── `/decide` workflow 车道拒绝族(B-070 / L-200;sdk README §9.0.0,server ≥7.69.0)──────────
+//
+// 背景一句话:`/decide` 7.69.0 起长出**第三条车道** —— 停在耐久审批门上的那一只 checkpoint 属于一个
+// **workflow 子代**时,决断要投给它的**宿主会话**去 wake。这条车道的 200 与另外两条**不是同一句话**
+// (见 `src/decideReceipt.ts` 顶注),而它的三个拒绝码也各有各的出路,合并判就会把「重发没用」
+// 与「等一会儿重发」说成同一件事。
+/**
+ * `decide.workflow_host_unknown`(409;sdk README §9.0.0 逐字:「run 上没有发起会话锚 ⇒ 无处投递,
+ * **无重试价值**」)。
+ * 🔴 出路**不是等**:这条 run 上根本没有可投递的宿主锚,重发一百次也一样。人能做的是据拒体的
+ *    `runId` 自己去看那条 run(或换一条路 resume 它)。
+ */
+export const DECIDE_WORKFLOW_HOST_UNKNOWN = 'decide.workflow_host_unknown';
+/**
+ * `decide.workflow_host_not_parked`(409;同上:「宿主此刻没停在可唤醒的 park 上 ⇒ **等它再 park
+ * 后重发**,或据 `runId` 自行 resume」)。
+ * 🔴 与上一码**刻意分成两个词**:这一个**可以**重发(宿主是时序问题),上一个不能。
+ *    ⚠️ 但它**不在** {@link RESUME_RETRY_LATER_CODES} 里,也不该在 —— 那张表闭的是「server 在哪些码上
+ *    铸 `retryAfterSec`」,而本码**恒无窗**(server 给不出「等多久」)。可等 ≠ 有窗。
+ */
+export const DECIDE_WORKFLOW_HOST_NOT_PARKED = 'decide.workflow_host_not_parked';
+/**
+ * `decide.workflow_remember_unsupported`(400;同上:「本车道 fail-closed 拒 `remember:"session"`」)。
+ * 🔴 出路是**去掉 `remember` 重发**,而且 sdk 顶注逐字保证「零副作用」——这一格与另外两个 409
+ *    的分法不是严重程度,是**改什么才能过**(改参数 / 等时序 / 没救)。
+ */
+export const DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED = 'decide.workflow_remember_unsupported';
+/**
+ * `/decide` workflow 车道的拒绝码**闭集**(三员)。
+ *
+ * 🔴 闭的不是「`decide.*` 一共有几个码」(那仍是开集:`approval_binding_mismatch` /
+ *    `approval_stale` / `gate_not_tool_approval` 等都不在本表,它们各有既有处置),闭的是
+ *    「**这三个码是 workflow 那条新车道独有的、而且各自有一句人话**」。
+ * 🔴 **形制**:`Object.freeze` 的数组,不是 `ReadonlySet`(同 {@link RESUME_RETRY_LATER_CODES} 的
+ *    已定谳病形 —— `ReadonlySet` 只在类型面只读,而判定查的就是公面上这同一个实例)。
+ * 🔴 加成员必须**同批**补那一句人话 + 判据,不许靠 `decide.` 前缀放宽(前缀下住着三种处置)。
+ */
+export const DECIDE_WORKFLOW_LANE_CODES = Object.freeze([
+    DECIDE_WORKFLOW_HOST_UNKNOWN,
+    DECIDE_WORKFLOW_HOST_NOT_PARKED,
+    DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
+]);
 // ── drain / 场景执法族(A-028.11/.13 单源化,#244 族E,2026-08-15)────────────────────────────
 /**
  * server 温切 drain 门的 pre-stream 拒收码(503 + `errorCode:"draining"`;server 侧

package/dist/fleet/fleetProjection.d.ts

@@ -170,7 +170,30 @@ export declare const TERMINAL_FLEET_TASK_STATUSES: ReadonlySet<string>;
  *  `projectTasks` 传的是 SDK 必填闭集 `FleetTaskRow['status']`),继续留着是死分支。
  */
 export declare function coerceTaskStatus(s: string): FleetTaskStatus;
-/** 中性 workflow run 状态(running|completed|failed)→ 渲染词汇。 */
+/**
+ * 中性 workflow 状态(run 席 `running|completed|failed`;item 席多一个 `parked`)→ 渲染词汇。
+ *
+ * 🔴 **0.65.0 加 `parked`(L-215① / B-079②)**:sdk 9.0.0 把 item 席具名成 `WorkflowItemStatus`
+ * 并加了 `parked`(「这一序数停在耐久审批门上等一次决定」),core 7.10.0 #642 是它的出处。
+ * 修前这里**没有这个 case**,于是它落进 `default` 被折成 `running` —— fleet 车道上一条**停着等人**
+ * 的工作流被渲成「在跑」,而那正是「等你」与「不需要你动」的分界。折成 `running` 之后用户没有任何
+ * 线索去按 ctrl+t 找那张卡,run 就一直停在那里。
+ * ⇒ 与 {@link coerceTaskStatus} 的 `parked` 臂**同一个落点** `awaiting approval`:同一件事在两条
+ *   车道上必须渲同一个词(两处各渲各的正是同名不同义的来源)。
+ *
+ * 🔴 **为什么直接加词、而不是铸一个 `_sema_parked: true` 超集键**(任务书要求写明选形理由):
+ * 判据是 sdk 那一位**在型面上开不开**,不是「它今天有几个已知值」——
+ * `FleetWorkflowRow.status` 在 sdk 8.8.0 与 9.0.0 上都声明成裸 `string`(`dist/resources/fleet.d.ts`
+ * 的 `status: string`,头注逐字「the NEUTRAL workflow run status (`running`|`completed`|`failed`),
+ * **open on read**」)。**它不是闭集** ⇒ 一个新词在 wire 上、在型面上都合法,消费端要做的就是
+ * 认它;此时再加一个 `_sema_` 前缀的孪生布尔,等于替一件上游已经能说清楚的事**另铸第二个真源**,
+ * 而两个真源迟早分叉(本包一贯要根治的形)。超集键留给「上游那一位真是闭集、加词会让严格消费端
+ * 判违约」的那一类,这里不是。
+ *
+ * ⚠️ **本函数仍收 run 席与 item 席两处**(调用点见 `projectWorkflows`):core 的两张词表里
+ * `parked` 只在 item 席,所以 run 席读到它属于上游异常 —— 但**渲染面的处置相同**(都是「等人」),
+ * 在这里为「哪一席」分叉只会长出一条没有用户面差别的分支。
+ */
 export declare function coerceWorkflowStatus(s: string | undefined): FleetTaskStatus;
 /**
  * 187 给 fleet 行命名用的是 agent 的**身份**,从不是它的 objective:

package/dist/fleet/fleetProjection.js

@@ -63,7 +63,30 @@ export function coerceTaskStatus(s) {
             return 'idle';
     }
 }
-/** 中性 workflow run 状态(running|completed|failed)→ 渲染词汇。 */
+/**
+ * 中性 workflow 状态(run 席 `running|completed|failed`;item 席多一个 `parked`)→ 渲染词汇。
+ *
+ * 🔴 **0.65.0 加 `parked`(L-215① / B-079②)**:sdk 9.0.0 把 item 席具名成 `WorkflowItemStatus`
+ * 并加了 `parked`(「这一序数停在耐久审批门上等一次决定」),core 7.10.0 #642 是它的出处。
+ * 修前这里**没有这个 case**,于是它落进 `default` 被折成 `running` —— fleet 车道上一条**停着等人**
+ * 的工作流被渲成「在跑」,而那正是「等你」与「不需要你动」的分界。折成 `running` 之后用户没有任何
+ * 线索去按 ctrl+t 找那张卡,run 就一直停在那里。
+ * ⇒ 与 {@link coerceTaskStatus} 的 `parked` 臂**同一个落点** `awaiting approval`:同一件事在两条
+ *   车道上必须渲同一个词(两处各渲各的正是同名不同义的来源)。
+ *
+ * 🔴 **为什么直接加词、而不是铸一个 `_sema_parked: true` 超集键**(任务书要求写明选形理由):
+ * 判据是 sdk 那一位**在型面上开不开**,不是「它今天有几个已知值」——
+ * `FleetWorkflowRow.status` 在 sdk 8.8.0 与 9.0.0 上都声明成裸 `string`(`dist/resources/fleet.d.ts`
+ * 的 `status: string`,头注逐字「the NEUTRAL workflow run status (`running`|`completed`|`failed`),
+ * **open on read**」)。**它不是闭集** ⇒ 一个新词在 wire 上、在型面上都合法,消费端要做的就是
+ * 认它;此时再加一个 `_sema_` 前缀的孪生布尔,等于替一件上游已经能说清楚的事**另铸第二个真源**,
+ * 而两个真源迟早分叉(本包一贯要根治的形)。超集键留给「上游那一位真是闭集、加词会让严格消费端
+ * 判违约」的那一类,这里不是。
+ *
+ * ⚠️ **本函数仍收 run 席与 item 席两处**(调用点见 `projectWorkflows`):core 的两张词表里
+ * `parked` 只在 item 席,所以 run 席读到它属于上游异常 —— 但**渲染面的处置相同**(都是「等人」),
+ * 在这里为「哪一席」分叉只会长出一条没有用户面差别的分支。
+ */
 export function coerceWorkflowStatus(s) {
     switch (s) {
         case 'completed':
@@ -72,6 +95,8 @@ export function coerceWorkflowStatus(s) {
             return 'failed';
         case 'killed':
             return 'killed';
+        case 'parked':
+            return 'awaiting approval';
         default:
             return 'running';
     }

package/dist/fleetAgentPanelProjection.js

@@ -47,6 +47,8 @@ import { publishEngineAgentPanelEvent } from './engineAgentPanelStore.js';
 import { rowIdTail } from './workflow.js';
 import { TERMINAL_FLEET_TASK_STATUSES } from './fleet/fleetProjection.js';
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
+// L-215+(0.65.0;core [6908]):「非成功终局」的单铸谓词(与 notifications 的同名位同源)。
+import { isTerminalNotSuccess } from './runTerminal.js';
 /** 行从投影集消失多久之后按 completed 兜底 settle(重连空窗 / snapshot 清表远小于此)。 */
 export const ABSENT_SETTLE_MS = 30_000;
 /** REF-CC-045(fleet2-07):settled 条目的回收期 —— settle 后这么久仍未再被投影 ⇒ 台账整条
@@ -158,7 +160,10 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 publishEngineAgentPanelEvent({
                     kind: 'end',
                     taskId,
-                    isError: status === 'failed' || status === 'killed',
+                    // L-215② 族扫(0.65.0):与 `notifications.enqueueBgChildNotification` 的 `isError` 位
+                    //    **同一个病形**(内联两词 ⇒ core [6908] 的 `blocked` 漏成「成功」)。两处一次改齐,
+                    //    读同一个单铸谓词;只修当格 = 下一次加词又漏一处。
+                    isError: isTerminalNotSuccess(status),
                 });
             }
             seenMap.set(taskId, {

package/dist/gateVocabulary.d.ts

@@ -58,10 +58,18 @@ export declare const ASK_ORIGIN_WORDS: readonly string[];
 /**
  * 一个 `origin` 词 → 一句人话。**唯一铸点**(三端共用;端零自拼)。
  *
+ * @param origin  帧/行上的 `origin` 词(开集;非串/空串走兜底)
+ * @param message 🆕 **0.65.0 additive 第二参**(B-080③):引擎在这只调用上给的散文
+ *   (`PermissionResult.message` / 卡上的同名位)。**只在 {@link ORIGIN_PREFERS_ENGINE_MESSAGE}
+ *   的词上优先**,其余词一字不读 —— 理由写在那张表的头注。缺席 / 非串 / 空白串 ⇒ 行为与本参
+ *   出现之前**逐字节相同**(表里那一句中性定义句)。
+ *
  * 🔴 表外词的那一句说的是「**这个词比这一端新**」,不是「坏记录」——理由见模块顶注(server 只判
  *    非空串,core 加词当天合法的帧就带着它到达)。原样带上那个词,并明说这次仍然是在问人:
  *    读不懂出身**不改变**这只 ask 要人回答这件事。
  * 🔴 非串 / 空串:同走兜底但词位渲 `(none)` —— 「没报出身」与「报了一个读不懂的出身」在这一句里
  *    不必分家(两者对用户的下一步相同:照常回答这只 ask),但都**不许**被折成十一词里的任何一个。
+ * 🔴 `message` 是引擎/工具产文,**只渲不回喂模型**(与卡上其余散文位同一条纪律);本铸点
+ *    **不截断不改写**它 —— 显示封顶归端(它才知道自己的行宽)。
  */
-export declare function askOriginDetail(origin: unknown): string;
+export declare function askOriginDetail(origin: unknown, message?: unknown): string;

package/dist/gateVocabulary.js

@@ -90,34 +90,76 @@ export const ASK_ORIGIN_WORDS = Object.freeze([
  *   · `shell_gate_tighten` / `safety_tighten`:两条 tighten 分成两个词,正是为了说出**哪一层**
  *     引擎逻辑提的问(粗粒度 shellGate 教条 vs 调用的显式事实:egress 标 / 不可逆标 / 写保护);
  *   · `org_rule` / `ask_rule`:组织的规则 vs 这个人自己的常驻 ask 行。
+ *
+ * ── 🔴 0.65.0 三句订正(B-080③;core `dist/core/ask-origin.d.ts` 真字节)───────────────────────
+ * 三句修前各自漂开了上游的定义,而漂的方向都是「把引擎真正说的事换成一件别的事」:
+ *   · **`unresolvable`** 修前渲「门拿不定主意」—— core:36-38 逐字是「the call is MARKED by an
+ *     ancestor (an inherited approver-unavailable float, or a durable mandate floated down because
+ *     this task can park it): it must reach the park with no synchronous decision-maker in between」。
+ *     那不是犹豫,是**祖先盖的标记**+一条硬路径约束;渲成「拿不定主意」会让人去找一个不存在的
+ *     「让门自己拿主意」的配置。
+ *   · **`shell_gate_tighten`** 修前渲「**每一条** shell 命令都问」—— 过度陈述。core:58-59 逐字是
+ *     「raised the ask over a tier the COARSE `shellGate` doctrine installed」:问的是**这一档以上**的,
+ *     不是全部。
+ *   · **`rule_store_unavailable`** 修前渲固定的「规则店读不出来」—— 而这一个词 core 7.9.0 起盖的是
+ *     **两种机制**(store 读失败 **或** tightening lexer 的 `unreadable`:展开里有读不懂的词 / 引号未
+ *     闭合 / 语法错,core:44-51),core CHANGELOG 7.9.1 逐字交代处置:「a card that hard-codes store
+ *     wording for the origin should read the message」。⇒ 本铸点改成**引擎的 `message` 优先**(见
+ *     {@link askOriginDetail} 的 additive 第二参),表里留的那一句改成两种机制都成立的中性句。
  */
 const ASK_ORIGIN_SENTENCES = Object.freeze({
     content_question: 'the tool itself asked you a question',
-    unresolvable: 'the gate could not decide on its own, so it asks',
+    unresolvable: 'an ancestor marked this call (an inherited approver-unavailable float, or a durable mandate): it must reach the park with no synchronous decision-maker in between',
     org_unavailable: 'the organization policy was unavailable, so this call asks',
     org_rule: 'an organization rule asks about this call',
-    rule_store_unavailable: 'the rule store was unavailable, so this call asks',
+    rule_store_unavailable: 'this call could not be checked against your standing deny/ask rules, so it asks',
     hook: 'a PreToolUse hook asked about this call',
     ask_rule: 'a persisted ask rule matches this call',
     denial_limit_fallback: 'the auto-mode classifier hit its denial limit and handed this call back to you',
-    shell_gate_tighten: 'this deployment asks about every shell command at this gate setting',
+    shell_gate_tighten: 'this deployment asks about shell commands the coarse shell gate rates above this tier',
     safety_tighten: 'the gate tightened on this call’s own facts (network egress, irreversibility, or a protected write)',
     policy: 'this deployment’s permission policy asks about this call',
 });
+/**
+ * 哪些 `origin` 词的一句人话应当**让位给引擎自己的 `message`**(闭集;0.65.0 新铸)。
+ *
+ * 🔴 **不是「有 message 就用 message」**:绝大多数出身词的那一句是本包写的、对每一只同出身的 ask
+ *    都成立的**定义句**,而引擎的 `message` 是**这一只**调用的拒因/疑因散文 —— 两者不同类,
+ *    无差别地拿 message 顶掉定义句会把「谁问的」换成「引擎这一次写了什么」。
+ * 🔴 本集只收**一个词盖了多种机制**的那一类:`rule_store_unavailable` 的两条腿(店读不出来 /
+ *    这条命令对不上你的规则行)对人的下一步不同,而只有引擎的 message 分得出来。
+ *    加员 = 上游又把一个词做成了多机制合并词,必须同批带坐标。
+ */
+const ORIGIN_PREFERS_ENGINE_MESSAGE = new Set(['rule_store_unavailable']);
 /**
  * 一个 `origin` 词 → 一句人话。**唯一铸点**(三端共用;端零自拼)。
  *
+ * @param origin  帧/行上的 `origin` 词(开集;非串/空串走兜底)
+ * @param message 🆕 **0.65.0 additive 第二参**(B-080③):引擎在这只调用上给的散文
+ *   (`PermissionResult.message` / 卡上的同名位)。**只在 {@link ORIGIN_PREFERS_ENGINE_MESSAGE}
+ *   的词上优先**,其余词一字不读 —— 理由写在那张表的头注。缺席 / 非串 / 空白串 ⇒ 行为与本参
+ *   出现之前**逐字节相同**(表里那一句中性定义句)。
+ *
  * 🔴 表外词的那一句说的是「**这个词比这一端新**」,不是「坏记录」——理由见模块顶注(server 只判
  *    非空串,core 加词当天合法的帧就带着它到达)。原样带上那个词,并明说这次仍然是在问人:
  *    读不懂出身**不改变**这只 ask 要人回答这件事。
  * 🔴 非串 / 空串:同走兜底但词位渲 `(none)` —— 「没报出身」与「报了一个读不懂的出身」在这一句里
  *    不必分家(两者对用户的下一步相同:照常回答这只 ask),但都**不许**被折成十一词里的任何一个。
+ * 🔴 `message` 是引擎/工具产文,**只渲不回喂模型**(与卡上其余散文位同一条纪律);本铸点
+ *    **不截断不改写**它 —— 显示封顶归端(它才知道自己的行宽)。
  */
-export function askOriginDetail(origin) {
+export function askOriginDetail(origin, message) {
     // 🔴 自有属性判据,理由与 `gateDeniedByDetail` 逐字相同(冻结不移除原型)。
     const known = typeof origin === 'string' && Object.hasOwn(ASK_ORIGIN_SENTENCES, origin)
         ? ASK_ORIGIN_SENTENCES[origin]
         : undefined;
+    // 🔴 让位只在**多机制合并词**上发生,且只在 message 真是一句非空散文时:引擎没给 / 给的是坏值
+    //    ⇒ 回落表里那一句中性定义句(绝不渲半句、绝不渲空)。
+    if (typeof origin === 'string' && ORIGIN_PREFERS_ENGINE_MESSAGE.has(origin)) {
+        const spoken = typeof message === 'string' ? message.trim() : '';
+        if (spoken.length > 0)
+            return spoken;
+    }
     if (known !== undefined)
         return known;
     const word = typeof origin === 'string' && origin.length > 0 ? origin : '(none)';

package/dist/hitl/askGateWire.js

@@ -186,7 +186,28 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
         lastRoundDecided = resolution.progress === true && !sameCall;
         lastRoundPresentedCard = resolution.presented; // 每次调用的真回执:规则直决 / 取件失败 = false ⇒ 触顶时收场卡照呈
         progressedSinceReattach = false;
-        const seq = led.lastSeq();
+        // ── B-070 / L-200(0.65.0):**换挂** —— 这一轮的 decide 200 说了「受理了,续跑在另一条 run 上」──
+        // sdk README §9.0.0 逐字:workflow 车道的受理形回执带的是**宿主新铸**的 run id(「poll 它,
+        // 不要盯那张卡」)。修前这里恒用原 `taskId.current` 重挂 ⇒ 旧 run 上再也不会有推进帧,
+        // 预算一路烧到 hop 上限、终帧是一句与真因无关的话。判据在 `readDecideReceipt`(两件合取)
+        // 与 `resolvePark`(还要与当前 taskId 不同)里,这里只执行。
+        // 🔴 **换挂必须同时丢掉 `lastEventId`**:durable seq 是 **per-run** 的序号,拿旧 run 的序号去
+        //    续读新 run 是跨命名空间取数([same-name-different-meaning-crosses-layers])——
+        //    要么被 server 拒,要么静默跳过新 run 的开头(那正是本 bug 的另一种死法)。
+        // 🔴 台账里**跟着 run 走**的那几格同批清掉(`forgetRunScopedState`,逐格理由见该动词头注):
+        //    ① seq 游标 —— 不清的话,下一轮若没有换挂,`led.lastSeq()` 会把**上一条 run** 的序号带回
+        //       新 run 的续读上,同一个跨命名空间取数换个时点再犯一次;
+        //    ② 🔴 **已渲 call 集 + 两张 args 快照表** —— 异源复审 [high] 实撞的安全格:`toolCallId`
+        //       不保证跨 run 唯一,而 `routeToolStart` 在 `markStarted` 判重后直接早退,新 run 的
+        //       `noteGatedStart` 于是不执行 ⇒ 卡面渲**旧 run 的入参**,而 decide 回显**新 pending 行**
+        //       的 D-1 绑定:人看见 A、批准的是 B。
+        //    「这一只 ask 的历史」(已决身份 / 扣留帧 / 同因计数)**刻意保留** —— 它们正是换挂的理由。
+        const handoff = resolution.handoffTaskId;
+        if (handoff !== undefined) {
+            taskId.current = handoff;
+            led.forgetRunScopedState();
+        }
+        const seq = handoff !== undefined ? undefined : led.lastSeq();
         stream = deps.runsEvents(taskId.current, {
             ...(seq !== undefined ? { lastEventId: seq } : {}),
             ...(opts?.signal ? { signal: opts.signal } : {}),

package/dist/hitl/gateLedger.d.ts

@@ -54,6 +54,30 @@ export interface GateLedger {
      *  re-attach 从一个陈旧位置重放,把已经决断的 park 又送一遍(实测:消费到 16 却 attach from 8)。 */
     noteSeq(ev: AgentEvent): void;
     lastSeq(): string | undefined;
+    /**
+     * 🔴 **换挂到另一条 run 时,把「跟着 run 走」的那几格忘掉**(B-070 / L-200,0.65.x)。
+     *
+     * workflow 车道的 decide 受理形把续跑交给**宿主新铸**的 run(sdk README §9.0.0),于是同一本
+     * turn 级台账第一次要跨**两条 run** 活着。台账里有两类记账,它们的射程不同:
+     *
+     * **① 跟着 run 走 ⇒ 本动词清掉**:
+     *   · `lastSeq` —— durable seq 是 **per-run** 的序号,带着旧 run 的号去续读新 run 是跨命名空间
+     *     取数([same-name-different-meaning-crosses-layers]);
+     *   · **`markStarted` 的已渲 call 集**与**两张 args 快照表**(gated 的与在飞的)——
+     *     🔴 **这一条是安全格**(异源复审 [high] 实撞):`toolCallId` **不保证跨 run 唯一**,而
+     *     `routeToolStart` 在 `markStarted` 判重后**直接早退**(`skip`),`noteGatedStart` 不再执行。
+     *     ⇒ 新 run 复用同一个 callId 时,卡面渲的是**上一条 run 的入参快照**,而 decide 回显的是
+     *     **新 pending 行**的 D-1 绑定 —— 人看见 A、批准的是 B。这正是「两处各持一半事实」那一族
+     *     里代价最高的一格,所以换挂那一拍必须把这三张表一起清掉,让新 run 的 `tool_start`
+     *     重新走一遍完整的渲染 + 记账路径。
+     *
+     * **② 属于「这一只 ask 的历史」⇒ 刻意保留**(它们正是换挂的**理由**,清掉就自相矛盾):
+     *   · `decidedGates` / `lastFsOrShellGatedCall` —— 「这张 park 已经被决断过」的身份留痕,
+     *     #110 那条「重放的 park 不是失败」的判据靠它;
+     *   · 扣留帧表(`heldAskEnds`)—— 本 turn 尚未吐出的帧,「一帧不丢」靠它;
+     *   · 同因连续计数与批级判据 —— 它们数的是「这一只门重放了几次」,与流挂在哪条 run 上无关。
+     */
+    forgetRunScopedState(): void;
     /** 首见 ⇒ true(并记账);durable 重放的已渲 call ⇒ false。 */
     markStarted(callId: string): boolean;
     /** 🔴 存 **tool_start 当拍的 `args` 快照**而非帧引用(与拆分前 `askArgsByCall` 逐字同语义;

package/dist/hitl/gateLedger.js

@@ -161,6 +161,14 @@ export function createGateLedger() {
         lastSeq() {
             return seq;
         },
+        forgetRunScopedState() {
+            seq = undefined;
+            // 🔴 三张 per-call 表一起清(理由见接口头注的安全格):`toolCallId` 不保证跨 run 唯一,
+            //    留着任何一张都会让新 run 的同名 call 走进「渲旧入参、决新绑定」那条路。
+            startedCalls.clear();
+            gatedStartArgsByCall.clear();
+            startArgsByCall.clear();
+        },
         markStarted(callId) {
             if (startedCalls.has(callId))
                 return false;

package/dist/hitl/hitlBridge.js

@@ -649,8 +649,20 @@ export class HitlBridge {
             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;
+                // 🔴 **B-070(0.65.0):200 是投递受理,不是「门已解决」——所以这里不再清 `active`。**
+                //    sdk README §9.0.0 逐字:「workflow 车道的 200 只是**投递受理** —— 子代的 checkpoint 仍
+                //    pending,`/v1/approvals` 上那张卡**可能还在**。据 200 立刻把卡从 UI 抹掉,用户会看到
+                //    一张『批过了却还在』的幽灵卡」;core `runner/contracts.d.ts:1492` 同向(这一步
+                //    **launches the run that re-invokes**)。修前这一行正上方的注释自己写着「the gate clears
+                //    on the next running arm」—— 而代码在同一拍就把它清了,注释与码互相矛盾,矛盾的那一半
+                //    是码。
+                // ⇒ 判据锚换到**真正决定结果的量**上:`active` 由 {@link HitlBridge.observe} 在**流上的下一条
+                //   running 臂 / 终态臂**上清([anchor-on-the-deciding-quantity])。那条腿修前就在
+                //   (`observe` 的 `text`/`tool_start`/`turn_end`/`done`/`failed` 五臂),本批只是把抢跑的
+                //   那一行拿掉,没有新增任何清除路径。
+                // ⚠️ 影响面如实说:`active` 今天只在宿主真的驱动 `observe()` 时才 latch(两处生产调用点都
+                //    不驱动,见 `reviewPlan` 顶注),所以这一行的现实效果 = 对已驱动 observe 的宿主
+                //    (desktop/web 的座位层)不再谎报「门没了」;不驱动的宿主逐字节不变。
                 return r;
             }
             catch (e) {

package/dist/hitl/parkResolver.d.ts

@@ -17,6 +17,7 @@ import { type GateCurrentPending, type HitlFailureStage } from './hitlBridge.js'
 import { type QuestionAnswer } from '../liveQuestionStore.js';
 import type { AskAnsweredOutput, GateLedger } from './gateLedger.js';
 import { type AskGateWireDeps, type GatePark } from './frameRouter.js';
+import { type DecideReceiptView } from '../decideReceipt.js';
 /**
  * L-80(2026-09-03,[6215];#357 复发):**连续非进展轮**上限 —— 数的是「壳再附着之后那段流里一个
  * host 推进帧都没有」的轮次,**不是** park 次数。修前这里是 `24` 且按每次 park 递增
@@ -60,10 +61,15 @@ export declare const MAX_TOTAL_PARKS = 64;
  */
 export declare const GATE_FAILURE_CODES: readonly ["no_pending", "binding_mismatch", "wrong_gate", "bad_plan_edit", "empty_answer"];
 export type GateFailureCode = (typeof GATE_FAILURE_CODES)[number];
-export type GateOutcome = {
+export type GateOutcome = 
+/** `receipt`(B-070 / L-200,0.65.0):这次 decide 的 **200 回执读数** —— 与 fs 腿的
+ *  `FsApprovalOutcome.receipt` **同形同源**(同形存量清剿:两条决断腿一次改齐)。语义与缺席纪律
+ *  逐字见 `decideReceipt.ts` 顶注;🔴 它**不是**「门已解决」的证据(200 只是投递受理)。 */
+{
     kind: 'decided';
     gatedCallId?: string | undefined;
     answered?: AskAnsweredOutput | undefined;
+    receipt?: DecideReceiptView | undefined;
 } | {
     kind: 'aborted';
     gatedCallId?: string | undefined;
@@ -99,17 +105,32 @@ export declare function toAnsweredOutput(questions: unknown[], answer: QuestionA
 /** 外环决断的两种出路(见文件头注)。 */
 /** resolvePark 的续流判决:`progress` 位 = 这一轮决断真落地了一次(驱动侧不据此复位计数 —— 复位只看
  *  下一段流有没有 host 推进帧);非进展轮携 `reason`(收场文案用)。 */
-export type ParkResolution = {
+export type ParkResolution = 
+/**
+ * `handoffTaskId`(B-070 / L-200,0.65.0):🔴 **这一轮之后该盯哪条 run**。
+ *
+ * sdk README §9.0.0 的 workflow 车道逐字:受理形 200 上的 `taskId` 是「**宿主新铸**的 run id
+ * (poll 它,**不要盯那张卡**)」。修前重挂腿恒用**原** taskId 重挂 `runs.events` —— 而那条 run
+ * 已经把续跑交给了另一条,于是旧流上再也不会有推进帧,预算一路烧到 hop 上限,终帧还是一句
+ * 与真因无关的话。
+ * 🔴 **缺席 = 没有换挂**(终局形 / 幂等回放形 / 老 server / 这一轮压根没 decide 成功):调用方
+ *    **照旧用原 taskId**;绝不把缺席折成任何别的意思。
+ * 🔴 **换挂时 `lastEventId` 必须丢掉**:durable seq 是 **per-run** 的,拿旧 run 的序号去续读新
+ *    run 是跨命名空间取数([same-name-different-meaning-crosses-layers])。调用点有断言。
+ */
+{
     kind: 'reattach';
     progress: true;
     presented: boolean;
     gatedCallId?: string | undefined;
+    handoffTaskId?: string | undefined;
 } | {
     kind: 'reattach';
     progress: false;
     reason: string;
     presented: boolean;
     gatedCallId?: string | undefined;
+    handoffTaskId?: string | undefined;
 } | {
     kind: 'failsoft';
     events: readonly AgentEvent[];

package/dist/hitl/parkResolver.js

@@ -5,6 +5,8 @@ import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
 import { observeCancelByDeny } from './hitlHostSurface.js';
 import { flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
+// B-070 / L-200(0.65.0):`/decide` 200 回执的单一读面(换挂句柄 + executionOutcome)。
+import { readDecideReceipt } from '../decideReceipt.js';
 /**
  * L-80(2026-09-03,[6215];#357 复发):**连续非进展轮**上限 —— 数的是「壳再附着之后那段流里一个
  * host 推进帧都没有」的轮次,**不是** park 次数。修前这里是 `24` 且按每次 park 递增
@@ -246,6 +248,7 @@ parkGatedCallId, onPresented) {
         observeCancelByDeny(bridge.decideTool({ decision: 'deny', reason: 'Interrupted by user' }, gatedCallId, undefined, pending), taskId);
         return { kind: 'aborted', gatedCallId };
     }
+    let declinedReceipt;
     try {
         // REF-CC-038(2026-08-02):`answer.answers` 已经是 `AskAnswer[]`(liveQuestionStore 的
         // `QuestionAnswer` 直用 hitlBridge 的 `AskAnswer` 为唯一源)—— 不再需要靠 cast 把两个
@@ -253,14 +256,22 @@ parkGatedCallId, onPresented) {
         const entries = answer.answers ?? [];
         const hasContent = entries.some(a => (a.selected?.length ?? 0) > 0 || (a.note?.length ?? 0) > 0);
         if (hasContent) {
-            await bridge.answerQuestion(entries, gatedCallId, signal ? { signal } : undefined, pending);
-            return { kind: 'decided', gatedCallId, answered: toAnsweredOutput(questions, answer) };
+            const raw = await bridge.answerQuestion(entries, gatedCallId, signal ? { signal } : undefined, pending);
+            // B-070:回执原样读一次(缺席即缺席);两条腿同形 —— fs 腿在 `toolApprovalWire` 的三处。
+            const receipt = readDecideReceipt(raw);
+            return {
+                kind: 'decided',
+                gatedCallId,
+                answered: toAnsweredOutput(questions, answer),
+                ...(receipt !== undefined ? { receipt } : {}),
+            };
         }
         else {
             // 用户拒答(overlay reject/dismiss 送空 answers)= 诚实 deny;模型收 denied 结果自续。
-            await bridge.decideTool({ decision: 'deny', reason: 'User declined to answer' }, gatedCallId, signal ? { signal } : undefined, pending);
+            const raw = await bridge.decideTool({ decision: 'deny', reason: 'User declined to answer' }, gatedCallId, signal ? { signal } : undefined, pending);
+            declinedReceipt = readDecideReceipt(raw);
         }
-        return { kind: 'decided', gatedCallId };
+        return { kind: 'decided', gatedCallId, ...(declinedReceipt !== undefined ? { receipt: declinedReceipt } : {}) };
     }
     catch (e) {
         // REF-CC-033:HitlSafetyError.code 是 hitlBridge.ts 自己的闭集契约(见其类型头注),
@@ -558,9 +569,26 @@ export async function resolvePark(park, ctx) {
         if ('answered' in outcome && outcome.answered)
             led.rememberAnswer(outcome.gatedCallId, outcome.answered);
     }
+    // ── B-070:200 = 投递受理,续跑可能挂在**另一条 run** 上 ────────────────────────────────────
+    // workflow 车道的受理形回执带的是**宿主新铸**的 run id(sdk README §9.0.0:「poll 它,不要盯那张
+    // 卡」)。修前这里恒用原 `taskId` 重挂 `runs.events` ⇒ 旧流上再无推进帧,一路烧到 hop 上限。
+    // 🔴 判据是回执上的**两件合取**(`status:"resuming"` ∧ 非空 taskId,判在 `readDecideReceipt` 里),
+    //    而且**必须与当前 taskId 不同**才算换挂 —— 任务级车道的受理形回执带的就是同一条 run,
+    //    把它当「换挂」会白白丢掉 `lastEventId`(等于从头重放一遍这条流)。
+    const handoffTaskId = 'receipt' in outcome && outcome.receipt?.handoffTaskId !== undefined && outcome.receipt.handoffTaskId !== taskId
+        ? outcome.receipt.handoffTaskId
+        : undefined;
     const seq = led.lastSeq();
-    hostLog('debug', `liveHitlAskWire: gate decided (call ${outcome.gatedCallId ?? '?'}) — attaching runs.events(${taskId})${seq ? ` from seq ${seq}` : ''}`);
-    return { kind: 'reattach', progress: true, presented: presentedThisRound, gatedCallId: outcome.gatedCallId };
+    hostLog('debug', handoffTaskId !== undefined
+        ? `liveHitlAskWire: gate decided (call ${outcome.gatedCallId ?? '?'}) — the decide was ACCEPTED for delivery (status "resuming") and the engine handed the continuation to run ${handoffTaskId}; attaching runs.events(${handoffTaskId}) from the start (durable seq is per-run, so ${seq ?? 'the previous seq'} does not apply there)`
+        : `liveHitlAskWire: gate decided (call ${outcome.gatedCallId ?? '?'}) — attaching runs.events(${taskId})${seq ? ` from seq ${seq}` : ''}`);
+    return {
+        kind: 'reattach',
+        progress: true,
+        presented: presentedThisRound,
+        gatedCallId: outcome.gatedCallId,
+        ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
+    };
 }
 /**
  * fail-soft 收场的事件序列:扣留帧一律走中断感知出口(件 B:五个排水出口同一形,零-park 硬门必挡,语义等价 no-op;