@sema-agent/server 7.133.0 → 7.135.0

package/dist/tool-approval.d.ts

@@ -1,65 +1,8 @@
-/**
- * [ref]/[ref]② tool-approval bridge — the SERVICE side of core's `RunnerDeps.onAsk` seam (core `tool-policy.ts`
- * `resolveAsk`, 1.290's sync-ask leg). The SIBLING of {@link import("./question.js").QuestionCoordinator}: onQuestion
- * routes the agent's AskUserQuestion tool to a live human; THIS routes a policy `ask` DECISION (e.g. the
- * `createFsWriteGatePolicy` fs-write gate, an ask-list rule, or a non-durable safety ask) to the live human as a
- * CC-parity three-choice card (Yes / Yes-allow-all-session / No).
- *
- * Wire shape (mirrors question end to end): core adjudicates a tool call `ask` → `resolveAsk(req, onAsk)` calls this
- * coordinator's `ask` → we mint a pending entry + emit a `tool_approval` SSE frame on the run's live stream → the
- * shell renders the three-choice card → `POST /v1/tool-approvals/:id/respond` settles the parked promise →
- * `resolveAsk` maps our boolean to allow/deny. RESPOND BODY selection rationale: the question precedent's body is
- * core's own QuestionAnswer (a structured multi-answer object) because core FENCES its semantics; an approval has no
- * core-side answer object — `OnAsk` resolves to a BARE boolean — so the wire body is a minimal closed enum
- * `{decision: "allow" | "allow_session" | "deny"}` mapping 1:1 onto the CC card's three choices (no free text = no
- * fence needed; "allow_session" carries the Yes-allow-all intent that a boolean cannot).
- *
- * Session state ([ref]② "桥内会话态"): `allow_session` remembers a per-CAPABILITY grant keyed by
- * `[owner, sessionId, category]` — a LATER ask in that (owner, session) whose tool maps to the SAME category
- * auto-allows WITHOUT a card (CC 207: "Yes, allow all edits during this session") only through the FOUR-WAY
- * conjunction at the short-circuit (see `ask`): {@link standingAnswerHome} over the ask's three facts
- * (NOT governance-forced [ref] 件7/[ref], NOT `requiresRealApproval` [ref], NOT `mandated` S-660 — the SAME
- * predicate decides whether an `allow_session` answer may MINT a grant, see `finishRespond`) ∧ a truthy sessionId ∧
- * the grant itself ∧ `sessionGrantUncontestedByRow` (the durable row must not contradict the local peek). The category collapses the
- * fs-WRITE tool family (Write/Edit/NotebookEdit, canonical space) into ONE bucket `"fs-write"`; any OTHER tool is
- * its OWN bucket `"tool:<canonical>"`. 🔴 A `allow_session` on a NON-fs-write ask (an irreversible-Bash safety ask,
- * an ask-list rule on another tool) therefore unlocks ONLY that same tool for the session — it must NEVER unlock the
- * fs-write family (the "approve a cheap ask once → all future Write/Edit auto-allowed" scope widening, 三路复审 A 组 修2).
- * The key is scoped to the VERIFIED owner too, so a session id shared across principals cannot inherit another's
- * grant. This is the cheapest mid-task implementation; a mode SWITCH (default → acceptEdits) still goes through the
- * shell's intent on the next task ([ref] table).
- *
- * 🔒 FAIL-CLOSED everywhere (the inverse of the question lane — an unanswered QUESTION never blocks the run: since
- * [ref] the coordinator reports `unavailable` and CORE decides the landing, which depends on WHEN the human became
- * unreachable — at policy time the durable gate says `ask` and the leg parks; once the tool is already running core is
- * past `suspendAsk`, so it continues on `declined_unavailable`; an unanswered APPROVAL must NOT let the write
- * proceed): TTL expiry and client disconnect ([ref] `parkOpenAsksForTask` → `forceParkNow`) land on the ONE
- * unattended-outcome former ({@link ToolApprovalCoordinator.unattendedOutcome}, [ref] R-13) — park route
- * ("unavailable" ⇒ core durable-parks) by default, a DEPLOYMENT-POLICY refusal (`{allow:false, settledBy:"policy",
- * reason}` ⇒ core settles `policy_refused`; S-689 — never a bare `false`, which core reads as a PERSON's refusal)
- * ONLY where the deployment declared `UNATTENDED_APPROVAL_POLICY=deny`; a run ABORT (task cancel → `runCancel`)
- * still resolves `false` — the row goes VOID, there is nothing left to redeem. Since [ref] G1 (core 1.295
- * OnAsk 三值化) the "no reachable human" class returns
- * "unavailable" instead of false — no ALS context AND no bound-closure broker hit(1.258 起 bg/嵌套子代经
- * spec.onAsk 的 bound 闭包 + streams broker 直达宿主活流,「无 ctx」只剩 durable-submit/headless resume
- * 残余腿)and emit failure
- * (card never delivered, and only when this catch is the first settler — a human verdict that raced in during the
- * await keeps its boolean) ⇒ "unavailable" → core durable-parks (or fail-closed denies without a checkpoint). core's
- * `resolveAsk` maps false to a deny WITH the ask message, so the model can re-route (deny + continue turn, [ref]⑤).
- * Owner gate on respond = the VERIFIED principal (gatedPrincipal at the HTTP layer), 404 without an existence oracle
- * — same posture as question/elicit. The frame's model-authored surfaces (message + args) are secret-REDACTED
- * before they are streamed; the SIZE bound is per-surface: args ride a byte cap (`MAX_APPROVAL_ARGS_BYTES`,
- * over-cap ⇒ `argsOmitted`), while the legacy frame's `message` is redacted but NOT length-capped — the char
- * cap (`MAX_MESSAGE`, approval-card.ts `capText`) lives on the card/`approval_request` projection only (same
- * redact-at-write contract as question; the args are shown to a human,
- * never re-fed to a model). No throttle (unlike question): an approval breach-default would be a DENY (task failure),
- * and asks are turn-blocking by construction — the TTL bounds the human-side exposure instead.
- */
-import { type ParkedGateFace } from "./approval-content-kind.js";
 import { type ApprovalDecidedBy, type HostSettledBy, type RetiredDecisionKeyFacts } 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 } from "@sema-agent/core";
+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 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 { ApprovalAskAuditSink } from "./approval-ask-audit-store.js";
@@ -69,20 +12,6 @@ import { type GovernanceAskMarks } from "./governance-ask-marks.js";
 import { type GovernancePosture } from "./runtime-governance.js";
 import { type GrantBinding, type StandingAnswerCall } from "./standing-answer-grant.js";
 import { type ApprovalExemptionStore } from "./plugins/approval-exemption-store.js";
