@sema-agent/server 7.150.0 → 7.152.0

package/dist/tool-approval.d.ts

@@ -1,14 +1,14 @@
 import type { ApprovalLegOrigin } from "./approval-leg-origin.js";
-import { type ApprovalDecider, type HostSettledBy, type HostSource, type RetiredDecisionKeyFacts } from "./host-decision.js";
+import { type ApprovalDecider, type HostSettledBy, type HostSource } from "./host-decision.js";
 import type { IncomingMessage } from "node:http";
 import { type AskClass, type AskRequest, type AskOutcome, type PermissionResult, type CheckpointGate, type PendingAction, type PersistedRuleMandate, type ReadRootGrantCandidate, type RuleOffer, type AutoModeFallbackCause, type BoundGrantAbsence, type BoundSkillGrants, type ToolApprovalCard, type ReopenReason } from "@sema-agent/core";
 import { type CardRulePersisted, type RuleConsentLane } from "./rules-consent.js";
 import type { GateCurrencyStore } from "./approval-gate-currency.js";
 import { type HitlTransport } from "./hitl-delivery.js";
 import { type AllowRuleShadowProjection, type DenialLimitFallback, type RuleOffersAbsence, type ApprovalRequestFrame, type ApprovalRevokeFrame, type ApprovalCardLegFrame, type ApprovalCompleteFrame, type RuleEvidenceProjection } from "./approval-card.js";
-import { type ApprovalAskStore, type AskRow } from "./plugins/approval-ask-store-sql.js";
+import { type ApprovalAskStore, type AskDecision, type AskDecisionRecord, type AskRow, type DecideResult, type RecordParkedDecisionResult } from "./plugins/approval-ask-store-sql.js";
 import type { ApprovalAskAuditSink } from "./approval-ask-audit-store.js";
-import { type AskRowEndingCause, type SettleCause, type SettleOutcome } from "./approval-deny-reasons.js";
+import { type AskRowEndingCause, type SettleCause } from "./approval-deny-reasons.js";
 import type { ParkCommitWatch } from "./plugins/park-commit-watch.js";
 import { type GovernanceAskMarks } from "./governance-ask-marks.js";
 import { type GovernancePosture } from "./runtime-governance.js";
@@ -36,7 +36,7 @@ export declare const MAX_ALLOW_SESSIONS = 4096;
 export declare function approvalDecidePath(sessionId: string): string;
 /**
  * 一只转停驻的问**去哪只会话决** —— 它的停车行(检查点卡)落在哪只会话上,耐久回决口 `POST /v1/approvals/:sessionId/decide` 就按这只会话找卡(卡自己的会话,
- * 决断口的地址;不是卡归属的 run 会话 —— cascade 级上的卡归调用方的 run,却只能在级自己的会话上决)。三处同读这一只:决断口对 PARKED 行的 `410 gone.ask_parked`
+ * 决断口的地址;不是卡归属的 run 会话 —— cascade 级上的卡归调用方的 run,却只能在级自己的会话上决)。三处同读这一只:决断口对 PARKED 行在这台部署交不了停驻赎回时(直连门)的 `410 gone.ask_parked`
  * 回显、迟到回决口对 PARKING 行的 `202` 与按问读口 `parked` 的 `decidePath`。
  * 停车行落在**铸它那条腿**的会话上 = 行上的发起会话 `sourceSessionId`(core 铸停车行的 `sessionId` 与铸这一问的发起会话是同一只变量;根腿 = 行上的会话,
  * 委派 / 后台子代腿 = 子代自己的会话,不是行上记的投递会话):
@@ -46,25 +46,24 @@ export declare function approvalDecidePath(sessionId: string): string;
  */
 export declare function parkSessionOf(row: Pick<AskRow, "state" | "sourceSessionId" | "taskId">): string | undefined;
 /**
- * [ref] 随批小件:`tool_approval.not_pending` 404 的**判别位**([ref] 排障代价实证 —— 三因合并成一句人话,现场分不出「答案没地方兑」与「打错副本了」)。
- * 🔴 `tool_approval.not_pending` 整个码**只在已过属主门的面上出**(属主看得见的「这张卡不在待决」)。调用方**看不见**这只问 —— 无行 / 行不是调用方的 /
- * 行读不出 / 这台部署没有问账可判 —— 一律 404 `not_found.ask`(与耐久决断口同一个词:两扇门底下是同一只问;不带任何状态位,属主门不过与未知 id 逐字节同,
- * 唯一成形口 {@link ToolApprovalCoordinator.askNotVisible})。
- * DECIDED/PARKED 已从 404 分流(DECIDED ⇒ 200 回放首决,回执带 `decidedBy`,**不是**成因;PARKED ⇒ 赎回席),过了属主门的残余两类:
- *  · 行 `VOID` / `DENIED`(没有人决过它)—— `cause` = **行上记的那个成因词**(问账 `ending_cause` 列;与决断口 410 `gone.ask` 体的 `cause`、审计 settle 行
- *    的 `cause` 同一个词,闭集 {@link SettleCause});行上没写归因(存量行)⇒ 缺席,不替没写的行编一个词;
- *  · {@link NOT_PENDING_UNKNOWN_CAUSE} —— 行仍待决而本副本没有在等它的登记(本副本不认得它的活卡:它活在别的副本上,或本副本这条登记已散场):
- *    换副本或换端点重试才有意义(这个词只属于 404 面,不是结局成因)。
- * **无持久店的部署上恒不带 `cause`**:那台机器压根没有行可判,编一个 cause 是撒谎。
+ * [ref] 随批小件:`tool_approval.not_pending` 404 的**判别位**([ref] 排障代价实证)。这个码只在按问读口**已过可见门**之后出(属主看得见的「这张卡此刻说不出待决」;
+ * 调用方**看不见**这只问 —— 无行 / 不属这只 task / 行不是调用方的 / 行读不出 —— 一律 404 `not_found.ask`,唯一成形口 {@link ToolApprovalCoordinator.askNotVisible})。
+ * 判别位只有一个词:{@link NOT_PENDING_UNKNOWN_CAUSE} —— 行仍待决而本副本没有在等它的登记(它活在别的副本上,或本副本这条登记已散场):换副本重读才有意义
+ * (这个词只属于 404 面,不是结局成因;没有人决过的行在读口上是 `state:"void"` + 行上的成因词,不走这个码)。坏行(读不出可用的决议)⇒ `cause` 缺席。
  */
 export declare const NOT_PENDING_UNKNOWN_CAUSE: "unknown_or_other_replica";
-export type NotPendingCause = AskRowEndingCause | typeof NOT_PENDING_UNKNOWN_CAUSE;
+export type NotPendingCause = typeof NOT_PENDING_UNKNOWN_CAUSE;
 /**
- * `GET /v1/tool-approvals/:approvalId` 应答体 `state` 的**闭集**(一只 ask 此刻在哪一态;读法与应答口逐条同源):
- *  · `pending` —— 本副本上有在等它的活登记(应答口此刻收得下);
- *  · `decided` —— 行 `DECIDED`(有人 / 有策略决过;回执三键同晚答回放体),**或**行 `PARKED` 而它的门已被决([ref]:checkpoint 已结算,见 {@link ParkedGateReading});
- *  · `parked`  —— 行 `PARKING`,或行 `PARKED` 且门仍是该会话当前待决的审批门(转后台候批;应答口走迟到受理,耐久回决口照收);门是被引擎重开的(决过之后续跑腿在动作开跑前失败)⇒ 另带 `reopened`([ref],见 {@link ReopenedGate});
- *  · `void`    —— 行 `DENIED` / `VOID`(没有人决过它,答案无处兑现;`cause` 同晚答 404),**或**行 `PARKED` 而它的门已过期 / 被取代(含停驻 run 被取消;此时 `cause` 缺席)。
+ * 审批卡同根两扇口(决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`、按问读口 `GET /v1/tasks/:taskId/asks/:askId`)对**看不见**这只问的调用方的那一句
+ * (`404 not_found.ask`;查无 / 不属这只 task / 不是你的 / 行读不出 同一句)—— 一句一处:两扇口底下是同一只问,句子分岔就等于把「它存在但不是你的」写在 wire 上。
+ */
+export declare const ASK_NOT_FOUND_UNDER_TASK = "no such approval ask under this task (never existed, belongs to another task, or is not yours)";
+/**
+ * `GET /v1/tasks/:taskId/asks/:askId` 应答体 `state` 的**闭集**(一只 ask 此刻在哪一态;读法 = {@link ToolApprovalCoordinator.readStateOfRow} 的六态表):
+ *  · `pending` —— 本副本上有在等它的活登记(决断口的 live 臂此刻收得下);
+ *  · `decided` —— 行 `DECIDED`(有人 / 有策略决过;`decision` / `decidedAtMs` / `decisionNote`,与决断口回放同一对词),**或**行 `PARKED` 而它的门已被决([ref]:checkpoint 已结算,见 {@link ParkedGateReading});
+ *  · `parked`  —— 行 `PARKING`,或行 `PARKED` 且门仍是该会话当前待决的审批门(转后台候批;决断口的停驻臂与耐久回决口照收);门是被引擎重开的(决过之后续跑腿在动作开跑前失败)⇒ 另带 `reopened`([ref],见 {@link ReopenedGate});
+ *  · `void`    —— 行 `DENIED` / `VOID`(没有人决过它,答案无处兑现;`cause` = 行上记的成因词,与决断口 410 同一列),**或**行 `PARKED` 而它的门已过期 / 被取代(含停驻 run 被取消;此时 `cause` 缺席)。
  */
 export declare const TOOL_APPROVAL_READ_STATES: readonly ["pending", "decided", "parked", "void"];
 export type ToolApprovalReadState = (typeof TOOL_APPROVAL_READ_STATES)[number];
@@ -77,12 +76,12 @@ export interface AskRowReadProjection {
     toolName?: string;
     frame?: ApprovalRequestFrame;
 }
-/** `GET /v1/tool-approvals/:approvalId` 的 200 体:列表面同一只行投影 + `state` + 各态附键。 */
+/** `GET /v1/tasks/:taskId/asks/:askId` 的 200 体:列表面同一只行投影 + `state` + 各态附键。`decision` 与决断口同一对词(`approve` / `deny`,行上的词)。 */
 export type ToolApprovalReadBody = ({
     state: "pending";
 } & LivePendingRow) | ({
     state: "decided";
-    decision: "allow" | "deny";
+    decision: AskDecision;
     decidedAtMs: number;
     decisionNote?: string;
 } & AskRowReadProjection) | ({
@@ -93,6 +92,14 @@ export type ToolApprovalReadBody = ({
     state: "void";
     cause?: AskRowEndingCause;
 } & AskRowReadProjection);
+/** 一条行的**可读决议**(权威四合取:二值 ∧ 非 provisional ∧ 有 `decidedAtMs` ∧ 态确为 DECIDED;四合取各自的来由见耐久决断口 `decidedRowIsAuthoritative`
+ *  的顶注)。**这是那只判据的唯一读法** —— 读口、唯一写者的迟到臂、耐久决断口的守卫都读它。读不出 ⇒ `undefined`(各口按「不是一条可用的人的决议」
+ *  处置,绝不把坏行包装成首决交出去)。 */
+export declare function decidedRowFacts(row: AskRow): {
+    decision: AskDecision;
+    decidedAtMs: number;
+    decisionNote?: string;
+} | undefined;
 /**
  * 结算一张卡的**判决** —— 判别联合,逼每个调用点说清「这次等待是怎么结束的」:
  *  · `by:"human"` —— 一次**决议**到了(人答,或从问账行读回来的决议,含部署政策拒落成的 `DECIDED` 行,`hostSource` 记它的来源词与机器座位):`allowed` 说方向;审计 settle 行
@@ -135,7 +142,7 @@ export type SettleVerdict = {
  * 悬挂 promise 的可能是另一个副本(F4 的轮询腿会在它自己的下一拍续跑)。run 的生死读 run 面。
  *
  * [ref] 起**同一个词、同一句语义**也出现在 live 面:审批机起服时从问账接管的登记(没有引擎腿在等)在 `livePending` 行上带它,
- * 在 live 应答口的 200 回执上按同一判据(本副本被唤醒的等待腿数 = 0)带它。一个事实,各面一个读法。
+ * 在决断口 live 形的 200 回执上按同一判据(本副本被唤醒的等待腿数 = 0)带它。一个事实,各面一个读法。
  */
 export declare const ASK_DECISION_CONSUMER_ABSENT = "absent";
 /**
@@ -165,58 +172,118 @@ export interface ParkedAskRedeemRequest {
     /** 卡上点的是 `allow_session` ⇒ `"session"`:与 `/decide` 体上的 `remember:"session"` 是**同一只**「本会话放行」请求,交同一个铸点
      *  (续跑腿 `resumeCheckpoint`;可记与否从同一条停驻行判、落同一只豁免店、只在结清之后落)。缺席 = 只放行这一次的那两个词。 */
     remember?: "session";
+    /** 「不再询问」的规则位(已过唯一判官 {@link readPersistRuleSlot})—— 与 `/decide` 体上的 `persistRule` 是**同一只**请求,交同一个铸点(续跑腿结清点,记录 = 这张卡的问行)。 */
+    persistRule?: ParsedPersistRule;
     /** 发起本次 respond 的**已验证**调用方(live 腿 `gatedSubject` 的那一把)。席在赎回之前拿它与
      *  **checkpoint 当下的 scope** 对一次(codex R1-[high] 一:收编改写身份之后,任何缓存的属主判据都
      *  过期;门必须贴在当下的持久事实上)。 */
     principal?: string;
+    /** 调用方的**运维身份**(交来这一问的那扇门已判过的那一格;[ref] α):席复核 checkpoint 当下的 scope、续跑腿复核载入行时按它读面表 `scope.decide` 的运维列。
+     *  耐久决断口 = 它的面表 `ask.decide` 运维列读到的那位(显式运维代决别人的卡,live 与停驻两形同放);7.151.x 及以前的应答口恒 `false`(面表 `ask.answer` 没有运维列;该口 7.152.0 起已删)。
+     *  必填:缺省等于替门作答「不是运维」或「是运维」—— 两个方向都是同一扇门对两形说两种话。 */
+    operator: boolean;
     /** 发起本次 respond 的真实 HTTP 请求。赎回腿据它做准入解析与舰队 scope(与 `/decide` 腿同姿势);
      *  缺席 ⇒ 那条腿按「无请求」形处置(它自己的成文语义,本席不替它决定)。 */
     httpReq?: IncomingMessage;
 }
+/**
+ * 一次对停驻卡的决定 —— 耐久决断口的停驻形(7.151.x 及以前另有应答口 PARKED 臂同调)交给**同一只**赎回(`ToolApprovalCoordinator` 的 `runParkedFlight`)的那一份。
+ * 门各自已过属主门、把自己的词映进来:`write` = 这次决定的记录(决议向 · 出处 · 理由 · 署名 · 键 —— 停驻门受理之后落在问行上的就是它),其余是停驻门要的余项。
+ */
+export interface ParkedDecisionRequest {
+    readonly write: AskDecisionWrite;
+    /** 「本会话放行」(决断体上的 `remember:"session"`;与 `/decide` 的 `remember:"session"` 同一只请求、同一个铸点 —— 续跑腿 `resumeCheckpoint`)。 */
+    readonly remember?: "session";
+    /** 「不再询问」的规则位(决断体上的 `persistRule`,唯一判官 {@link readPersistRuleSlot})—— 交赎回席,由续跑腿的结清点兑(记录 = 这张卡的问行)。 */
+    readonly persistRule?: ParsedPersistRule;
+    /** ctrl+g 编辑实参(只 approve 交给门的绑定;不落问行)。 */
+    readonly updatedInput?: unknown;
+    readonly principal?: string;
+    /** 见 {@link ParkedAskRedeemRequest.operator}(同一格,原样交席)。 */
+    readonly operator: boolean;
+    /** 要人门([ref])的判词,由口按这张卡与决定者位判好交来(`true` ⇒ 这一形的放行不归策略答)。只在「这一次要写」时读:门上已站着决定 ⇒ 先回放 / 冲突。 */
+    readonly policyMayNotApprove?: boolean;
+    readonly httpReq?: IncomingMessage;
+}
+/** 耐久决断口对一只停驻的问拿到的答案(`ToolApprovalCoordinator.decideParkedAsk`;口按自己的 wire 律渲染,与 `DECIDED` 行同一条回放 / 冲突律)。 */
+export type ParkedAskAnswer = 
+/** 本次请求被停驻门受理(赎回席的受理恒是 `200`:`acceptedResumingReceipt` 一只铸点;`body` = 那只受理体;`recorded` = 受理之后落了记录的那一行,没落成 ⇒ 缺席)。 */
+{
+    readonly kind: "accepted";
+    readonly body: Record<string, unknown>;
+    readonly recorded?: AskRow;
+    readonly rememberApplied?: boolean;
+    readonly rule?: RuleSlotReceipt;
+}
+/** 没生效(门 / 席 / 准入的拒,原样)。 */
+ | {
+    readonly kind: "refused";
+    readonly status: number;
+    readonly body: Record<string, unknown>;
+}
+/** 门上已站着一次决定(向 / 时刻 / 理由取门;署名取行上的记录 —— 只在记录说的就是门上这一向时;`byThisRequest` = 本次请求的键就是记录上那把)。 */
+ | {
+    readonly kind: "standing";
+    readonly decision: AskDecision;
+    readonly decidedAtMs: number;
+    readonly decisionNote?: string;
+    readonly actor?: unknown;
+    readonly byThisRequest: boolean;
+}
+/**
+ * 这台部署上停驻形**只有耐久审批门收**:赎回席没接(直连门部署 —— 停驻门的决定要签名信封,而这扇口没有决策证明;fail-closed,接线处 `boot/late-binds.ts`),
+ * 或行上没有门坐标(受损行,没有门可交)。口按自己的词指路那道门。
+ */
+ | {
+    readonly kind: "gate_only";
+}
+/** 重判那一读读不出 / 行已不在门判过的属主域(门读之后被收编改写)⇒ 与查无同答(口按自己的词)。 */
+ | {
+    readonly kind: "gone";
+}
+/** 要写的是一次策略对要人的卡的放行(`ParkedDecisionRequest.policyMayNotApprove`)⇒ 写之前拒(口按自己的词;与 live 形同一道门、同一个位置)。 */
+ | {
+    readonly kind: "policy_refused";
+};
 /** [ref]:赎回席的结局 = 赎回腿的原始 HTTP 结果面 + 请求带了 `remember` 时铸点的真答(`rememberApplied`:落没落;不进 `body` —— 首次受理的回执挂它,
  *  受理回执(幂等回放的那一份)不存它)。 */
 export interface ParkedAskRedeemResult {
     status: number;
     body: Record<string, unknown>;
     rememberApplied?: boolean;
-    /**
-     * [ref]:这次赎回所决的那道门的世代(席读到的那一行 checkpoint 的世代号,core `checkpointRevOf`)—— 受理回执的键的一半,由**真正决了它的那一席**交回。
-     * 生产席读到行之后的每一答都带(行读不到的拒答不带);缺席 ⇒ 回执说不出这一代 ⇒ 照旧回放({@link receiptAnswersNow})。
-     */
-    gateGeneration?: number;
+    /** 请求带了 `persistRule` 时续跑腿结清点铸的规则回执(2xx 恒带;不进 `body` —— 首次受理的回执挂它:回放不兑规则)。 */
+    rule?: RuleSlotReceipt;
 }
 /** [ref]:赎回席(装配层注入;缺席 ⇒ PARKED 臂逐字回落修前 404)。 */
 export type ParkedAskRedeem = (req: ParkedAskRedeemRequest) => Promise<ParkedAskRedeemResult>;
 /**
  * 一张门被引擎**重开**过的停驻卡([ref]):决过之后,续跑腿在被批准的动作开跑之前失败,引擎把同一张门(同一把 token)翻回待决。
- * `reason` = core 记在行上的重开因由词原样(闭集 `REOPEN_REASONS`:`env_failed` 同一个决议再交一次即可续跑(两扇决议口都行:应答口的受理回执键带门世代,重开之后不再回放首次受理,[ref]);`tool_unavailable` / `constraint_rejected` 要重新决;`config_refused` 改好部署配置后再交原决议,或重新决);
+ * `reason` = core 记在行上的重开因由词原样(闭集 `REOPEN_REASONS`:`env_failed` 同一个决议再交一次即可续跑(决断口与耐久回决口都行);`tool_unavailable` / `constraint_rejected` 要重新决;`config_refused` 改好部署配置后再交原决议,或重新决);
  * `decision` / `decidedAtMs` / `decisionNote?` = 重开之前的那次决议(读法与已结算门的 `decided` 同一只;读不出 ⇒ 三键缺席,只带因由词)。
  */
 export type ReopenedGate = {
     readonly reason: ReopenReason;
 } | {
     readonly reason: ReopenReason;
-    readonly decision: "allow" | "deny";
+    readonly decision: AskDecision;
     readonly decidedAtMs: number;
     readonly decisionNote?: string;
 };
 /**
  * 按问读口对一张 `PARKED` 卡的**门读法**([ref];判官的唯一属主 = `approval-gate-currency.ts`,协调器本身不认识 checkpoint 的形):
- *  · `open` —— 这张卡的门仍是该会话当前待决的审批门(应答口收得下)⇒ 读口说 `parked`;门被引擎重开过 ⇒ 另带 `reopened`([ref],{@link ReopenedGate});
- *    `generation` = 这道门此刻的世代号(core `checkpointRevOf`:每一次 resolve / reopen 都推它)—— 应答口受理回执的键的一半([ref]:重开 = 新一代 = 新键);
+ *  · `open` —— 这张卡的门仍是该会话当前待决的审批门(决断口的停驻臂收得下)⇒ 读口说 `parked`;门被引擎重开过 ⇒ 另带 `reopened`([ref],{@link ReopenedGate});
  *  · `decided` —— 门已被决:方向 / 时刻 / 理由取自 checkpoint 上的结算赢家 ⇒ 读口说 `decided`;
  *  · `void` —— 门已过期 / 被取代(含停驻 run 被取消:取消先把门 expire)⇒ 读口说 `void`(没有人决过它,答案无处兑现);
  *  · `unknown` —— 说不出可信的话:`row_absent` = checkpoint 行没了;`decision_unreadable` = 门已结算却读不出可用的决议(行的 status 词或结算种类不在闭集表里 / 结算记录过不了 core 的
- *    门记录筛 / 方向或时刻读不出)⇒ 读口答 404 `tool_approval.not_pending`(坏行不包装成首决;应答口并不同判:它的 PARKED 臂只对 checkpoint 行没了答 404,已结算的门答 409 `approval_stale`),
+ *    门记录筛 / 方向或时刻读不出)⇒ 读口答 404 `tool_approval.not_pending`(坏行不包装成首决),
  *    并记一行 error:`defects` 是读不出的那几处(非空),日志带首句 + 计数。
  */
 export type ParkedGateReading = {
     readonly kind: "open";
-    readonly generation: number;
     readonly reopened?: ReopenedGate;
 } | {
     readonly kind: "decided";
-    readonly decision: "allow" | "deny";
+    readonly decision: AskDecision;
     readonly decidedAtMs: number;
     readonly decisionNote?: string;
 } | {
@@ -300,7 +367,7 @@ export type StandingAnswerHome = "none" | "seat" | "server_store";
 /**
  * 🔴 **[ref] —— 会话级放行的唯一判据:站着的答案能不能退掉这一问,能的话它记在哪({@link StandingAnswerHome})。** 纯函数,读者:
  *  · **读侧**(`askBroadcast` 的会话授权短路 {@link ToolApprovalCoordinator.standingGrantSettles}):`seat` 才可能由既有授权代答,否则往下走真出卡;
- *  · **写侧**(`finishRespond` 与 `recordDeploymentListAnswer`,经 {@link liveSessionAnswer}):`seat` 把 `allow_session` 铸成进程内授权;`server_store` 落 server 的会话豁免店;
+ *  · **写侧**(`settleLiveDecision`,经 {@link liveSessionAnswer}):`seat` 把 `remember:"session"` 铸成进程内授权;`server_store` 落 server 的会话豁免店;
  *    `none` 只放行这一次、`rememberApplied:false`;
  *  · **卡面提示位**(活卡帧 / 条目 / `livePending` 行的 `rememberRefused`):在场 ⇔ 本函数答 `none` 或这条腿记不下(读的是 {@link liveSessionAnswer},它先问本函数);
  *  · **耐久可记性**({@link standingAnswerDurablyRecordable}:`/decide` 的 remember、运维队列行、策略层两只豁免读面)。
@@ -372,23 +439,19 @@ export declare function parkRowStandingAnswerFacts(stored: Extract<PendingAction
 }>, gate: CheckpointGate, governance: GovernancePosture | undefined, 
 /** 部署名单门对这一行的调用出不出它自己的问(`approval.ts` 的 `deploymentListAsks`,调用方现读活配置;停驻行上只有 wire 名)。 */
 deploymentListAsks: boolean): StandingAnswerFacts;
-/** A live approval frame delivered to whoever tails this run's stream. `type` IS the SSE event name (named-event
- *  convention, same as question). The shell renders `tool_approval` as the CC three-choice card and dismisses on
- *  `tool_approval_complete`.
- *  🔴 **旧族**:只投给呈卡协议未上场的腿(一条腿一个帧族,见 {@link ToolApprovalRunContext});呈卡腿上同一次铸定的这只对象仍是
- *  卡外开卡事实的来源(`ApprovalRequestLiveFacts` 取自它)与 `livePending` 行的 `frame`。 */
+/** 一只 ask 在 `askBroadcast` 里铸定的**素材对象**(一处脱敏属主)—— 呈卡帧的卡({@link ApprovalCardSource})与卡外开卡事实
+ *  (`ApprovalRequestLiveFacts`)都取自它。🔴 **它本身不上 wire**:审批只有呈卡族一个帧族(旧族的开卡 / 闭合帧连同只属于它们的 `type` 与闭合三键已退役;
+ *  `approvalId` 随身份退役那一步收;键集账见 `trace/core-keyset-guard.ts`)。 */
 export interface ToolApprovalFrame {
-    type: "tool_approval" | "tool_approval_complete";
     approvalId: string;
-    /** "tool_approval" only: which tool asked (canonical core name as core sent it) + the policy's ask message. */
+    /** which tool asked (canonical core name as core sent it) + the policy's ask message. */
     toolName?: string;
-    /** [ref] "tool_approval" only: **core 的 tool-call id**(`AskRequest.toolCallId`,逐字透传)——消费端用它
+    /** [ref] **core 的 tool-call id**(`AskRequest.toolCallId`,逐字透传)——消费端用它
      *  把审批卡锚到助手消息里那个 `tool_use` 块。`approvalId` 是审批自己的新 uuidv7、与该块**无关**,
      *  此前帧上只有它 ⇒ 两个宿主都只能拿它当 key 铸卡,而那个 id 之后再没有任何帧提到过,卡永远停在
      *  awaiting_approval。「拿最近一次 tool_start 当锚」这类补偿也不成立:**审批帧比 `tool_start` 先到**
      *  (cli 帧级取证 4020ms vs 4142ms)。durable(parked)腿本来就存着这个值(parked-decide.ts),
-     *  本键 = 把 live 腿的字段集与它对齐。闭合帧(`tool_approval_complete`)不带——它按 approvalId 消卡,
-     *  多一个锚只会多一份歧义。 */
+     *  本键 = 把 live 腿的字段集与它对齐(卡上 `card.toolCallId`)。 */
     toolCallId?: string;
     /** **只在委派子代的 ask 上在场**(现判别键 = {@link ToolApprovalFrame.fromSubagent};本字段本身
      *  [ref] MED-1 后不再是判别式,core JSDoc 钉明「不是子代判别键」)。值 = 子代的 core session id
@@ -416,7 +479,7 @@ export interface ToolApprovalFrame {
     };
     message?: string;
     /**
-     * [ref]/[ref] **ADDITIVE**,`"tool_approval"` only —— `true` ⇔ 这只 ask 的门来自**运维治理层**
+     * [ref]/[ref] **ADDITIVE** —— `true` ⇔ 这只 ask 的门来自**运维治理层**
      * (`AUTONOMY` / `commandPolicy` / `MANUAL_MODE_SHELL_GATE` / `SENSITIVE_WRITE_PATTERNS` 合成的那条
      * policy,`applyRuntimeGovernance`),而不是模型默认门或客户端表态。壳据此渲染「治理强制」徽标,回答
      * [ref]#1/[ref] 实证的那个 UX 缺口:「我都开 bypassPermissions 了为什么还在问」。
@@ -428,7 +491,7 @@ export interface ToolApprovalFrame {
      * `governance-ask-marks.ts` 顶注。
      */
     governanceForced?: true;
-    /** [ref]([ref]③/[ref];**ADDITIVE**,`"tool_approval"` only)——core PreToolUse hook/策略族铸的
+    /** [ref]([ref]③/[ref];**ADDITIVE**)——core PreToolUse hook/策略族铸的
      *  **安全类 ask 出身位**(`AskRequest.requiresRealApproval`,core 5.37 起可选、真才带)。帧顶层契约与
      *  core 侧同构:**真才带,缺席绝不编 false**(governanceForced 同形)——与 `card.requiresRealApproval`
      *  (approval-card.ts,恒在布尔)**两侧契约刻意不同、别混**:卡是 durable 店形(askStore 在场)专属,
@@ -438,7 +501,7 @@ export interface ToolApprovalFrame {
      *  `card.risk.requiresRealApproval`、列表行顶层同值)。 */
     requiresRealApproval?: true;
     /**
-     * **[ref]**(core 7.26.0;**ADDITIVE**,`"tool_approval"` only)—— **这一问没有任何规则能清掉**
+     * **[ref]**(core 7.26.0;**ADDITIVE**)—— **这一问没有任何规则能清掉**
      * (`AskRequest.mandated`:org / 治理层、保护判官、hook 的筛查权、被祖先的应答者裁决的问…… 由引擎在闸站
      * 盖章,策略方不可自填、只可收紧)。壳据它渲染「规则清不掉这一问」,并让**声明了自动应答姿态**的席位知道
      * 哪些卡它不该自动答。
@@ -468,9 +531,9 @@ export interface ToolApprovalFrame {
      */
     mandated?: true;
     /**
-     * **7.116.0(审计修复批 S4;ADDITIVE,`"tool_approval"` only)—— 这张卡上的「本会话放行」只放行这一次、不会被记住。**
+     * **7.116.0(审计修复批 S4;ADDITIVE,卡外 / 卡内事实)—— 这张卡上的「本会话放行」只放行这一次、不会被记住。**
      * 在场 ⇔ 同一只判官 {@link liveSessionAnswer} 答 `none`(问本身记不住:治理强制 / 必须真人 / 强制 / 应答还授予别的东西 / 类集清不掉;或这条腿记不下:
-     * 没有会话 / 读不出会话住客),回决侧写授权(`finishRespond`)读的是同一只 ⇒ 帧说不可记 ⇔ 点了 `allow_session` 回执 `rememberApplied:false`。壳读这一位决定渲不渲
+     * 没有会话 / 读不出会话住客),回决侧写授权(`settleLiveDecision`)读的是同一只 ⇒ 帧说不可记 ⇔ 带了 `remember:"session"` 回执 `rememberApplied:false`。壳读这一位决定渲不渲
      * 「本会话放行」,不再从 `requiresRealApproval` / `mandated` / `governanceForced` 三位自己推断(那一推断漏掉第四个理由:core 7.41.0
      * 的 `Skill` 卡批准即授予清单,三位全无)。`card_json` 卡面、`livePending` 行、运维队列行同名同义。
      * 判官是 {@link liveSessionAnswer}(这一问的事实 + 这条腿记不记得下:没有会话的腿、读不出会话住客的腿同样在场),回决写侧读同一只。
@@ -478,7 +541,7 @@ export interface ToolApprovalFrame {
      */
     rememberRefused?: true;
     /**
-     * **[ref](core 7.32.0 [ref];ADDITIVE,`"tool_approval"` only)** —— 强制位**站在哪一个词上**:core `PERSISTED_RULE_MANDATES`
+     * **[ref](core 7.32.0 [ref];ADDITIVE,卡外 / 卡内事实)** —— 强制位**站在哪一个词上**:core `PERSISTED_RULE_MANDATES`
      * 六词之一(`operator_always` / `tool_marks` / `probe_mandate` / `probe_unanswered` / `write_protection` /
      * `target_unresolved`,词义属主在 core)。只在 `mandated: true` 的**整因**是那一个词时在场;另一扇门(治理 / hook /
      * 祖先)或不止一个理由 ⇒ 缺席 —— **缺席从不命名一个词**,也不等于「不强制」(读 `mandated`)。值经 `approval-card.ts` 的
@@ -488,7 +551,7 @@ export interface ToolApprovalFrame {
      */
     mandate?: PersistedRuleMandate;
     /**
-     * **[ref]③/[ref]**(core 7.5.0;**ADDITIVE**,`"tool_approval"` only)—— 这只 ask 的**出身**:
+     * **[ref]③/[ref]**(core 7.5.0;**ADDITIVE**)—— 这只 ask 的**出身**:
      * 谁提的这一问,一个 core 闭集词(`ASK_ORIGINS` **11 员**,core 7.14.0 现值:content_question /
      * ancestor_marked / org_unavailable / org_rule / rule_store_unavailable / hook / ask_rule /
      * denial_limit_fallback / shell_gate_tighten / safety_tighten / policy)。引擎在门上盖章(core d.ts:
@@ -518,7 +581,7 @@ export interface ToolApprovalFrame {
      */
     origin?: string;
     /**
-     * **ADDITIVE,`"tool_approval"` only** —— 这一问的调用是**一张扩展注册自己发起**的(`$.tool.call`,core 7.56.0 `AskRequest.requestedBy`):
+     * **ADDITIVE,卡外 / 卡内事实** —— 这一问的调用是**一张扩展注册自己发起**的(`$.tool.call`,core 7.56.0 `AskRequest.requestedBy`):
      * `{ kind: "extension", name }`,卡上「扩展 X 想跑 …」那一行的出处。模型消息带来的调用上缺席。display 事实,不是裁决输入。
      * 读法与 `tool_start` / `tool_end` 上的同名键是同一只(`trace/extension-call-face.ts`:注册名过注册方文本的出口纪律,与 `wiring_manifest.mods[]` 的 `name`
      * 逐字节同;形不对 ⇒ 丢 + 计一次)。呈卡腿上它是 `approval_request` 顶层的卡外座之一(`APPROVAL_REQUEST_LIVE_FACT_KEYS`,同一只帧对象的值);
@@ -526,7 +589,7 @@ export interface ToolApprovalFrame {
      */
     requestedBy?: ExtensionRequesterFace;
     /**
-     * **[ref] ②(core 7.37.0 [ref];ADDITIVE,`"tool_approval"` only)** —— 这一问的**类**:`classes` 的首员(core `ASK_CLASSES` 序),
+     * **[ref] ②(core 7.37.0 [ref];ADDITIVE,卡外 / 卡内事实)** —— 这一问的**类**:`classes` 的首员(core `ASK_CLASSES` 序),
      * `MODE_ARBITRATION` 的行键(权限模式读的就是它 / 它们)。引擎在每一个铸 `origin` 的站盖章(策略自报的值在盖章处被替换),本仓经
      * `approval-card.ts` 的 `readAskClassPair(req)` 窄读(判法 = core 屏 `screenAskClassMembers`,[ref] ⑥ / [ref],本仓零自写对判;屏拒 ⇒ 两键都不投 + 计一次
      * [ref] 集外 tag)。**与 {@link classes} 同在同缺**;缺席 = 老引擎 / 不盖类的站(共享制品读确认,core [ref]),不是「无类」。
@@ -539,7 +602,7 @@ export interface ToolApprovalFrame {
      *  几类)。与 `askClass` 同在同缺、同一只窄读;逐字同序过境,不排序不去重。 */
     classes?: AskClass[];
     /**
-     * core 7.43.0 [ref] / [ref](**ADDITIVE**,`"tool_approval"` only)—— 对引擎 `Skill` 工具的调用,批准它**还授予**的东西的摘要
+     * core 7.43.0 [ref] / [ref](**ADDITIVE**)—— 对引擎 `Skill` 工具的调用,批准它**还授予**的东西的摘要
      * (`AskRequest.boundGrantDigest`,技能名 + 两只清单规范拼写的哈希);别的卡缺席。与停驻行 / inbox 行的同名位同值(core:同一只工厂铸,
      * 活卡与它的停驻孪生按 `(toolCallId, boundGrantDigest)` 对账)。逐字过境,本仓不重算;站着的答案按「工具 + 它」记([ref])。
      */
@@ -547,7 +610,7 @@ export interface ToolApprovalFrame {
     /** 上一位哈希的那一份值:`{ skill, allowedTools, disallowedTools }`(`skill: null` = 调用没点名任何已载技能)。与摘要同在同缺;**部署文本**,
      *  壳按上下文转义渲染(core:display metadata)。逐字过境。 */
     boundGrants?: BoundSkillGrants;
-    /** [ref](core 7.51.0 [ref],**ADDITIVE**,`"tool_approval"` only):这张卡为什么没有 {@link boundGrantDigest} —— 引擎铸的每张卡恰带两者之一:
+    /** [ref](core 7.51.0 [ref],**ADDITIVE**):这张卡为什么没有 {@link boundGrantDigest} —— 引擎铸的每张卡恰带两者之一:
      *  `not_bindable`(这一问不是引擎 `Skill` 工具的激活,不绑任何授予 ⇒ 应答可按工具记)/ `unreadable`(绑着却读不出;活卡上引擎恒给摘要,这一词
      *  只出现在读存量行的面上)。闭集经 `readClosedWordSeat(req, "boundGrantAbsence")` 窄读(筛 = core `BOUND_GRANT_ABSENCES`),集外 ⇒ 缺席 + 计一次。
      *  与停驻行 / 运维队列行 / inbox 行的同名位同值;站着的答案的授予绑定读它(`standing-answer-grant.ts` `grantBindingOf`,问是谁的都同读)。display。 */
@@ -556,7 +619,7 @@ export interface ToolApprovalFrame {
      *  `readClosedWordSeat(req, "classifierNoRuling")` 窄读(筛 = core `isAutoModeFallbackCause`),集外 ⇒ 缺席 + 计一次。display:本仓不按它裁决。 */
     classifierNoRuling?: AutoModeFallbackCause;
     /**
-     * **core 7.49.0 [ref](ADDITIVE,`"tool_approval"` only)—— 这一问渲在哪张卡上**:引擎在闸站铸的那一个词(闭集 = core 的 `TOOL_APPROVAL_CARDS`,
+     * **core 7.49.0 [ref](ADDITIVE,卡外 / 卡内事实)—— 这一问渲在哪张卡上**:引擎在闸站铸的那一个词(闭集 = core 的 `TOOL_APPROVAL_CARDS`,
      * 本文不抄词表 —— 词表的唯一写者在引擎),`AskRequest.approvalCard` 逐字过境,经
      * `approval-content-kind.ts` 的 `readApprovalCard` 闭集窄读(集外 ⇒ 缺席 + 计一次 closed-word-out-of-set)。`question` = 问用户的问题(引擎保留的
      * 问答工具),不是副作用工具。**本仓不从工具名回推卡**(工具名只作展示):此前按名字铸的 `livePending` 行 / 队列行 `contentKind` 随本键删。
@@ -566,7 +629,7 @@ export interface ToolApprovalFrame {
      */
     approvalCard?: ToolApprovalCard;
     /**
-     * **[ref]**(core 7.19.0;**ADDITIVE**,`"tool_approval"` only)—— 这只**根外读** ask 的**清障目录**:
+     * **[ref]**(core 7.19.0;**ADDITIVE**)—— 这只**根外读** ask 的**清障目录**:
      * 把 `dir` 加进本会话的读目录(壳侧既有的 `/add-dir` 口),同一条调用就不会再问。
      *
      * 🔴 **在场才读,永远不读缺席**。缺席不是「无计可施」:它同时覆盖敏感路径 deny 行(按模式判,加任何
@@ -585,11 +648,11 @@ export interface ToolApprovalFrame {
      * 一只 PARKED 的根外读 ask 渲的仍是单独那张确认卡。所以停驻行 / 运维队列行 / inbox 行**没有**这一座,本仓也不
      * 自铸一个(自铸 = 同一事实的第二个源,而且那个源会在 park 兑现时说谎)。问行卡信封的活面事实座(7.143.0)不是自铸:
      * 它是呈卡帧上这一格的同一份值、同一条写落下,只供同一只还在流上的问的重放帧读(断流续读 / 开流 preamble),
-     * 射程与卡上 `ruleOffers` 同一句(回授经重放帧自己的 `approvalId` 走活应答口)。
+     * 射程与卡上 `ruleOffers` 同一句(回授经重放帧自己的 `askId` 走决断口的 live 形)。
      */
     readRootCandidate?: ReadRootGrantCandidate;
     /**
-     * **E-14**([ref]② Trojan Source 族;**ADDITIVE**,`"tool_approval"` only)—— 这只 ask 的**工具输入**
+     * **E-14**([ref]② Trojan Source 族;**ADDITIVE**)—— 这只 ask 的**工具输入**
      * (`AskRequest.args`)里含 bidi 控制符(LRM/RLM、嵌入/覆写、隔离符;字符类与在场谓词的属主是 core 的 `BIDI_CONTROL_CHARS` / `carriesBidiControls`,经 `text-bidi.ts` 的 `hasBidiControls` 取)。
      *
      * 🔴 **真才带,缺席绝不编 `false`**(与 `governanceForced`/`requiresRealApproval` 同形)。缺席的含义是
@@ -601,11 +664,11 @@ export interface ToolApprovalFrame {
      * 执行的那串字节(卡上显示的与真跑的不是同一个东西),**比不披露更坏**;所以 server 只报「有」,显形
      * 归壳的渲染面(转义/高亮/加标记,壳自己定)。
      *
-     * **判据素材** = `boundArgs` 里对**原字节**(`redactDeep` 之前)的那一次序列化,且在**字节帽判定之前**算:
-     *  · 超帽时 args 以 `argsOmitted:true` 缺席上帧(卡上根本没有 args)—— 那正是人最看不见输入的一格,
+     * **判据素材** = `boundArgs` 里对**原字节**(`redactDeep` 之前)的那一次序列化,与折叠判定无关:
+     *  · 动作卡超帽时 args 以 `argsOmitted:true` 缺席上帧(卡上根本没有 args)—— 那正是人最看不见输入的一格,
      *    更需要知道「你看不到的那份里有隐形字符」,所以帽不影响本键;
-     *  · 序列化失败(循环引用 / 抛错的 `toJSON` / BigInt)⇒ 两件事一起交白卷:args 不上帧,本键**不铸**
-     *    (两次 `JSON.stringify` 共用同一个 try/catch —— 顶注反对的是第二个**静默降级点**,不是第二次序列化);
+     *  · 序列化失败(循环引用 / 抛错的 `toJSON` / BigInt;脱敏后那一份或原字节那一份,任一)⇒ 两件事一起交白卷:args 不上帧,本键**不铸**
+     *    (结局只有一个,且看得见:`argsOmitted`);
      *  · 素材是**原字节**,不是脱敏后那份:7.70.0–7.124.x 的脱敏器吐出剥掉全部 `\p{Cf}` 的文本(bidi 控制符整族都是
      *    `\p{Cf}`),在它上面扫本键恒缺席;7.125.0 起脱敏产物回到原文(认出的凭据跨度映回原文坐标替换,跨度外的
      *    格式字符逐字保留),原字节与卡面在 bidi 控制符上已无差别,素材仍取原字节(脱敏前那一次序列化,上一条)。
@@ -616,9 +679,9 @@ export interface ToolApprovalFrame {
      * 在骗你的眼睛」,把两个来源折进一个布尔会让壳无法判断该给哪一段加显形标记。
      */
     inputHasBidi?: true;
-    /** [ref]([ref]② cli 请托;**ADDITIVE**,`"tool_approval"` only,7.34.0+)——窗三键,与
+    /** [ref]([ref]② cli 请托;**ADDITIVE**,7.34.0+)——窗三键,与
      *  `approval_request` 帧([ref] 呈卡帧)同名同义:`expiresAtMs` = 本 ask 的绝对到期墙钟
-     *  (有店=行上一次铸定的 `expiresAtMs`,与卡帧/落库同值;无店 D1=注册时刻算定的同名初值),
+     *  (行上一次铸定的 `expiresAtMs`,与卡帧/落库同值),
      *  `serverNowMs` = **帧铸造时刻**(cli [ref] 锚定语义:倒计时锚=帧到手时刻的服务器钟),
      *  `expiresInMs` = `max(0, expiresAtMs - serverNowMs)` 现算。三键同生同缺(没有活审批通道的腿不发帧,
      *  发出的帧恒带);旧消费端无感,新壳借此给旧族帧补倒计时([ref] Q2 那类 77 分钟死卡的根治半场)。 */
@@ -626,7 +689,7 @@ export interface ToolApprovalFrame {
     expiresInMs?: number;
     serverNowMs?: number;
     /**
-     * core 7.42.0 [ref](**硬破坏换名**:取代 7.41.x 的 `persistedRuleShadowed`,零别名;`"tool_approval"` only)——
+     * core 7.42.0 [ref](**硬破坏换名**:取代 7.41.x 的 `persistedRuleShadowed`,零别名;卡外 / 卡内事实)——
      * allow 层里**命中了这次调用、却没能清掉这只 ask** 的成员,每个成员一条 `{ member, entries, omitted? }`:`member` ∈ core `ALLOW_RULE_MEMBERS`
      * (`hook` 部署 PreToolUse hook 的 allow / `deployment` 运维的 `APPROVAL_GRANT` / `persisted` 人存的 allow 规则 / `skill` 被激活技能的清单 /
      * `request` 请求的 `settings.permissions.allow`);`entries` = 那个成员命中的条目原文(hook 恒空表);`omitted` = 没列出的条目数。
@@ -649,7 +712,7 @@ export interface ToolApprovalFrame {
      */
     allowRuleShadowed?: AllowRuleShadowProjection[];
     /**
-     * [ref] 车二(core 5.18.0 [ref]):`"tool_approval"` only —— 引擎为这次 ask 铸的**规则候选**
+     * [ref] 车二(core 5.18.0 [ref]):卡外 / 卡内事实 —— 引擎为这次 ask 铸的**规则候选**
      * (`AskRequest.ruleOffers`,core 5.58.0 判别联合逐字透传:闭词表 `kind`/`match` + 引擎铸的文本,
      * server 不重铸不重排;序即契约——exact single 恒 0、batch 恒末,选择键=offer index)。
      * 壳据它渲「不再询问」,回决时用 `persistRule.rule` 报出选中的那一条。
@@ -661,7 +724,7 @@ export interface ToolApprovalFrame {
      */
     ruleOffers?: readonly RuleOffer[];
     /**
-     * [ref] 第五单(core [ref] 修②;**ADDITIVE**,`"tool_approval"` only)—— `ruleOffers` 的**缺席因由**:
+     * [ref] 第五单(core [ref] 修②;**ADDITIVE**)—— `ruleOffers` 的**缺席因由**:
      * 规则车道在场却无可给时,引擎点名哪扇门关了(闭三词集 `mandated`/`shadowed`/`lane_cannot_speak`,
      * 引擎侧与 `ruleOffers` 互斥)。壳据它把「为什么没有不再询问」渲成对应文案(`mandated` 臂**不得**
      * 指向写规则)。ADVISORY 展示元数据、永不是裁决输入;**缺席不是断言**(covers「有 offers」与三扇
@@ -670,7 +733,7 @@ export interface ToolApprovalFrame {
      */
     ruleOffersAbsence?: RuleOffersAbsence;
     /**
-     * [ref](core 7.4.0 [ref];**ADDITIVE**,`"tool_approval"` only)—— 这只 ask 是 auto 模式分类器的**限额
+     * [ref](core 7.4.0 [ref];**ADDITIVE**)—— 这只 ask 是 auto 模式分类器的**限额
      * 回落卡**:分类器连续(缺省 3)或累计(缺省 20)拒到限额的**那一次**调用不再静默 deny,而是落成一张
      * 必须真人批的卡(同一次铸造同时盖 `requiresRealApproval`,两键是孪生)。
      * `{consecutive, total, limit:"consecutive"|"total", autoDenyAfterMs}` —— 触限时的两个计数、哪一道界
@@ -692,7 +755,7 @@ export interface ToolApprovalFrame {
      */
     denialLimitFallback?: DenialLimitFallback;
     /**
-     * [ref] 件 G1(core 5.33.0 backlog [ref],判据帖 [ref] G1;**ADDITIVE**,`"tool_approval"` only)——
+     * [ref] 件 G1(core 5.33.0 backlog [ref],判据帖 [ref] G1;**ADDITIVE**)——
      * 这次 ask **为什么**被收紧的**结构化**因由(`AskRequest.probeCause`:工具的 `reversibilityProbe`
      * 判不出可回滚时,引擎在 maybe 档收紧点铸并 `normalizeProbeCause` 校验过的那一只)。
      *
@@ -724,7 +787,7 @@ export interface ToolApprovalFrame {
         };
     };
     /**
-     * [ref](7.115.0;**ADDITIVE**,`"tool_approval"` only)—— 这次 ask 被收紧时探针给出的那一句**散文**因由
+     * [ref](7.115.0;**ADDITIVE**)—— 这次 ask 被收紧时探针给出的那一句**散文**因由
      * (`AskRequest.probeReason`:core 在 maybe 档收紧点 `inlineUntrusted(…, 200)` 过的一句话)。与
      * {@link probeCause}(结构化因由)**并列、不替代**:引擎自己铸的因由走结构位,**部署自写的探针**只会写这一句
      * —— 一只只给 reason 不给 cause 的探针,此前其审批人在活卡上读不到任何因由(耐久面
@@ -740,7 +803,7 @@ export interface ToolApprovalFrame {
      */
     probeReason?: string;
     /**
-     * [ref] 件 G2(core 5.35.0 [ref] G-2;**ADDITIVE**,`"tool_approval"` only)—— 这只 ask 背后的
+     * [ref] 件 G2(core 5.35.0 [ref] G-2;**ADDITIVE**)—— 这只 ask 背后的
      * **规则出处证据**(`AskRequest.ruleEvidence`,引擎在 gate 内盖章):org 快照 `orgRevision` / 命中的
      * org 规则原文 `orgRule` / 被越级个人规则的 add dots `personalRuleDots`,**每员 = 值或五词命名缺席**
      * (`not_wired|not_adjudicated|unavailable|no_match|not_reported`,core `AskEvidenceAbsence` 闭集)。
@@ -758,49 +821,17 @@ export interface ToolApprovalFrame {
      * 本键的 dots 是那条规则的**机器身份**(a rule is a set of adds;数组即身份,消费端禁 join 成标量)。
      */
     ruleEvidence?: RuleEvidenceProjection;
-    /** "tool_approval" only: the tool call's args, secret-redacted, UNTRUSTED-for-display. Absent (with
+    /** the tool call's args, secret-redacted, UNTRUSTED-for-display. Absent (with
      *  `argsOmitted: true`) when over the byte cap or unserializable. */
     args?: unknown;
     argsOmitted?: boolean;
-    /** [ref] 随批小件([ref]-5 视觉真空的 server 半场;**ADDITIVE**,`"tool_approval_complete"` only,
-     *  真才带)——`outcome:"expired"` 一词三义(park / 当场 deny / 无设施 deny,见 outcome 注)里 **park
-     *  那一义的显式判别位**:在场 ⇔ **这条 ask 本身**按 park 路由收尾(`parkRouted`,settle 咽喉里置位;
-     *  [ref] F1/F3:首版读政策口〔unattendedPolicy+askStore 在场〕,对批内被连坐 VOID 的兄弟、取消/断连、
-     *  D5 fail-open 等非 park 终局全撒谎)。同一把 `approvalId`(= 行的键)仍可打 `respond` 走迟到受理兑现
-     *  (wire 契约迟到受理段;迟到腿直接读行,任一副本可达)。
-     *  壳据此把「卡失效」改渲「已转后台候批」。缺席**禁**读作
-     *  「真 deny」:无店部署 / deny 政策 / VOID 兄弟都发不出这个键,缺席只是「无 park 证据」。 */
-    parked?: true;
-    /**
-     * "tool_approval_complete" only: how the ask settled. `allowed`/`denied` = a human decision.
-     *
-     * 🔴 `expired` = **这张卡失效了**(TTL / abort / 断连 / 批内兄弟被撤卡 superseded),**不等于「这次调用
-     * 被拒了」**([ref]:本注上一版逐字写着「fail-closed deny the shell should render as such」——那是
-     * [ref] 断连转 park 与 [ref] R-13 窗到期转 park **之前**的语义,两批都没回来改这一行)。同一个词今天有
-     * 三种落点,由部署决定,壳**不能**从这个词自己推出终局:
-     *   · park 设施在场 + 缺省 `park` 政策 ⇒ core durable park(run 挂起候补批,`shapeOutcome` 交
-     *     `"unavailable"` 而本帧仍发 `expired`);
-     *   · `UNATTENDED_APPROVAL_POLICY=deny` ⇒ 当场 fail-closed deny(旧注只描述了这一支);
-     *   · 无 park 设施的部署 ⇒ core 自己 fail-closed deny。
-     * ⇒ 壳把它渲成「卡消失了」,**终局读 done 帧的 `status`/`errorCode`/`pendingGate`**。成文真源 =
-     * docs/ASSISTANT-WIRE-CONTRACT.md §4a-bis(「别把 expired 本身当拒绝回执渲染」)。
-     * 成因表也补了第四支:`settleVoidedSiblings` 的撤卡兄弟走的同样是这个词,那既不是 TTL 也不是断连。
-     * Cosmetic dialog-dismiss(这句仍成立——它讲的是**帧的角色**,不是终局)。
-     */
-    outcome?: SettleOutcome;
-    /**
-     * "tool_approval_complete" only(**ADDITIVE**):`outcome:"expired"` 的**成因** —— 与审计 settle 行 `cause` 是同一个词(闭集 {@link SettleCause}:窗到期 / 广播全灭 /
-     * 断连 / 呈不出去 / run 取消 / run 退出 / 批撤 / 兄弟被撤 / 崩溃 / 关停 ……)。**在场 ⇔ 非人结局**;人答(`allowed` / `denied`)不带。壳据它把「卡消失了」渲成具体的话
-     * (「已取消」「已到期」「断连」各自一句),而不再只有 `expired` 一个词。⚠️ 缺席不是证据:旧 server 从不发这个键,人答也不发。
-     */
-    cause?: SettleCause;
 }
 /** The per-run context `ask` recovers via ALS (mirrors QuestionRunContext + sessionId, which keys the allow-all). */
 /** [ref]:`GET /v1/approvals` 第二顶层键 `livePending` 的行形(与 durable `pending` 行**分数组不混编**
- *  ——两族行形与决议路由不同:本族行的决议口=`POST /v1/tool-approvals/:approvalId/respond`,durable 行
+ *  ——两族行形与决议路由不同:本族行的决议口=决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`,durable 行
  *  =decide 口;数组名即路由判据)。可选位全部「只记真、缺席不编」。 */
 export interface LivePendingRow {
-    /** = `respond()` / `GET /v1/tool-approvals/:id` 收的 wire id:有行的 ask = 行的键 `askId`,无行的 ask = 登记本地键(见 {@link PendingApproval.approvalId})。 */
+    /** 这只 ask 的 wire 身份 = 行的键 `askId`(与内嵌帧上的同名键同值;见 {@link PendingApproval.approvalId})。 */
     approvalId: string;
     toolName: string;
     /** 登记时刻(ms epoch)。 */
@@ -831,16 +862,16 @@ export interface LivePendingRow {
      * 不是「不强制 / 没有出身」—— 消费方按不知道读(强制与否不知道 ⇒ 按强制)。活登记恒不带(活铸帧上恒有事实);只记真。
      */
     liveFactsUnknown?: true;
-    /** 发起者为委派子代(originTaskId 在场)。 */
+    /** 发起者为委派子代(`sourceSessionId` 在场)。 */
     fromSubagent?: true;
-    /** [ref] C2(additive):委派子代的 **canonical taskId**。值域精确成文(codex R1-F3 问询后按 core dist
-     *  亲证):值 = `AskRequest.sourceSessionId` = 发起 task 的 sessionId(core prepare-task `askSourceIdentity`);
+    /** 委派子代的**会话 id**(additive 键,与内嵌帧 {@link frame} 的卡上的同名键同名同值:一个事实一个名字)。值域精确成文(按 core dist
+     *  亲证):值 = `AskRequest.sourceSessionId` = 发起这只问的会话(core prepare-task `askSourceIdentity`);
      *  而 core 的 canonical taskId = `spec.taskId ?? sessionId`(runtask.js `runSourceTaskId`),Runner 铸的
      *  委派子代 spec **不带** taskId ⇒ 子代 canonical taskId ≡ 子代 sessionId ≡ 本键 ≡
      *  `task_progress.taskId`(同一 `runSourceTaskId` 铸)—— 关联 join 在本键存在的唯一面(`fromSubagent`
-     *  子代 ask)上恒等成立。缺席 = 顶层 ask。`fromSubagent` 保留不动(byte-compat:先于本键的消费方仍按
+     *  子代 ask)上恒等成立。缺席 = 宿主自身的 ask。`fromSubagent` 保留不动(byte-compat:先于本键的消费方仍按
      *  它判别)。 */
-    originTaskId?: string;
+    sourceSessionId?: string;
     /** core 7.49.0 [ref]:这一问的卡词 —— 与 {@link frame} 上的 `approvalCard` **同一个值**(行读帧上那一格,不另读一遍),与 durable
      *  队列行顶层的同名键同层同形(那一面读门的 `gate.approvalCard`)。缺席 = 引擎没给(宿主自建 ask / 老引擎)。展示/分诊用,永不参与决议路由。
      *  (此前此处是按工具名铸的 `contentKind`,随 [ref] 删:卡只有引擎铸的这一个词。) */
@@ -860,10 +891,9 @@ export interface LivePendingRow {
      *
      * 缺席 = 老 server(7.86.0 及以前);本服务自 7.87.0 起**恒在场**(条目上是必填格)。恒不铸 `null`。
      *
-     * 🔴 **一只 ask 一个帧族(7.133.0 起)**:呈卡族的 ask(有行 —— 呈卡协议上场的 worker)⇒ 呈卡帧 `approval_request`(卡内事实在 `card` 里,
-     * 卡外的活面事实在帧顶层);旧族的 ask(无行)⇒ 活卡帧 `tool_approval`。按 `frame.type` 判别。
+     * 🔴 **只有一个帧族**:恒是呈卡帧 `approval_request`(卡内事实在 `card` 里,卡外的活面事实在帧顶层)—— 没有行的 ask 不登记、不上列表。
      */
-    frame?: ToolApprovalFrame | ApprovalRequestFrame;
+    frame?: ApprovalRequestFrame;
     /**
      * [ref]:**本副本上没有引擎腿在等这只问** —— 与耐久决断口 200 体同名同值同义的那一位({@link ASK_DECISION_CONSUMER_ABSENT})。
      * 在场 ⇔ 这一行是审批机起服时从问账接管的问(前一个进程 / 别的副本铸下、行仍 `STREAM_PENDING`;见 {@link ToolApprovalCoordinator.adoptOpenAsks}):
@@ -875,23 +905,19 @@ export interface LivePendingRow {
 /**
  * 一条执行腿的审批上下文 = 腿的身份三位 + 腿轴 + **帧族词 + 一只同族传输**。
  *
- * 🔴 **一条腿一个帧族**({@link ApprovalLegFamily}):呈卡协议在本腿上场(装配点按 `resolveApprovalLeg(...).active`)⇒ 族词 `approval_request`,
- * 本腿上一只 ask 的开卡 / 消卡 / 撤卡只走呈卡族(`approval_request` / `approval_complete` / `approval_revoke`),旧族帧一帧不发;协议未上场 ⇒
- * 族词 `tool_approval`(`tool_approval` / `tool_approval_complete`)。传输按族定型:呈卡族上下文的传输收不进旧族帧,「同一只 ask 在同一条腿上
- * 发两种开卡帧」不可构造。消费方在 wire 上判别本腿是哪一族:`GET /v1/capabilities` 的 `streamApproval`(与装配点同一只判据
- * `resolveStreamApprovalGate`,按 worker 求值;为真 ⇒ 本 worker 每条呈卡的腿都是呈卡族)。
+ * 🔴 **一只 ask 一个帧族,全仓只有一族**(`approval_request`:开卡 `approval_request` / 消卡 `approval_complete` / 批级撤卡 `approval_revoke`)。
+ * 只有呈卡协议在本 worker 上场(`resolveStreamApprovalGate(...).active`)、这条腿没关窗、这条 run 声明了这一族时才有上下文
+ * ({@link resolveApprovalLeg} 的 `unattended` 缺席);其余每一形这条腿都没有活审批通道,问当场交无人值守政策口 —— 没有「协议没上场就回退发另一族」的腿。
+ * 传输按族定型(收不进别的帧)。消费方在 wire 上读同一只判据:`GET /v1/capabilities` 的 `approvalFrameFamilies`(`[]` / `["approval_request"]`)。
  *
  * 传输是本腿**一只**(问题 / 表单两只协调器的上下文共用同一只;律在 `hitl-delivery.ts`:先本 run 账本、再直写,账本落不下 ⇒ 不上直写)。
  */
 export type ToolApprovalRunContext = ToolApprovalRunContextBase & ApprovalLegFamily;
 /** 帧族词 + 同族传输(见 {@link ToolApprovalRunContext} 顶注)。族词取自 {@link APPROVAL_FRAME_FAMILIES} 闭集。 */
-export type ApprovalLegFamily = {
+export interface ApprovalLegFamily {
     readonly family: "approval_request";
     readonly transport: HitlTransport<ApprovalCardLegFrame | ApprovalRevokeFrame>;
-} | {
-    readonly family: "tool_approval";
-    readonly transport: HitlTransport<ToolApprovalFrame>;
-};
+}
 /** 两族共有的腿身份与腿轴。 */
 interface ToolApprovalRunContextBase extends ApprovalLegOrigin {
     taskId: string;
@@ -911,7 +937,6 @@ interface ToolApprovalRunContextBase extends ApprovalLegOrigin {
      *  可 park 的 ask 拖成 abort-deny。真值由车3 的装配点供给,本车只立形+消费。 */
     legDeadlineMonotonic?: number;
 }
-export type ToolApprovalDecision = "allow" | "allow_session" | "deny";
 /**
  * [ref] 车二:回决回执上 `ruleRefusal` 的**闭词表**(「不再询问」这次为什么没存上)。
  *
@@ -981,42 +1006,160 @@ export declare const PERSIST_RULE_BATCH_EXCLUSIVE_ERROR = "persistRule.batchOffe
  */
 /** [ref](core 7.32.0 [ref])—— `readRootGrant` 只随 `decision:"allow"`(CC 卡的第三选项「Yes, and add directory」= 放行这一次
  *  + 加目录;`allow_session` 不是那一个选项,`deny` 上它没有意义)。裁决之前响亮拒,不静默丢。 */
-export declare const READ_ROOT_GRANT_ALLOW_ONLY = "readRootGrant is only meaningful with decision \"allow\" \u2014 it is the card's \"Yes, and add directory\" answer (allow this call and add the card's readRootCandidate.dir to this run's read directories)";
+export declare const READ_ROOT_GRANT_ALLOW_ONLY = "readRootGrant is only meaningful with a plain allow-this-call decision (not a deny, not a session allow) \u2014 it is the card's \"Yes, and add directory\" answer (allow this call and add the card's readRootCandidate.dir to this run's read directories)";
 /**
  * [ref]:这台部署不受理读根授权时,带 `readRootGrant` 的应答的拒句。受理与否是**部署姿态**(能力事实 `readRootGrant`,位 `approvalReadRootGrant`;
  * 判据的唯一属主在 `capability-facts.ts`,回决路由把它读来交给 {@link ToolApprovalCoordinator.respond}):不受理 ⇒ 裁决**之前**响亮 400,
  * 这只 ask 没被结算,同一张卡不带该键的 `allow` 照常成。不静默丢键 —— 壳以为加上了目录而引擎只看到一次普通放行,是 [ref] 修过的那一种病。
  */
-export declare const READ_ROOT_GRANT_NOT_ACCEPTED = "readRootGrant is not accepted on this deployment \u2014 a read-directory grant is honored only on a single-user host-lane deployment (GET /v1/capabilities approvalReadRootGrant is false here); answer with plain decision \"allow\" instead";
+export declare const READ_ROOT_GRANT_NOT_ACCEPTED = "readRootGrant is not accepted on this deployment \u2014 a read-directory grant is honored only on a single-user host-lane deployment (GET /v1/capabilities approvalReadRootGrant is false here); answer with a plain allow-this-call decision instead";
 /** [ref]:`readRootGrant` 的形 —— 卡上 `readRootCandidate.dir` 的原串(非空,≤ core `READ_ROOT_CANDIDATE_DIR_MAX`;超限整只拒,不截:截过的目录是另一个目录)。 */
 export declare const READ_ROOT_GRANT_SHAPE = "readRootGrant must be the card's readRootCandidate.dir sent back byte for byte \u2014 a non-empty string of at most 1024 characters";
-export declare const PERSIST_RULE_SCOPE_REFUSED = "this endpoint does not accept a rule scope \u2014 the server mints it from where the approval happened (send neither `scope` nor `persistRule.scope`)";
-/** [ref]:`respond()` 要的**部署事实**(由回决路由从能力事实交进;协调器不读 config,也不自判姿态)。 */
-export interface ToolApprovalRespondDeployment {
-    /** 这台部署受理不受理应答体里的 `readRootGrant` —— 能力事实 `readRootGrant` 的 `.available`(位 `approvalReadRootGrant` 的同一个值)。 */
-    readonly readRootGrantAccepted: boolean;
-}
-/** {@link parseToolApprovalResponse} 的成功分支形(`respond()` 拆分出的私有收尾方法复用,避免裸内联匿名类型重复三处)。 */
-type ParsedToolApproval = {
+/**
+ * 读根授权只交得给**在等这张卡的引擎腿**(引擎的问 `AskOutcome.readRootGrant`;续跑的决议形没有这一格)—— 卡已停驻(问行 `PARKED`)时带它 ⇒ 决议之前响亮拒,
+ * 卡不被结算(否则决定生效、目录静默不加)。去掉这一键重决即可。
+ */
+export declare const READ_ROOT_GRANT_LIVE_ONLY = "readRootGrant can only be honored while the card is live (an engine leg is waiting on it); this ask is parked, so the directory could not be added \u2014 answer it again without readRootGrant";
+/**
+ * 决定体上读根授权那一键(`readRootGrant`)的**唯一读法**(形门 + 只随「放行这一次」门;都只看体就能判 ⇒ 裁决之前、存在性之前响亮拒,卡不被结算)。
+ * `plainApprove` = 这次决定是不带「本会话放行」的放行。只判形,**不判**它是不是那张卡上的串(判官是 core:对不上 ⇒ 引擎拒授权、放行照旧)。
+ * 受理姿态(部署事实 `readRootGrant`,{@link READ_ROOT_GRANT_NOT_ACCEPTED})由口在本读法之后判。
+ */
+export declare function readReadRootGrantSlot(raw: unknown, plainApprove: boolean): {
     ok: true;
-    value: ToolApprovalDecision;
-    updatedInput?: unknown;
-    persistRule?: ParsedPersistRule;
-    note?: string;
-    decider: ApprovalDecider;
-    readRootGrant?: string;
+    grant?: string;
+} | {
+    ok: false;
+    error: string;
 };
+export declare const PERSIST_RULE_SCOPE_REFUSED = "this endpoint does not accept a rule scope \u2014 the server mints it from where the approval happened (send neither `scope` nor `persistRule.scope`)";
 /**
- * Validate the respond body — the closed three-choice enum (rationale in the module header).
- *
- * 失败形的机读位:体里带着退役键 `settledBy` 的任何一次拒(无论这次拒的**句子**说的是它还是体里别的毛病 —— 校验是顺序短路的,先撞上谁谁说话)都另带
- * 机读位 `field`({@link retiredDecisionKeyFacts} 的 `extra`,三条决定口同一只铸点;`respond()` 映射 400 时带出);拒的成因就是退役键时,**句**也取自同一铸点。
- * 铸在**这一层**而不是散在下面每个失败 return 上:一个事实一处读。
+ * `persistRule` 位的**唯一体形判官**(凡能决一张工具审批卡的口都调它:活卡回决口、耐久决断口 `/decide`;拒句一字不改)。
+ * 两个显式臂:候选臂(缺 `edited` 或 `edited:false`,文本是卡上某只候选的逐字文本)/ 自由文本臂(`edited:true`,人手改过的规则);batch 臂用 `batchOfferIndex`
+ * (面上候选数组的下标),与文本两臂互斥。`scope` 不属于携带方(server 从授权发生地自铸)。`deny` 带这一位 ⇒ 忽略(人拒了这次操作,谈不上持久化同意)。
  */
-export declare function parseToolApprovalResponse(body: unknown): ParsedToolApproval | ({
+export declare function readPersistRuleSlot(raw: unknown, decision: "allow" | "deny"): {
+    ok: true;
+    slot?: ParsedPersistRule;
+} | {
     ok: false;
     error: string;
-} & Partial<RetiredDecisionKeyFacts["extra"]>);
+};
+/** 一张卡铸时的那一份规则记录(兑付的唯一素材;三只读者各从自己的载体读出同一形)。 */
+export interface CardRuleRecord {
+    /** 规则落在谁名下 = 这一次决断的门判过的那位属主(收编之后是新属主)。 */
+    readonly owner: string;
+    readonly toolName: string;
+    /** 卡形的绑定值(被裁决的命令原字节,或值形卡的那一只值;`cardBindingOf`)。 */
+    readonly command: string;
+    /** 唯一读者 `readCardRuleOffers` 读出的那份数组(原字)—— 面上投出的候选是它的展示形,下标同一个空间。 */
+    readonly offers: readonly RuleOffer[];
+    readonly toolCallId?: string;
+    readonly boundInputHash?: string;
+    /** 铸卡快照的 project root;缺席 = 授权发生地在 server 坐标系里不可知 ⇒ 不铸 scope(core 答 `scope-unresolved`,只会拒不会放宽)。 */
+    readonly scopeRoot?: string;
+}
+/** 记录读者的读数:读出一份记录,或说清为什么没有(三个词都是 {@link RuleRefusalReason} 的成员,回执原样带出)。 */
+export type CardRuleRecordReading = {
+    readonly kind: "record";
+    readonly record: CardRuleRecord;
+} | {
+    readonly kind: "absent";
+    readonly refusal: "rule_lane_unavailable" | "rule_governance_forced" | "rule_material_absent" | "rule_store_error";
+};
+/** 规则位的回执(键集 = 契约里回决回执的规则位五键;只出现在带了 `persistRule` 的首决回执上,幂等回放不带)。 */
+export interface RuleSlotReceipt {
+    readonly rulePersisted: boolean;
+    readonly ruleRefusal?: RuleRefusalReason;
+    /** 自由文本臂落下的**规范拼写**(core 可能把 `Bash(adb *)` 规范成 `Bash(adb:*)`)。 */
+    readonly persistedRule?: string;
+    /** batch 臂落下的规则文本(展示序)。 */
+    readonly persistedRules?: readonly string[];
+    /** batch 臂逐条自描述锚(offer 空间:`offerIndex` = 请求体那个下标,`memberIndex` = 那只批 `rules[]` 的位置);车道证不出归属 ⇒ 缺席。 */
+    readonly persistedRuleAnchors?: readonly {
+        readonly offerIndex: number;
+        readonly memberIndex: number;
+        readonly rule: string;
+    }[];
+}
+/**
+ * **有问行的停驻卡**的记录读者:问行上的 `rule_command` / `rule_scope_root`(铸卡快照)/ `card_json`(候选表 / 工具名 / 治理位)/ `tool_call_id` / `bound_input_hash`。
+ * 读它不依赖本副本有没有这张卡的登记(任何副本兑得了);卡读不回来 / 治理档 / `rule_command` 为 NULL(从没进过规则车道,或凭据形在铸行时已扣下)⇒ 没有素材。
+ * `owner` = 续跑腿已复核过的属主;行此刻不带这位属主(收编在两读之间改写了它)⇒ 这一行不是这张卡的记录 ⇒ 没有素材。
+ */
+export declare function readCardRuleRecordOfAskRow(row: AskRow, owner: string | null): CardRuleRecordReading;
+/** 一只问行上这张卡铸时的候选(`card_json.ruleOffers`;唯一读者在铸点读过)—— 运维队列行投影有问行的停驻卡时读的就是它(与 {@link readCardRuleRecordOfAskRow} 同一份数组)。
+ *  卡读不回来 ⇒ `undefined`(队列行不投候选,与记录读者的「没有素材」同向)。 */
+export declare function cardRuleOffersOfAskRow(row: AskRow): readonly RuleOffer[] | undefined;
+/**
+ * **没有问行的停驻卡**(直停驻 / 窗 0 / 其余不经活卡的工具门)的记录读者:core 在停驻那一刻铸的这一份 —— 候选 = 同一只读者 `readCardRuleOffers` 读
+ * `pendingAction.ruleOffers`(与队列行的投影同一份数组),绑定值 = 与活卡铸点同一只 `cardBindingOf`,治理档 = 行上的治理标(与队列行 `governanceForced`
+ * 同读,调用方交进来),scope = 停驻行上 server 铸的快照列(没有快照的存量行 ⇒ 缺席 ⇒ `scope-unresolved`,与真不可兑同形)。没有引擎铸的候选 ⇒ 没有素材。
+ */
+export declare function readCardRuleRecordOfParkRow(pa: Pick<Extract<PendingAction, {
+    kind: "tool_approval";
+}>, "toolName" | "args" | "toolCallId" | "boundInputHash" | "ruleOffers">, facts: {
+    readonly owner: string | null;
+    readonly governanceForced: boolean;
+    readonly scopeRoot: string | null;
+}): CardRuleRecordReading;
+/**
+ * **唯一兑付函数**(`persistCardRule` 在 src 里只在这里调)。门序只有一份:治理档 → 车道 / 属主 → 素材缺席 → 提交歧义(`eligible`,只有活卡的提交歧义臂会是 false)
+ * → 编辑放行(`updatedInput` 与 `persistRule` 同在 ⇒ `rule_input_edited`:生效的是编辑后的调用,候选是从原始命令铸的)→ batch 臂(下标指不到 / 指到 single ⇒ `rule_not_offered`)
+ * / 文本臂(候选臂:报来的文本恰好对上一只 single 候选的原字或展示形 ⇒ 兑那一只的原字;对不上或对上不止一只 ⇒ `rule_not_offered`)→ `persistCardRule`
+ * → 失败词原样回 / 店抛 ⇒ `rule_store_error`。失败**不改判**裁决(调用方在裁决已受理之后才调本函数),回执如实说没存上。
+ */
+export declare function redeemCardRule(lane: RuleConsentLane | undefined, reading: CardRuleRecordReading, slot: ParsedPersistRule, ctx: {
+    readonly inputWasEdited: boolean;
+    readonly eligible: boolean;
+}): Promise<RuleSlotReceipt>;
+/** 决断口 live 臂在 CAS 之前握住的那条登记的不透明把手({@link ToolApprovalCoordinator.holdLiveLeg} 铸,只交回 {@link ToolApprovalCoordinator.settleLiveDecision})。 */
+export interface HeldLiveLeg {
+    readonly askId: string;
+}
+/**
+ * 决断口 live 形一次人决随身带来的 live 词(已过各自的唯一读法:`readRememberSlot` / `readReadRootGrantSlot` / {@link readPersistRuleSlot})——
+ * 只在本请求干净赢下 CAS 之后由 {@link ToolApprovalCoordinator.settleLiveDecision} 一处兑。
+ */
+export interface LiveDecisionExtras {
+    /** 「本会话放行」。 */
+    readonly remember?: "session";
+    /** 读根授权(卡上 `readRootCandidate.dir` 原串)。 */
+    readonly readRootGrant?: string;
+    /** 「不再询问」的规则位。 */
+    readonly persistRule?: ParsedPersistRule;
+    /** 这次放行带了 ctrl+g 编辑(⇒ 规则位答 `rule_input_edited`)。 */
+    readonly inputWasEdited: boolean;
+}
+/**
+ * **一次人对一张卡的决定** —— 唯一的人决口(决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`)
+ * 两形(live / 停驻)落行的唯一入参形;{@link ToolApprovalCoordinator.writeAskDecision} 是它唯一的写者,{@link askDecisionRecordOf} 是它到店记录的唯一映射。
+ * `actor` = 耐久决断口铸的署名(审计投影,恒由已验证主体派生;应答口不铸,列 NULL);`idempotencyKey` = 耐久决断口的回决幂等键(应答口没有这一位)。
+ */
+export interface AskDecisionWrite {
+    readonly decision: AskDecision;
+    readonly decider: ApprovalDecider;
+    readonly note?: string;
+    readonly actor?: unknown;
+    readonly idempotencyKey?: string;
+}
+/** live 形的决定另带 ctrl+g 编辑实参(`undefined` = 没带;**`null` 是值**,语义三态的属主 = `AskRow.updatedInput`):随决议同一条 CAS 落列、交给在等的那条腿。
+ *  停驻形的编辑走停驻门的绑定(`DecideBinding.updatedInput`),不落问行。 */
+export interface LiveAskDecisionWrite extends AskDecisionWrite {
+    readonly updatedInput?: unknown;
+}
+/** 一张卡的人决落在哪一形上:live = `STREAM_PENDING → DECIDED` 的单赢者 CAS(带批维);停驻 = 停驻门受理之后落在仍 `PARKED` 的行上。 */
+export type AskDecisionForm = {
+    readonly kind: "live";
+    readonly batchId: string;
+} | {
+    readonly kind: "parked";
+};
+/**
+ * {@link AskDecisionWrite} → 店的那份记录({@link AskDecisionRecord})—— **唯一映射**(两形同读)。出处两格经同步座映射 {@link liveHostSource}
+ * (`person` ⇒ 不写 = 列 NULL = 人决;`policy` ⇒ `"policy"` + 座位),理由空 ⇒ NULL,署名 / 键缺席 ⇒ NULL。
+ */
+export declare function askDecisionRecordOf(write: AskDecisionWrite): AskDecisionRecord;
 /**
  * [ref] R-13 C —— `UNATTENDED_APPROVAL_POLICY` 的**闭集**词表([ref]Q1「裁2:A+C」/[ref] 裁②)。
  *
@@ -1064,32 +1207,30 @@ export type UnattendedAskOutcome = Extract<AskOutcome, "unavailable"> | Unattend
 /** [ref] 候裁 16:耐久会话授权店(`src/plugins/approval-exemption-store.ts` 的同一只店):审批席读它(引擎的问),活卡上部署名单那一问的
  *  「本会话放行」写它(名单门在出问之前读同一行)。 */
 export type SessionGrantStore = Pick<ApprovalExemptionStore, "has" | "grant">;
-/** redactDeep + size-bound the UNTRUSTED tool args before they are streamed. Over the cap / unserializable ⇒
- *  undefined (frame rides argsOmitted — see MAX_APPROVAL_ARGS_BYTES). */
 /**
- * 给审批人看的一份入参 —— 卡上 `args` 的**同一种读法**({@link boundArgs}:脱敏 + 字节帽;超帽 / 序列化不出 ⇒ `undefined`)。
+ * 给审批人看的一份入参 —— 卡上 `args` 的**同一种读法**({@link boundArgs} → `human-facing-args.ts` 的 `humanFacingArgs`:脱敏;问 / 计划卡整份,
+ * 其余卡与无卡超 `HUMAN_FACING_ARGS_BYTES` UTF-8 字节 ⇒ `undefined`;序列化不出 ⇒ `undefined`)。与停驻行 `input` 同一只判定。
  * 读者:卡帧 / 卡面(经 `boundArgs` 本体)与续跑拒体的 `acceptableForm`(core 7.56.0 [ref]:编辑复判只收改写后的那一形,人在决定口看到它、批准它)。
  */
-export declare function approverFacingArgs(args: unknown): unknown;
+export declare function approverFacingArgs(args: unknown, card: ToolApprovalCard | undefined): unknown;
 /**
  * [ref] 车3 刀 3b —— 「流内审批协议到底上不上场」的**单一谓词**(设计稿 §2.3 注入 / §2.4 能力面 /
  * §8.4 park 设施自检,三处同一份判据)。
  *
  * 🔴 为什么必须是一个函数而不是三处各写一遍的合取式:车4 落地时曾在回决端点里放了一份局部的
  * `backend.kind !== "local"` 临时判据,并在注释里写死「等能力面谓词落地就换掉本段 —— 两份判据长期并存
- * 必然漂」。这就是那一车。三个消费点(协调器注入 / `/v1/capabilities` / 回决端点 501)现在读同一个符号,
- * 于是「能力面说 true」⟺「协调器真拿到了 askStore」⟺「回决端点真有账可 CAS」是**结构成立**的,
+ * 必然漂」。这就是那一车。三个消费点(协调器构造 / `/v1/capabilities` / 回决端点 501)现在读同一个符号,
+ * 于是「能力面说 true」⟺「协调器在场(恒带 askStore)」⟺「回决端点真有账可 CAS」是**结构成立**的,
  * 不再靠三处注释互相提醒。
  *
- * 四个合取项,缺一即不上场(每一项的缺席都有它自己的 `reason`,供启动期 info 与诊断分辨):
- *  1. `toolApprovalEnabled` —— 连活卡腿都没有,谈不上流内协议;
- *  2. `streamApprovalEnabled` —— 协议总开关(`STREAM_APPROVAL_ENABLED`,树上已**默认 ON**;显式 `false`
- *     是唯一干净还原键。默认极性与版本坐标的属主口径见 `config.ts` 的 `streamApprovalConfig()` 头注);
- *  3. `backend` 在场 —— env-only worker 没有 `StoreBackend` 本体;
- *  4. **park 设施在场**(§8.4)—— 缺席时「窗到期 ⇒ unavailable」在 core 侧没有降级目的地,结局是
- *     fail-closed deny,**比现状(5min 活卡、人能批)更差**。所以自检不满足 ⇒ **协议不上场**、现行
- *     `tool_approval` 活卡腿逐字保留,而不是「把 ask 推向一个不存在的目的地」(§14 属主照准,core [ref]
- *     回帖确认即原意)。
+ * 三个合取项,缺一即不上场(每一项的缺席都有它自己的 `reason`,供启动期 info 与诊断分辨):
+ *  1. `toolApprovalEnabled` —— 连审批席都没有,谈不上呈卡;
+ *  2. `backend` 在场 —— env-only worker 没有 `StoreBackend` 本体,也就没有 ask 账;
+ *  3. **park 设施在场**(§8.4)—— 缺席时「窗到期 ⇒ unavailable」在 core 侧没有降级目的地。
+ * 🔴 **不上场 ⇒ 这台 worker 不呈卡,也没有审批协调器**(`boot/coordinators.ts` 不构造它;协调器缺席 = 协议不上场,消费方一律这样读):
+ * 审批只有一个帧族(呈卡族,开卡帧无持久身份不铸),没有「协议没上场就回退发另一族活卡」的腿。没有审批席 ⇒ 受门的问的终局归 core:
+ * 第 1 项不满足(开关关)而 park 设施在场 ⇒ 照常 durable park;第 2 / 3 项不满足 ⇒ 无处可停,core 的无审批席臂当场拒(fail-closed)。
+ * 曾经的第二项(协议总开关 `STREAM_APPROVAL_ENABLED`)与它的拒因词一起退役(零别名):那个开关的「关」就是回退发旧族活卡,旧族没了它就没有可关的东西。
  *
  * 🔴 **[ref]:第 5 项(旧第 4 项 `volatile_ask_ledger` = 「账必须是持久的」,判据 `kind !== "local"`)
  * 已整条删除,词也从闭集里删了(零别名)**。它当年成立的唯一输入是 local 车道交的 `InMemoryApprovalAskStore`;
@@ -1104,20 +1245,12 @@ export type StreamApprovalGate<TStore extends GateCurrencyStore = GateCurrencySt
     checkpointStore: TStore;
 } | {
     active: false;
-    reason: "no_tool_approval" | "protocol_disabled" | "no_backend" | "no_park_facility";
+    reason: "no_tool_approval" | "no_backend" | "no_park_facility";
 };
 /** {@link resolveStreamApprovalGate} 的入参。`backend` 用**结构形**(不 import `StoreBackend`):本模块是
  *  协调器的家,不该为一个布尔判据把整棵 store 依赖树拖进类型面。 */
 export interface StreamApprovalGateInput<TStore extends GateCurrencyStore = GateCurrencyStore> {
     toolApprovalEnabled: boolean;
-    /** 协议总开关。⚠️ 调用点一律写 `config.streamApproval?.enabled === true` —— **可选链的缺席臂折算
-     *  false**(段整段缺席 ⇒ 协议不上场)。
-     *  🔴 当年这条写的理由是「缺席折算值 == 产品默认(那时是 OFF)」,所以 `?.` 纯粹无副作用;产品默认
-     *  现已翻 ON(`config.ts` 的 `streamApprovalConfig()`),两者**不再相等**,那条理由作废。现行的
-     *  (更弱也更诚实的)判据:真实 boot 恒有此段(`config.ts` 无条件铸 + 白名单门盯着),`?.` 服务的只是
-     *  那些只填被测路由用得到的键的 stub-harness,而一个没填这个段的 harness 要的必然是「别上场」。
-     *  **不要**照「缺席 = 与产品默认同」去推理。 */
-    streamApprovalEnabled: boolean;
     backend: {
         readonly kind: "mysql" | "pg" | "local";
         approvalAsk(): ApprovalAskStore;
@@ -1133,25 +1266,22 @@ export interface StreamApprovalGateInput<TStore extends GateCurrencyStore = Gate
 }
 export declare function resolveStreamApprovalGate<TStore extends GateCurrencyStore>(input: StreamApprovalGateInput<TStore>): StreamApprovalGate<TStore>;
 /**
- * 审批开卡帧的**帧族词表**(闭集)—— wire 上一只 ask 的开卡帧可能属于的族:
- *  · `tool_approval`:旧族(活卡帧 `tool_approval` / 消卡帧 `tool_approval_complete`);
- *  · `approval_request`:呈卡族(开卡帧 `approval_request` / 消卡帧 `approval_complete` / 批级撤卡帧 `approval_revoke`)。
+ * 审批开卡帧的**帧族词表**(闭集,一个词)—— `approval_request`:开卡帧 `approval_request` / 消卡帧 `approval_complete` / 批级撤卡帧 `approval_revoke`。
  *
- * 一条腿选哪个族只由上面 {@link resolveStreamApprovalGate} 的 `active` 定(为真 ⇒ 上下文的族词 `approval_request`;为假 ⇒ `tool_approval`,
- * 见 {@link ToolApprovalRunContext});`GET /v1/capabilities` 的 `approvalFrameFamilies` 把**同一份**判据结果(能力事实 `streamApproval` 的那一次求值)
- * 译成本词表里的词(`capability-facts.ts` 的 `approvalFrameFamilies`,对判据拒因的穷举 switch:拒因多一个 ⇒ 编译红)。
- * 腿选口的规则与能力位的映射是同一条,由 `test/stream-approval-on-e2e.test.ts` 在同一台 worker 上拿真腿发出的开卡帧族对拍能力位,不靠注释互相提醒。
+ * 一台 worker 呈不呈这一族只由上面 {@link resolveStreamApprovalGate} 的 `active` 定({@link presentedApprovalFrameFamily});`GET /v1/capabilities` 的
+ * `approvalFrameFamilies` 是**同一份**判据结果(能力事实 `streamApproval` 的那一次求值)的投影:`["approval_request"]` / `[]`。
+ * 腿判的规则与能力位的映射是同一条,由 `test/stream-approval-on-e2e.test.ts` 在同一台 worker 上拿真腿发出的开卡帧族对拍能力位,不靠注释互相提醒。
  * 词表只有这一份(元组即类型);加一族而没有逐处跟进 ⇒ `test/capability-facts.test.ts` 的 `satisfies Record<ApprovalFrameFamily, true>` 编译红。
  */
-export declare const APPROVAL_FRAME_FAMILIES: readonly ["tool_approval", "approval_request"];
+export declare const APPROVAL_FRAME_FAMILIES: readonly ["approval_request"];
 export type ApprovalFrameFamily = (typeof APPROVAL_FRAME_FAMILIES)[number];
 /**
- * 这台 worker **呈卡用的那一个族**(活卡协调器在场时)—— 全仓唯一的映射,三个读者:能力位 `approvalFrameFamilies`(`capability-facts.ts`,
- * 壳读它决定声明什么)、{@link resolveApprovalLeg}(腿判「这条 run 声明了没有」)与耐久事件流开流 preamble(`routes/runs.ts`:这条 run 名下的卡
- * 铸于声明了这一族的腿,卡作证的声明就是它)。各写一份三元式 = 壳照一份声明、服务端照另一份判,那正是 [ref] 要封的「两边各说各话」。
+ * 这台 worker **呈卡用的族**(缺席 = 这台 worker 不呈卡)—— 全仓唯一的映射,三个读者:能力位 `approvalFrameFamilies`(`capability-facts.ts`,
+ * 壳读它决定声明什么)、{@link resolveApprovalLeg}(腿判「这台 worker 呈不呈卡、这条 run 声明了没有」)与耐久事件流开流 preamble(`routes/runs.ts`:这条 run
+ * 名下的卡铸于声明了这一族的腿,卡作证的声明就是它)。各写一份三元式 = 壳照一份声明、服务端照另一份判,那正是 [ref] 要封的「两边各说各话」。
  * 入参 = {@link resolveStreamApprovalGate} 的 `active`。
  */
-export declare function presentedApprovalFrameFamily(streamApprovalOn: boolean): ApprovalFrameFamily;
+export declare function presentedApprovalFrameFamily(streamApprovalOn: boolean): ApprovalFrameFamily | undefined;
 /** 坏声明的拒体(fresh 受理面 400 `request.field_invalid`):一句话 + 机读位,形与 [ref] 座位族 / [ref] 三桶的 `bad_entry` 同。 */
 export interface ApprovalFrameFamiliesIssue {
     readonly message: string;
@@ -1177,13 +1307,15 @@ export declare function declaredApprovalFrameFamilies(settings: unknown): Readon
 /** 一条腿**没有活审批通道**的成因(见 {@link ApprovalLegAssembly.unattended});`frame_family_undeclared` 带上缺的那个族。 */
 export type LegUnattended = {
     readonly arm: "window_zero";
+} | {
+    readonly arm: "card_protocol_absent";
 } | {
     readonly arm: "frame_family_undeclared";
     readonly family: ApprovalFrameFamily;
 };
 /** {@link resolveApprovalLeg} 的入参(sync / bg / resume 三腿 + 开流 preamble 共用一份形)。 */
 export interface ApprovalLegInput {
-    /** = `resolveStreamApprovalGate(...).active`(协议在本 worker 上场没有)。 */
+    /** = `resolveStreamApprovalGate(...).active`(呈卡协议在本 worker 上场没有;不上场 ⇒ 这台 worker 不呈卡)。 */
     streamApprovalOn: boolean;
     /** `config.streamApproval.windowMs`(`STREAM_ASK_WINDOW_MS`)。
      *  🔴 [ref]:`undefined` = **这份装配没有 `streamApproval` 段**(只出现在只填被测键的 stub-harness ——
@@ -1227,8 +1359,9 @@ export interface ApprovalLegInput {
  *
  * 🔴 **[ref]**:「这条腿有没有活审批通道」多一个成因 —— 这条 run 没声明本 worker 呈卡用的族。它与关窗是**同一件事**(不呈卡、问当场交政策口),
  * 所以进同一个字段(`unattended` 的成因词),三条腿零新分支;判据读 {@link presentedApprovalFrameFamily}(能力位读同一只)。
- * 判据**不**放进 {@link resolveStreamApprovalGate}:那是 worker 级谓词(协调器注入 / 能力位 / 回决 501 都没有 run),且它为假时腿退回旧族 `emit` ——
- * 正是「回退发 `tool_approval`」。
+ * 🔴 **这台 worker 不呈卡**(呈卡协议不上场:无 store backend / 无 park 设施 —— 能力位 `approvalFrameFamilies: []`)是同一件事的第三个成因
+ * `card_protocol_absent`:同一个字段、同一只席、三条腿零新分支。审批只有一个帧族,没有「协议不上场就回退发旧族活卡」的腿;判据仍是
+ * {@link presentedApprovalFrameFamily}(缺席 ⇒ 这一成因),worker 级谓词 {@link resolveStreamApprovalGate} 不变。
  *
  * **没有活审批通道的两件事必须同时做**(调用方契约):不包 ALS **且** `spec.onAsk` = {@link ToolApprovalCoordinator.boundUnattendedAsk}(带成因)。
  * 只做一件另一条路仍会呈卡(ALS 腿是 `deps.onAsk` 的到达路;不包 ALS 也让这条腿不进 broker 活流集合 = 不是别的腿的卡的投递目标)。
@@ -1236,21 +1369,20 @@ export interface ApprovalLegInput {
  * 旧文「bg/resume 无装配点,不包 ALS 即等价」的缺席论证已退役,别再据它推断「少装一件也行」。
  */
 export interface ApprovalLegAssembly {
-    /** 协议在本腿上是否上场。false ⇒ 呈卡族的上下文不接(族词 `approval_request`、`legKey` /
-     *  `legDeadlineMonotonic` 都不接)—— **协议件**逐字保持协议之前的行为。
-     *  ⚠️ [ref] 门职分离(codex R1-F1 随修):本位**不再兼职**「审批席在场性」—— `spec.onAsk = boundAsk`
-     *  三腿恒装(判据 = 协调器在场,即 `TOOL_APPROVAL_ENABLED`),协议关时 bg/resume 腿的 ask 也能命中
-     *  同 (owner, session) 活流呈活卡(sync 腿 [ref] 起本就如此;bg/resume 的这条行为差 = [ref] CHANGELOG
-     *  披露的行为面变更)。旧文「本腿逐字保持协议之前的行为」只对协议件成立,别再把它读成「协议关 = 零呈卡」。 */
+    /** 呈卡协议在本 worker 上是否上场。false ⇒ 这条腿恒没有活审批通道({@link unattended} 恒在场:关窗或 `card_protocol_absent`)。
+     *  协议不上场 = 零呈卡:生产装配上这时没有审批协调器(`boot/coordinators.ts`),三条腿都不装审批席,每只受门的问由 core 的无审批席臂拒;
+     *  没有「借同 (owner, session) 的另一条活流呈活卡」的路 —— 那条路只在呈卡腿之间存在(呈卡腿的 `boundAsk` 经活流集合投卡,活流集合里只有呈卡腿)。 */
     active: boolean;
     /** **这条腿没有活审批通道**(在场 ⇒ 不包 ALS、不是任何卡的投递目标、`spec.onAsk` 是 {@link ToolApprovalCoordinator.boundUnattendedAsk}
-     *  席 —— 每只问当场交无人值守政策口,臂 = 本值)。缺席 ⇒ 这条腿按 {@link presentedApprovalFrameFamily} 的族呈卡。成因闭集两个,先后即判序:
+     *  席 —— 每只问当场交无人值守政策口,臂 = 本值)。缺席 ⇒ 这条腿按 {@link presentedApprovalFrameFamily} 的族呈卡。成因闭集三个,先后即判序:
      *  · `window_zero`(§8.3)—— 运维关窗(`STREAM_ASK_WINDOW_MS=0`),或协议上场时本腿剩余 walltime 撑不住安全余量。
      *    🔴 [ref] 起与 `active` 解耦:`0` 是**部署级**旋钮,在两条车道上是同一个意思(旧形下关协议的部署配了 `0` 拿到的是等满 5min 的活卡)。
      *    ⚠️ 「窗**缺席**」(`windowMs: undefined` = 这份装配根本没有 streamApproval 段,只出现在 stub-harness)**不是**关窗。
      *    排在声明之前:那时谁都不呈卡,缺的不是客户端的声明。
-     *  · `frame_family_undeclared`([ref])—— 这条 run 的请求没有声明本 worker 呈卡用的族(`settings.approvalFrameFamilies`)。判据对两个族同一条:
-     *    不回退发另一族、不双发、没有「键缺席 ⇒ 视作旧族」的默认。
+     *  · `card_protocol_absent` —— 这台 worker 不呈卡(呈卡协议不上场:无 store backend / 无 park 设施;能力位 `approvalFrameFamilies` 为 `[]`)。
+     *    排在声明之前:那时这台 worker 谁都不呈卡,缺的不是客户端的声明。
+     *  · `frame_family_undeclared`([ref])—— 这条 run 的请求没有声明本 worker 呈卡用的族(`settings.approvalFrameFamilies`)。
+     *    没有「键缺席 ⇒ 视作声明了」的默认。
      *  三条腿只问「在场没有」,成因随席交给唯一铸点(遥测臂 + deny 政策的拒因句)。 */
     unattended?: LegUnattended;
     /** §7.3 本 leg 的 walltime deadline(`performance.now()` 单调基)。只在 `active ∧ 有活审批通道 ∧
@@ -1288,11 +1420,11 @@ type DecidedRowFacts = Pick<AskRow, "decision" | "settledBy" | "decidedVia" | "d
  *    字面值 ⇒ 对象臂(语义三态的唯一属主 = `AskRow.updatedInput` 顶注);
  *  · **结算来源**([ref])—— 行上非 null 即宿主自报的那个词(`null` = 人决,与「不铸这个键」同义;
  *    语义属主 = `AskRow.settledBy` 顶注);
- *  · **拒因**([ref] 的行派生半场)—— 拒行上**非空**的 `decisionNote` 铸成 `reason`(与应答口 `shapeDeny` 同键同形:core 以带说明的人拒句
+ *  · **拒因**([ref] 的行派生半场)—— 拒行上**非空**的 `decisionNote` 铸成 `reason`(与 7.151.x 及以前应答口的 `shapeDeny` 同键同形:core 以带说明的人拒句
  *    把它交给模型,围栏 `delimitUntrusted` 与长度上限 `REVIEWER_NOTE_MAX_BODY` 全在 core,本仓只透传不预判;空串按 core 契约的缺席读,不铸只装了
  *    空值的对象臂)。**allow 行的说明恒不铸**:core 对 allow 行的 `reason` 恒销毁,说明只走审计面(行的 `decisionNote` 列)。
  *    此前这一格不在铸点里 ⇒ 耐久决断口 / 重放 / 兄弟广播 / claim 败方 / 歧义提交恢复 / 悬挂轮询六条行派生的路,都把带说明的拒交成裸 `false`
- *    (core 读作「一个人拒了、没说怎么办」:STOP 句 + 本轮收住),而同一段说明经应答口到达却带着 `reason` 进模型 —— 一扇门两种去向。
+ *    (core 读作「一个人拒了、没说怎么办」:STOP 句 + 本轮收住),而同一段说明经应答口(7.152.0 起已删)到达却带着 `reason` 进模型 —— 一扇门两种去向。
  *
  * 🔴 [ref]:来源位**两向都读**。决定体的出处位 `decidedBy:"policy"` 在 allow 与 deny 上都会落列(引擎 7.39.0 起铸
  * `policy_allowed`),所以 approve 行带来源位是一条合法的行,它的每条读回路径交还 `{allow:true, settledBy:"policy", updatedInput?}`
@@ -1326,8 +1458,7 @@ export declare class ToolApprovalCoordinator {
     /** 判据钩子(生产路径不调)。 */
     terminalClaimsInFlightForTest(askId: string): number;
     /** [ref] 车2(codex 交叉复审 round3 抓获真 finding,round5 精化成 Set):次级索引,键 = 持久层 askId
-     *  (与 {@link pending} 的 wire-面 uuidv7 `id` 是两条独立的身份轴,顶注同精神)——只在 askStore 在场且
-     *  这只 ask 真有 askId 时才登记。**同一 askId 下可能同时挂着不止一条本地条目**(round5 抓获:
+     *  (与 {@link pending} 的 wire-面 uuidv7 `id` 是两条独立的身份轴,顶注同精神)——每条登记都在这里(每只 ask 都有 askId)。**同一 askId 下可能同时挂着不止一条本地条目**(round5 抓获:
      *  `ensureAsk` 是幂等 upsert,若 core 对同一 (sourceSessionId,runId,toolCallId,legKey) 真发起过两次并发调用——如
      *  重试/failover 场景,round4 finding2 的顶注同源——两次 `askBroadcast` 各自的调用栈都会在行仍是
      *  STREAM_PENDING 时各自注册一条独立的本地 pending 条目,值形若是单值 Map 会被后到者覆盖前者的登记,
@@ -1359,11 +1490,11 @@ export declare class ToolApprovalCoordinator {
      *  {@link DEFAULT_UNREACHED_ASK_TTL_MS} = 1h,域 [60s, 24h] 由 config 守)。只作用于
      *  `AskReachability === "unreached"` 的那一支;有活流的 ask 恒用 {@link ttlMs}。 */
     private readonly unreachedTtlMs;
-    /** [ref] 车2([ref] §7 协调器半场,D1):可选持久层——缺席 ⇒ 每一条现行为逐字不变(in-memory
-     *  promise 机械即契约);在场 ⇒ 四竞争者(回决/窗到期/取消/emit 全灭)的终局多一道持久 CAS 记账。
-     *  additive 改造,不是替换——settle 闭包/pending map/TTL/broker 全保留,CAS 只决定「谁有权 settle
-     *  成什么终局」。 */
-    private readonly askStore?;
+    /** 这台 worker 的审批问账([ref] §7 协调器半场)—— **必选**:协调器只在呈卡协议上场时构造(`boot/coordinators.ts`,
+     *  判据 {@link resolveStreamApprovalGate}),每一只协调器都有账。四竞争者(回决 / 窗到期 / 取消 / emit 全灭)的终局恒经这本账的
+     *  持久 CAS 记账;settle 闭包 / pending map / TTL / broker 是本副本的活面,CAS 决定「谁有权 settle 成什么终局」。
+     *  没有「无账协调器」这一形:呈卡协议不上场的 worker 根本没有协调器(缺席 = 协议不上场)。 */
+    private readonly askStore;
     /** [ref] 车2([ref] §3.3 D3):窗长三元公式的安全余量,构造期定,详见 {@link effectiveAskWindowMs}。 */
     private readonly windowMarginMs;
     /** [ref] 车3 刀 3b(设计稿 §0 X-2 写侧准入门):per-task / per-owner 的未决 ask 上限。 */
@@ -1378,9 +1509,9 @@ export declare class ToolApprovalCoordinator {
     /** [ref] F4:悬挂决议轮询腿的**轮转游标**(整数偏移,与集合成员无关 —— 理由见
      *  `pollSuspendedDecisions` 里那段:按 askId 记的形会在「上一拍最后碰的那条被结算掉」时塌回队首,
      *  构造出永久饥饿的前缀)。只回答「上一拍扫到第几个」,单调推进、按当前长度取模。 */
-    private suspendedPollOffset;
-    /** [ref]:悬挂轮询腿第二层(接管登记)的轮转游标 —— 与 {@link suspendedPollOffset} 同一条理由,两层各一只。 */
-    private adoptedPollOffset;
+    private readonly suspendedPollCursor;
+    /** [ref]:悬挂轮询腿第二层(接管登记)的轮转游标 —— 与 {@link suspendedPollCursor} 同一条理由,两层各一只。 */
+    private readonly adoptedPollCursor;
     /** [ref] + codex R3-[critical]:askId → **此刻正带着 `updatedInput` 决它的请求数**(见
      *  {@link markEditedDecisionInFlight} 顶注)。只在 `decideAsk` 那一次调用期间非空,故天然有界。 */
     private readonly editedDecisionsInFlight;
@@ -1407,11 +1538,9 @@ export declare class ToolApprovalCoordinator {
      *  core 的 global 缺省(= 现行为,恒不更宽;也绝不错铸一个坐标系不对的 root)。装配见 main.ts:
      *  registry cwd(host lane 显式注册的 launch dir)?? 无手(`none`)单用户形的 `process.cwd()`。 */
     private readonly ruleScopeRootFor;
-    /** [ref]:停驻行迟到决议的受理回执表(键 = 行的键 `askId`,插入序 = 逐出序)。语义与有界理由见
-     *  {@link ParkRedemption} 顶注。 */
+    /** 停驻卡在飞的赎回表(键 = 行的键 `askId`;一飞落定即收回)。语义与有界理由见 {@link ParkRedemption} 顶注。 */
     private readonly parkRedemptions;
     private readonly parkRedemptionMax;
-    private readonly parkRedemptionTtlMs;
     /** [ref]:per-principal 子帽(语义与取值理由见 {@link DEFAULT_PARK_REDEMPTION_PER_PRINCIPAL_MAX})。 */
     private readonly parkRedemptionPerPrincipalMax;
     /** [ref]:PARKED 臂的赎回席**取值口**(晚绑 —— 赎回腿要 checkpoint/bg 店与裸 Agent 工具,它们在协调器
@@ -1443,12 +1572,12 @@ export declare class ToolApprovalCoordinator {
     /** [ref] F1:有序关停下路由到 park、**处置尚未被观察到**的卡 —— 审计 settle 行在这里候着({@link settleParksAwaitingCommit})。
      *  只在关停期有成员(进程随后退出,不需要回收)。 */
     private readonly parksAwaitingCommit;
-    constructor(opts?: {
+    constructor(opts: {
         ttlMs?: number;
-        /** [ref](案A):零活流铸造的 ask 的窗(见 {@link unreachedTtlMs})。装配点在协议**上场**时才传
-         *  (与 `ttlMs` 同条件、同理由:悬挂的三条发现通道全长在 ask 行上);缺席 ⇒ 1h 代码默认。 */
+        /** [ref](案A):零活流铸造的 ask 的窗(见 {@link unreachedTtlMs});缺席 ⇒ 1h 代码默认。 */
         unreachedTtlMs?: number;
-        askStore?: ApprovalAskStore;
+        /** 审批问账(必选,见 {@link askStore})。 */
+        askStore: ApprovalAskStore;
         windowMarginMs?: number;
         admitMaxPerTask?: number;
         admitMaxPerOwner?: number;
@@ -1464,10 +1593,8 @@ export declare class ToolApprovalCoordinator {
         parkedRedeem?: () => ParkedAskRedeem | undefined;
         /** [ref]:按问读口的门读席(见 {@link ToolApprovalCoordinator.parkedGate})。 */
         parkedGate?: ParkedGateRead;
-        /** [ref]:受理回执表两道界(缺省见 {@link DEFAULT_PARK_REDEMPTION_MAX}/{@link DEFAULT_PARK_REDEMPTION_TTL_MS})。
-         *  不是部署旋钮(不接 env),可注入只为让「有界」这件事被判据观测得到。 */
+        /** 在飞赎回表的容量帽(缺省见 {@link DEFAULT_PARK_REDEMPTION_MAX})。不是部署旋钮(不接 env),可注入只为让「有界」这件事被判据观测得到。 */
         parkRedemptionMax?: number;
-        parkRedemptionTtlMs?: number;
         /** [ref]:per-principal 子帽(同上不接 env;生效值恒 `min(本值, parkRedemptionMax)`)。 */
         parkRedemptionPerPrincipalMax?: number;
         /** [ref] (c):local 车道审计 sink(见 {@link ToolApprovalCoordinator.askAudit})。 */
@@ -1489,8 +1616,8 @@ export declare class ToolApprovalCoordinator {
      * onAsk 契约里是「一个人拒了」,而本口的全部臂都是「没有人能答」。
      *
      * 五臂(设计稿 §1 的表)全部读它,`unattendedPolicy` 因此是一处施加、五处消费:
-     *  (a) 有店窗到期 `expireAsk` 赢 CAS / (b) 无店窗到期(D1)/ (c) 有店但 `expireAsk` 报错
-     *  —— 三条走 `windowRouteUnavailable` 标志,在 {@link shapeOutcome}(askBroadcast 内)成形;
+     *  (a) 窗到期 `expireAsk` 赢 CAS / (c) `expireAsk` 报错
+     *  —— 两条走 `windowRouteUnavailable` 标志,在 {@link shapeOutcome}(askBroadcast 内)成形;
      *  (d) 没有活审批通道的腿(装配层短路:关窗 / 未声明呈卡族,[ref])与无 ALS 上下文的 headless 腿 —— 走本方法/{@link ask};
      *  (e) 断连 `forceParkNow` / emit 全灭 / 写侧准入超限 —— 走本方法。
      *
@@ -1577,7 +1704,7 @@ export declare class ToolApprovalCoordinator {
      * 超限的处置是 `"unavailable"`(park 路由),**缺省 park 政策下永不 deny**:过载是**我方**的容量事实,不是人对这次
      * 操作的判断;用 deny 表达过载会把一次「本可以 park 后由人补批」的操作变成任务失败(§3.3 硬条款)。
      *
-     * 只在 `askStore` 在场(= 协议开着)时把关:开关关闭时本方法恒放行,现行为逐字不变(D1/A-1)。
+     * 每一只协调器都把关(协调器只在呈卡协议上场时存在,见 {@link askStore})。
      *
      * ⚠️ **已认领的偏离**(设计 X-2 字面要求「计数在持久层做」):v1 是**进程内**计数 —— 它对单副本完整
      * 有效,多副本下每个副本各自把关(真实上限 = N × 帽)。理由=持久层计数要么在每只 ask 的热路径上多一次
@@ -1598,51 +1725,6 @@ export declare class ToolApprovalCoordinator {
     private static ruleOffersEqual;
     private static batchMemberEqual;
     private static uncoveredDetailEqual;
-    /**
-     * [ref] / 5.58 复审 F-1 —— OFFER 的**文本座尺**(红先修)。
-     *
-     * 🔴 病灶(真复现,`npm run build --flag=<700 字> && git status`):`batch` 成员的 `segment` 是复合命令
-     * 那一段的**原字节**,它**不经** `parseRuleText`,所以 core 的 `MAX_RULE_TEXT_CHARS` 对它一个字
-     * 都不管;而卡的 `ApprovalCardSchema` 对四个文本座一律 `.max(MAX_RULE_TEXT_CHARS)`。逐字拷进卡 ⇒
-     * `card_json` 落库 ⇒ `ensureAsk` 当场回读 `safeParse` 判假 ⇒ `persisted-row-unusable` ⇒ **整只 ask 走
-     * park**,重放腿一并跳过该行。与「重扫二轮 §基数帽」是**同一条悬崖的另一条边**(那次是 offer 条数
-     * 没执法,这次是文本长度),5.58 换形之前不存在——旧 `RuleSuggestion` 三个座全是解析器输出,结构性 ≤512。
-     *
-     * 两个座两种处置,**刻意不同**:
-     *  · `segment` = **纯渲染座**(core 明写「never adjudication input」)⇒ 截长是诚实省略,与
-     *    `toolName`/`message` 的 `capText` 同待遇,也与耐久腿 `boundedRuleOffers` 的同名处置同形。
-     *  · `rule`/`command` = **兑付等式的左边**(回决 `persistRule.rule` 按文本在引擎重铸的 offer 表里定位)
-     *    ⇒ 截一个字就恒 `rule_not_offered`,所以**绝不截**;真超尺(= core 放宽了自己的 512 或本仓与 core
-     *    版本不同步)⇒ **整条车道撤回**(返回 `undefined`),与本文件既有的治理撤回 / 漂移撤回逐字同形:
-     *    少渲一格是安全方向,渲一格按不动的才是 wire 谎言。今天这条臂不可达(每个座都是解析器产物),
-     *    它守的是版本不同步那一形 —— 与 `isCommandRuleMatch` 的运行期 `default` 同族。
-     *
-     * 位置在**素材铸点**(与基数帽同一处):两族帧 + `card_json` + 回决口的等式左边从此拿的是**同一份**
-     * 已截素材,而不是两处各截一遍。
-     */
-    /** 兑付侧座(single 的 rule/command、command 成员的 rule/command、directoryRead 成员的 rule/directory)任一超尺?
-     *  `segment` 与 `uncoveredDetail[].segment` 是纯渲染座,不在此列(截长是诚实省略)。 */
-    private static ruleOfferTextsOverSize;
-    /** codex r1 [high]([ref]):offer 的自称座与 `parseRuleText(rule, "allow")` 派生的三元组逐字一致?(理由见调用点)`cardTool` = 这张卡的工具(`req.toolName`)。 */
-    private static ruleOfferDerivedFactsAgree;
-    /**
-     * 一只 single 候选属于这张卡吗 —— 一条规则:**它的规则文本点名的就是这张卡的工具,且它的匹配词的卡形就是这只工具的卡形**(两只读法都在
-     * `permission-rule-vocab.ts`:{@link cardRuleFormOf} / {@link CARD_RULE_FORM_OF_MATCH})。core 为一张卡铸的 single 恰是这一形:shell 卡上的命令规则、
-     * 名字 / 主机工具卡上那一条精确值规则、没有规则词替它说话的工具卡上的整工具规则;兑付侧 `prepareCardApproval` 按「这张卡的工具 + 绑定值」重铸,
-     * 别的形 / 别的工具的候选在那里恒兑不动 ⇒ 渲出来就是一格按不动的「不再询问」。丢(与本文件其余撤回 / 丢弃臂同一方向:少渲一格是安全方向)。
-     */
-    private static singleOfferBelongsOnCard;
-    private static boundRuleOfferTexts;
-    /**
-     * 这张卡的**绑定值**(`prepareCardApproval` 的 `command`,也是耐久行的 `rule_command`)= **卡形的绑定值**(core `prepareCardApproval` 对 `command` 入参的逐形定义):
-     *  · 值形(整工具 / 名字 / 主机:core 对这三形只铸**一只** single,它的 `command` 座就是那个值 —— 整工具 `""`、名字工具是调用带的名字、主机工具是调用到达的主机)
-     *    ⇒ 那一只候选自己的 `command`;
-     *  · 其余(命令形候选 / 批,或读者把候选丢光了)⇒ 被裁决的命令原字节 `args.command`(非空串;读不出 ⇒ 没有素材)。空候选表不说任何值形:
-     *    绑定值回到调用自己的命令(编辑面兑的就是它)。
-     * 候选走到这里之前已过 {@link singleOfferBelongsOnCard}:每只 single 都是这张卡的工具、这只工具的卡形 ⇒ 值形与命令形不会同卡。值形候选不止一只 = 不是 core 铸得出的卡
-     * ⇒ 没有素材(整条车道撤回,与本文件其余撤回臂同形)。`req.args` 窄读,禁裸 as-cast。
-     */
-    private static cardBindingOf;
     private buildRuleLaneMaterial;
     /** [ref]([ref]/[ref] 双属主裁定):把某 wire run 的**流内未决 ask** 立即转 durable park——断连支专用。
      *  匹配键=`ctxTaskId`(wire run id)。该字段的顶注说它「不是清扫判据」——那是因为清扫要判**连接**的
@@ -1874,32 +1956,14 @@ export declare class ToolApprovalCoordinator {
      */
     private dispatchClaimTruth;
     /**
-     * [ref]:为一次**赎回**开一格(单飞句柄的座位)。调用点唯一 = {@link redeemParkedAsk} 开飞之前。在飞的格不受容量帽约束 ——
-     * 它们有界于此刻在飞的赎回请求数,且开飞即受理承诺之前的那一段(逐它会撕正在进行的兑付);容量帽只管落定之后留下的**回执**
-     * ({@link retainParkRedemption})。
-     */
-    /**
-     * 受理回执表的**准入**半场:在飞的格(赎回腿还没回来)永不被逐 —— 单飞靠它 —— 所以表的两道界对它们只能在开格之前判。
+     * 在飞赎回表的**准入**:在飞的格(赎回腿还没回来)永不被逐 —— 单飞靠它 —— 所以表的两道界只能在开格之前判。
      * 本 principal 在飞的格已到生效子帽,或全表在飞的格已到全局帽 ⇒ 拒新(`429 limit.rate_exceeded` + `retryAfterSec`,路由据体铸 `Retry-After` 头),
      * 不开格、不进赎回腿;已在飞的那几只照常落定,之后同一只卡的受理照常。回 `undefined` = 放行。
-     * 两道界与回执半场({@link retainParkRedemption})同一组数:表里每一格都有界 —— 回执靠逐出,在飞的格靠准入。
      */
     private parkRedemptionAdmission;
+    /** 为一次赎回开一格(单飞句柄的座位)。调用点唯一 = {@link runParkedFlight} 开飞之前(读口已保证此刻没有在飞的格)。 */
     private openParkRedemption;
-    /**
-     * [ref] / [ref]:一次赎回**受理成功**之后,它的回执留不留(容量帽按**插入序**逐出最旧,与 `allowAllSessions` 同款有界纪律)。回 `false` = 容量拒新:
-     * 这一格当场收回(那一次受理照旧生效,只是没有本副本的回执可依 —— 200 丢包后的重试再进赎回腿,终局由它的 CAS 定)。
-     *
-     * 两道界**只数回执**(已受理、不在飞的格;在飞的格永不被逐),且**只看本 principal 的那一段**(理由与两条臂的方向差见
-     * {@link DEFAULT_PARK_REDEMPTION_PER_PRINCIPAL_MAX}),生效子帽对全局帽取小。记账用开格那一刻行上的 owner —— 要的是「压力来自谁」这个近似,
-     * 不是「谁有权决这只 ask」(权威属主门恒按行上当下的 `owner` 复判)。
-     *  · 本 principal 的回执数已到子帽 ⇒ 逐本 principal 最旧的那张(过期的优先)—— 量产者自伤;
-     *  · 全表回执已到全局帽 ⇒ 先收全表第一张过期回执(清扫是惰性的,若干租户各自远低于子帽却把全局填满时,TTL 过后没人再来查那些旧 id,
-     *    不回收就永远满 —— 回收过期条目不是「挤他人」,是收垃圾);一张过期的都没有 ⇒ 拒新,一格都不挤别人([ref] Q3)。
-     */
-    private retainParkRedemption;
-    /** [ref]:取受理回执(**惰性清扫**:过期回执读到即删,不另起定时器 —— 这张表只在迟到回决那一刻被读)。**在飞的格不随 TTL 过期**:重叠的请求
-     *  (哪怕晚于 TTL 才到)照样等它、回放它的结果,绝不另起第二次赎回。 */
+    /** 这只问此刻在飞的赎回(没有 ⇒ `undefined`)。 */
     private lookupParkRedemption;
     /**
      * [ref] 车4 §12-E(F29/F30 裁定形):外部回决(车4 端点或本类 respond 腿)**赢下持久 CAS 之后**,把同
@@ -1911,12 +1975,46 @@ export declare class ToolApprovalCoordinator {
      * 真决议」,重复注册必须拿到**同一个**决议(approve 就是 approve)——合并会把外部批准的重复条目错
      * 结算成拒绝。已被结算过的条目再调 settle 天然无操作(幂等),所以本口对「赢家自己已 settle」安全。
      */
-    notifyExternalDecision(askId: string, outcome: DecidedAskOutcome): {
+    notifyExternalDecision(askId: string, outcome: DecidedAskOutcome, readRootGrant?: string): {
         settled: number;
     };
+    /**
+     * 决断口 live 臂在 CAS **之前**握住本副本上等这只问的那条登记({@link HeldLiveLeg};没有 ⇒ 空握)。CAS 写成与回读之间,别的观察者(悬挂轮询 / 同一只问的另一次请求)
+     * 可能先按行把登记结清、移出活集合 —— 赢家的授予({@link settleLiveDecision} 的 ①)读的是它判时握住的这一条,不在结清时再查活集合。
+     */
+    holdLiveLeg(askId: string): HeldLiveLeg;
+    /**
+     * 这只问「要人」的读法 —— 行上那张卡 ∪ 本副本上等它的这一腿的请求(只升不降;重入的腿把位升在登记上,行上那张卡是首次登记铸的):
+     * 决断口的要人门读它(活卡形与停驻形同一只;停驻卡没有活登记 ⇒ 只剩行上那张卡)。
+     */
+    askDemandsAPerson(row: AskRow, held: HeldLiveLeg): boolean;
+    /**
+     * 🔴 **有问行的卡唯一的人决口**(决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`)live 形 CAS **干净赢下**之后的结清 —— 这条终局是本请求写下的,
+     * 于是这次请求带来的 live 词在这里一处兑掉(调用方 = 决断口 live 臂的赢者那一支;回放 / 冲突 / 提交歧义臂都不进来:那几支没有做任何授予判定):
+     *  ① 「本会话放行」(`remember:"session"`):家由卡面那只判官定({@link liveSessionAnswer},读决断口在 CAS 之前握住的那条登记 {@link holdLiveLeg} —— 卡面提示位与写侧同一只);
+     *     `seat` ⇒ 进程内会话放行在**结清之前**铸(同一条腿紧跟着的下一问读得到);`server_store` ⇒ 部署名单那一问的会话豁免在结清之后落店;
+     *     `none` / 本副本上没有等它的登记(决定打在别的副本上)⇒ 记不住。`rememberApplied` 按真结果说(只在请求带了这一键时在场)。
+     *  ② 读根授权(`readRootGrant`)随结清交给本副本上等它的引擎腿(行上没有这一列 ⇒ 只交得给本副本;一条都没有 ⇒ 回执的 `consumerState` 如实说本副本没人消费)。
+     *  ③ 「不再询问」(`persistRule`)交唯一兑付函数 {@link redeemCardRule},记录 = 这只问的**行**({@link readCardRuleRecordOfAskRow};任一副本都兑得了;属主 = 门判过的那一位)。
+     * 结清本身与行派生的结清同一只({@link notifyExternalDecision}:结算取行)。`settled` = 本副本上把它当终局消费掉的腿数。
+     */
+    settleLiveDecision(row: AskRow, held: HeldLiveLeg, judgedOwner: string | null, principal: string | undefined, extras: LiveDecisionExtras): Promise<{
+        settled: number;
+        rememberApplied?: boolean;
+        rule?: RuleSlotReceipt;
+    }>;
+    /**
+     * [ref]:自由文本规则的**裁决前**文本预检(决断口 live 形,CAS 之前;回 `undefined` = 放行,回拒 = 400 且这只问没被结算,人改好文本按同一只问再来)。
+     * 触发条件与兑付函数的前置门逐条同源(只在这次决定**真的会**去兑一条编辑过的自由文本规则时才判):编辑放行 / 治理档 / 车道不供 / 无属主 / 行上没有素材 ⇒ 不判
+     * (那几形走「裁决落定 + `rulePersisted:false` + 各自的拒因词」)。素材读的是行(与兑付同一份记录)。
+     */
+    precheckEditedRuleOfAskRow(row: AskRow, judgedOwner: string | null, persistRule: ParsedPersistRule, inputWasEdited: boolean): {
+        message: string;
+        ruleRejectCode?: string;
+    } | undefined;
     /**
      * [ref] 车6:把一张**批级撤卡帧**投给给定的一组连接 —— 逐 ctx 经本腿那一只传输(`deliverHitlNotice`:先本 run 账本、再直写,
-     * 与开卡帧同一条律、同一条账本链;账本里的序 = 入链序)。只有呈卡族的腿收撤卡帧(旧族没有撤卡帧)。
+     * 与开卡帧同一条律、同一条账本链;账本里的序 = 入链序)。
      *
      * 空名单不发(零信息的帧只会让壳多一次无意义的对账)。投递永不 reject、**绝不回滚已经落定的持久 CAS** —— 帧是通知,行才是真源;
      * 没送到记一次 `server.hitl.close-frame-dropped`,壳侧的结构补偿是重连 preamble 的全量对账基准。
@@ -1947,7 +2045,7 @@ export declare class ToolApprovalCoordinator {
      *  inverse of question's release-unanswered — but no longer a blunt "any one target exits ⇒ kill it" rule,
      *  see {@link PendingApproval.onTargetGone}).
      *  [ref] 注意([ref] core 点名的火):委派子代的 ask 经 {@link boundAsk} 落 pending 时不带
-     *  `targetCtxs`/`onTargetGone`(只有 `originTaskId === undefined` 的宿主自身条目才带)——session-scoped
+     *  `targetCtxs`/`onTargetGone`(只有 `sourceSessionId === undefined` 的宿主自身条目才带)——session-scoped
      *  bg 子代活过宿主 turn 时其未决卡不被这里触碰(TTL/abortSignal 仍兜底)。 */
     runWithContext<T>(ctx: ToolApprovalRunContext, fn: () => Promise<T>): Promise<T>;
     /** 测试/可观测性钩子:该 (owner, session/taskId) broker key 下当前活跃连接数——断言多连接注册/清扫
@@ -1989,122 +2087,44 @@ export declare class ToolApprovalCoordinator {
     private askBroadcast;
     /** {@link askBroadcast} 的本体(计数在外层,一处进出)。 */
     private askBroadcastCounted;
-    /** `POST /v1/tool-approvals/:id/respond` — settle a parked approval with the shell's decision. Owner-gated with a
-     *  404 (no existence oracle), body validated first (400 is existence-independent) — question/steer parity. The HTTP
-     *  layer owns auth (gatedSubject + REQUIRE_PRINCIPAL) before calling.
-     *
-     *  [ref] 车2(D1/D2):return type 是 UNION,不是把整个方法标 `async`——askStore 缺席时这个方法逐字同步
-     *  完成(D1 现行为不变;现存量测试对它的同步断言/`void` 调用零改动)。在场时才真的变成 Promise(D2 的
-     *  「settle 前先赢一把 decideAsk CAS」离不开 await,同步函数做不到)。唯一生产调用点(`routes/runs.ts`)
-     *  统一 `await`——`await` 对非 Promise 值是恒等操作,两条路径对它透明。 */
-    respond(id: string, principal: string | undefined, body: unknown, 
-    /** [ref]:发起本次回决的真实 HTTP 请求。**只**沿 PARKED 臂透传给赎回席(那条腿要它做准入解析与
-     *  舰队 scope,与 `/decide` 腿同姿势);live 命中路径一个字节都不看它。缺席 = 非 HTTP 调用点
-     *  (测试/内部),赎回席按「无请求」形处置。 */
-    httpReq?: IncomingMessage, 
-    /** [ref]:本次回决的**部署事实**(协调器自己不读 config;回决路由从能力事实读来交进)。缺席 ⇒ 按「不受理读根授权」读(失败方向 = 拒)。 */
-    deployment?: ToolApprovalRespondDeployment): {
-        status: number;
-        body: unknown;
-    } | Promise<{
-        status: number;
-        body: unknown;
-    }>;
-    /** [ref]:这条登记**有没有问账行**(有 ⇒ 属主的唯一来源是行上当下的 owner 列;没有 ⇒ 登记记下的那一位是唯一可读的属主事实)。 */
-    private registrationHasRow;
-    /**
-     * [ref]([ref] 的接管登记一臂并进来):**读行判属主**的应答 —— 接管登记恒走这里;活登记在登记记下的属主不认调用方时走这里(行可能已被收编改给调用方)。
-     * 属主门读**行当下的** owner:登记上记下的那一格是铸卡(或接管)那一刻的进程内快照,`/v1/adoption` 改写行之后它就落后了(契约:应答口的授权判据取
-     * 当下的持久事实,收编之后旧属主手里的卡作废、新属主照常答得了 —— 与耐久决断口同答)。行仍 `STREAM_PENDING` ⇒ {@link answerRegistration}(同一把
-     * `decideAsk` CAS,绑门刚读到的那位属主,[ref];活登记上那条在等的腿照常收到决议);行已有终局(别处答了 / 对账器收了,本副本还没闻讯)⇒ 按行的真相答
-     * (与晚答口同一张表)。读不出行 ⇒ 不知道属主是谁 ⇒ 与未知 id 同形同码(属主门 fail-closed)。
-     */
-    private respondByRow;
-    /** 一条已过属主门的登记(活登记或接管登记)的应答 —— 两者同一条路:规则文本前门 → 要人门 → CAS → 兑付。
-     *  `judgedOwner` = 门判过的那位属主([ref]:决议作用域的属主维,CAS 与确认读都绑它;见 `askRowCarriesOwner`)。 */
-    private answerRegistration;
-    /** 一次 live 回决**落定之后**的两件兑付(部署名单那一问的豁免、「不再询问」的规则)—— 两件都只在 200 那一支、都读同一只资格。
-     *  `judgedOwner` = 这次决议的门判过的那位属主([ref]:一次决议只读一次属主 —— 决议 CAS、会话放行、规则落店、豁免记账都用这一份,不回头重读登记上的那一格)。 */
-    private afterLiveDecision;
-    /**
-     * **部署名单(`APPROVAL_REQUIRE`)那一问的「本会话放行」只落 server 的会话豁免店**(问的人按自己这一问的事实决定退不退):名单的问是 server 铸的,
-     * 名单门在出问之前读这只店(键 = 会话 × wire 工具名,与耐久 `/decide` 的 `remember:"session"` 写下的同形),命中就不出问 —— 引擎看到的
-     * 是「这次调用没出问」。不铸进程内授权(那是审批席替引擎的问记的答案;本席不代答名单的问),不交任何东西给引擎的规则店。
-     *
-     * 只在这次回决**真成了终局、而且终局是本请求写的**之后写(200 那一支 ∧ {@link RulePersistEligibility} 合格;CAS 输 / 条目已被别人结算 ⇒ 不写;
-     * 提交歧义臂 —— 行上只证得出「有一条同向决议」,可能是并发的另一路「只批这一次」写的 —— 撤销资格 ⇒ 不写):一次不是自己的放行不留站着的答案。写在结算之后,
-     * 所以同一条腿紧跟着的下一问若先于这次写落到名单门,会多出一张卡(方向是多问,不是静默放行)。回执 `rememberApplied` 按这次写的真实结果说:
-     * 写成 ⇒ `true`;写失败 / 超时 ⇒ `false` + 一行 warn(这一次照旧放行,与 `/decide` 腿「grant 失败不回滚 approve」同向)。
-     * 不是名单的问、记不住的卡(卡上还带着别人的问、强制、授予绑定 ……)、没有会话 ⇒ 原样交回(那几形的回执已由 {@link finishRespond} 定)。
-     */
-    private recordDeploymentListAnswer;
-    /**
-     * [ref]:自由文本规则的**裁决前**文本预检 —— 回 `undefined` = 放行(继续正常回决),回一个响应 = 400。
-     *
-     * 🔴 **触发条件与兑付口的前置门逐条同源**,一个都不许多(这是本方法最容易写错的地方):只有在这次回决
-     * **真的会去兑付一条自由文本规则**时才预检。任何一条前置门本来就会把兑付挡掉的形(治理档 ask /
-     * 车道不供 / 无属主 / ctrl+g 编辑放行),都**必须**照旧走「裁决落定 + `rulePersisted:false` + 各自的
-     * 拒因词」那条老路 —— 否则一次带着坏规则文本的**治理档回决**会被 400 掉,而它本来是能决的:那是把一个
-     * 附带愿望的失败升级成主动作的失败,方向完全错。逐门对照见 {@link persistRuleAfterDecision}。
-     *
-     * 候选臂(`edited !== true`)不进这道门:它的等式是「文本必须在引擎铸的候选里」(`rule_not_offered`),
-     * 那是记录级判据、不是文本级判据,`precheckEditedRuleText` 答不了也不该答。
-     */
-    private precheckEditedRuleBeforeDecision;
-    /** [ref]:回执上两个新键的**唯一**成形口 —— 只在这次请求真的走了**自由文本臂**时铸。
-     *  候选臂的回执因此逐字节不变(老壳按固定键集解析,多一个键就是一次没人要的 wire 变更)。 */
-    private editedArmEcho;
-    /** [ref]:`tool_approval.not_pending` 的**唯一**成形口 —— 只在已过属主门的面上调(调用方看不见这只问 ⇒ {@link askNotVisible})。文案逐字不变
-     *  (存量壳/SDK 按它认这条 404),只 additive 加判别位;`cause` 缺席 = 这台部署没有行可判(D1 无店)或行形不可信(见各调用点)。 */
+    /** [ref]:`tool_approval.not_pending` 的**唯一**成形口 —— 只在按问读口已过属主门之后调(调用方看不见这只问 ⇒ {@link askNotVisible})。文案逐字不变
+     *  (存量壳/SDK 按它认这条 404),只 additive 加判别位;`cause` 缺席 = 行形不可信(见各调用点)。 */
     private notPending;
     /**
-     * 调用方**看不见**这只问的**唯一**成形口(应答口与按问读口同一只):无行 / 行不是调用方的 / 行读不出(不知道属主是谁 ⇒ 属主门 fail-closed)/
-     * 这台部署没有问账可判。404 `not_found.ask` —— 与耐久决断口 `POST /v1/tasks/:taskId/asks/:askId/decision` 的属主门同一个词(两扇门底下是同一只问),
+     * 按问读口上调用方**看不见**这只问的**唯一**成形口:无行 / 行不属路径上的 task / 行不是调用方的 / 行读不出(不知道属主是谁 ⇒ 属主门 fail-closed)。
+     * 404 `not_found.ask` + {@link ASK_NOT_FOUND_UNDER_TASK} —— 与同根的决断口 `POST /v1/tasks/:taskId/asks/:askId/decision` 逐字节同一体(两扇口底下是同一只问),
      * 不带任何状态位:属主门不过与未知 id 逐字节同,404 对看不见它的人不做存在 / 状态神谕。
      */
     private askNotVisible;
     /**
-     * `GET /v1/tool-approvals/:approvalId` —— **按问读口**:一只 ask 此刻在哪一态({@link TOOL_APPROVAL_READ_STATES})。与 {@link respond} 同根同门
-     * (HTTP 层的鉴权 / 属主身份同一只 `gatedSubject`;看不见这只问 —— 属主不过 / 查无 / 行读不出 / 没有问账 —— 与应答口同答 404 `not_found.ask`({@link askNotVisible}),
-     * 无存在性 / 状态谕示)。看不看得见只有一个来源:有行的问 = 店答出的行上当下的属主(按 id 读行,{@link askRowFor} + {@link askRowVisibleTo});
-     * 店答不出 ⇒ 看不见,本副本登记上记下的那一位(行上属主的读缓存)不替店作答。没有行的问(问账没上场 / 旧族腿)= 登记记下的那一位(唯一可读的属主事实)。
+     * `GET /v1/tasks/:taskId/asks/:askId` —— **按问读口**:一只 ask 此刻在哪一态({@link TOOL_APPROVAL_READ_STATES})。与决断口同根同门
+     * (路径同一对身份 `taskId` × `askId`;HTTP 层的鉴权 / 属主身份同一只 `gatedSubject`;看不见这只问 —— 查无 / 不属这只 task / 属主不过 / 行读不出 ——
+     * 与决断口同一体 404 `not_found.ask`({@link askNotVisible}),无存在性 / 状态谕示)。看不看得见只有一个来源:店答出的行上当下的 `taskId` 与属主
+     * (按 id 读行,{@link askRowFor} + {@link askRowVisibleUnder});店答不出 ⇒ 看不见,本副本登记上记下的那一位(行上属主的读缓存)不替店作答。
      * 读到的行仍 `STREAM_PENDING`:本副本有在等它的登记 ⇒ `pending`(行投影 = 列表面 `livePending[]` 的同一只投影);没有 ⇒ 它活在别的副本上,
-     * 与晚答口同答 404 `tool_approval.not_pending` + `unknown_or_other_replica`(那里才有兑现它的闭包;属主看得见的态);其余行态 → 读态与晚答口的分派同一张表。
-     * 纯读:零写、零结算、不碰本地登记(晚答口的 DECIDED 臂会顺手同步本副本的活登记,读口不做)。
+     * 答 404 `tool_approval.not_pending` + `unknown_or_other_replica`(那里才有兑现它的闭包;属主看得见的态);其余行态按 {@link readStateOfRow} 的六态表。
+     * 纯读:零写、零结算、不碰本地登记(与列表面同一读)。
      */
-    readApproval(id: string, principal: string | undefined): {
-        status: number;
-        body: unknown;
-    } | Promise<{
+    readAsk(taskId: string, askId: string, principal: string | undefined): Promise<{
         status: number;
         body: unknown;
     }>;
     /**
      * 有行的登记的按问读口 —— 行可见且仍 `STREAM_PENDING` ⇒ `pending`(列表面同一只行投影);否则按行的态答(与读行半场同一张表)。
      * 行读不出(店抛 / 超时)与查无同答 404 —— 活登记与接管登记一样:登记上那一格只是行上属主的读缓存,店答不出时它不替店说「你看得见」
-     * (应答口同律:属主门那一读读不出 ⇒ 同一句 404;决议写失败之后读不回行 ⇒ 500,那是「不知道落没落」,不是看得见)。
+     * (7.151.x 及以前的应答口同律;7.152.0 起决断口对「属主门那一读读不出」答 500 `internal.error`、读口答这一句 404;决议写失败之后读不回行 ⇒ 500,那是「不知道落没落」,不是看得见)。
      */
     private readByRow;
-    /** {@link readApproval} 的读行半场。 */
+    /** {@link readAsk} 的读行半场。 */
     private readAskRowState;
     /**
      * `PARKED` 行的门读法([ref]):问判官「这张卡的门此刻还是不是该会话当前待决的审批门」。行是终态、不随赎回 / 取消改写,所以只有 checkpoint 知道。
      * `undefined` = **没读到**:没有门读席 / 行上没有 gate token / 读不出(店故障 / 超时,按本协调器的店故障姿势记账 + 一次 warn)。两个读者各自表态:
-     * 按问读口读作 `parked`(读口只能说行说的话;只影响**展示**,应答口对同一张卡仍按自己的判官 fail-closed);应答口的受理回执读作「说不出这一代」({@link receiptAnswersNow})。
+     * 按问读口读作 `parked`(读口只能说行说的话;只影响**展示**,决断口对同一张卡仍按自己的判官 fail-closed);决断口的停驻臂读作「门上没站着决定」({@link decideParkedAsk})。
      */
     private readParkedGate;
-    /** [ref]:这张停驻卡的门此刻站开在哪一代 —— 门读席读到它仍是该会话当前待决的审批门 ⇒ 它的世代号;没读到 / 门不在待决 ⇒ `undefined`。 */
-    private openGateGeneration;
     /** 一条行 → 按问读口的答案(行态六态穷举:新增 `AskState` 而不在此表态 = **编译错**)。 */
     private readStateOfRow;
-    /**
-     * [ref] —— live 未命中之后的**状态感知分派**(设计 §三的那张表)。
-     *
-     * 有行的 ask 的 wire 身份就是行的键 ⇒ 按 id **直接读行**(任一副本、重启前后都读得到;不再经任何进程内的桥)。持久店缺席(没有行可判)/ 店在场而行不在 /
-     * 行读不出 / 不是调用方的 ⇒ 调用方看不见这只问 ⇒ 404 `not_found.ask`({@link askNotVisible};属主不过与未知同形,无存在性谕示)。行在、调用方是属主、
-     * 行仍待决而本副本没有在等它的登记 ⇒ 404 `tool_approval.not_pending` + `unknown_or_other_replica`(那正是「换副本/换端点重试才有意义」的那一因)。
-     */
-    private respondLate;
     /**
      * 新开的 sync 连接经 **preamble** 呈出的卡 → 登记进这条连接的**消卡订阅**(连接的 `approval_complete` 只投给接下过开卡帧的连接 —— 这些卡的开卡帧
      * 就是 preamble 那一帧)。这几只 ask 在本副本上的最后一条活登记落定时,`deliver` 收一帧 `approval_complete`(落定那一拍铸定的那一只对象)。
@@ -2124,120 +2144,77 @@ export declare class ToolApprovalCoordinator {
     /** settle 咽喉调:一只 ask 在本副本上的最后一条活登记落定 ⇒ 订了它的每条连接按唯一写者规则收一帧消卡(见 {@link watchPresentedCards}),随即退订。 */
     private notifyPresentedCardWatchers;
     /**
-     * 一个 wire 身份 → 本副本上**此刻在等它**的那一条活登记(应答口与读口共用这一只读法)。
-     *  · 有行的 ask:wire 身份 = 行的键 ⇒ 同一只 ask 的活登记(重复登记各一条)里**最早**的那一条(插入序;CAS 单赢,赢后其余登记经
-     *    同 askId 的广播口按同一份行真相结清);
-     *  · 无行的 ask:wire 身份 = 登记本地键 ⇒ 直接取那一条。登记本地键对有行的 ask 不是 wire 身份(它从不上 wire),拿它来问 ⇒ 查无。
+     * 一个 wire 身份 → 本副本上**此刻在等它**的那一条活登记(读口与决断口 live 形握登记共用这一只读法)。wire 身份 = 行的键 ⇒ 同一只 ask 的活登记(重复登记各一条)
+     * 里**最早**的那一条(插入序;CAS 单赢,赢后其余登记经同 askId 的广播口按同一份行真相结清)。登记本地键不是 wire 身份(它从不上 wire),拿它来问 ⇒ 查无。
      */
     private liveEntryFor;
-    /** {@link respondLate} 的读行:按 id 读出行,交 {@link dispatchRowTruth}。 */
-    private dispatchLateByRow;
     /**
-     * 按 wire 身份(= 行的键)读行,给属主门用(应答口 / 晚答口 / 按问读口):读到了 ⇒ 那一行;读得出的「没有这一行」与读不出(店抛或超时,记账)同答 `null`。
+     * 按 wire 身份(= 行的键)读行,给属主门用(按问读口;决断口停驻形的重判读行同用):读到了 ⇒ 那一行;读得出的「没有这一行」与读不出(店抛或超时,记账)同答 `null`。
      * 读不出 = **不知道**属主是谁、这只 ask 落在哪一态 ⇒ 调用方看不见它(与查无同答 404):属主门 fail-closed,受理臂不把未知说成受理,读口不把未知说成待决。
      */
     private askRowFor;
     /**
-     * 一只有行的问**此刻的行** —— 应答口 / 按问读口 / 列表面读行的**唯一**入口:{@link askRowFor} 点读(读不出 ⇒ `null` ⇒ 看不见),读到仍待决的行就把这只问在本副本上的登记
-     * 对齐到行上当下的属主([ref];先于各口的门判:门判的是调用方,不是这次对齐)。读序号在**发起读之前**取({@link nextRowReadSeq}):晚回来的旧读盖不掉之后发起的读。
-     */
-    private askRowFollowingOwner;
-    /**
-     * 一条行(的此刻真相)→ 应答口的答案:属主门 + 受理回执 + 六态穷举分派(闭集:新增 `AskState` 而不在此表态 = **编译错**)。两个入口:本副本没有在等
-     * 这只 ask 的登记({@link dispatchLateByRow} 读出行),以及有登记但回决的 CAS 干净地输(行已有终局,`decideAsk` 带回的那条行)—— 一只 ask 的
-     * 应答只看行的真相,与本副本有没有残留登记无关。
-     */
-    private dispatchRowTruth;
-    /** [ref]:迟到腿上的 `persistRule` 兑付面 —— 本地条目(规则车道素材的载体)早已随 park 路由散场,
-     *  没有任何可对的候选表 ⇒ 如实拒(裁决本身照常受理,与 {@link persistRuleAfterDecision} 的
-     *  「失败不翻转裁决」同判)。用既有词 `rule_lane_unavailable`,不为这一支新造词。 */
-    private lateRuleRefusal;
-    /**
-     * [ref] G2 —— DECIDED 行的**幂等回放**([ref] 锚③)。
-     *
-     * 同向迟到答与**反向**迟到答同判:都是 200 回放**首决**。反向不是 409、不是报错、更不改判 —— 那是
-     * 一个 CAS 败者的诚实答:决议早已由首决落定,这次请求只是晚到,响应体把首决交回去,消费端自判向。
-     *
-     * 权威性四合取与 durable 回决腿的 `decidedRowIsAuthoritative` **同判据**(那处顶注是唯一真源):
-     * 决议二值 ∧ 非 provisional ∧ 有 `decidedAtMs` ∧ 态确为 DECIDED。不合形 ⇒ 退回修前 404(绝不把一条
-     * 坏行包装成「人的首决」交出去);此处比那条腿更保守地不铸 500,理由是本腿的客户端是壳上那张卡,
-     * 它对 404 有成文处置(消卡),对 500 没有。
-     */
-    private replayDecidedAsk;
-    /**
-     * [ref] G1 —— PARKED 行的迟到决议:**桥接既有赎回腿**([ref] 锚①「同腿新调用方,零新终局语义」)。
-     *
-     * 为什么桥接而不是在这里 revive-直续:PARKED 的语义是「候下一 run 重呈或 operator 决议」,而
-     * operator 决议早有成文入口(`/decide` 那条链:checkpoint decide CAS → resume)。桥接 = 那条链多一个
-     * 调用方,单赢者仍是它的 CAS;直续则要发明第三种赎回形,与 core 的 park/revive 契约重叠。
-     *
-     * 200 是**受理**语义([ref] 先例):resume 的驱动是 core 内的 fire-and-forget,结果面走 run/events。
-     * 非 2xx 原样透出(gate 被别人收走 ⇒ 409 等),绝不粉饰成受理。
-     */
-    private redeemParkedAsk;
-    /**
-     * [ref] —— **durable 回决腿的规则位**:PARKED 行的迟到决议携 `persistRule` 时,用**行上**的素材兑付。
-     *
-     * 回 `undefined` = 这次请求没带 `persistRule`(一个键都不加,老壳的回执逐字节不变);否则回一个
-     * `{rulePersisted, ruleRefusal?, …echo}` 片段,由调用点铺进 200 体 —— 与 live 腿 `withFlag` 的键集
-     * **同形**(壳的解析器一套判据吃两条腿)。
-     *
-     * ## 素材从哪来(这是本方法存在的全部理由)
-     * live 腿的等式左边是**进程内条目** `PendingApproval.ruleLane`,而 park 路由把条目连同素材一起散场
-     * 了(行之外不留任何进程内素材)。本腿因此从**行**取,一件一件对着 live 腿的入参:
-     *  · `command` = `rule_command` 列(**[ref] 新列**;缺席即本方法唯一的新拒因,见下);
-     *  · `scope` = `rule_scope_root` 列 ⇒ `{kind:"project", root}`,缺席则**不铸 scope**(core 落 global,
-     *    = live 腿 `material.scopeRoot` 缺席时逐字同形 —— 绝不在坐标系不明时编一个 root);
-     *  · 候选表 / `toolName` / 治理位 = 行上的 `card_json`(呈卡帧的同一份;**人看见的就是它**)。
-     *    ⚠️ 卡上的 `toolName` 带 200 字符的投影帽(`approval-card.ts` 的 `MAX_IDENT`),理论上可被截。
-     *    **那一支结构性 fail-closed、不会静默存错规则**:规则文本由 `toolName` + 命令派生,截过的名字
-     *    让 core 重铸出**另一条**规则 ⇒ 候选臂的文本等式当场不成立(`unknown-candidate`),编辑臂则被
-     *    core 自己的覆盖门拒。现网不可达(canonical / `mcp__srv__tool` 都远短于 200),记在这里免得
-     *    下一个人以为是漏了;
-     *  · `toolCallId` / `boundInputHash` = 行上的同名列(与 live 腿铸素材时读的是同一个 `req` 的同两件)。
-     *
-     * ## 三道门与 live 腿逐条同源(顺序也同,理由逐字见 `persistRuleAfterDecision`)
-     * 治理档先判(否则一只治理 ask 会拿到「这台部署不供规则」这个更宽的词)→ 车道/属主 → 素材 →
-     * `updatedInput`(ctrl+g 编辑放行 ⇒ `rule_input_edited`:生效的是编辑后的调用,而候选是从**原始**
-     * 命令铸的)→ 候选臂的文本等式。
-     *
-     * ## 与 live 腿**刻意不同**的一处:没有裁决前的自由文本预检([ref] 的那道 400)
-     * 那道门的语义是「拒的时候这张卡还在,改好再来」;而本腿走到这里时赎回腿的 CAS **已经赢了**
-     * (checkpoint 已被消费),卡不可能还在 —— 400 回去只会把一次**已经生效**的放行谎报成失败。
-     * 所以编辑臂在本腿上照旧落「裁决受理 + `rulePersisted:false` + `edit-rejected`」那条老路(= [ref]
-     * 之前 live 腿的行为),如实登记为本腿的残余。
-     */
-    private persistRuleFromRow;
-    /** [ref]:回执/单飞胜者的**回放形** —— 与首次受理同键集,多一位 `idempotent`,`decision` 恒是**受理时**
-     *  那一向(反向重试不改判,与 DECIDED 臂同一条纪律)。 */
-    private replayRedeemReceipt;
+     * 🔴 **停驻卡的那一只赎回**([ref] α):准入 → 开格(单飞句柄)→ 一飞(赎回席 → 落行 → 规则位)→ 收格。
+     * 决断口先过属主门、把这一问的词映成 {@link ParkedDecisionRequest},经 {@link decideParkedAsk} 交这里 —— 计费 / 就绪 / 服务凭据三道门、checkpoint 当下的 scope 复核、
+     * 「本会话放行」的铸点、规则位的兑付、决定的落行,一处一份。
+     *
+     * 句柄内的序是硬的(与 live 腿同一条纪律):赎回席非 2xx ⇒ 什么都不落(一次没生效的决定不留记录、不留规则);2xx ⇒ **先**落行(停驻卡的决定记在它的问行上,
+     * 唯一写者 {@link writeAskDecision} 的停驻形),**再**兑规则位。两件都在句柄之内:单飞的后到者 `await` 的就是这枚句柄,它拿到的答案与行上的记录同时成立。
+     * 落行失败(店错 / 超时 / 键被同 task 另一只问抢先占了)不改判:这次决定已经被停驻门受理、续跑已经开始 —— 记一笔 fail-open(登记 tag),回执照常;
+     * 代价是这一问的耐久回放(同键重发)读不到这把键,重发不是回放(店错 ⇒ 首决回显的冲突句;键被另一只问占着 ⇒ 决断口幂等预查的跨问冲突句)。
+     */
+    private runParkedFlight;
+    /** 停驻门受理之后落行(唯一写者的停驻形)。落成 ⇒ 落后的行;没落成 ⇒ `undefined` + 一笔 fail-open(这次决定照常生效,见 {@link runParkedFlight} 顶注)。 */
+    private recordParkedOutcome;
+    /**
+     * 🔴 **耐久决断口对一只停驻的问**([ref] α:留下的那扇口吃下停驻形;此前这里答 `410 gone.ask_parked` 指路 `/decide`)。属主门 `ask.decide` 与体门在调用方
+     * (`routes/runs.ts`)已过;要人门的判词由调用方判好交进来({@link ParkedDecisionRequest.policyMayNotApprove}),这里在「这一次要写」时用。停驻形的两件:
+     *  ① **门上已站着一次决定吗**({@link standingParkedDecision}:读停驻门 + 行上的记录)⇒ 站着 ⇒ 交回它(调用方按与 `DECIDED` 行同一条律答:同键 ⇒ 200 回放;否则 409 首决回显)。
+     *  ② 没站着(门仍开着 —— 从没被决过,或被引擎重开过)⇒ 交**同一只**赎回({@link runParkedFlight}),受理后决定落行。
+     * 判只在本副本上没有这只问的赎回在飞时做(有 ⇒ 等它落定、从头再读再判);赎回没生效而门此刻已决 ⇒ 也从头再判(答案是门上那一次)。不读进程内回执(7.152.0 起没有受理回执表):本口的回放律读行 + 门。
+     */
+    decideParkedAsk(store: ApprovalAskStore, row: AskRow, request: ParkedDecisionRequest, idempotencyKey: string | undefined): Promise<ParkedAskAnswer>;
+    /**
+     * **这道停驻门属于哪只问**(读口 `listAsksAtGate`:发起会话 = 停驻行的会话 ∧(PARKED ∧ 门上的绑定对相等 ∨ 还没绑上的 PARKING ∧ 这只问自己的调用 id 与展示摘要相等);
+     * 走既有索引,零 DDL;跨过绑定那一拍是同一行同一份卡)—— 两个读者同调这一只:
+     * 续跑腿的规则记录读者与运维队列行的候选投影(同一张卡在队列行上投的候选与兑付读的记录是同一份,下标同一个空间)。
+     * 恰好一行 ⇒ 这张卡的记录是它;零行 ⇒ 没有问行(直停驻卡,读停驻行);多行 / 读抛 / 超时 ⇒ 读不出记录(fail-closed:不退到停驻行 ——
+     * 那会换一份记录兑;队列行同答:不投候选)。
+     */
+    readParkedAskOfGate(sourceSessionId: string, binding: {
+        readonly boundCallId: string;
+        readonly boundInputHash: string;
+    }): Promise<{
+        readonly kind: "row";
+        readonly row: AskRow;
+    } | {
+        readonly kind: "none";
+    } | {
+        readonly kind: "unreadable";
+    }>;
     /**
-     * [ref] 车二:回决携规则确认 ⇒ prepare→confirm→redeem(实现在 `rules-consent.ts`,本方法只做门与回显)。
-     *
-     * 三道门,每道都是**拒绝**而不是降级:
-     *  ① 裁决必须真落定(200)—— 见调用点注;
-     *  ② 必须有已验明的 owner —— 规则是**某个人**的持久同意,一条 `owner === null` 的 ask 没有归属人可写;
-     *  ③ 本 ask 必须登记过规则车道素材(店在场 ∧ 引擎铸过候选 ∧ 命令可读)。
-     *
-     * 失败**不翻转裁决**:人的「允许这次」已经生效并且已经交给引擎了,把整个回决改判成 4xx 会让一次真实的
-     * 放行凭空消失。诚实的形是 200 + `rulePersisted:false`(壳据它告诉人「这次放行了,但『不再询问』没存上」)。
+     * 🔴 **一张卡的人决的唯一写者**(决断口两形同一只;店上两只动词 `decideAsk` / `recordParkedDecision` 在 src 里只有这里调 —— 钉 `test/ask-decision-single-writer.test.ts`)。
+     *  · live 形:`STREAM_PENDING → DECIDED` 的单赢者 CAS(批维 + [ref] 属主维),套墙钟上限;**迟到的成功**(这次调用报了超时,决议其实落了盘)⇒
+     *    行过了权威四合取({@link decidedRowFacts})才把同 askId 下还挂着的本地条目按**行**结清(结算取行,[ref]),不让它们等自己的窗再绕一圈。决断口(`routes/runs.ts`)经这里。
+     *  · 停驻形:停驻门(续跑腿的门 CAS)**已经受理**之后把记录落在仍 `PARKED` 的行上(态不变,终局恒是那道门);只由停驻赎回的那一飞调({@link runParkedFlight})。
+     * 入参映射只有一只({@link askDecisionRecordOf} / {@link liveDecideInputOf})。抛 = 店错 / 超时(调用方各自的歧义臂接)。
      */
-    private persistRuleAfterDecision;
-    /** store 在场时的回决 CAS 门(D2)——`respond()` 的异步分支,拆出以保持 `respond()` 本身在 store 缺席
-     *  时仍是纯同步函数(D1)。`askStore`/`askId`/`batchId` 由调用方在已窄化的分支里传入(避免非空断言）。 */
-    private respondWithCas;
-    /** 回决收尾(D1 现行为逐字不变的那一半)——session allow-all 记账 + settle + 200 响应体。原 `respond()`
-     *  方法体的逐字搬运([ref] 车2 拆分,行为零改动)。 */
-    private finishRespond;
+    writeAskDecision(store: ApprovalAskStore, askId: string, form: {
+        readonly kind: "live";
+        readonly batchId: string;
+    }, owner: string | null, write: LiveAskDecisionWrite): Promise<DecideResult>;
+    writeAskDecision(store: ApprovalAskStore, askId: string, form: {
+        readonly kind: "parked";
+    }, owner: string | null, write: AskDecisionWrite): Promise<RecordParkedDecisionResult>;
     /**
      * 🔴 [ref] —— **起服接管**:把问账里仍 `STREAM_PENDING` 的问接进本审批机的活集合,让 `livePending[]`(及 `/v1/approvals/stream` 的 live 半场、
-     * 按问读口、应答口)在重启之后不重开流也看得见、答得了它们。审批机仍是这些读面**唯一**的候选源(哪些问在本副本上有登记):扫问账找待决行的只有这里(起服一次),之后列表行由
+     * 按问读口、决断口)在重启之后不重开流也看得见、答得了它们。审批机仍是这些读面**唯一**的候选源(哪些问在本副本上有登记):扫问账找待决行的只有这里(起服一次),之后列表行由
      * 同一只 {@link livePendingRowOf} 投影,卡帧 = `buildReplayFrame`(开流 preamble 同一只构造)—— 不是 GET 上按属主扫表的第二 reader;列表面对候选逐只点读行(见 {@link listLivePending}),候选集之外的问它不认识。
      *
      * 律(设计稿 `design-[ref].md` §2):接管登记**没有引擎腿在等它**(铸它的进程没了,或它活在别的副本上),与活登记同一只状态机 ——
-     * 应答 = 同一把 `decideAsk` CAS({@link answerRegistration}),收敛 = 同一条悬挂轮询腿读行({@link pollSuspendedDecisions});它活多久只由行说了算,
+     * 决定 = 同一把 `decideAsk` CAS(决断口经 {@link writeAskDecision}),收敛 = 同一条悬挂轮询腿读行({@link pollSuspendedDecisions});它活多久只由行说了算,
      * 没有自己的窗(无等待腿的行的到期写者已经存在:对账器段二,同一只政策感知终态 claim,窗 + 宽限 —— 接管不新增竞争者)。
-     * 「本副本没有引擎腿在等它」机读披露:列表行与应答回执带 `consumerState:"absent"`({@link ASK_DECISION_CONSUMER_ABSENT})。
+     * 「本副本没有引擎腿在等它」机读披露:列表行与决断口回执带 `consumerState:"absent"`({@link ASK_DECISION_CONSUMER_ABSENT})。
      *
      * 装配点 = `boot/stage-07` 起服收敛之后、reaper / HTTP 之前(local 车道上收敛先把前世问收成 `VOID` ⇒ 这里读到零行,车道无分叉)。
      * 幂等:本副本已有这只 askId 的登记就跳过;每次起服由行重新推导。读失败 ⇒ **拒启**(抛;与起服收敛同一拍、同姿态 —— 照常起来等于让
@@ -2259,25 +2236,6 @@ export declare class ToolApprovalCoordinator {
      * (不发帧 —— 问不是被谁答掉的,编一帧消卡就是撒谎;壳的结构补偿仍是下一次 preamble 的全量对账基准)。还有活登记 ⇒ 订阅留给它的结算。
      */
     private forgetAdoptedAsk;
-    /**
-     * 🔴 [ref]:**有行的登记,属主跟行走** —— 本协调器每读到这只问仍待决的行一次(悬挂轮询 / 应答口读行 / 读口读行 / 收编后的重读),就把这只问在本副本上的
-     * **每一条**登记对齐到行上当下的属主。活登记与接管登记同一条(修前只有接管登记跟,活登记的那一格停在铸卡那一刻:收编之后列表面仍按前属主列、
-     * 店写失败 + 确认读也失败的那一支按前属主放行一次)。行的属主只有 `/v1/adoption` 改写;这里只对齐、不判授权(授权照旧在各扇门里按面表判)。
-     */
-    private followRowOwner;
-    /** [ref]:行读的单调序号 —— 每一次会拿来对齐属主的行读在**发起之前**取一个;同一副本内后发起的读看到的行不比先发起的旧(店的单行读按提交序)。 */
-    private rowReadSeq;
-    private nextRowReadSeq;
-    /**
-     * [ref]:**收编落定后的重读** —— `approval_ask.owner` 唯一的写者(`/v1/adoption`)在本副本落成回执后由路由调一次:本副本每一只有行的问点读一次
-     * (带墙钟期限),仍待决 ⇒ {@link followRowOwner}。读不出 ⇒ 记账(与其它店调用同一只 `noteStoreError`)、这只问原样留着上一次读到的属主,不编;
-     * 行没了 / 已终局 ⇒ 不在这里处置(悬挂轮询与应答口各有自己的收法)。射程 = 本副本(多副本部署里别的副本的登记由它们自己的行读跟上;收编的运维前提是先停引擎)。
-     */
-    followRowOwners(): Promise<{
-        read: number;
-        followed: number;
-        unreadable: number;
-    }>;
     /** 这只 askId 在本副本上有几条**有引擎腿在等**的登记(接管登记不算)—— 轮询腿的「被唤醒数」读它。 */
     private waitingRegistrationCount;
     /**
@@ -2289,13 +2247,13 @@ export declare class ToolApprovalCoordinator {
      * (R7:不带主体的调用方列得出它答得了的那几张),其余串 = 只见 `owner === scope` 的条目(null-owner 行对具名主体不列,宁少列不超范围)。
      * 行的 `approvalId` 就是 `respond()` 收的 id(同源可达,[ref] 判据);`expiresAtMs` 照抄登记时单点铸定的窗死线([ref] 三键同一个数)。
      *
-     * 🔴 **有行的问,列表只列按问读口会答 `pending` 的**(看不看得见只有一个来源,{@link readApproval} 同一条律):本副本此刻的登记只是**候选**(哪些问在本副本上有登记);
-     * 有行的问,列不列它、列给谁只由店答出的行说了算 —— 对每只候选点读行({@link askRowFollowingOwner},与读口 / 应答口同一只 {@link askRowFor}):行读不出(店抛 / 超时)⇒ 看不见 ⇒ 不列
+     * 🔴 **有行的问,列表只列按问读口会答 `pending` 的**(看不看得见只有一个来源,{@link readAsk} 同一条律):本副本此刻的登记只是**候选**(哪些问在本副本上有登记);
+     * 有行的问,列不列它、列给谁只由店答出的行说了算 —— 对每只候选点读行({@link askRowFor},与读口 / 决断口同一只):行读不出(店抛 / 超时)⇒ 看不见 ⇒ 不列
      * (与读口的 `404 not_found.ask` 同隐;店恢复后下一次列表即回),行已离开 `STREAM_PENDING`(别处答了 / 收走了,本副本的登记还没闻讯)⇒ 不列(读口答的是它此刻的态),
-     * 行上当下的属主不在 `scope` 内 ⇒ 不列(登记上记下的那一位只是行上属主的读缓存,不替店作答)。没有行的问(问账没上场 / 旧族腿)登记记下的属主是唯一可读的属主事实 ⇒ 照登记列。
+     * 行上当下的属主不在 `scope` 内 ⇒ 不列(登记上记下的那一位只是行上属主的读缓存,不替店作答)。
      * 读行并发发起、各自带 {@link DURABLE_CONVERGE_READ_TIMEOUT_MS} 的墙钟 ⇒ 一次列表至多等一个期限;行体的投影取在读完之后、对每个列出的 wire 身份重取此刻代表它的那条登记
      * ({@link liveEntryFor}):读行期间已结算的不列,读行期间被活登记接替的接管登记按活登记的样子列。
-     * 读行的次数 = 本副本此刻**有行的不同 ask 数**(重复登记共用一次读,没有行的问不读),**不按 `scope` 先筛**(登记上的属主只是读缓存,不替店判谁看得见 —— scope 之外的卡也要读一次行才判得出);
+     * 读行的次数 = 本副本此刻**不同 ask 数**(重复登记共用一次读),**不按 `scope` 先筛**(登记上的属主只是读缓存,不替店判谁看得见 —— scope 之外的卡也要读一次行才判得出);
      * 登记数的上界是每个任务 / 每个属主各一个未决帽(`STREAM_APPROVAL_ADMIT_MAX_PER_TASK` / `_PER_OWNER`)加起服接管上限 {@link ADOPT_OPEN_ASKS_MAX},本副本的总数没有全局帽。
      * 列表行 ⊆ 按问读口对同一调用方答 `pending` 的那些;反过来不然 —— `scope` 比读口窄:具名主体的列表不含无主的卡(宁少列),运维列表按 `?owner=` / 全量列、含读口对运维不放行的卡。
      */