-/** [ref]:审批 gate kind 闭集(core gateMatch 的 `human`/`irreversible_ask` ↔ outcome.gate "policy_ask")。
- *  此前 7 份手写副本散在两只 checkpoint store 的数组/SQL 字面与 /decide 守卫——core 加审批味 kind 时
- *  全部静默漂移。core 无导出词表(全大写导出面零命中,2026-08-09 亲验),属主落此;SQL IN 片段从
- *  数组派生保证同源。门=test/approval-gate-kinds-single-owner.test.ts(副本回潮即红)。 */
-export declare const APPROVAL_GATE_KINDS: readonly ["human", "irreversible_ask"];
-export type ApprovalGateKind = (typeof APPROVAL_GATE_KINDS)[number];
-export declare function isApprovalGateKind(k: string | undefined): k is ApprovalGateKind;
-/**
- * 停驻行的到期归 SLA 拒扫腿(deny)而不是作废(expire)?—— **一只谓词**:审批门型 ∧ core `facetOf(gate)` 读作 `A`(问答卡 ⇒ `B`,到期作废;
- * 无门型 / 非审批门 ⇒ 不归拒扫)。两只店的拒扫选行与作废腿的补集都读这一只(SQL 腿的 `gate_kind IN …` 只是它的粗筛前置,判官仍是 core)。
- */
-export declare function denySweepOwns(gate: ParkedGateFace | undefined): boolean;
-/** 两方言同形的 SQL IN 片段(值为闭集常量字面,无注入面)。 */
-export declare const APPROVAL_GATE_KINDS_SQL_IN: string;
 /** {@link ToolApprovalCoordinator.adoptOpenAsks} 的读数(装配点进启动日志)。 */
 interface OpenAskAdoption {
     /** 本次接管进活集合的问数。 */
@@ -95,7 +24,7 @@ interface OpenAskAdoption {
     readonly capped: boolean;
 }
 /**
- * 耐久回决口 `POST /v1/approvals/:sessionId/decide` 的路径串 —— S-1280:迟到回决口 PARKING 臂 202 体的机读指路 `decidePath`。
+ * 耐久回决口 `POST /v1/approvals/:sessionId/decide` 的路径串 —— [ref]:迟到回决口 PARKING 臂 202 体的机读指路 `decidePath`。
  * 路由表那一行(`http/routes/approvals-assistant.ts` 的 `approval-decide`)按 pattern 匹配它;两者同形由往返钉守
  * (`test/parked-late-decision.test.ts` G3-c:本函数的输出经 `lookupRoute` 落 `approval-decide`)。会话段按路由的 `safeDecode` 对称编码。
  */
@@ -114,9 +43,9 @@ export type NotPendingCause = AskRowEndingCause | typeof NOT_PENDING_UNKNOWN_CAU
 /**
  * `GET /v1/tool-approvals/:approvalId` 应答体 `state` 的**闭集**(一只 ask 此刻在哪一态;读法与应答口逐条同源):
  *  · `pending` —— 本副本上有在等它的活登记(应答口此刻收得下);
- *  · `decided` —— 行 `DECIDED`(有人 / 有策略决过;回执三键同晚答回放体);
- *  · `parked`  —— 行 `PARKING` / `PARKED`(转后台候批;应答口走迟到受理,耐久回决口照收);
- *  · `void`    —— 行 `DENIED` / `VOID`(没有人决过它,答案无处兑现;`cause` 同晚答 404)。
+ *  · `decided` —— 行 `DECIDED`(有人 / 有策略决过;回执三键同晚答回放体),**或**行 `PARKED` 而它的门已被决([ref]:checkpoint 已结算,见 {@link ParkedGateReading});
+ *  · `parked`  —— 行 `PARKING`,或行 `PARKED` 且门仍是该会话当前待决的审批门(转后台候批;应答口走迟到受理,耐久回决口照收);门是被引擎重开的(决过之后续跑腿在动作开跑前失败)⇒ 另带 `reopened`([ref],见 {@link ReopenedGate});
+ *  · `void`    —— 行 `DENIED` / `VOID`(没有人决过它,答案无处兑现;`cause` 同晚答 404),**或**行 `PARKED` 而它的门已过期 / 被取代(含停驻 run 被取消;此时 `cause` 缺席)。
  */
 export declare const TOOL_APPROVAL_READ_STATES: readonly ["pending", "decided", "parked", "void"];
 export type ToolApprovalReadState = (typeof TOOL_APPROVAL_READ_STATES)[number];
@@ -140,6 +69,7 @@ export type ToolApprovalReadBody = ({
 } & AskRowReadProjection) | ({
     state: "parked";
     decidePath?: string;
+    reopened?: ReopenedGate;
 } & AskRowReadProjection) | ({
     state: "void";
     cause?: AskRowEndingCause;
@@ -185,7 +115,7 @@ export type SettleVerdict = {
  * 语义边界(禁扩读):它答的是「本副本此刻有没有活体消费者」,**不是**「这条 run 还活着吗」——持有
  * 悬挂 promise 的可能是另一个副本(F4 的轮询腿会在它自己的下一拍续跑)。run 的生死读 run 面。
  *
- * S-247 起**同一个词、同一句语义**也出现在 live 面:审批机起服时从问账接管的登记(没有引擎腿在等)在 `livePending` 行上带它,
+ * [ref] 起**同一个词、同一句语义**也出现在 live 面:审批机起服时从问账接管的登记(没有引擎腿在等)在 `livePending` 行上带它,
  * 在 live 应答口的 200 回执上按同一判据(本副本被唤醒的等待腿数 = 0)带它。一个事实,各面一个读法。
  */
 export declare const ASK_DECISION_CONSUMER_ABSENT = "absent";
@@ -207,7 +137,7 @@ export interface ParkedAskRedeemRequest {
     decision: "approve" | "deny";
     /** [ref] 同源的人写理由(deny 时 core 把它交给模型;allow 只进审计面)。 */
     note?: string;
-    /** S-1154:决定体的**出处位**(已过 `readDecidedBy` 的 wire 词,缺席已落成 `"person"`),经 `hostDecisionFacts` 落到停驻座的
+    /** [ref]:决定体的**出处位**(已过 `readDecidedBy` 的 wire 词,缺席已落成 `"person"`),经 `hostDecisionFacts` 落到停驻座的
      *  `hostDecision.decidedBy`。live 命中臂与本 PARKED 臂读**同一格** —— 同一份体落在哪条臂上只取决于副本与时序;两臂各走自己座的
      *  那一只映射(live = `liveSettledBy`,停驻 = 恒等),词表只有一份。 */
     decidedBy: ApprovalDecidedBy;
@@ -226,6 +156,51 @@ export type ParkedAskRedeem = (req: ParkedAskRedeemRequest) => Promise<{
     status: number;
     body: Record<string, unknown>;
 }>;
+/**
+ * 一张门被引擎**重开**过的停驻卡([ref]):决过之后,续跑腿在被批准的动作开跑之前失败,引擎把同一张门(同一把 token)翻回待决。
+ * `reason` = core 记在行上的重开因由词原样(闭集 `REOPEN_REASONS`:`env_failed` 同一个决议经耐久回决口(`decidePath`)再交一次即可续跑 —— 本副本还留着首次受理回执时(缺省 1 小时内、未被容量帽逐出)应答口回放那张回执、不驱续跑;`tool_unavailable` / `constraint_rejected` 要重新决;`config_refused` 改好部署配置后再交原决议,或重新决);
+ * `decision` / `decidedAtMs` / `decisionNote?` = 重开之前的那次决议(读法与已结算门的 `decided` 同一只;读不出 ⇒ 三键缺席,只带因由词)。
+ */
+export type ReopenedGate = {
+    readonly reason: ReopenReason;
+} | {
+    readonly reason: ReopenReason;
+    readonly decision: "allow" | "deny";
+    readonly decidedAtMs: number;
+    readonly decisionNote?: string;
+};
+/**
+ * 按问读口对一张 `PARKED` 卡的**门读法**([ref];判官的唯一属主 = `approval-gate-currency.ts`,协调器本身不认识 checkpoint 的形):
+ *  · `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`),
+ *    并记一行 error:`defects` 是读不出的那几处(非空),日志带首句 + 计数。
+ */
+export type ParkedGateReading = {
+    readonly kind: "open";
+    readonly reopened?: ReopenedGate;
+} | {
+    readonly kind: "decided";
+    readonly decision: "allow" | "deny";
+    readonly decidedAtMs: number;
+    readonly decisionNote?: string;
+} | {
+    readonly kind: "void";
+} | {
+    readonly kind: "unknown";
+    readonly why: "row_absent";
+} | {
+    readonly kind: "unknown";
+    readonly why: "decision_unreadable";
+    readonly defects: readonly [string, ...string[]];
+};
+/** 门读席:入参 = 问账行上的 gate 坐标(PARKED 行恒带 `gateToken`)。读不出(店抛错)⇒ 抛,协调器按店故障姿势处置(见 `readParkedGate`)。 */
+export type ParkedGateRead = (row: {
+    readonly gateToken: string;
+    readonly gateBoundCallId: string | null;
+}) => Promise<ParkedGateReading>;
 /** 阶梯里**重发**一把 claim 的墙钟上限(ms;首把用 `DURABLE_CALL_TIMEOUT_MS`)。🔴 codex 交叉复审 C5
  *  (2026-08-06 真缺陷):只数重试次数是**不够**的 —— 次数只约束「已经返回或已经 reject 的调用」,一次
  *  **挂住不返回**的店调用(DB 连接黑洞、池饿死)会让整个退避循环连一格都走不完,`onAsk` 的 promise 于是永久
@@ -240,7 +215,7 @@ export declare function carriesDeploymentListQuestion(deploymentListAsks: boolea
  * 继承问),而**能不能读**与审批席 / 回决写侧是同一只判据({@link standingAnswerDurablyRecordable}):记得下的才代答,记不下的(带授予绑定的问 ……)不代答,
  * 存量行也不例外 —— 一事一读。事实取自**这一问本身**:类集经 core 包根唯一的类派生 `classifyAsk`({@link NO_GATE_FACTS});`requiresRealApproval` /
  * `mandated` 读这一问自报的成员;治理位恒假(本层不是治理层);授予绑定读**调用**(`callGrantBindingOf` —— 本层手里还没有引擎铸的卡,core 7.51.0 不在
- * `ToolCallRequest` 上盖绑定词,S-1493 载体问题见 `standing-answer-grant.ts` 头注)。
+ * `ToolCallRequest` 上盖绑定词,[ref] 载体问题见 `standing-answer-grant.ts` 头注)。
  */
 export declare function policyAskStandingAnswerFacts(req: StandingAnswerCall, ask: Extract<PermissionResult, {
     action: "ask";
@@ -252,7 +227,7 @@ export declare function policyAskStandingAnswerFacts(req: StandingAnswerCall, as
  * 而不是漏传一格被静默读成 `false`(那是安全轴上的 fail-open)。读者各自从自己手里的形折成这三格,
  * 然后交**同一只** {@link standingAnswerHome}(判据只有一份,折法各归读者):
  *  · live 读侧取 `req` + 本地治理 peek;live 写侧取 pending 条目;
- *  · 耐久 `/decide` 腿(S-663 → NP-1,7.100.0)取 park 行,经 {@link parkRowStandingAnswerFacts}(三格全从行上读)。
+ *  · 耐久 `/decide` 腿([ref] → NP-1,7.100.0)取 park 行,经 {@link parkRowStandingAnswerFacts}(三格全从行上读)。
  * 本型**不绑** live 条目。
  */
 export interface StandingAnswerFacts {
@@ -263,9 +238,9 @@ export interface StandingAnswerFacts {
     /** core 闸站盖的强制位([ref]):规则清不掉、站着的答案退不掉,只有对**这一次调用**的应答能答。 */
     readonly mandated: boolean;
     /** 这一问的应答**授不授予**这一次调用之外的东西、授予的话绑定是什么(批准引擎的 `Skill` = 激活技能 + 本 run 内清单免问)。
-     *  `bound` ⇒ 站着的答案按「工具 + 绑定」记、只代答绑定相同的问(core 7.43.0 #1348 / #1357:活的问与停驻行同带 `boundGrantDigest`);
+     *  `bound` ⇒ 站着的答案按「工具 + 绑定」记、只代答绑定相同的问(core 7.43.0 [ref] / [ref]:活的问与停驻行同带 `boundGrantDigest`);
      *  `unreadable` ⇒ 不可记、不被代答(fail-closed)。读者一律经 `standing-answer-grant.ts` 折这一位:载体由问的属主定(`questionGrantBindingOf`)——
-     *  引擎铸的问读卡上引擎的词(`grantBindingOf`),部署名单自己的问与策略层的调用读 `callGrantBindingOf`(S-1493)。 */
+     *  引擎铸的问读卡上引擎的词(`grantBindingOf`),部署名单自己的问与策略层的调用读 `callGrantBindingOf`([ref])。 */
     readonly grantBinding: GrantBinding;
     /** 引擎盖在这一问上的**类集**(`AskRequest.classes` / 停驻行孪生座;经 core 的屏 `screenAskClassMembers` 读)。`undefined` = 卡上没有类
      *  (老引擎 / 不盖类的站)或屏拒 —— 读不出的类不是「无类」。 */
@@ -287,7 +262,7 @@ export interface StandingAnswerFacts {
  */
 export type StandingAnswerHome = "none" | "seat" | "server_store";
 /**
- * 🔴 **S-660 —— 会话级放行的唯一判据:站着的答案能不能退掉这一问,能的话它记在哪({@link StandingAnswerHome})。** 纯函数,读者:
+ * 🔴 **[ref] —— 会话级放行的唯一判据:站着的答案能不能退掉这一问,能的话它记在哪({@link StandingAnswerHome})。** 纯函数,读者:
  *  · **读侧**(`askBroadcast` 的会话授权短路 {@link ToolApprovalCoordinator.standingGrantSettles}):`seat` 才可能由既有授权代答,否则往下走真出卡;
  *  · **写侧**(`finishRespond` 的 `grantable` 与 `recordDeploymentListAnswer`):`seat` 把 `allow_session` 铸成进程内授权;`server_store` 落 server 的会话豁免店;
  *    `none` 只放行这一次、`rememberApplied:false`;
@@ -299,7 +274,7 @@ export type StandingAnswerHome = "none" | "seat" | "server_store";
  * **为什么三位是同一类**(「站着的答案退不掉的一问」):会话授权 = **上一次**应答记下的一揽子放行,不是对
  * **这一次**调用的应答 —— 与持久 allow 规则同族,只是更短命(`askBroadcast` 短路处的注早已这么定性)。
  *  · `mandated`:core `PermissionResult` ask 臂 `mandated` 成员的文档。7.29.0 原句「no persisted allow rule and no standing
- *    posture may retire it, only an answer to THIS call」;**7.30.0 起 d.ts 已落 [ref] 澄清**(S-616 在 7.30.1 装树亲核):
+ *    posture may retire it, only an answer to THIS call」;**7.30.0 起 d.ts 已落 [ref] 澄清**([ref] 在 7.30.1 装树亲核):
  *    core `PermissionResult` ask 臂的 `mandated` 成员文档「no persisted allow rule and no STANDING ANSWER (a release remembered
  *    from an earlier call, at any scope, a session included) may retire it」,`AskRequest.mandated` 孪生句同义 ——
  *    「从早先某次回答记住的放行,**任何 scope、会话级也算**」都是站着的答案。core `ruleClearanceOf` 的文档
@@ -315,7 +290,7 @@ export type StandingAnswerHome = "none" | "seat" | "server_store";
  * **自己**的位 —— core 每一次过闸(含 failover / 重启后的重入)都由 `runGateLanes` 里的 `stampAskOrigin`
  * 重新盖、经同一处的 `carryOf` 带上 `AskRequest`,读侧手里的 `req` 恒是这一次过闸的真值。`governanceForced`
  * 需要行读,是因为它来自本仓的**进程内**治理标表:failover / 重启后幂等命中既有行时本地表恒空,行上的卡才
- * 存着落库那一刻的判定。(那张「行」是本仓的 ask 账本行,不是 core 的 park 行;core 7.31.0 #1079 起 park 行上的
+ * 存着落库那一刻的判定。(那张「行」是本仓的 ask 账本行,不是 core 的 park 行;core 7.31.0 [ref] 起 park 行上的
  * `mandated` 孪生座由**耐久** `/decide` 腿读,见 {@link parkRowStandingAnswerFacts}。)
  */
 export declare function standingAnswerHome(facts: StandingAnswerFacts): StandingAnswerHome;
@@ -328,7 +303,7 @@ export declare function standingAnswerHome(facts: StandingAnswerFacts): Standing
  */
 export declare function standingAnswerDurablyRecordable(facts: StandingAnswerFacts): boolean;
 /**
- * 🔴 **S-663 → NP-1(7.100.0 合并复审 [ref] 交叉表 #2)—— 耐久 `/decide` 腿的 {@link StandingAnswerFacts}:从 park 行铸三位。**
+ * 🔴 **[ref] → NP-1(7.100.0 合并复审 [ref] 交叉表 #2)—— 耐久 `/decide` 腿的 {@link StandingAnswerFacts}:从 park 行铸三位。**
  * 纯投影,**不判**:判据是同一只 {@link standingAnswerHome}(唯一读点 = `http/resume-legs.ts` 的 remember 可记性,
  * `standingAnswerDurablyRecordable(parkRowStandingAnswerFacts(…))`)。修前耐久腿自成一只谓词、只读 `ruleOffersAbsence` 一词,同一行上
  * core 盖好的 `requiresRealApproval` 与治理出身都不读 ⇒ 那两类卡的 `remember:"session"` 照旧铸会话免询问,而 live 腿对同一张卡
@@ -340,18 +315,18 @@ export declare function standingAnswerDurablyRecordable(facts: StandingAnswerFac
  *    park 行上唯一的取证格只有 `riskDescriptor.shellGateDoctrine`(见下方 🚧);
  *  · `requiresRealApproval` —— 行上 core 铸的那一位,经 `approval-card.ts` 的 {@link readParkRowTrueSeat}(与运维
  *    队列 `parkRowFacts` 同一只读法,`=== true`)。刻意**不**经 `parkRowFacts` 本身:那只展示投影顺手对 `ruleOffersAbsence`
- *    的集外词计展示面 F 类 tag,而本读者对同一格是 fail-closed(S-663 codex r1 钉「权限面不计展示面 tag」);
- *  · `mandated` —— **S-663 二段(core #1079,7.31.0 / S-723)**:行上 core 铸的孪生座 `PendingAction.tool_approval.mandated`,经
+ *    的集外词计展示面 F 类 tag,而本读者对同一格是 fail-closed([ref] codex r1 钉「权限面不计展示面 tag」);
+ *  · `mandated` —— **[ref] 二段(core [ref],7.31.0 / [ref])**:行上 core 铸的孪生座 `PendingAction.tool_approval.mandated`,经
  *    **同一只** {@link readParkRowTrueSeat}(`=== true`);**或**强制子集 `ruleOffersAbsence` 经三态窄读
  *    {@link readRuleOffersAbsenceSeat} 读成 `"mandated"` / 读不出(集外词 / 非串值,世代差)⇒ `true`。两臂是**两个事实**的析取,
  *    不是同一个事实的新旧两种读法:core 对 `"mandated"` 这一词的定义就是「no persisted rule could ever clear this ask」(强制的
- *    充分条件),而 #1079 之前铸的行(7.30.x 引擎 park、升级后才被 `/decide`)没有孪生座 —— 只读孪生座会让这类在飞行照旧落豁免,
+ *    充分条件),而 [ref] 之前铸的行(7.30.x 引擎 park、升级后才被 `/decide`)没有孪生座 —— 只读孪生座会让这类在飞行照旧落豁免,
  *    是对上一版的回归;读不出按强制是 fail-closed(一个本仓不认识的新词可能正是一种强制因由)。
  *
  * 🚧 **剩余不对称一处**(耐久腿读得到的事实比 live 腿少,读不到的一律照旧可记):
- *  ① (已关,S-663 二段)`mandated` 孪生位 —— core #1079 到货,行上词为 `shadowed` / 缺席的强制卡由孪生座读到
+ *  ① (已关,[ref] 二段)`mandated` 孪生位 —— core [ref] 到货,行上词为 `shadowed` / 缺席的强制卡由孪生座读到
  *    (`test/approval-exemption-http.test.ts` 原 🚧 格已按钉翻成「false + 零行」);
- *  ② **非 shell 治理(候 S-707)**:治理位经 `governanceOriginOf` 只覆盖 shell 门 `always` 档;敏感写路径
+ *  ② **非 shell 治理(候 [ref])**:治理位经 `governanceOriginOf` 只覆盖 shell 门 `always` 档;敏感写路径
  *    (`SENSITIVE_WRITE_PATTERNS`)、`commandPolicy`、`AUTONOMY` 内层策略产的门与 shellGate `classify` 档,park 行上没有取证格
  *    (live 腿靠进程内标记表,跨副本 / 重启后够不着),本折法读不到它们的治理出身。
  */
@@ -428,8 +403,8 @@ export interface ToolApprovalFrame {
      * 车道**有什么可给,而那条车道对它不说话的工具、**没接规则店的部署**(本仓的 live-only 形)、装不下规则的
      * 任务都是结构性沉默 —— 它的缺席**不是**断言。本键是这一问**自己**的属性,凡强制皆在场。读错的代价 core
      * 实测过:同一条根外读命令在 shell 工具上是强制问、在 monitor 工具上看起来是普通问。
-     * (耐久 `/decide` 腿手里只有 park 行:core 7.31.0 #1079 起行上有本键的孪生座 `PendingAction.tool_approval.mandated`,
-     * S-663 二段读它;#1079 之前铸的行没有孪生座,那条腿仍读那一词的**在场**(`"mandated"` ⇒ 强制)、从不读它的缺席 —— 见
+     * (耐久 `/decide` 腿手里只有 park 行:core 7.31.0 [ref] 起行上有本键的孪生座 `PendingAction.tool_approval.mandated`,
+     * [ref] 二段读它;[ref] 之前铸的行没有孪生座,那条腿仍读那一词的**在场**(`"mandated"` ⇒ 强制)、从不读它的缺席 —— 见
      * {@link parkRowStandingAnswerFacts}。live 腿恒读本键。)
      *
      * 🔴 **它不是 `requiresRealApproval`**:强制只说「没有规则能清掉」,**不**说「没有应答者可以答」——
@@ -437,12 +412,12 @@ export interface ToolApprovalFrame {
      *
      * 🔴 **真才带,缺席绝不编 `false`**(`governanceForced` / `requiresRealApproval` 同形)。缺席覆盖「不是强制」「老引擎」
      * 两形。**本仓从不自铸本键**:活卡帧(与 `livePending` 行顶层,T4①)只读 `AskRequest.mandated`;耐久面(运维队列行 / inbox 行)
-     * 自 core 7.31.0 #1079 起读 core 在 park 行上铸的孪生座(`PendingAction.tool_approval.mandated` / `CheckpointSummary.mandated`,
-     * S-663 二段),同样只投 core 给的那一位 —— 自铸一个就是本仓成了这个事实的第二个源。⚠️ **`card_json` 卡面不带本键**
+     * 自 core 7.31.0 [ref] 起读 core 在 park 行上铸的孪生座(`PendingAction.tool_approval.mandated` / `CheckpointSummary.mandated`,
+     * [ref] 二段),同样只投 core 给的那一位 —— 自铸一个就是本仓成了这个事实的第二个源。⚠️ **`card_json` 卡面不带本键**
      * (`ApprovalCardSchema` 没有这一位,`.strict()`)⇒ 断连重放的 `approval_request` 帧(`buildReplayFrame` 只回放卡)上它恒缺席,
      * 消费方读队列行 / 活卡帧 / `livePending` 行(8D-6:此前这里写的「`card_json` 只读 `AskRequest.mandated`」是错句,T4② 车OC 改真)。
      * 🔴 **server 不判「是不是强制」**(判定属主在 core 的闸站),只**读**闸站盖好的这一位 —— 读者恰一个:
-     * S-660 起的会话级放行判据 {@link standingAnswerHome}(会话授权是**上一次**应答记下的站着的答案,
+     * [ref] 起的会话级放行判据 {@link standingAnswerHome}(会话授权是**上一次**应答记下的站着的答案,
      * 不是对这一次调用的应答 ⇒ 强制卡上既不被既有 grant 代答、也不铸 grant)。上一段「一揽子 `onAsk:"allow"`
      * 席照常答得了」说的是**这一次调用的应答者**,本仓不改它。
      */
@@ -457,7 +432,7 @@ export interface ToolApprovalFrame {
      */
     rememberRefused?: true;
     /**
-     * **S-721(core 7.32.0 #1092;ADDITIVE,`"tool_approval"` only)** —— 强制位**站在哪一个词上**:core `PERSISTED_RULE_MANDATES`
+     * **[ref](core 7.32.0 [ref];ADDITIVE,`"tool_approval"` only)** —— 强制位**站在哪一个词上**:core `PERSISTED_RULE_MANDATES`
      * 六词之一(`operator_always` / `tool_marks` / `probe_mandate` / `probe_unanswered` / `write_protection` /
      * `target_unresolved`,词义属主在 core)。只在 `mandated: true` 的**整因**是那一个词时在场;另一扇门(治理 / hook /
      * 祖先)或不止一个理由 ⇒ 缺席 —— **缺席从不命名一个词**,也不等于「不强制」(读 `mandated`)。值经 `approval-card.ts` 的
@@ -467,7 +442,7 @@ export interface ToolApprovalFrame {
      */
     mandate?: PersistedRuleMandate;
     /**
-     * **S-125③/[ref]**(core 7.5.0;**ADDITIVE**,`"tool_approval"` only)—— 这只 ask 的**出身**:
+     * **[ref]③/[ref]**(core 7.5.0;**ADDITIVE**,`"tool_approval"` only)—— 这只 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:
@@ -485,7 +460,7 @@ export interface ToolApprovalFrame {
      * 🔴 **不枚举词表**(`string` 而不是本仓自铸的联合):词表单一属主在 core,在这里抄一份会把 core 加的
      * 新词吞成缺席 —— 与 `wiring_manifest.autoMode.reason` 的透传纪律逐字同规。缺席 = 老引擎 / 非 ask 路径。
      *
-     * 同一个词的其余四面(S-755 起全部在场):`livePending` 行顶层 / `live_pending` 帧(条目铸定时与本键**同一次**读定);运维队列行
+     * 同一个词的其余四面([ref] 起全部在场):`livePending` 行顶层 / `live_pending` 帧(条目铸定时与本键**同一次**读定);运维队列行
      * (`GET /v1/approvals` 的 `pending[]` + `/stream` 的 `pending` 帧,读 park 行孪生座 `PendingAction.tool_approval.origin`,经
      * `approval-card.ts` 的 `readClosedWordSeat(…, "origin")` —— 那一面读的是持久层原字节、中间没有 core 投影,所以亲手调 core 的
      * `isAskOrigin`);inbox 行(core `CheckpointSummary.origin`,core 投影处已筛)。本键读的是引擎在门上刚盖好的值(盖章点即 core
@@ -497,38 +472,38 @@ export interface ToolApprovalFrame {
      */
     origin?: string;
     /**
-     * **S-934 ②(core 7.37.0 #1214;ADDITIVE,`"tool_approval"` only)** —— 这一问的**类**:`classes` 的首员(core `ASK_CLASSES` 序),
+     * **[ref] ②(core 7.37.0 [ref];ADDITIVE,`"tool_approval"` only)** —— 这一问的**类**:`classes` 的首员(core `ASK_CLASSES` 序),
      * `MODE_ARBITRATION` 的行键(权限模式读的就是它 / 它们)。引擎在每一个铸 `origin` 的站盖章(策略自报的值在盖章处被替换),本仓经
-     * `approval-card.ts` 的 `readAskClassPair(req)` 窄读(判法 = core 屏 `screenAskClassMembers`,S-955 ⑥ / #1249,本仓零自写对判;屏拒 ⇒ 两键都不投 + 计一次
-     * S-249 集外 tag)。**与 {@link classes} 同在同缺**;缺席 = 老引擎 / 不盖类的站(共享制品读确认,core KL-1214-a),不是「无类」。
-     * display:壳按类渲卡(cli 卡面、client-core CC-272),durable 审批席按类答;**本仓不按它裁决**(无人值守腿的按类作答读 core 交来的
+     * `approval-card.ts` 的 `readAskClassPair(req)` 窄读(判法 = core 屏 `screenAskClassMembers`,[ref] ⑥ / [ref],本仓零自写对判;屏拒 ⇒ 两键都不投 + 计一次
+     * [ref] 集外 tag)。**与 {@link classes} 同在同缺**;缺席 = 老引擎 / 不盖类的站(共享制品读确认,core KL-1214-a),不是「无类」。
+     * display:壳按类渲卡(cli 卡面、client-core [ref]),durable 审批席按类答;**本仓不按它裁决**(无人值守腿的按类作答读 core 交来的
      * `AskRequest.classes` 本身)。同一对的其余面:`card_json` 卡面 / `approval_request` 呈卡帧 / 断连重放帧(同一份素材)、运维队列行
      * (`parkRowFacts`,读停车行孪生座 `PendingAction.tool_approval.askClass`);inbox 行不带(core `CheckpointSummary` 不回显)。
      */
     askClass?: AskClass;
-    /** S-934 ②:这一问属于的**全部**类(core `ASK_CLASSES` 序,`classes[0] === askClass`,非空)—— 读整只集合,别只读 {@link askClass}(一问可同属
+    /** [ref] ②:这一问属于的**全部**类(core `ASK_CLASSES` 序,`classes[0] === askClass`,非空)—— 读整只集合,别只读 {@link askClass}(一问可同属
      *  几类)。与 `askClass` 同在同缺、同一只窄读;逐字同序过境,不排序不去重。 */
     classes?: AskClass[];
     /**
-     * core 7.43.0 #1348 / #1357(**ADDITIVE**,`"tool_approval"` only)—— 对引擎 `Skill` 工具的调用,批准它**还授予**的东西的摘要
+     * core 7.43.0 [ref] / [ref](**ADDITIVE**,`"tool_approval"` only)—— 对引擎 `Skill` 工具的调用,批准它**还授予**的东西的摘要
      * (`AskRequest.boundGrantDigest`,技能名 + 两只清单规范拼写的哈希);别的卡缺席。与停驻行 / inbox 行的同名位同值(core:同一只工厂铸,
-     * 活卡与它的停驻孪生按 `(toolCallId, boundGrantDigest)` 对账)。逐字过境,本仓不重算;站着的答案按「工具 + 它」记(S-1115)。
+     * 活卡与它的停驻孪生按 `(toolCallId, boundGrantDigest)` 对账)。逐字过境,本仓不重算;站着的答案按「工具 + 它」记([ref])。
      */
     boundGrantDigest?: string;
     /** 上一位哈希的那一份值:`{ skill, allowedTools, disallowedTools }`(`skill: null` = 调用没点名任何已载技能)。与摘要同在同缺;**部署文本**,
      *  壳按上下文转义渲染(core:display metadata)。逐字过境。 */
     boundGrants?: BoundSkillGrants;
-    /** S-1493(core 7.51.0 #1688,**ADDITIVE**,`"tool_approval"` only):这张卡为什么没有 {@link boundGrantDigest} —— 引擎铸的每张卡恰带两者之一:
+    /** [ref](core 7.51.0 [ref],**ADDITIVE**,`"tool_approval"` only):这张卡为什么没有 {@link boundGrantDigest} —— 引擎铸的每张卡恰带两者之一:
      *  `not_bindable`(这一问不是引擎 `Skill` 工具的激活,不绑任何授予 ⇒ 应答可按工具记)/ `unreadable`(绑着却读不出;活卡上引擎恒给摘要,这一词
      *  只出现在读存量行的面上)。闭集经 `readClosedWordSeat(req, "boundGrantAbsence")` 窄读(筛 = core `BOUND_GRANT_ABSENCES`),集外 ⇒ 缺席 + 计一次。
      *  与停驻行 / 运维队列行 / inbox 行的同名位同值;站着的答案的授予绑定(引擎铸的问那一家;部署名单自己的问读调用口)读它(`standing-answer-grant.ts` `grantBindingOf`)。display。 */
     boundGrantAbsence?: BoundGrantAbsence;
-    /** core 7.43.0 #1353:分类器没给判词的成因词(`error` / `timeout` / `parse_error`;只在类 `classifier_no_ruling` 的卡上)。闭集经 core 的
+    /** core 7.43.0 [ref]:分类器没给判词的成因词(`error` / `timeout` / `parse_error`;只在类 `classifier_no_ruling` 的卡上)。闭集经 core 的
      *  `readClosedWordSeat(req, "classifierNoRuling")` 窄读(筛 = core `isAutoModeFallbackCause`),集外 ⇒ 缺席 + 计一次。display:本仓不按它裁决。 */
     classifierNoRuling?: AutoModeFallbackCause;
     /**
-     * **core 7.49.0 #1414(ADDITIVE,`"tool_approval"` only)—— 这一问渲在哪张卡上**:引擎在闸站铸的那一个词(闭集 core `TOOL_APPROVAL_CARDS`:
-     * `file-edit` / `file-write` / `notebook-edit` / `shell` / `fetch` / `plan` / `question` / `generic`),`AskRequest.approvalCard` 逐字过境,经
+     * **core 7.49.0 [ref](ADDITIVE,`"tool_approval"` only)—— 这一问渲在哪张卡上**:引擎在闸站铸的那一个词(闭集 = core 的 `TOOL_APPROVAL_CARDS`,
+     * 本文不抄词表 —— 词表的唯一写者在引擎),`AskRequest.approvalCard` 逐字过境,经
      * `approval-content-kind.ts` 的 `readApprovalCard` 闭集窄读(集外 ⇒ 缺席 + 计一次 closed-word-out-of-set)。`question` = 问用户的问题(引擎保留的
      * 问答工具),不是副作用工具。**本仓不从工具名回推卡**(工具名只作展示):此前按名字铸的 `livePending` 行 / 队列行 `contentKind` 随本键删。
      * 停驻孪生 = 门的 `gate.approvalCard`(运维队列行顶层同名键,两只店读同一只 `parkedApprovalCard`)。display:本仓不按它裁决。
@@ -588,13 +563,13 @@ export interface ToolApprovalFrame {
      *  `approval_request` 帧([ref] 呈卡帧)同名同义:`expiresAtMs` = 本 ask 的绝对到期墙钟
      *  (有店=行上一次铸定的 `expiresAtMs`,与卡帧/落库同值;无店 D1=注册时刻算定的同名初值),
      *  `serverNowMs` = **帧铸造时刻**(cli [ref] 锚定语义:倒计时锚=帧到手时刻的服务器钟),
-     *  `expiresInMs` = `max(0, expiresAtMs - serverNowMs)` 现算。三键同生同缺(windowZero 腿不发帧,
+     *  `expiresInMs` = `max(0, expiresAtMs - serverNowMs)` 现算。三键同生同缺(没有活审批通道的腿不发帧,
      *  发出的帧恒带);旧消费端无感,新壳借此给旧族帧补倒计时([ref] Q2 那类 77 分钟死卡的根治半场)。 */
     expiresAtMs?: number;
     expiresInMs?: number;
     serverNowMs?: number;
     /**
-     * core 7.42.0 #1327(**硬破坏换名**:取代 7.41.x 的 `persistedRuleShadowed`,零别名;`"tool_approval"` only)——
+     * core 7.42.0 [ref](**硬破坏换名**:取代 7.41.x 的 `persistedRuleShadowed`,零别名;`"tool_approval"` only)——
      * 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` = 没列出的条目数。
@@ -638,7 +613,7 @@ export interface ToolApprovalFrame {
      */
     ruleOffersAbsence?: RuleOffersAbsence;
     /**
-     * S-114(core 7.4.0 [ref];**ADDITIVE**,`"tool_approval"` only)—— 这只 ask 是 auto 模式分类器的**限额
+     * [ref](core 7.4.0 [ref];**ADDITIVE**,`"tool_approval"` only)—— 这只 ask 是 auto 模式分类器的**限额
      * 回落卡**:分类器连续(缺省 3)或累计(缺省 20)拒到限额的**那一次**调用不再静默 deny,而是落成一张
      * 必须真人批的卡(同一次铸造同时盖 `requiresRealApproval`,两键是孪生)。
      * `{consecutive, total, limit:"consecutive"|"total", autoDenyAfterMs}` —— 触限时的两个计数、哪一道界
@@ -678,7 +653,7 @@ export interface ToolApprovalFrame {
      * 耐久路的对偶 = `gate.riskDescriptor.probeCause`(同值,core `buildRiskDescriptor` 铸),走 checkpoint
      * 行的**整体透传**到 `GET /v1/approvals` —— 键集零施工,钉在同一个文件的 §4。
      *
-     * 姊妹键 `probeReason`(同一件事的**散文**兄弟)见下一键 —— 7.115.0 起投影(S-733),与本键**并列不替代**。
+     * 姊妹键 `probeReason`(同一件事的**散文**兄弟)见下一键 —— 7.115.0 起投影([ref]),与本键**并列不替代**。
      */
     probeCause?: {
         code: string;
@@ -692,7 +667,7 @@ export interface ToolApprovalFrame {
         };
     };
     /**
-     * S-733(7.115.0;**ADDITIVE**,`"tool_approval"` only)—— 这次 ask 被收紧时探针给出的那一句**散文**因由
+     * [ref](7.115.0;**ADDITIVE**,`"tool_approval"` only)—— 这次 ask 被收紧时探针给出的那一句**散文**因由
      * (`AskRequest.probeReason`:core 在 maybe 档收紧点 `inlineUntrusted(…, 200)` 过的一句话)。与
      * {@link probeCause}(结构化因由)**并列、不替代**:引擎自己铸的因由走结构位,**部署自写的探针**只会写这一句
      * —— 一只只给 reason 不给 cause 的探针,此前其审批人在活卡上读不到任何因由(耐久面
@@ -779,15 +754,15 @@ export interface LivePendingRow {
     governanceForced?: true;
     /** T4①(八病审计 8D-5,车OC / 7.101.0):强制位([ref],`AskRequest.mandated`)—— 与上两位**同层同形**(真才带,缺席不编 false),
      *  值 = 条目上那一位(`askBroadcast` 铸条目时取自这一次过闸的 `req.mandated`,与 {@link frame} 上的同名键同源)。此前只在
-     *  `frame` 里:同一个 `GET /v1/approvals` 响应的 durable `pending[]` 行顶层带它(S-663 二段),live 行却要进帧里读。 */
+     *  `frame` 里:同一个 `GET /v1/approvals` 响应的 durable `pending[]` 行顶层带它([ref] 二段),live 行却要进帧里读。 */
     mandated?: true;
     /** 7.116.0(审计修复批 S4):这张卡上的「本会话放行」不会被记住 —— 与 {@link ToolApprovalFrame.rememberRefused} 同名同义同源
      *  (同一只判据,读条目上的四位事实);真才带。 */
     rememberRefused?: true;
-    /** S-721(core 7.32.0 #1092):强制位站在哪一个词上 —— 与 `mandated` 同层同形(在场逐字,缺席不编词),值 = 条目上那一个词
+    /** [ref](core 7.32.0 [ref]):强制位站在哪一个词上 —— 与 `mandated` 同层同形(在场逐字,缺席不编词),值 = 条目上那一个词
      *  (与 {@link frame} 上同名键同源;帧型该键顶注是全文)。 */
     mandate?: PersistedRuleMandate;
-    /** S-755(cli L-695 / [ref]):ask 的**出身词**(谁提的这一问,core `ASK_ORIGINS` 闭集一词)—— 与 `mandate` 同层同形(在场逐字,
+    /** [ref](cli [ref] / [ref]):ask 的**出身词**(谁提的这一问,core `ASK_ORIGINS` 闭集一词)—— 与 `mandate` 同层同形(在场逐字,
      *  缺席不编词),值 = 条目上那一个词(铸条目那一次与 {@link frame} 上同名键**同一次**读定;帧型该键顶注是全文)。同一个
      *  `GET /v1/approvals` 响应里 durable `pending[]` 行的 `origin` 也在顶层(park 行孪生座),两族行同一种读法。 */
     origin?: string;
@@ -801,12 +776,12 @@ export interface LivePendingRow {
      *  子代 ask)上恒等成立。缺席 = 顶层 ask。`fromSubagent` 保留不动(byte-compat:先于本键的消费方仍按
      *  它判别)。 */
     originTaskId?: string;
-    /** core 7.49.0 #1414:这一问的卡词 —— 与 {@link frame} 上的 `approvalCard` **同一个值**(行读帧上那一格,不另读一遍),与 durable
+    /** core 7.49.0 [ref]:这一问的卡词 —— 与 {@link frame} 上的 `approvalCard` **同一个值**(行读帧上那一格,不另读一遍),与 durable
      *  队列行顶层的同名键同层同形(那一面读门的 `gate.approvalCard`)。缺席 = 引擎没给(宿主自建 ask / 老引擎)。展示/分诊用,永不参与决议路由。
-     *  (此前此处是按工具名铸的 `contentKind`,随 #1414 删:卡只有引擎铸的这一个词。) */
+     *  (此前此处是按工具名铸的 `contentKind`,随 [ref] 删:卡只有引擎铸的这一个词。) */
     approvalCard?: ToolApprovalCard;
     /**
-     * 🔴 S-454(P1;cli L-397 / 板 [ref]):这只 ask **本来会 emit 的那只活卡帧**。
+     * 🔴 [ref](P1;cli [ref] / 板 [ref]):这只 ask **本来会 emit 的那只活卡帧**。
      *
      * 值 = {@link PendingApproval.frame} 的**引用** —— `askBroadcast` 里那一处唯一构造(已过
      * `redactDeep` / 字节帽 / [ref] 窗三键补写)的**同一个对象**,悬挂与可达两条路共用它。⇒ 这一格
@@ -825,7 +800,7 @@ export interface LivePendingRow {
      */
     frame?: ToolApprovalFrame | ApprovalRequestFrame;
     /**
-     * S-247:**本副本上没有引擎腿在等这只问** —— 与耐久决断口 200 体同名同值同义的那一位({@link ASK_DECISION_CONSUMER_ABSENT})。
+     * [ref]:**本副本上没有引擎腿在等这只问** —— 与耐久决断口 200 体同名同值同义的那一位({@link ASK_DECISION_CONSUMER_ABSENT})。
      * 在场 ⇔ 这一行是审批机起服时从问账接管的问(前一个进程 / 别的副本铸下、行仍 `STREAM_PENDING`;见 {@link ToolApprovalCoordinator.adoptOpenAsks}):
      * 它照常列得出、照常应答得了(行落 `DECIDED`,应答回执同带这一位),但这一决不会让本副本上任何在跑的东西续跑 —— 续没续跑读 run 面。
      * 只记真:缺席 = 本副本有引擎腿在等它(或老 server)。
@@ -966,19 +941,19 @@ export declare const PERSIST_RULE_BATCH_EXCLUSIVE_ERROR = "persistRule.batchOffe
  * 指定 scope = 让一次「在项目 A 里点的同意」写成一条覆盖项目 B(或全局)的常驻放行 —— 那是这条轴上
  * 最贵的一次扩权。静默忽略同样不行:客户端会以为自己设上了。响亮拒,一句话说清谁拥有这一格。
  */
-/** S-720(core 7.32.0 #1093)—— `readRootGrant` 只随 `decision:"allow"`(CC 卡的第三选项「Yes, and add directory」= 放行这一次
+/** [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)";
 /**
- * S-765:这台部署不受理读根授权时,带 `readRootGrant` 的应答的拒句。受理与否是**部署姿态**(能力事实 `readRootGrant`,位 `approvalReadRootGrant`;
+ * [ref]:这台部署不受理读根授权时,带 `readRootGrant` 的应答的拒句。受理与否是**部署姿态**(能力事实 `readRootGrant`,位 `approvalReadRootGrant`;
  * 判据的唯一属主在 `capability-facts.ts`,回决路由把它读来交给 {@link ToolApprovalCoordinator.respond}):不受理 ⇒ 裁决**之前**响亮 400,
- * 这只 ask 没被结算,同一张卡不带该键的 `allow` 照常成。不静默丢键 —— 壳以为加上了目录而引擎只看到一次普通放行,是 S-720 修过的那一种病。
+ * 这只 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";
-/** S-720:`readRootGrant` 的形 —— 卡上 `readRootCandidate.dir` 的原串(非空,≤ core `READ_ROOT_CANDIDATE_DIR_MAX`;超限整只拒,不截:截过的目录是另一个目录)。 */
+/** [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`)";
-/** S-765:`respond()` 要的**部署事实**(由回决路由从能力事实交进;协调器不读 config,也不自判姿态)。 */
+/** [ref]:`respond()` 要的**部署事实**(由回决路由从能力事实交进;协调器不读 config,也不自判姿态)。 */
 export interface ToolApprovalRespondDeployment {
     /** 这台部署受理不受理应答体里的 `readRootGrant` —— 能力事实 `readRootGrant` 的 `.available`(位 `approvalReadRootGrant` 的同一个值)。 */
     readonly readRootGrantAccepted: boolean;
@@ -1019,8 +994,8 @@ export declare function parseToolApprovalResponse(body: unknown): ParsedToolAppr
  */
 export type UnattendedApprovalPolicy = "park" | "deny";
 /**
- * S-689 —— `deny` 政策下「无人可答」交给 core 的形:core `AskOutcome` 对象臂的**部署政策拒**
- * (`settledBy:"policy"` ⇒ core 结算 `policy_refused`、`who.party:"policy"`(core 7.39.0 #1265 起;此前 `"none"`),模型读的是策略句)。
+ * [ref] —— `deny` 政策下「无人可答」交给 core 的形:core `AskOutcome` 对象臂的**部署政策拒**
+ * (`settledBy:"policy"` ⇒ core 结算 `policy_refused`、`who.party:"policy"`(core 7.39.0 [ref] 起;此前 `"none"`),模型读的是策略句)。
  *
  * 修前这里交**裸 `false`** —— 而在 core 的 onAsk 契约里裸 `false` 就是「一个人拒了」:结算记
  * `human_refused` / `who.party:"person"`,模型被告知「用户不想继续,停下来等他」,run 以
@@ -1040,15 +1015,15 @@ export type UnattendedPolicyRefusal = Extract<AskOutcome, {
 /**
  * {@link UnattendedPolicyRefusal} 的**唯一**构造(纯数据 ⇒ `build*`)。来源词读店落行的**同一个**常量(`POLICY_REFUSAL_DECISION`,NP-2):
  * 行上记的与交给 core 的在构造上是一个词。两个铸点读它:协调器 deny 政策的「无人可答」({@link ToolApprovalCoordinator.unattendedOutcome})
- * 与 run-local 本地席没有人可问的两臂(S-956:无 TTY / 参数展示不出 —— `src/run-local.ts` `createLocalApprover`)。`reason` = 铸点的
+ * 与 run-local 本地席没有人可问的两臂([ref]:无 TTY / 参数展示不出 —— `src/run-local.ts` `createLocalApprover`)。`reason` = 铸点的
  * 闭集拒因句(core 以 `policy note` 围栏交给模型),不带调用方的字节。
  */
 export declare function buildUnattendedPolicyRefusal(reason: string): UnattendedPolicyRefusal;
 /** 「无人可答」终局的**闭集** —— core `AskOutcome` 联合里只有这两臂由 {@link ToolApprovalCoordinator.unattendedOutcome}
- *  铸:park 政策的路由答 `"unavailable"`,deny 政策的 {@link UnattendedPolicyRefusal}。没有布尔臂(S-689:裸 `false`
+ *  铸:park 政策的路由答 `"unavailable"`,deny 政策的 {@link UnattendedPolicyRefusal}。没有布尔臂([ref]:裸 `false`
  *  是人的拒绝,这个口从不替人说话)。 */
 export type UnattendedAskOutcome = Extract<AskOutcome, "unavailable"> | UnattendedPolicyRefusal;
-/** S-877 候裁 16:耐久会话授权店(`src/plugins/approval-exemption-store.ts` 的同一只店):审批席读它(引擎的问),活卡上部署名单那一问的
+/** [ref] 候裁 16:耐久会话授权店(`src/plugins/approval-exemption-store.ts` 的同一只店):审批席读它(引擎的问),活卡上部署名单那一问的
  *  「本会话放行」写它(名单门在出问之前读同一行)。 */
 export type SessionGrantStore = Pick<ApprovalExemptionStore, "has" | "grant">;
 /**
@@ -1071,23 +1046,24 @@ export type SessionGrantStore = Pick<ApprovalExemptionStore, "has" | "grant">;
  *     `tool_approval` 活卡腿逐字保留,而不是「把 ask 推向一个不存在的目的地」(§14 属主照准,core [ref]
  *     回帖确认即原意)。
  *
- * 🔴 **S-384:第 5 项(旧第 4 项 `volatile_ask_ledger` = 「账必须是持久的」,判据 `kind !== "local"`)
+ * 🔴 **[ref]:第 5 项(旧第 4 项 `volatile_ask_ledger` = 「账必须是持久的」,判据 `kind !== "local"`)
  * 已整条删除,词也从闭集里删了(零别名)**。它当年成立的唯一输入是 local 车道交的 `InMemoryApprovalAskStore`;
  * `FileApprovalAskStore` 落地后 `StoreBackend.approvalAsk()` 的三条腿全是持久店 ⇒ 这条合取项**没有任何
  * 能让它为假的输入**,留着就是一条永不触发的规则(「修完让规则集更小」)。持久性的义务搬到
  * `StoreBackend.approvalAsk()` 的接口契约上(那条注 + `wiring-governance-operator.test.ts` 的三腿机器钉)——
  * 它是**装配面**的事实,而本谓词能看见的只有 `kind`,拿 `kind` 当持久性的代理正是这次要拆掉的那层间接。
  */
-export type StreamApprovalGate = {
+export type StreamApprovalGate<TStore extends GateCurrencyStore = GateCurrencyStore> = {
     active: true;
     askStore: ApprovalAskStore;
+    checkpointStore: TStore;
 } | {
     active: false;
     reason: "no_tool_approval" | "protocol_disabled" | "no_backend" | "no_park_facility";
 };
 /** {@link resolveStreamApprovalGate} 的入参。`backend` 用**结构形**(不 import `StoreBackend`):本模块是
  *  协调器的家,不该为一个布尔判据把整棵 store 依赖树拖进类型面。 */
-export interface StreamApprovalGateInput {
+export interface StreamApprovalGateInput<TStore extends GateCurrencyStore = GateCurrencyStore> {
     toolApprovalEnabled: boolean;
     /** 协议总开关。⚠️ 调用点一律写 `config.streamApproval?.enabled === true` —— **可选链的缺席臂折算
      *  false**(段整段缺席 ⇒ 协议不上场)。
@@ -1101,14 +1077,16 @@ export interface StreamApprovalGateInput {
         readonly kind: "mysql" | "pg" | "local";
         approvalAsk(): ApprovalAskStore;
     } | undefined;
-    /** park 设施在场性。本仓真码里 `checkpointStore` 的构造条件本身就是
-     *  `backend?.checkpoint !== undefined && config.durableApproval`(main.ts),所以设计 §8.4 那条析取式的
+    /** park 设施 = checkpoint 店本身:在场(非 `undefined`)即设施在场,上场时它随 `active` 臂交出去(与 `askStore` 同形)—— 在场性与实例是一个事实,调用点不必另持一份布尔再断言实例非空。
+     *  类型只收店的形({@link GateCurrencyStore}:协调器读它的那两个口),`backend.checkpoint` 这种工厂方法过不了 tsc —— 全进程的店只有 stage-06 铸的那一只,装配点喂的是它,不是再造一只。
+     *  本仓真码里 `checkpointStore` 的构造条件本身就是
+     *  `backend?.checkpoint !== undefined && config.durableApproval`,所以设计 §8.4 那条析取式的
      *  「safety 词表非空」一支在**装配时刻**结构上不可达(core 的 irreversible/egress 集合来自 **per-task**
      *  的 `spec.tools[].irreversibility/egress`,composition root 看不到)——两条缺失形因此在本仓收敛成
      *  同一个 `no_park_facility`(D-5/D-6 两钉打的是两种**输入**形,不是两个 reason)。 */
-    parkFacility: boolean;
+    checkpointStore: TStore | undefined;
 }
-export declare function resolveStreamApprovalGate(input: StreamApprovalGateInput): StreamApprovalGate;
+export declare function resolveStreamApprovalGate<TStore extends GateCurrencyStore>(input: StreamApprovalGateInput<TStore>): StreamApprovalGate<TStore>;
 /**
  * 审批开卡帧的**帧族词表**(闭集)—— wire 上一只 ask 的开卡帧可能属于的族:
  *  · `tool_approval`:旧族(活卡帧 `tool_approval` / 消卡帧 `tool_approval_complete`);
@@ -1122,6 +1100,64 @@ export declare function resolveStreamApprovalGate(input: StreamApprovalGateInput
  */
 export declare const APPROVAL_FRAME_FAMILIES: readonly ["tool_approval", "approval_request"];
 export type ApprovalFrameFamily = (typeof APPROVAL_FRAME_FAMILIES)[number];
+/**
+ * 这台 worker **呈卡用的那一个族**(活卡协调器在场时)—— 全仓唯一的映射,三个读者:能力位 `approvalFrameFamilies`(`capability-facts.ts`,
+ * 壳读它决定声明什么)、{@link resolveApprovalLeg}(腿判「这条 run 声明了没有」)与耐久事件流开流 preamble(`routes/runs.ts`:这条 run 名下的卡
+ * 铸于声明了这一族的腿,卡作证的声明就是它)。各写一份三元式 = 壳照一份声明、服务端照另一份判,那正是 [ref] 要封的「两边各说各话」。
+ * 入参 = {@link resolveStreamApprovalGate} 的 `active`。
+ */
+export declare function presentedApprovalFrameFamily(streamApprovalOn: boolean): ApprovalFrameFamily;
+/** 坏声明的拒体(fresh 受理面 400 `request.field_invalid`):一句话 + 机读位,形与 [ref] 座位族 / [ref] 三桶的 `bad_entry` 同。 */
+export interface ApprovalFrameFamiliesIssue {
+    readonly message: string;
+    readonly fields: {
+        readonly field: "settings.approvalFrameFamilies";
+        readonly reason: "bad_entry";
+        readonly index?: number;
+    };
+}
+/**
+ * [ref] —— 请求面声明 `settings.approvalFrameFamilies` 的**唯一判官**:这条 run 的客户端渲染得了哪些审批开卡帧族。
+ * 合法 = 数组,每项是 {@link APPROVAL_FRAME_FAMILIES} 里的词、各出现一次(空数组合法 = 一个族都不渲染,与缺席同读)。非数组 / 词表外 / 重复 ⇒ 拒体点名坐标。
+ * 两个读者:fresh 受理门(`http/admission.ts`,400)与宽容读者 {@link declaredApprovalFrameFamilies}(续跑重放读存体)。入参是 `body.settings`
+ * 本身(非对象 / 缺席 ⇒ 本判官不判,留给 `settings` 自己的形门)。拒句不回显调用方的字节,只报坐标与词表。
+ */
+export declare function approvalFrameFamiliesIssue(settings: unknown): ApprovalFrameFamiliesIssue | null;
+/**
+ * [ref] —— 一条 run 声明的帧族集合(三条执行腿读的**唯一**读者;读的是这条 run 的请求体 `settings`:sync = 本次请求、bg = 受理过的提交体、
+ * resume / wake = 持久化体 —— 声明随体重放,不另存)。缺席 ⇒ 空集。判官说不合法 ⇒ 空集:只有绕过受理门的存体走得到这一形,
+ * 空集 = 这条腿没有活审批通道(问当场交无人值守政策口)—— 失效方向是不呈卡,不是猜一个族去呈。
+ */
+export declare function declaredApprovalFrameFamilies(settings: unknown): ReadonlySet<ApprovalFrameFamily>;
+/** 一条腿**没有活审批通道**的成因(见 {@link ApprovalLegAssembly.unattended});`frame_family_undeclared` 带上缺的那个族。 */
+export type LegUnattended = {
+    readonly arm: "window_zero";
+} | {
+    readonly arm: "frame_family_undeclared";
+    readonly family: ApprovalFrameFamily;
+};
+/** {@link resolveApprovalLeg} 的入参(sync / bg / resume 三腿 + 开流 preamble 共用一份形)。 */
+export interface ApprovalLegInput {
+    /** = `resolveStreamApprovalGate(...).active`(协议在本 worker 上场没有)。 */
+    streamApprovalOn: boolean;
+    /** `config.streamApproval.windowMs`(`STREAM_ASK_WINDOW_MS`)。
+     *  🔴 [ref]:`undefined` = **这份装配没有 `streamApproval` 段**(只出现在只填被测键的 stub-harness ——
+     *  真实 boot 无条件铸该段,见 `config.ts`)。此前三个调用点各写 `?? 0` 把这一形折成「0」,在旧语义下
+     *  是死代码(`windowZero` 那时挂在 `streamApprovalOn` 后面,协议关就恒 false);[ref] 让 `0` 在协议关的
+     *  腿上也真生效之后,那个折算会把一台**什么都没配**的 harness 判成「运维显式关窗」。故本字段收成
+     *  `number | undefined`,由每个调用点如实交出「有没有这个值」,不许再就地编一个。 */
+    windowMs: number | undefined;
+    /** `config.streamAskWindowMarginMs`(`STREAM_ASK_WINDOW_MARGIN_MS`)。 */
+    windowMarginMs: number;
+    /** `spec.limits.maxWalltimeMs`。缺席 = 没有 walltime 墙 ⇒ 第三源不参与(**缺席 ≠ 0**)。 */
+    legWalltimeMs?: number;
+    /** 本腿**开始执行的时刻**的 `performance.now()`。取值点绝不能挪到腿启动之后:误差方向必须是
+     *  「窗偏短」(安全侧,§7.3 的误差方向论证)。 */
+    nowMonotonicMs: number;
+    /** [ref]:这条 run 声明的帧族(唯一读者 {@link declaredApprovalFrameFamilies},读本 run 的请求体 / 存体)。必填 —— 漏传的装配点编译红,
+     *  不许有「没传 ⇒ 当作声明了」的默认。 */
+    declaredFamilies: ReadonlySet<ApprovalFrameFamily>;
+}
 /**
  * [ref] 车3 刀 3b —— **一条执行腿的审批装配裁定**(sync / bg / resume **三腿共用**)。
  *
@@ -1140,14 +1176,19 @@ export type ApprovalFrameFamily = (typeof APPROVAL_FRAME_FAMILIES)[number];
  * `prepare-task.js` 的 durableMandate/contentMandate 与 durableQuestionFace 等),
  * 故不在本函数内。
  *
- * 🔴 **[ref](半接线旋钮族)**:`windowZero` 的第一源(`STREAM_ASK_WINDOW_MS=0`)自此**不再挂在
+ * 🔴 **[ref](半接线旋钮族)**:关窗的第一源(`STREAM_ASK_WINDOW_MS=0`)自此**不再挂在
  * `streamApprovalOn` 后面** —— 那是部署级旋钮,它的语义不该因为这台机器有没有 durable ask 账而改变
- * (`ApprovalLegAssembly.windowZero` 顶注写了那条病)。第三源(贴 deadline)照旧只在协议上场时参与。
+ * (`ApprovalLegAssembly.unattended` 顶注写了那条病)。第三源(贴 deadline)照旧只在协议上场时参与。
+ *
+ * 🔴 **[ref]**:「这条腿有没有活审批通道」多一个成因 —— 这条 run 没声明本 worker 呈卡用的族。它与关窗是**同一件事**(不呈卡、问当场交政策口),
+ * 所以进同一个字段(`unattended` 的成因词),三条腿零新分支;判据读 {@link presentedApprovalFrameFamily}(能力位读同一只)。
+ * 判据**不**放进 {@link resolveStreamApprovalGate}:那是 worker 级谓词(协调器注入 / 能力位 / 回决 501 都没有 run),且它为假时腿退回旧族 `emit` ——
+ * 正是「回退发 `tool_approval`」。
  *
- * **`windowZero` 的两件事必须同时做**(调用方契约):不包 ALS **且**注入 immediate-unavailable 闭包。
- * 只做一件另一条路仍会呈卡。⚠️ [ref] 起**三腿都有** per-task `spec.onAsk` 装配点(sync=routes/tasks.ts,
- * bg=runs.ts,resume=server.ts driveResumeLeg),windowZero 的第二件在三腿都是显式闭包 —— 旧文「bg/
- * resume 无装配点,不包 ALS 即等价」的缺席论证已退役,别再据它推断「少装一件也行」。
+ * **没有活审批通道的两件事必须同时做**(调用方契约):不包 ALS **且** `spec.onAsk` = {@link ToolApprovalCoordinator.boundUnattendedAsk}(带成因)。
+ * 只做一件另一条路仍会呈卡(ALS 腿是 `deps.onAsk` 的到达路;不包 ALS 也让这条腿不进 broker 活流集合 = 不是别的腿的卡的投递目标)。
+ * ⚠️ [ref] 起**三腿都有** per-task `spec.onAsk` 装配点(sync=routes/tasks.ts,bg=runs.ts,resume=http/resume-legs.ts),第二件在三腿都是显式闭包 ——
+ * 旧文「bg/resume 无装配点,不包 ALS 即等价」的缺席论证已退役,别再据它推断「少装一件也行」。
  */
 export interface ApprovalLegAssembly {
     /** 协议在本腿上是否上场。false ⇒ **既不包 ALS、也不接** `emitCard`/`emitRevoke`/`legKey`/
@@ -1157,28 +1198,29 @@ export interface ApprovalLegAssembly {
      *  同 (owner, session) 活流呈活卡(sync 腿 [ref] 起本就如此;bg/resume 的这条行为差 = [ref] CHANGELOG
      *  披露的行为面变更)。旧文「本腿逐字保持协议之前的行为」只对协议件成立,别再把它读成「协议关 = 零呈卡」。 */
     active: boolean;
-    /** §8.3 窗=0 恒 park。
-     *  🔴 **[ref] 起它与 `active` 解耦**(旧文「`active` 为假时恒 false —— 协议都没上场,谈不上关窗」已
-     *  作废):`STREAM_ASK_WINDOW_MS` 是**部署级**旋钮,`0` 的语义(运维显式关窗 ⇒ 恒走
-     *  {@link ToolApprovalCoordinator.unattendedAskOutcome},连卡都不发)在两条车道上必须是同一个意思。
-     *  旧形下 local 车道(S-384 之前的「账不持久」臂)/ 无 park 设施 / 显式关协议的部署配了 `0`,拿到的是一张
-     *  等满 5min 的活卡 —— 与它自己的域注正好相反,且没有任何一行说出来。
-     *  ⚠️ 「窗**缺席**」(`windowMs: undefined` = 这份装配根本没有 streamApproval 段,只出现在 stub-harness)
-     *  **不是**关窗:那时逐字保持活卡腿。 */
-    windowZero: boolean;
-    /** §7.3 本 leg 的 walltime deadline(`performance.now()` 单调基)。只在 `active ∧ ¬windowZero ∧
+    /** **这条腿没有活审批通道**(在场 ⇒ 不包 ALS、不是任何卡的投递目标、`spec.onAsk` 是 {@link ToolApprovalCoordinator.boundUnattendedAsk}
+     *  席 —— 每只问当场交无人值守政策口,臂 = 本值)。缺席 ⇒ 这条腿按 {@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`)。判据对两个族同一条:
+     *    不回退发另一族、不双发、没有「键缺席 ⇒ 视作旧族」的默认。
+     *  三条腿只问「在场没有」,成因随席交给唯一铸点(遥测臂 + deny 政策的拒因句)。 */
+    unattended?: LegUnattended;
+    /** §7.3 本 leg 的 walltime deadline(`performance.now()` 单调基)。只在 `active ∧ 有活审批通道 ∧
      *  有 walltime 墙` 时在场 —— 关着时供值会把既有 5min 活卡窗按三元公式缩短(§7.2 真行为变更)。 */
     legDeadlineMonotonic?: number;
 }
 /**
  * [ref] 车3 刀 3b(codex 交叉复审 round2 R2-1,2026-08-06 真 finding)—— 呈卡腿的**双 sink 投递口**(开卡帧 + 消卡帧)。
  *
- * 🔴 为什么必须收成一个有属主的工厂:「呈卡帧送达」决定「卡到底有没有送到人手上」(见 `emitOne` 顶注;S-1683 起呈卡腿只有这一族)。
+ * 🔴 为什么必须收成一个有属主的工厂:「呈卡帧送达」决定「卡到底有没有送到人手上」(见 `emitOne` 顶注;[ref] 起呈卡腿只有这一族)。
  * sync 腿原来那个内联闭包把两个 sink 的失败都吞掉、然后**正常返回** —— 于是「账本写失败 ∧ socket 已死」这种**真的一路都没送到**的
  * 情形被上报成成功,`anySucceeded` 因此压住了 park 路由。诚实的形只有一个:**至少一个 sink 真的接下了才算送达**,一个都没接下就抛 ——
  * 调用点(`emitOne`)的 catch 会把它如实记成没送到。
  *
- * 🔴 **两只 sink 各自推进、各自配对**(S-1683 codex 一轮 F1 / F2,红先钉在 `test/approval-leg-frame-family.test.ts`):
+ * 🔴 **两只 sink 各自推进、各自配对**([ref] codex 一轮 F1 / F2,红先钉在 `test/approval-leg-frame-family.test.ts`):
  *  · 开卡帧同时交两只 sink,**任一只接下即算送达**(不按序串行 —— 旧族退场后 live 面只剩呈卡族这一条路,一只挂住的账本写不能挡住
  *    健康的 live 出口;修前先 await 账本再写 live)。两只都失败才抛。
  *  · 消卡帧只交给**接下过本卡开卡帧**的那只 sink,且排在该 sink 自己的开卡写之后(每只 sink 内开在合前;没接下开卡的 sink 不收消卡 =
@@ -1196,24 +1238,15 @@ export declare function createApprovalCardEmitter(sinks: {
     /** live SSE 口。**已死的流应当由调用方判成缺席或让它抛**,不要写一个静默 no-op —— 那正是本 finding。 */
     writeLive?: (frame: ApprovalCardLegFrame) => void | Promise<void>;
 }): (frame: ApprovalCardLegFrame, registration: string) => Promise<void>;
-export declare function resolveApprovalLeg(input: {
-    /** = `resolveStreamApprovalGate(...).active`(协议在本 worker 上场没有)。 */
-    streamApprovalOn: boolean;
-    /** `config.streamApproval.windowMs`(`STREAM_ASK_WINDOW_MS`)。
-     *  🔴 [ref]:`undefined` = **这份装配没有 `streamApproval` 段**(只出现在只填被测键的 stub-harness ——
-     *  真实 boot 无条件铸该段,见 `config.ts`)。此前三个调用点各写 `?? 0` 把这一形折成「0」,在旧语义下
-     *  是死代码(`windowZero` 那时挂在 `streamApprovalOn` 后面,协议关就恒 false);[ref] 让 `0` 在协议关的
-     *  腿上也真生效之后,那个折算会把一台**什么都没配**的 harness 判成「运维显式关窗」。故本字段收成
-     *  `number | undefined`,由每个调用点如实交出「有没有这个值」,不许再就地编一个。 */
-    windowMs: number | undefined;
-    /** `config.streamAskWindowMarginMs`(`STREAM_ASK_WINDOW_MARGIN_MS`)。 */
-    windowMarginMs: number;
-    /** `spec.limits.maxWalltimeMs`。缺席 = 没有 walltime 墙 ⇒ 第三源不参与(**缺席 ≠ 0**)。 */
-    legWalltimeMs?: number;
-    /** 本腿**开始执行的时刻**的 `performance.now()`。取值点绝不能挪到腿启动之后:误差方向必须是
-     *  「窗偏短」(安全侧,§7.3 的误差方向论证)。 */
-    nowMonotonicMs: number;
-}): ApprovalLegAssembly;
+export declare function resolveApprovalLeg(input: ApprovalLegInput): ApprovalLegAssembly;
+/**
+ * 🔴 **开流 preamble 往本连接投卡与否的唯一判据**([ref] / H5)—— 两条 preamble 共用:sync 腿(`routes/tasks.ts`,入参的声明读本次请求的 `settings`:
+ * 那条连接列的是整个会话的卡)与耐久事件流(`routes/runs.ts`,那条连接只列这条 run 名下的卡,而无通道的腿一张卡都不落 ⇒ 声明由卡作证,入参 =
+ * {@link presentedApprovalFrameFamily})。preamble 也是往本连接投卡:只在本腿**有活审批通道**时重放、订消卡 ——
+ * 协议在本 worker 上场、没关窗、这条 run 声明了本 worker 呈卡用的族;与本腿呈不呈卡是同一只装配({@link resolveApprovalLeg}),不在 preamble 一侧另写一份合取式。
+ * 为假 ⇒ 零帧且零 ask 账读(与「协议未上场」同形)。时钟不参与这一判:`nowMonotonicMs` 只喂 `legDeadlineMonotonic`(窗长三元),不进 `unattended` 的三个成因。
+ */
+export declare function approvalPreambleReplays(input: Omit<ApprovalLegInput, "nowMonotonicMs">): boolean;
 /** 一条 **DECIDED 行**能交还给引擎的全部形(`AskOutcome` 减掉 park 路由那一臂 —— 一条有决议的行
  *  从定义上不是「投递面拿走了它」)。{@link ToolApprovalCoordinator.notifyExternalDecision} 收的就是它。 */
 export type DecidedAskOutcome = Exclude<AskOutcome, "unavailable">;
@@ -1222,7 +1255,7 @@ type DecidedRowFacts = Pick<AskRow, "decision" | "settledBy"> & {
     updatedInput?: unknown;
 };
 /**
- * 🔴 **一条 DECIDED 行 → 交还给引擎的那个 outcome:全仓唯一铸点**(S-558)。
+ * 🔴 **一条 DECIDED 行 → 交还给引擎的那个 outcome:全仓唯一铸点**([ref])。
  *
  * 存在理由 = 这条投影此前被**手抄**在每个消费点上(`row.decision === "approve"` + `row.updatedInput`,
  * 六处),于是给行加一格新事实就得记得改六处 —— `settledBy` 正是那个没人改到的格:一次**策略拒**在
@@ -1233,10 +1266,10 @@ type DecidedRowFacts = Pick<AskRow, "decision" | "settledBy"> & {
  *  · **方向** —— `decision !== "approve"` 即拒(列的二值由店的 CAS 保证);
  *  · **编辑载荷**([ref])—— `updatedInput` 键缺席 = 没带编辑 ⇒ 裸 `true`;在场(**含 `null`**)= 编辑的
  *    字面值 ⇒ 对象臂(语义三态的唯一属主 = `AskRow.updatedInput` 顶注);
- *  · **结算来源**(S-558)—— 行上非 null 即宿主自报的那个词(`null` = 人决,与「不铸这个键」同义;
+ *  · **结算来源**([ref])—— 行上非 null 即宿主自报的那个词(`null` = 人决,与「不铸这个键」同义;
  *    语义属主 = `AskRow.settledBy` 顶注)。
  *
- * 🔴 S-1154:来源位**两向都读**。决定体的出处位 `decidedBy:"policy"` 在 allow 与 deny 上都会落列(引擎 7.39.0 起铸
+ * 🔴 [ref]:来源位**两向都读**。决定体的出处位 `decidedBy:"policy"` 在 allow 与 deny 上都会落列(引擎 7.39.0 起铸
  * `policy_allowed`),所以 approve 行带来源位是一条合法的行,它的每条读回路径交还 `{allow:true, settledBy:"policy", updatedInput?}`
  * —— 与当次回决交给引擎的那一只逐字同形。
  */
@@ -1321,7 +1354,7 @@ export declare class ToolApprovalCoordinator {
      *  `pollSuspendedDecisions` 里那段:按 askId 记的形会在「上一拍最后碰的那条被结算掉」时塌回队首,
      *  构造出永久饥饿的前缀)。只回答「上一拍扫到第几个」,单调推进、按当前长度取模。 */
     private suspendedPollOffset;
-    /** S-247:悬挂轮询腿第二层(接管登记)的轮转游标 —— 与 {@link suspendedPollOffset} 同一条理由,两层各一只。 */
+    /** [ref]:悬挂轮询腿第二层(接管登记)的轮转游标 —— 与 {@link suspendedPollOffset} 同一条理由,两层各一只。 */
     private adoptedPollOffset;
     /** [ref] + codex R3-[critical]:askId → **此刻正带着 `updatedInput` 决它的请求数**(见
      *  {@link markEditedDecisionInFlight} 顶注)。只在 `decideAsk` 那一次调用期间非空,故天然有界。 */
@@ -1360,12 +1393,15 @@ export declare class ToolApprovalCoordinator {
      *  构造之后才装配;同款 holder 先例 = main.ts 的 `getRunDenySweep`)。取到 undefined ⇒ 该臂逐字回落
      *  修前 404,partial 部署安全。 */
     private readonly parkedRedeem;
+    /** [ref]:按问读口对 `PARKED` 卡的门读席(见 {@link ParkedGateRead})。缺席(没有 checkpoint 店的部署 / 只装 ask 账的嵌入)⇒ 读口只能说行说的话(`parked`)。
+     *  不是晚绑取值口:checkpoint 店在协调器构造之前就装好了(`boot/stage-06`),与 `parkCommits` 同一只店。 */
+    private readonly parkedGate;
     /** [ref] 裁 (c):local 车道的 File ask **审计** sink(在场 ⇔ `DB_BACKEND=local` ∧ 审批面开着,装配点
      *  `boot/coordinators.ts`)。三个挂线点:铸造(askBroadcast register 后)/ 决议(`settle()` 公共咽喉)/
      *  腿闭(`runWithContext` finally)。**纯观察面**:sink 自己吞写失败并 `recordFailOpen`,任何一次审计
      *  写都不得改变审批终局(店头注成文)。SQL 车道恒缺席(那里有真 ask 店)。 */
     private readonly askAudit;
-    /** S-877 候裁 16 → A:耐久会话授权店(`/decide` 的 `remember:"session"` 写、本席读)。在场 ⇔ 部署有 store backend
+    /** [ref] 候裁 16 → A:耐久会话授权店(`/decide` 的 `remember:"session"` 写、本席读)。在场 ⇔ 部署有 store backend
      *  (装配点 `boot/coordinators.ts`,与 `/decide` 写的是**同一只**店)。读口唯一 = {@link standingGrantSettles};写口唯一 = {@link recordDeploymentListAnswer}
      *  (活卡上部署名单那一问的「本会话放行」)。 */
     private readonly sessionGrants;
@@ -1373,13 +1409,13 @@ export declare class ToolApprovalCoordinator {
      *  缺席(没有豁免店的装配)⇒ 没有一张卡读作名单的问 —— 名单那一问的答案没有地方记,它就按引擎的类表读(记不住)。
      *  活的一问(`AskRequest`)上只有 wire 名(没有调用的别名面)⇒ 名单靠别名命中的调用读不出属主,按引擎的问读(记不住;方向是多问)。 */
     private readonly deploymentListAsks;
-    /** S-929:有序关停已开始(`drainForShutdown` 锁存,不复位 —— 进程正在退出)。之后登记的每一张卡在登记那一刻按关停收场。 */
+    /** [ref]:有序关停已开始(`drainForShutdown` 锁存,不复位 —— 进程正在退出)。之后登记的每一张卡在登记那一刻按关停收场。 */
     private shutdownDraining;
-    /** S-929:此刻在 `askBroadcast` 里的 ask 数(进出成对,见那里的 try/finally)—— 关停等待「还没登记进 `pending` 的卡」的计数。 */
+    /** [ref]:此刻在 `askBroadcast` 里的 ask 数(进出成对,见那里的 try/finally)—— 关停等待「还没登记进 `pending` 的卡」的计数。 */
     private asksInFlight;
-    /** S-929 F1:park 提交的观察面(checkpoint 店的装饰层;在场 ⇔ 本部署有 park 设施,装配点 `boot/stage-06-runners.ts`)。 */
+    /** [ref] F1:park 提交的观察面(checkpoint 店的装饰层;在场 ⇔ 本部署有 park 设施,装配点 `boot/stage-06-runners.ts`)。 */
     private readonly parkCommits;
-    /** S-929 F1:有序关停下路由到 park、**处置尚未被观察到**的卡 —— 审计 settle 行在这里候着({@link settleParksAwaitingCommit})。
+    /** [ref] F1:有序关停下路由到 park、**处置尚未被观察到**的卡 —— 审计 settle 行在这里候着({@link settleParksAwaitingCommit})。
      *  只在关停期有成员(进程随后退出,不需要回收)。 */
     private readonly parksAwaitingCommit;
     constructor(opts?: {
@@ -1401,6 +1437,8 @@ export declare class ToolApprovalCoordinator {
         ruleScopeRootFor?: (sessionId: string | undefined) => string | undefined;
         /** [ref]:PARKED 臂赎回席的**晚绑取值口**(见 {@link ToolApprovalCoordinator.parkedRedeem})。 */
         parkedRedeem?: () => ParkedAskRedeem | undefined;
+        /** [ref]:按问读口的门读席(见 {@link ToolApprovalCoordinator.parkedGate})。 */
+        parkedGate?: ParkedGateRead;
         /** [ref]:受理回执表两道界(缺省见 {@link DEFAULT_PARK_REDEMPTION_MAX}/{@link DEFAULT_PARK_REDEMPTION_TTL_MS})。
          *  不是部署旋钮(不接 env),可注入只为让「有界」这件事被判据观测得到。 */
         parkRedemptionMax?: number;
@@ -1409,26 +1447,26 @@ export declare class ToolApprovalCoordinator {
         parkRedemptionPerPrincipalMax?: number;
         /** [ref] (c):local 车道审计 sink(见 {@link ToolApprovalCoordinator.askAudit})。 */
         askAudit?: ApprovalAskAuditSink;
-        /** S-877 候裁 16:耐久会话授权店(见 {@link ToolApprovalCoordinator.sessionGrants})。 */
+        /** [ref] 候裁 16:耐久会话授权店(见 {@link ToolApprovalCoordinator.sessionGrants})。 */
         sessionGrants?: SessionGrantStore;
         /** 问的属主的读法(见 {@link ToolApprovalCoordinator.deploymentListAsks})。只能与 `sessionGrants` 同在:名单那一问的答案就记在那只店里。 */
         deploymentListAsks?: (call: {
             readonly toolName: string;
         }) => boolean;
-        /** S-929 F1:park 提交的观察面(见 {@link ToolApprovalCoordinator.parkCommits})。 */
+        /** [ref] F1:park 提交的观察面(见 {@link ToolApprovalCoordinator.parkCommits})。 */
         parkCommits?: ParkCommitWatch;
     });
     /**
      * [ref] R-13 C —— 「**无人可答**」这一类终局的**唯一**成形口(park 路由 vs deny 政策)。
      *
-     * 终局形(S-689):park ⇒ `"unavailable"`;deny ⇒ {@link UnattendedPolicyRefusal}
+     * 终局形([ref]):park ⇒ `"unavailable"`;deny ⇒ {@link UnattendedPolicyRefusal}
      * `{allow:false, settledBy:"policy", reason}`(core 记 `policy_refused`)。**从不**交裸 `false`:那在 core 的
      * onAsk 契约里是「一个人拒了」,而本口的全部臂都是「没有人能答」。
      *
      * 五臂(设计稿 §1 的表)全部读它,`unattendedPolicy` 因此是一处施加、五处消费:
      *  (a) 有店窗到期 `expireAsk` 赢 CAS / (b) 无店窗到期(D1)/ (c) 有店但 `expireAsk` 报错
      *  —— 三条走 `windowRouteUnavailable` 标志,在 {@link shapeOutcome}(askBroadcast 内)成形;
-     *  (d) `windowZero`(装配层短路)与无 ALS 上下文的 headless 腿 —— 走本方法/{@link ask};
+     *  (d) 没有活审批通道的腿(装配层短路:关窗 / 未声明呈卡族,[ref])与无 ALS 上下文的 headless 腿 —— 走本方法/{@link ask};
      *  (e) 断连 `forceParkNow` / emit 全灭 / 写侧准入超限 —— 走本方法。
      *
      * **持久回放的两个口也归它管**(codex R1-F1 验真后收口,红先钉在
@@ -1438,7 +1476,7 @@ export declare class ToolApprovalCoordinator {
      * 的终局会取决于「谁赢了那把 CAS」「重试没重试」—— 比残余更坏的不可解释性。人的**真决议**(回放出
      * `true`/`false`)当然不过这个口:那不是「无人可答」。
      *
-     * **`ensureAsk` 的两条兜底臂也归它管**(S-702,7.100.0 合并复审 opus 腿 E1;此前两臂直接交裸 `"unavailable"`,是这句
+     * **`ensureAsk` 的两条兜底臂也归它管**([ref],7.100.0 合并复审 opus 腿 E1;此前两臂直接交裸 `"unavailable"`,是这句
      * 「唯一成形口」的例外):行不可用(`persisted_row_unusable`:信封形不合 / deadline 越界)与身份不定(`ensure_indeterminate`:
      * ensure 失败且复核读全失败)。两臂的**处置**不变 —— 不编造 wire 身份、不在身份未定时呈卡收人决(fail-closed)—— 变的只是
      * 「不呈卡之后交什么」:它们同样是「这只 ask 没有人能答」,于是同样过这个口(park ⇒ `"unavailable"` 逐字不变;deny ⇒
@@ -1450,9 +1488,9 @@ export declare class ToolApprovalCoordinator {
      * `refuse` 意图(政策→意图的唯一映射在 `approval-policy-settlement.ts` 的 `settleByPolicy`)—— STREAM_PENDING→DECIDED(deny) + `settled_by = "policy"`,**按 ask
      * 作用域**(不碰批、不连坐兄弟)。落的来源词与本口交给 core 的是**同一个常量**(`POLICY_REFUSAL_DECISION`),于是
      * 同 ask 重入 / 收敛后重入由 `outcomeOfDecidedRow` 读回同一个对象。当年「危害为零」的论证(PARKING 行绑不上、
-     * 自行收敛成 DENIED/VOID)在 S-689 之后不再成立:首判交 `{allow:false, settledBy:"policy"}`,行停 PARKING 的回放
+     * 自行收敛成 DENIED/VOID)在 [ref] 之后不再成立:首判交 `{allow:false, settledBy:"policy"}`,行停 PARKING 的回放
      * 却交裸 `false`(收敛后 DENIED 无来源)—— core 当成人拒、可停批,两次判决第一次可被观测地分家。
-     * S-702 / S-706 把同一只 claim 接到了另外三处:两条兜底臂({@link landUnattendedOutcome})与崩溃恢复腿(收敛器孤儿段,
+     * [ref] / [ref] 把同一只 claim 接到了另外三处:两条兜底臂({@link landUnattendedOutcome})与崩溃恢复腿(收敛器孤儿段,
      * 它是窗到期竞争者在崩溃后的补位)—— 四处调的是**一只** `settleByPolicy`,谁也不自己挑意图。deny 部署上仍按 PARKING
      * 记账的只剩一形:别的写者(park 政策副本 / 切换政策之前)推进过的行,重入走本口(`replayed_parked`)。
      * deny 政策下批仍是**单 ask 批**(见 {@link batchIdFor}):`refuse` 本来就不碰批,单 ask 批让新行与存量整腿批行
@@ -1461,28 +1499,27 @@ export declare class ToolApprovalCoordinator {
     private unattendedOutcome;
     /** 政策**读**口(不是终局铸口)—— 回答「这台部署把无人可答翻成 park 吗」。
      *
-     *  🔴 与 {@link unattendedOutcome} 分家是 S-187 的一半:此前两件事共用一只方法,于是 park 路由判别那次
+     *  🔴 与 {@link unattendedOutcome} 分家是 [ref] 的一半:此前两件事共用一只方法,于是 park 路由判别那次
      *  纯粹的**政策查询**(`unattendedOutcome() !== false`)会和同一只 ask 的真终局各记一条遥测 ——
      *  「一只 ask 一条线」当场不成立。读口不落日志,铸口落;谁也不兼职。 */
     private get unattendedRoutesToPark();
     /**
-     * 一只 ask 落在**哪只批**里 —— 批作用域随政策(S-689 codex R1-F1,判据全文见 {@link deriveAskScopedBatchId})。
+     * 一只 ask 落在**哪只批**里 —— 批作用域随政策([ref] codex R1-F1,判据全文见 {@link deriveAskScopedBatchId})。
      *  · park 路由 ⇒ 整腿一批(`deriveBatchId`):窗到期赢家整批转投递面、兄弟连坐,core 随后 park,腿就此结束;
      *  · deny 政策 ⇒ 单 ask 批:没有 park 路由,腿在一次部署政策拒之后继续跑 —— 整腿一批会让首只到期把批关掉,
      *    同腿后续的卡人批不动(`decideAsk` batch_closed ⇒ 404),兄弟还被连坐成 VOID、以裸 `false` 交 core(人拒)。
      * 读的是政策**读**口(不落遥测)。
      */
     private batchIdFor;
-    /** {@link unattendedOutcome} 的**公开**口:`windowZero` 的 immediate-unavailable 闭包长在装配层
-     *  (`http/routes/tasks.ts` 的 sync 腿),它必须与协调器内五臂读**同一个**旋钮值,而不是各算一遍。
-     *  出处随调用方给(那条腿知道自己是哪一只 ask)。 */
-    unattendedAskOutcome(site: {
+    /** {@link unattendedOutcome} 的**公开**口:没有活审批通道的腿({@link ApprovalLegAssembly.unattended})的席长在装配层,它必须与协调器内
+     *  五臂读**同一个**政策值,而不是各算一遍。成因(`why`)与出处随调用方给(那条腿知道自己为什么不呈卡、是哪一只 ask)。 */
+    unattendedAskOutcome(site: LegUnattended & {
         taskId?: string;
         owner?: string | null;
         toolName?: string;
     }): UnattendedAskOutcome;
     /**
-     * S-702 —— 两条兜底臂的「无人可答」终局的**落行**半场。交给 core 的值已由 {@link unattendedOutcome} 一处铸好,这里只回答
+     * [ref] —— 两条兜底臂的「无人可答」终局的**落行**半场。交给 core 的值已由 {@link unattendedOutcome} 一处铸好,这里只回答
      * 「这条持久行上落什么」,判据是「交出去的是不是**结算**」(行 = 真源:交出去的结算必须同时是行上的结算,否则同 ask 重入 /
      * 收敛后重入回放出来的是另一个答案 —— NP-2 在 live 腿上收掉的同一种分家):
      *  · park 路由(`"unavailable"`)不是结算 ⇒ 行**不动**:它留在 STREAM_PENDING,投递面由既有机器接(崩溃恢复腿按政策代打),
@@ -1492,7 +1529,7 @@ export declare class ToolApprovalCoordinator {
      * 🔴 **只对「本次调用插下的」行调用**(调用方的义务;codex 对抗复审 F1 + R2-2 / [ref] 件2 同一条纪律「放弃收尾只许动本次插入的
      * 行」):兜底臂发生在**窗开之前** —— 一条幂等命中的 STREAM_PENDING 行此刻可能正被别的登记(另一副本 / 另一版本 / 重入)呈卡、
      * 有人正要按;当场 refuse 等于把一张活卡在它自己的窗走完之前作废。所以归属证不出(幂等命中、ensure 报错、迟到结果
-     * `inserted:false`)⇒ 本方法不被调用、行不动:它的属主按自己的窗收场,属主不在了由收敛器孤儿段(同一只 claim,S-706)在
+     * `inserted:false`)⇒ 本方法不被调用、行不动:它的属主按自己的窗收场,属主不在了由收敛器孤儿段(同一只 claim,[ref])在
      * 窗过 + 宽限之后落同一个政策结算。`row.batchId` 恒取**行上**的批(claim 的 scope;本地派生的批可能与存量行不同,
      * 错 scope 的 claim 答 absent,不证明「行上没有决议」—— codex F1)。
      *
@@ -1579,7 +1616,7 @@ export declare class ToolApprovalCoordinator {
      */
     beginDrain(): void;
     /**
-     * 🔴 **S-929 —— 有序关停的审批面收尾(一只;`boot/shutdown.ts` 的 `hardShutdown` 起点调,SIGTERM / SIGINT / SIGHUP 三条停止路同一处)。**
+     * 🔴 **[ref] —— 有序关停的审批面收尾(一只;`boot/shutdown.ts` 的 `hardShutdown` 起点调,SIGTERM / SIGINT / SIGHUP 三条停止路同一处)。**
      *
      * 病(cli [ref] S7):修前关停序不碰协调器 ⇒ 本进程握着的活卡在下一次 boot 被审计收敛器标成 `crashed_before_park`,
      * 用户屏上看到「crashed」而实为有序重启。
@@ -1587,7 +1624,7 @@ export declare class ToolApprovalCoordinator {
      * 三步:
      *  ① 本进程握着的**每一张**未决卡(可达 / 悬挂 / 委派子代,不挑)按**断连同路**收场 —— {@link PendingApproval.forceParkNow}(park 路由;
      *     `deny` 政策下是部署政策拒;有持久 ask 店时走同一把终局 claim)。有序关停与断连是同一件事:投递面要没了,**不是**有人拒了
-     *     (不交裸 `false`,S-689 同律)。审计 settle 行携 `cause:"shutdown_before_park"`(`forceParkNow` 的调用点点名它);
+     *     (不交裸 `false`,[ref] 同律)。审计 settle 行携 `cause:"shutdown_before_park"`(`forceParkNow` 的调用点点名它);
      *  ② 在 `deadlineMs` 之前等:未决卡结清、在飞腿闭合(闭了的腿照常落 `leg_closed`)、**本次路由到 park 的卡全部结清**
      *     (F1:观察到 core 已处置这次调用 —— 停车行提交或承载它的腿退场 ⇒ 那张卡的审计 settle 行此刻才写,见 {@link settleParksAwaitingCommit})、
      *     店里在飞的 `put` 静默;
@@ -1608,7 +1645,7 @@ export declare class ToolApprovalCoordinator {
         }>;
     }>;
     /**
-     * S-929 F1:checkpoint 店的观察层报「一只审批停车行提交了」({@link CommittedParkCalls}:行自己陈述的会话与握着的调用)⇒ 候着的
+     * [ref] F1:checkpoint 店的观察层报「一只审批停车行提交了」({@link CommittedParkCalls}:行自己陈述的会话与握着的调用)⇒ 候着的
      * **同一次调用**结清:执行会话**相等**(候者记的是 ask 自己陈述的发起会话,行陈述的是它停住的会话 —— core 同一个变量)∧ 调用 id ∈ 行握着的调用。
      * 不做「会话相交」:调用 id 只在 run 内唯一(父子各自的第一只调用常同名),宿主会话若作子代的等价别名,宿主停车行一提交就会冒充子代的提交(车 SO)。
      * 只在关停期有候者;非关停期的提交一个不碰。
@@ -1616,7 +1653,7 @@ export declare class ToolApprovalCoordinator {
      */
     private noteParkCommitted;
     /**
-     * S-929 F1 的**结清口**(一处):有序关停下 park 路由的卡,在**观察到 core 已处置这次调用**时写它的审计 settle 行 —— 两种观察,同一件事实:
+     * [ref] F1 的**结清口**(一处):有序关停下 park 路由的卡,在**观察到 core 已处置这次调用**时写它的审计 settle 行 —— 两种观察,同一件事实:
      *  · `park-committed` —— 停车行提交了(观察层看到 `put` 落定,或 core 回读确认的那一次 `get` 读到了行);
      *  · `leg-closed`     —— **承载它的那条腿**退场了(`runWithContext` finally 按 ctx 身份配 {@link ParkAwaitingCommit.carrierLeg}:core 已走完这条腿 ——
      *                        停靠了,或拒了停靠 fail-closed 继续)。
@@ -1659,12 +1696,12 @@ export declare class ToolApprovalCoordinator {
      *  投递到哪条连接不参与 —— 见 {@link AskOriginIdentity} 顶注。 */
     private governanceForcedOf;
     /**
-     * 🔴 **S-877 候裁 16 → A —— 站着的答案(会话授权)的唯一兑现口**(主会话裁定 2026-09-29;core 7.34.0 wire 段逐字指定的兑现位:
+     * 🔴 **[ref] 候裁 16 → A —— 站着的答案(会话授权)的唯一兑现口**(主会话裁定 2026-09-29;core 7.34.0 wire 段逐字指定的兑现位:
      * 「a host approval seat that settles asks from a session grant reads it [`authoredBy`] to keep its hands off」)。
      *
      * **一条判据**:一只 ask 由会话授权代答 ⇔ ① 判据说它的站着的答案在本席({@link standingAnswerHome} 答 `seat` —— 治理强制 /
      * `requiresRealApproval` / `mandated` 三位的既有排除一字不动;运维「恒问人」的卡(`APPROVAL_NEVER_AUTO` / 耐久预算耗尽)
-     * 自 S-877 起盖部署出身 ⇒ core 盖 `mandated`,同落这一臂)∧ ② 有真会话 ∧ ③ 两只授权店任一命中:live `allow_session` 的
+     * 自 [ref] 起盖部署出身 ⇒ core 盖 `mandated`,同落这一臂)∧ ② 有真会话 ∧ ③ 两只授权店任一命中:live `allow_session` 的
      * 进程内表(按能力桶,[ref]② 修2)或耐久 `/decide` `remember:"session"` 的豁免店(按 canonical 工具名,`/decide` 写的同一只店;
      * 读失败 ⇒ 不命中 = fail-closed,人多看一张卡而不是被静默代答)∧ ④ 行上没有与本地 peek 矛盾的出处({@link sessionGrantUncontestedByRow})。
      *
@@ -1685,21 +1722,22 @@ export declare class ToolApprovalCoordinator {
      *  问已经发出去了)。 */
     private durableGrantHas;
     /**
-     * 🔴 **S-877 候裁 16 —— 窗 0 席**:本席**不呈卡**,但在报「无人可答」之前先问站着的答案。装配点 = 三条腿的 `windowZero` 席
-     * (sync `http/routes/tasks.ts`、bg `runs.ts`、resume `http/resume-legs.ts`)。修前三处是装配层的就地闭包 `() => unattendedAskOutcome(...)`
+     * 🔴 **[ref] 候裁 16 —— 无通道席**(旧名「窗 0 席」):本席**不呈卡**,但在报「无人可答」之前先问站着的答案。装配点 = 三条腿上没有活审批通道
+     * 的那一支({@link ApprovalLegAssembly.unattended} 在场;sync `http/routes/tasks.ts`、bg `runs.ts`、resume `http/resume-legs.ts`),成因 `why`
+     * 随席交给唯一铸点(遥测臂 + deny 政策的拒因句;[ref] 起两个成因:关窗 / 这条 run 没声明呈卡族)。修前三处是装配层的就地闭包 `() => unattendedAskOutcome(...)`
      * —— 不读授权,引擎那一问(模式写门 / 形状层)在窗 0 部署上 remember 恒无效。改形后:授权命中 ⇒ `true`;否则逐字走
      * {@link unattendedAskOutcome} 这**一个**政策口(五臂一处施加,[ref] R-13 C 不变)。
      * parked 赎回腿的继承条目席**不**改:那条腿上到席的问全是继承问(core 盖 `mandated`),本席依约不退役,改了也兑现不了任何东西 ——
      * 赎回腿上那类问的授权照旧由重建链里 durable 名单门的策略层探针兑现(锚 = 行的 root 会话)。复活子代**自己的**引擎问(模式写门 /
-     * 形状层)则经赎回腿铸的 execute ctx `onAsk` 落本席(身份 = 行的 root 会话,S-877 四续 ⑪,`parked-decide.ts` `approverSeatFor`)。
+     * 形状层)则经赎回腿铸的 execute ctx `onAsk` 落本席(身份 = 行的 root 会话,[ref] 四续 ⑪,`parked-decide.ts` `approverSeatFor`)。
      */
     boundUnattendedAsk: (identity: {
         owner: string | null;
         taskId: string;
         sessionId?: string;
-    }) => ((req: AskRequest) => Promise<AskOutcome>);
+    }, why: LegUnattended) => ((req: AskRequest) => Promise<AskOutcome>);
     /**
-     * 🔴 session grant 短路前的**持久出处复核**([ref] 的 codex R1-[high] 补丁;[ref] 换判据;S-944 / SN-C1 换读口)。
+     * 🔴 session grant 短路前的**持久出处复核**([ref] 的 codex R1-[high] 补丁;[ref] 换判据;[ref] / SN-C1 换读口)。
      *
      * 回 `true` = 「这次调用在这条腿上从来没有过持久出处」⇒ 一揽子放行可以短路;
      * 回 `false` = 这次调用在腿内有行(任何状态、任何 ask 身份),**或**读不出来(不知道 = 不放宽)⇒ 调用方必须往下走真出卡。
@@ -1708,10 +1746,10 @@ export declare class ToolApprovalCoordinator {
      * 而 `ensureAsk` 会写行。为什么一行都没有就放行:这次调用在这条腿上的行只可能由**这次调用的某一问**铸出来,
      * 一行都没有 ⇒ 从来没有过一份能反驳本地判据的持久出处(这也是常见形:grant 命中的调用多半是头一次到)。
      *
-     * ## 争议按**调用**判,不按 ask 身份判(S-944 / SN-C1)
+     * ## 争议按**调用**判,不按 ask 身份判([ref] / SN-C1)
      *
      * 争议的真源是调用:人对这次调用说过什么、这次调用还有没有一张卡挂着。ask 身份(`deriveAskId`)只是其中**一问**的主键,而身份会加轴 ——
-     * S-944 把这一问的类集并进身份后,按身份点读会把两类行读成「不存在」:① 同一调用另一类集的那一问(core #1218 的委派第二张卡与首卡);
+     * [ref] 把这一问的类集并进身份后,按身份点读会把两类行读成「不存在」:① 同一调用另一类集的那一问(core [ref] 的委派第二张卡与首卡);
      * ② 升级前按旧派生写的行(同一 resume token 重投 = 同一 `legKey`,跨版本重入同一调用)。两形都让一揽子放行代答、人拒 / 挂着的卡被绕过
      * (codex 车内 r1 [high] + [ref] gpt-6 腿 A 同指)。⇒ 读口 = 店的 `listByCall`(四列 = 这次调用在这条腿上的坐标,精确匹配),本函数不派生 askId。
      * **身份可以加轴,争议判据不得依赖身份。**
@@ -1733,7 +1771,7 @@ export declare class ToolApprovalCoordinator {
      *  · **codex 交叉复审**([ref] 同批,验真后采纳):只补终态判据仍漏「卡还在别处挂着」——
      *    STREAM_PENDING 行意味着已有一张卡在等人,凭 grant 抢跑会让行上的终局与真实执行长期矛盾
      *    (那张卡随后可被人/另一副本决成相反答案,或 TTL 到点被收敛成幻影 gate)。
-     *  · **S-944 / SN-C1**(见上节):读口按身份点读,身份加轴后漏掉同调用别的问与旧派生的行。
+     *  · **[ref] / SN-C1**(见上节):读口按身份点读,身份加轴后漏掉同调用别的问与旧派生的行。
      * 几次都不是各自独立的 bug,是同一句话没说全,故最终判据收成一条而不是几个分支。
      *
      * 零额外 IO(一次读),且 fail-closed **by construction**:将来 `AskState` 加词、ask 身份再加轴,都不需要动这里。
@@ -1786,7 +1824,7 @@ export declare class ToolApprovalCoordinator {
     private hasOtherSuspendedOwner;
     private settleSameAskIdParkRoute;
     /**
-     * claim 败方真相的**同 askId 分发口**(codex [ref] R6-2 / R7-1 立在 live 腿的闭包里;S-702 codex F2 起两条兜底臂的落行半场
+     * claim 败方真相的**同 askId 分发口**(codex [ref] R6-2 / R7-1 立在 live 腿的闭包里;[ref] codex F2 起两条兜底臂的落行半场
      * {@link landUnattendedOutcome} 也调它 —— 一个分发口,不写第二份):真相是**行**的,不是某一条登记的 ⇒ 真决议经
      * {@link notifyExternalDecision}、投递面经 {@link settleSameAskIdParkRoute} 交给同 askId 的全部本地登记;各登记的 settle 自带
      * 单赢者卫兵,对已落的恒无操作。absent / 编辑在飞没有可分发的真相。
@@ -1923,7 +1961,7 @@ export declare class ToolApprovalCoordinator {
      *  舰队 scope,与 `/decide` 腿同姿势);live 命中路径一个字节都不看它。缺席 = 非 HTTP 调用点
      *  (测试/内部),赎回席按「无请求」形处置。 */
     httpReq?: IncomingMessage, 
-    /** S-765:本次回决的**部署事实**(协调器自己不读 config;回决路由从能力事实读来交进)。缺席 ⇒ 按「不受理读根授权」读(失败方向 = 拒)。 */
+    /** [ref]:本次回决的**部署事实**(协调器自己不读 config;回决路由从能力事实读来交进)。缺席 ⇒ 按「不受理读根授权」读(失败方向 = 拒)。 */
     deployment?: ToolApprovalRespondDeployment): {
         status: number;
         body: unknown;
@@ -1932,12 +1970,13 @@ export declare class ToolApprovalCoordinator {
         body: unknown;
     }>;
     /**
-     * S-247:**接管登记**的应答。接管登记是行的投影(没有引擎腿在等它),所以它的属主门读**行当下的** owner —— 接管时记下的那一格可能已被
+     * [ref]:**接管登记**的应答。接管登记是行的投影(没有引擎腿在等它),所以它的属主门读**行当下的** owner —— 接管时记下的那一格可能已被
      * `/v1/adoption` 改写(契约:应答口的授权判据取当下的持久事实,收编之后旧属主手里的卡作废)。行仍 `STREAM_PENDING` ⇒ 与活登记同一条应答路
      * ({@link answerRegistration}:同一把 `decideAsk` CAS);行已有终局(别处答了 / 对账器收了,本副本的轮询还没到)⇒ 按行的真相答(与晚答口同一张表)。
      */
     private respondAdopted;
-    /** 一条已过属主门的登记(活登记或接管登记)的应答 —— 两者同一条路:规则文本前门 → 要人门 → CAS → 兑付。 */
+    /** 一条已过属主门的登记(活登记或接管登记)的应答 —— 两者同一条路:规则文本前门 → 要人门 → CAS → 兑付。
+     *  `judgedOwner` = 门判过的那位属主([ref]:决议作用域的属主维,CAS 与确认读都绑它;见 `askRowCarriesOwner`)。 */
     private answerRegistration;
     /** 一次 live 回决**落定之后**的两件兑付(部署名单那一问的豁免、「不再询问」的规则)—— 两件都只在 200 那一支、都读同一只资格。 */
     private afterLiveDecision;
@@ -1987,10 +2026,16 @@ export declare class ToolApprovalCoordinator {
         status: number;
         body: unknown;
     }>;
-    /** S-247:接管登记的按问读口 —— 行可见且仍 `STREAM_PENDING` ⇒ `pending`(列表面同一只行投影);否则按行的态答(与读行半场同一张表)。 */
+    /** [ref]:接管登记的按问读口 —— 行可见且仍 `STREAM_PENDING` ⇒ `pending`(列表面同一只行投影);否则按行的态答(与读行半场同一张表)。 */
     private readAdopted;
     /** {@link readApproval} 的读行半场。 */
     private readAskRowState;
+    /**
+     * `PARKED` 行的门读法([ref]):问判官「这张卡的门此刻还是不是该会话当前待决的审批门」。行是终态、不随赎回 / 取消改写,所以只有 checkpoint 知道。
+     * 没有门读席 / 行上没有 gate token ⇒ `open`(读口只能说行说的话;应答口对同一张卡的 PARKED 臂此时也答不了受理,不另有第二个答案)。
+     * 读不出(店故障 / 超时)⇒ 按本协调器的店故障姿势(D5:记账 + 一次 warn)退回 `open` —— 这一臂只影响**展示**,应答口对同一张卡仍按自己的判官 fail-closed。
+     */
+    private readParkedGate;
     /** 一条行 → 按问读口的答案(行态六态穷举:新增 `AskState` 而不在此表态 = **编译错**)。 */
     private readStateOfRow;
     /**
@@ -2118,18 +2163,18 @@ export declare class ToolApprovalCoordinator {
      *  的唯一数据源,**同时**是 `/v1/approvals/stream` 的 live 半场 diff 源(推与拉必须同源:feed 收到
      *  `live_pending` 事件就会去 `list()`,两处各读各的会给出一条列不出来的事件)。纯读投影,零锁/零结算
      *  语义。
-     *  🔴 **S-454 起行上带整只活卡帧**(`frame`,见 {@link LivePendingRow.frame}):旧文那句「input/args
+     *  🔴 **[ref] 起行上带整只活卡帧**(`frame`,见 {@link LivePendingRow.frame}):旧文那句「input/args
      *  不上列表,详情走流帧」对**悬挂 ask 结构上不成立**(它永远没有流帧),而 `frame` 是 `askBroadcast`
      *  那一处构造的同一个对象 ⇒ 仍然只有**一个**脱敏属主、零第二投影。`scope` 与 durable 面同一个值(checkpoint scope):`undefined` = operator 全量(含 owner null 的
      *  条目),`_`(`CHECKPOINT_PUBLIC_SCOPE`)= 匿名那一组 = owner null 的条目(R7:不带主体的调用方列得出它答得了的那几张),
      *  其余串 = 只见 `owner === scope` 的条目(null-owner 行对具名主体不列,宁少列不超范围)。行的 `approvalId` 就是 `respond()` 收的 id
      *  (同源可达,[ref] 判据);`expiresAtMs` 照抄登记时单点铸定的窗死线([ref] 三键同一个数)。 */
     /**
-     * 🔴 S-247 —— **起服接管**:把问账里仍 `STREAM_PENDING` 的问接进本审批机的活集合,让 `livePending[]`(及 `/v1/approvals/stream` 的 live 半场、
+     * 🔴 [ref] —— **起服接管**:把问账里仍 `STREAM_PENDING` 的问接进本审批机的活集合,让 `livePending[]`(及 `/v1/approvals/stream` 的 live 半场、
      * 按问读口、应答口)在重启之后不重开流也看得见、答得了它们。审批机仍是这些读面**唯一**的读源:读问账的只有这里(起服一次),之后列表行由
      * 同一只 {@link livePendingRowOf} 投影,卡帧 = `buildReplayFrame`(开流 preamble 同一只构造)—— 不是 GET 上加一只读表的第二 reader。
      *
-     * 律(设计稿 `design-S-247.md` §2):接管登记**没有引擎腿在等它**(铸它的进程没了,或它活在别的副本上),与活登记同一只状态机 ——
+     * 律(设计稿 `design-[ref].md` §2):接管登记**没有引擎腿在等它**(铸它的进程没了,或它活在别的副本上),与活登记同一只状态机 ——
      * 应答 = 同一把 `decideAsk` CAS({@link answerRegistration}),收敛 = 同一条悬挂轮询腿读行({@link pollSuspendedDecisions});它活多久只由行说了算,
      * 没有自己的窗(无等待腿的行的到期写者已经存在:对账器段二,同一只政策感知终态 claim,窗 + 宽限 —— 接管不新增竞争者)。
      * 「本副本没有引擎腿在等它」机读披露:列表行与应答回执带 `consumerState:"absent"`({@link ASK_DECISION_CONSUMER_ABSENT})。
@@ -2141,26 +2186,26 @@ export declare class ToolApprovalCoordinator {
      */
     adoptOpenAsks(): Promise<OpenAskAdoption>;
     /**
-     * S-247:由一条待决行铸一条接管登记并放进活集合(唯一铸点;读法见 {@link AdoptedRegistrationPart})。事实全部取自行与行上的卡:属主 / 会话(adhoc 替身
+     * [ref]:由一条待决行铸一条接管登记并放进活集合(唯一铸点;读法见 {@link AdoptedRegistrationPart})。事实全部取自行与行上的卡:属主 / 会话(adhoc 替身
      * = taskId 时不投,与按问读口的行投影同读)/ 子代出身(卡 `fromSubagent` ⇒ 行 `sourceTaskId`)/ 窗死线 / 铸造时刻取行;工具名、要人位、治理位、类集取卡;
      * 授予绑定卡上没有 ⇒ `unreadable`(于是站着的答案判据答 `none`:`rememberRefused`,`allow_session` 只放行这一次 —— 既有律);规则素材不在 ⇒ `persistRule`
      * 答 `rule_lane_unavailable`(晚答腿同一个词)。卡面的 `rememberRefused` 与条目同一只判据(活登记那一处的同一条纪律)。
      */
     private registerAdopted;
-    /** S-247:放掉这只 askId 的全部接管登记(不碰行、不发消卡帧)。两个读者:悬挂轮询读到行没了(接管登记没有窗,没有行就没有活着的依据);本副本来了这只问的活登记(它让位)。活登记不动。 */
+    /** [ref]:放掉这只 askId 的全部接管登记(不碰行、不发消卡帧)。两个读者:悬挂轮询读到行没了(接管登记没有窗,没有行就没有活着的依据);本副本来了这只问的活登记(它让位)。活登记不动。 */
     private releaseAdoptedRegistrations;
     /**
-     * S-247:问账里**这只问的行没了**(行被删)⇒ 放掉它的接管登记;放完本副本若已没有这只问的任何登记,经 preamble 订了它的消卡订阅也一并撤掉
+     * [ref]:问账里**这只问的行没了**(行被删)⇒ 放掉它的接管登记;放完本副本若已没有这只问的任何登记,经 preamble 订了它的消卡订阅也一并撤掉
      * (不发帧 —— 问不是被谁答掉的,编一帧消卡就是撒谎;壳的结构补偿仍是下一次 preamble 的全量对账基准)。还有活登记 ⇒ 订阅留给它的结算。
      */
     private forgetAdoptedAsk;
-    /** S-247:接管登记的属主跟行走 —— 悬挂轮询每读到一次仍待决的行就对齐一次(`/v1/adoption` 改写 `approval_ask.owner` 之后,列表面在一拍之内跟上;应答口与读口另读行当下的 owner)。 */
+    /** [ref]:接管登记的属主跟行走 —— 悬挂轮询每读到一次仍待决的行就对齐一次(`/v1/adoption` 改写 `approval_ask.owner` 之后,列表面在一拍之内跟上;应答口与读口另读行当下的 owner)。 */
     private followAdoptedOwner;
     /** 这只 askId 在本副本上有几条**有引擎腿在等**的登记(接管登记不算)—— 轮询腿的「被唤醒数」读它。 */
     private waitingRegistrationCount;
     listLivePending(scope: string | undefined): LivePendingRow[];
     /**
-     * S-751:某只委派子代此刻有没有**待决**的活卡 —— fleet 对账腿「子代活性由属主说了算」的属主②读口(另一只是
+     * [ref]:某只委派子代此刻有没有**待决**的活卡 —— fleet 对账腿「子代活性由属主说了算」的属主②读口(另一只是
      * bg registry 账)。子代卡在一张没人答的卡上时当然不出帧,只看「静默」就会把它当孤儿扫下面板(报案的真形)。
      * 只答是非、不交出 Map(与 `isRunLiveOnThisReplica` 同姿势);纯读,零锁零结算语义。
      * 键 = ask 发起者域(`originTaskId` = core `AskRequest.sourceTaskId` = 子代自己的 core session id),**不是**
@@ -2245,7 +2290,7 @@ export declare class ToolApprovalCoordinator {
     /** [ref]:当前挂着的**悬挂**条目数(零投递集合铸的那一类)——运维/判据读它证「悬挂队列有多长」。 */
     suspendedCount(): number;
     sessionAllowedCount(): number;
-    /** S-247:当前在场的 preamble 消卡订阅(按 askId)数 —— 判据据它证「订阅有界于本副本的登记,没有登记、没有行的问不留订阅」。 */
+    /** [ref]:当前在场的 preamble 消卡订阅(按 askId)数 —— 判据据它证「订阅有界于本副本的登记,没有登记、没有行的问不留订阅」。 */
     presentedCardWatcherCount(): number;
     /** [ref]:当前在场的受理回执数(有界性的可观测面 —— 判据据它证「帽是硬的、过期会被清」)。 */
     parkRedemptionCount(): number;