@sema-agent/server 7.140.0 → 7.142.0

package/dist/approval-card.d.ts

@@ -86,9 +86,9 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
         host: "host";
         name: "name";
         path: "path";
+        pattern: "pattern";
         tool: "tool";
         exact: "exact";
-        pattern: "pattern";
         prefix: "prefix";
         wildcard: "wildcard";
         subpath: "subpath";
@@ -105,9 +105,9 @@ export declare const RuleOfferSchema: z.ZodUnion<readonly [z.ZodObject<{
             host: "host";
             name: "name";
             path: "path";
+            pattern: "pattern";
             tool: "tool";
             exact: "exact";
-            pattern: "pattern";
             prefix: "prefix";
             wildcard: "wildcard";
             subpath: "subpath";
@@ -149,6 +149,15 @@ export interface ReadRuleOffer {
  * 缺席(`undefined`)= 没有提议,答空、不计。展示帽(条数、成员前缀、扫描窗)、脱敏与截长归调用方 —— 它们是各腿的展示纪律,不是读法。
  */
 export declare function readRuleOfferList(raw: unknown): readonly ReadRuleOffer[];
+/**
+ * 一份(已解码的)规则提议列表里,**带着无 `kind` 存量成员**的 batch offer 有几只 —— 判官是 core `readRuleOffers` 给每只读出的 offer 打的 `kindlessForm` 记号
+ * (「这一只 batch 里至少一个成员是经无 `kind` 的存量形读的」;与 {@link readRuleOfferList} 同一只读者,不是本仓自己再写一遍「成员没有 `kind` 键」)。
+ * 起服普查(`approval-batch-census.ts`)用它给存量行记数:读者那条存量臂退役的前提是「零行还靠它读」。
+ *
+ * **只数,不落任何痕迹**:读不出的元素(`dropped`)与整只值不是列表(`problem`)是 {@link readRuleOfferList} 的计数口径(`server.rule-offers.offer-dropped`),这里不重复记,
+ * 它们也不是「靠存量臂读出来」的 —— 一个读不出的无 `kind` 成员(缺文本键)退役前后同样被丢,不改变任何一行的读法,所以不计入。
+ */
+export declare function countKindlessBatchOffers(raw: unknown): number;
 /**
  * 卡面/帧面共用的 offer **投影型**(= {@link RuleOfferSchema} 的输出形)。判别位 `kind` 上闭集,
  * 消费端(SDK/cli 渲染)按 core 契约分臂;`batch.rules` 成员是判别联合(`command` | `directoryRead`),
@@ -441,11 +450,13 @@ export interface AskClassPair {
  * bypass 姿态下按 `ask_rule` / `hook` 照问的那条壳规则无从落地。缺席 = 老行(core 7.5.0 之前 park 的)/ 集外词(计 [ref] tag)。
  * [ref] ②(core 7.37.0 [ref])第六 / 七位 `askClass` / `classes`:这一问的类对(经 {@link readAskClassPair};两位同在同缺,与活卡帧 / 呈卡帧的卡
  * 同名同义同值)—— durable 审批席按类答的依据。缺席 = 老行(core 7.37.0 之前 park 的,续跑不补)/ 读不出(计 [ref] tag)。
- * [ref](core 7.51.0 [ref])第八位 `boundGrantAbsence`:这张卡为什么没有授予绑定摘要(经 {@link readClosedWordSeat};与活卡帧 / inbox 行同名同义同值)——
- * `not_bindable` = 这一问不绑任何授予(「本会话放行」可按工具记)。缺席 = 技能卡(带摘要;摘要与清单、成因词三位走另一只投影 {@link skillCardFacts},见其顶注)/ 7.51.0 之前停驻的行(core inbox 投
- * `unreadable`,队列行如实缺席)/ 集外词(计 [ref] tag)。
+ * [ref](core 7.51.0 [ref])第八位 `boundGrantAbsence` / [ref] 起与 `boundGrantDigest` 合成**一臂**:这张卡的授予绑定 —— `tool_approval` 行**恰带**两者之一,
+ * 经本仓唯一读口 `grantBindingOf` 读停驻行、`grantBindingArm` 投回(`standing-answer-grant.ts`;与 core 投 inbox 行的那一臂逐形同值):摘要是串 ⇒ 摘要;
+ * 否则摘要键不在且行上的词是闭集成员 ⇒ 那个词;否则(7.51.0 之前停驻的行两者都不说 / 集外词 / 摘要在却不是串)⇒ `unreadable`。`not_bindable` = 这一问不绑任何授予
+ * (「本会话放行」可按工具记)。摘要读自停驻行本身 —— 不靠整行的检查点摘要,所以 SQL 腿那一次整行读失败也不丢这一臂;要 core 校验的清单与成因词走
+ * 另一只投影 {@link skillCardFacts}。
  */
-export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "ruleOffersAbsence" | "mandated" | "mandate" | "origin" | "askClass" | "classes" | "boundGrantAbsence">;
+export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "ruleOffersAbsence" | "mandated" | "mandate" | "origin" | "askClass" | "classes" | "boundGrantDigest" | "boundGrantAbsence">;
 /**
  * [ref] —— park 行事实的**唯一投影**(`pendingAction` 是寄存行上 core 铸的那一只,读自持久层 ⇒ `unknown`)。
  *
@@ -465,7 +476,8 @@ export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "rule
  *    park 孪生座与同步座是 core 同一个 factory 铸的同一闭集,不另起第二份词表;
  *  · `mandate` / `origin` —— 经 {@link readClosedWordSeat}(一座一只 core 成员筛 `isPersistedRuleMandate` / `isAskOrigin`,与 core
  *    `summarizeCheckpoint` 投 inbox 行时是同一只筛 ⇒ 两条耐久读面对同一张行同答;集外词读作缺席 + 计同一个集外 tag);
- *  · 缺席 ≠ false:各位都只在「真 / 有词」时在场,消费端读**在场**。
+ *  · 授予绑定([ref])—— 不是「在场才带」的一位,是恰一臂:`grantBindingArm(grantBindingOf(行))`,读法见 {@link ParkRowFacts} 顶注;
+ *  · 缺席 ≠ false:其余各位都只在「真 / 有词」时在场,消费端读**在场**。
  *
  * 🔴 **这是展示/分诊投影,不是权限判据**(core 对两位的定性都是 display metadata:「the resume belts keep reading
  * the gate's own bit」)。本投影对「在场却读不出」的方向是**缺席**(卡上少一行 ≪ 卡上出现生词);一条要从
@@ -474,28 +486,31 @@ export type ParkRowFacts = Pick<ToolApprovalPark, "requiresRealApproval" | "rule
  */
 export declare function parkRowFacts(stored: unknown): ParkRowFacts;
 /**
- * 🔴 **技能卡三位的唯一投影**:授予绑定摘要 `boundGrantDigest`、它哈希的清单 `boundGrants`、分类器没给判词的成因 `classifierNoRuling` ——
+ * 🔴 **技能卡两位的唯一投影**:授予绑定摘要哈希的那一份清单 `boundGrants`、分类器没给判词的成因 `classifierNoRuling` ——
  * 助手收件箱行(`GET /v1/assistant/inbox`)、运维队列行(`GET /v1/approvals` 的 `pending[]`)、`/v1/approvals/stream` 的 `pending` 帧三张停驻读面
  * **经这一只函数**投它们。同一张停驻的技能卡于是三面同一份字节:运维从队列决这张卡时,看得到批准它还授予了什么。
+ * (摘要本身 `boundGrantDigest` 不在这里:它是授予绑定那一臂的一半,队列两面经 {@link parkRowFacts} 从停驻行读 —— core 对串摘要也是原样回显,值相同;
+ * [ref] 起这样分,是为了那一臂不依赖整行的检查点摘要读得到读不到。)
  *
- * **输入恒是 core 的检查点摘要**({@link CoreCheckpointSummary},`summarizeCheckpoint` 的产物)—— 三位的校验点单点在 core:摘要是串才回显;清单**只在哈希等于摘要时**才发布
+ * **输入恒是 core 的检查点摘要**({@link CoreCheckpointSummary},`summarizeCheckpoint` 的产物)—— 两位的校验点单点在 core:清单**只在哈希等于摘要时**才发布
  * (「never a list beside a digest that binds another」—— 一份与摘要对不上的清单会让批准人看着一份清单、批的却是另一份绑定);成因词只在闭集成员时回显。
- * 本仓**不重算哈希**(core 的 `boundInputHashOf` 不在公开导出面上,清单校验读口 `readBoundBinding` 同样不导出),所以**不许**拿寄存行 `pendingAction` 上的原值直接投 ——
- * 原值上的清单是未经哈希校验的(这正是三位此前不上队列行的原因,见 `trace/core-keyset-guard.ts` ⑧b 记账的旧注)。两只店各自拿到「这一行的摘要」的办法不同
- * (LOCAL 孪生本来就握着 core 对同一行投的摘要;SQL 孪生对带三位之一的行读一次该行再调 core 的 `summarizeCheckpoint`,见 `plugins/checkpoint-store-sql.ts`),
+ * 本仓**不重算哈希**(core 的 `boundInputHashOf` 不在公开导出面上,清单校验读口 `readBoundBinding` 同样不导出),所以**不许**拿寄存行 `pendingAction` 上的原清单直接投 ——
+ * 原值上的清单是未经哈希校验的(这正是它此前不上队列行的原因,见 `trace/core-keyset-guard.ts` ⑧b 记账的旧注)。两只店各自拿到「这一行的摘要」的办法不同
+ * (LOCAL 孪生本来就握着 core 对同一行投的摘要;SQL 孪生对可能带两位之一的行读一次该行再调 core 的 `summarizeCheckpoint`,见 `plugins/checkpoint-store-sql.ts`),
  * 但投影只有这一只:OMIT 契约 —— 缺席即缺席,恒不铸 `undefined` 值的键。
  *
  * `boundGrants` 是**部署文本**(技能名、清单条目):本函数不脱敏、不转义,与收件箱行逐字同口径 —— 渲染按上下文转义是客户端的事(契约同句)。
- * 三位都不进 `card_json`(同步路铸点,另一条纪律)。
+ * 两位都不进 `card_json`(同步路铸点,另一条纪律)。
  *
- * 🚧 清单校验读口 `readBoundBinding` 若成为 core 的公开导出,SQL 孪生那一次整行读与 {@link parkRowCarriesSkillCardFacts} 一并退役:`parkRowFacts` 直接读寄存行原值经 core 的读口投三位。
+ * 🚧 清单校验读口 `readBoundBinding` 若成为 core 的公开导出,SQL 孪生那一次整行读与 {@link parkRowCarriesSkillCardFacts} 一并退役:`parkRowFacts` 直接读寄存行原值经 core 的读口投两位
+ * (`grantBindingOf` 也改成它的薄包装 —— 那时 core 是绑定读法的唯一属主)。
  */
-export type SkillCardFacts = Pick<CoreCheckpointSummary, "boundGrantDigest" | "boundGrants" | "classifierNoRuling">;
+export type SkillCardFacts = Pick<CoreCheckpointSummary, "boundGrants" | "classifierNoRuling">;
 export declare function skillCardFacts(summary: SkillCardFacts): SkillCardFacts;
 /**
- * 这一行的寄存行(`pendingAction`,读自持久层 ⇒ `unknown`)**有没有可能**让 core 的摘要投出三位里的任何一位 —— 只回答「值不值得为它取一次摘要」,**不投值**:
- * `tool_approval` 臂上摘要字段是串(core 只在这时回显摘要与清单),或成因词键在场(是不是闭集成员由 core 的摘要判)。判错的方向只有一个 —— 多取一次摘要(摘要读数为空),
- * 绝不漏取:摘要字段不是串 ⇒ core 的摘要既无摘要也无清单;成因词键不在 ⇒ 无成因词 —— 两者都不满足的行,摘要里这三位恒空。普通卡(绝大多数行)因此零额外读。
+ * 这一行的寄存行(`pendingAction`,读自持久层 ⇒ `unknown`)**有没有可能**让 core 的摘要投出两位里的任何一位 —— 只回答「值不值得为它取一次摘要」,**不投值**:
+ * `tool_approval` 臂上摘要字段是串(core 只在这时回显清单),或成因词键在场(是不是闭集成员由 core 的摘要判)。判错的方向只有一个 —— 多取一次摘要(摘要读数为空),
+ * 绝不漏取:摘要字段不是串 ⇒ core 的摘要没有清单;成因词键不在 ⇒ 无成因词 —— 两者都不满足的行,摘要里这两位恒空。普通卡(绝大多数行)因此零额外读。
  * 只读键在不在 / 是不是串,不读值的内容,所以不需要 {@link readClosedWordSeat} 那样的计数。
  */
 export declare function parkRowCarriesSkillCardFacts(stored: unknown): boolean;
@@ -556,12 +571,12 @@ export declare const ApprovalCardSchema: z.ZodObject<{
         question: "question";
         plan: "plan";
         skill: "skill";
-        workflow: "workflow";
         "file-edit": "file-edit";
         "file-write": "file-write";
         "notebook-edit": "notebook-edit";
         shell: "shell";
         fetch: "fetch";
+        workflow: "workflow";
         generic: "generic";
     }>>;
     inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
@@ -583,9 +598,9 @@ export declare const ApprovalCardSchema: z.ZodObject<{
             host: "host";
             name: "name";
             path: "path";
+            pattern: "pattern";
             tool: "tool";
             exact: "exact";
-            pattern: "pattern";
             prefix: "prefix";
             wildcard: "wildcard";
             subpath: "subpath";
@@ -602,9 +617,9 @@ export declare const ApprovalCardSchema: z.ZodObject<{
                 host: "host";
                 name: "name";
                 path: "path";
+                pattern: "pattern";
                 tool: "tool";
                 exact: "exact";
-                pattern: "pattern";
                 prefix: "prefix";
                 wildcard: "wildcard";
                 subpath: "subpath";
@@ -710,12 +725,12 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
             question: "question";
             plan: "plan";
             skill: "skill";
-            workflow: "workflow";
             "file-edit": "file-edit";
             "file-write": "file-write";
             "notebook-edit": "notebook-edit";
             shell: "shell";
             fetch: "fetch";
+            workflow: "workflow";
             generic: "generic";
         }>>;
         inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
@@ -737,9 +752,9 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
                 host: "host";
                 name: "name";
                 path: "path";
+                pattern: "pattern";
                 tool: "tool";
                 exact: "exact";
-                pattern: "pattern";
                 prefix: "prefix";
                 wildcard: "wildcard";
                 subpath: "subpath";
@@ -756,9 +771,9 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
                     host: "host";
                     name: "name";
                     path: "path";
+                    pattern: "pattern";
                     tool: "tool";
                     exact: "exact";
-                    pattern: "pattern";
                     prefix: "prefix";
                     wildcard: "wildcard";
                     subpath: "subpath";

package/dist/approval-card.js

@@ -4,6 +4,7 @@ import { redactSecrets } from "./trace/redact.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { readApprovalCard } from "./approval-content-kind.js";
 import { capText } from "./caller-text-echo.js";
+import { grantBindingArm, grantBindingOf } from "./standing-answer-grant.js";
 import { retireParkArmWords, retireStoredCardWords } from "./retired-card-words.js";
 export const MAX_AGENT_NAME = 200;
 const MAX_IDENT = 200;
@@ -61,6 +62,10 @@ export function readRuleOfferList(raw) {
     reading.dropped.forEach((d) => recordOfferDropped(d.problem, d.index));
     return reading.offers.map(withDetailSeatBounded);
 }
+export function countKindlessBatchOffers(raw) {
+    const reading = readRuleOffers(raw);
+    return "problem" in reading ? 0 : reading.offers.filter((o) => o.kindlessForm === true).length;
+}
 function withoutOverCapDetailSeat(item, index) {
     if (typeof item !== "object" || item === null)
         return item;
@@ -335,7 +340,6 @@ export function parkRowFacts(stored) {
     const mandate = readClosedWordSeat(pendingAction, "mandate");
     const origin = readClosedWordSeat(pendingAction, "origin");
     const askClassPair = readAskClassPair(pendingAction);
-    const boundGrantAbsence = readClosedWordSeat(pendingAction, "boundGrantAbsence");
     return {
         ...(readParkRowTrueSeat(pendingAction, "requiresRealApproval") ? { requiresRealApproval: true } : {}),
         ...(readParkRowTrueSeat(pendingAction, "mandated") ? { mandated: true } : {}),
@@ -343,12 +347,11 @@ export function parkRowFacts(stored) {
         ...(origin !== undefined ? { origin } : {}),
         ...(ruleOffersAbsence !== undefined ? { ruleOffersAbsence } : {}),
         ...(askClassPair ?? {}),
-        ...(boundGrantAbsence !== undefined ? { boundGrantAbsence } : {}),
+        ...grantBindingArm(grantBindingOf(pendingAction)),
     };
 }
 export function skillCardFacts(summary) {
     return {
-        ...(summary.boundGrantDigest !== undefined ? { boundGrantDigest: summary.boundGrantDigest } : {}),
         ...(summary.boundGrants !== undefined ? { boundGrants: summary.boundGrants } : {}),
         ...(summary.classifierNoRuling !== undefined ? { classifierNoRuling: summary.classifierNoRuling } : {}),
     };

package/dist/approval-crash-convergence.d.ts

@@ -1,6 +1,7 @@
 import type { ApprovalAskStore } from "./plugins/approval-ask-store-sql.js";
 import { FileApprovalAskAuditStore } from "./approval-ask-audit-store.js";
 import { type HolderGoneCause } from "./approval-deny-reasons.js";
+import { type ReconcileCheckpointPort } from "./approval-reconciler.js";
 import { type RunStoreReader } from "./user-input-ledger.js";
 import type { Logger } from "./observability/logger.js";
 /** 启动收敛的读数(进启动日志)。 */
@@ -10,17 +11,19 @@ export interface CrashConvergenceReport {
     readonly decided: number;
     readonly inconsistent: number;
     readonly corruptLines: number;
-    /** ask 账半场:按成因词计的、本次收成 VOID 的前世 `STREAM_PENDING` 行数。 */
+    /** ask 账半场:按成因词计的、本次收成 VOID 的前世 `STREAM_PENDING` 行与审计判孤儿的 `PARKING` 行数。 */
     readonly asksVoided: Readonly<Record<HolderGoneCause, number>>;
+    /** 审计判孤儿的 `PARKING` 行里判据 ① 命中、收成 `PARKED` 的行数(停车行其实已提交;每行另有一行 warn 点名)。 */
+    readonly parkingBound: number;
     /** 其中卡信封读不出、成因词是回落(`crashed_before_park`)的行数(同时记 fail-open tag)。 */
     readonly causeUnreadable: number;
 }
 /** 本次收成 VOID 的行数合计 —— 由成因闭集派生(对 `asksVoided` 的每个词求和;闭集加词不需要改这里)。 */
 export declare function totalAsksVoided(report: Pick<CrashConvergenceReport, "asksVoided">): number;
-/** 本函数读写的那几口(窄形:测试可以直给一只内存店)。 */
-export type CrashConvergenceAskPort = Pick<ApprovalAskStore, "listByState" | "transitionAsk">;
-/** 审计店的两口(收敛半场 + 成因判点)。 */
-export type CrashConvergenceAuditPort = Pick<FileApprovalAskAuditStore, "convergeCrashedAsks" | "causeFor">;
+/** 本函数读写的那几口(窄形:测试可以直给一只内存店)。`getBatch` / `bindBatch` 是判据 ① 执行体的两口。 */
+export type CrashConvergenceAskPort = Pick<ApprovalAskStore, "listByState" | "transitionAsk" | "getBatch" | "bindBatch">;
+/** 审计店的两口(收敛半场 + 持有者没了的判点)。 */
+export type CrashConvergenceAuditPort = Pick<FileApprovalAskAuditStore, "convergeCrashedAsks" | "holderGoneVerdict">;
 /**
  * 启动收敛读哪一份**审计证据**:活的审计店在场就用它;不在场(这一世 `TOOL_APPROVAL_ENABLED` 关着 ⇒ 装配三合取不成立)而盘上有前世的审计账本
  * ⇒ 开一只读它 —— 成因是盘上证据的函数,不随这一世的开关变(否则前世有序关停截断的问在这一世被写成 `crashed_before_park`,审批重新打开那天审计读面
@@ -32,12 +35,16 @@ export declare function openAuditEvidenceForConvergence(live: CrashConvergenceAu
     release: () => void;
 };
 /**
- * 启动收敛(见文件头)。只在数据根独占的车道上调,且必须在本进程铸出第一问之前。幂等跨启动:收过的行已不是 `STREAM_PENDING`,
- * 审计半场有自己的收敛锚;成因读冻结的前世审计账 ⇒ 半途崩溃再启,剩下的行得到与第一次相同的词。
+ * 启动收敛(见文件头)。只在数据根独占的车道上调,且必须在本进程铸出第一问之前。幂等跨启动:收过的行已不在 `STREAM_PENDING` / `PARKING`,
+ * 审计半场有自己的收敛锚;判定与成因读冻结的前世审计账 ⇒ 半途崩溃再启,剩下的行得到与第一次相同的判定与词。
+ * `checkpoints` = 判据 ① 的候选读口,必填、不可缺席(装配点交后端的只读口 `checkpointReadView()`;没有 checkpoint 店的后端交恒空读口):缺席会让判据 ① 恒不命中、
+ * 把已提交的停车行收成 VOID,所以既不给缺省,也不收 `undefined`。
  */
 export declare function convergeCrashedAsksAtBoot(input: {
     askStore: CrashConvergenceAskPort | undefined;
     audit: CrashConvergenceAuditPort | undefined;
+    checkpoints: ReconcileCheckpointPort;
+    logger: Pick<Logger, "warn">;
     now?: () => number;
 }): Promise<CrashConvergenceReport>;
 /**
@@ -45,12 +52,15 @@ export declare function convergeCrashedAsksAtBoot(input: {
  *  · 只在数据根独占的车道上跑 —— 车道事实与用户输入受理账本同一只 `writerGoneEvidenceFor`(local ⇒ `exclusive_data_root`);SQL 车道整步不做。
  *  · ask 店取 `backend.approvalAsk()`,**不看协议开关**:前世开着协议留下的行,今世关着也照收(否则重新打开协议那天它们又变得可决)。
  *  · 审计证据经 {@link openAuditEvidenceForConvergence}(这一世的审批开关不改变成因)。
+ *  · 判据 ① 的候选读口 = 后端的只读口 `backend.checkpointReadView()`,**不看 `DURABLE_APPROVAL`**(前世已提交的停驻不因这一世的开关消失;local 车道它与 durable 装配的那只是同一只店,
+ *    只是不接 run 店的收割探针)。
  *  · 有任何收敛 / 坏行 ⇒ 一行 warn `approval_ask_audit_crash_converged`(零动作不打)。收敛写入抛错 ⇒ 抛出 ⇒ 拒启。
  */
 export declare function runBootCrashConvergence(ctx: {
     backend: {
         readonly kind: "mysql" | "pg" | "local";
         approvalAsk(): CrashConvergenceAskPort;
+        checkpointReadView(): ReconcileCheckpointPort;
     } | undefined;
     runStore: RunStoreReader | undefined;
     liveAudit: CrashConvergenceAuditPort | undefined;

package/dist/approval-crash-convergence.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { APPROVAL_ASK_AUDIT_DIR, APPROVAL_ASK_AUDIT_LEDGER, FileApprovalAskAuditStore } from "./approval-ask-audit-store.js";
 import { readStoredCardEnvelope } from "./approval-card.js";
 import { APPROVAL_ENDING_CAUSES } from "./approval-deny-reasons.js";
+import { bindParkingAskAtGate } from "./approval-reconciler.js";
 import { writerGoneEvidenceFor } from "./user-input-ledger.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 const CONVERGE_PAGE = 500;
@@ -17,57 +18,128 @@ export function openAuditEvidenceForConvergence(live, localDataRoot) {
     const opened = new FileApprovalAskAuditStore(localDataRoot);
     return { audit: opened, release: () => opened.close() };
 }
+async function forEachRowInState(store, state, visit) {
+    const seen = new Set();
+    let stayed = 0;
+    for (;;) {
+        const page = (await store.listByState(state, stayed + CONVERGE_PAGE)).filter((r) => !seen.has(r.askId));
+        if (page.length === 0)
+            return;
+        for (const row of page) {
+            seen.add(row.askId);
+            if (!(await visit(row)))
+                stayed += 1;
+        }
+    }
+}
+function refusingToStart(state, row, err) {
+    return new Error(`approval crash convergence: could not close the previous process's ${state === "STREAM_PENDING" ? "pending" : "parking"} approval ask ${row.askId} (task ${row.taskId}): ` +
+        `${err instanceof Error ? err.message : String(err)} — refusing to start, because serving now would leave a card that nothing waits for ` +
+        "decidable with a 200. Fix the data root (disk full / read-only?) and start again.");
+}
 export async function convergeCrashedAsksAtBoot(input) {
     const now = input.now ?? Date.now;
-    const audited = input.audit?.convergeCrashedAsks() ?? { pending: 0, decided: 0, inconsistent: 0, corruptLines: 0 };
+    const audit = input.audit;
+    const audited = audit?.convergeCrashedAsks() ?? { pending: 0, decided: 0, inconsistent: 0, corruptLines: 0 };
     const asksVoided = { [APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK]: 0, [APPROVAL_ENDING_CAUSES.SHUTDOWN_BEFORE_PARK]: 0 };
     let causeUnreadable = 0;
+    let parkingBound = 0;
     const store = input.askStore;
     if (store !== undefined) {
-        const seen = new Set();
-        for (;;) {
-            const page = (await store.listByState("STREAM_PENDING", CONVERGE_PAGE)).filter((r) => !seen.has(r.askId));
-            if (page.length === 0)
-                break;
-            for (const row of page) {
-                seen.add(row.askId);
+        await forEachRowInState(store, "STREAM_PENDING", async (row) => {
+            const envelope = readStoredCardEnvelope(row.cardJson);
+            if (envelope === undefined) {
+                causeUnreadable += 1;
+                recordFailOpen("server.approval-crash-convergence.cause-unreadable", `ask ${row.askId} (task ${row.taskId}): card envelope unreadable — cause defaulted to ${APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK}`);
+            }
+            const reason = envelope !== undefined && audit !== undefined ? audit.holderGoneVerdict(envelope.approvalId).cause : APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK;
+            let won;
+            try {
+                won = await store.transitionAsk(row.askId, "STREAM_PENDING", "VOID", { endingCause: reason, updatedAtMs: now() });
+            }
+            catch (err) {
+                throw refusingToStart("STREAM_PENDING", row, err);
+            }
+            if (won)
+                asksVoided[reason] += 1;
+            return true;
+        });
+        if (audit !== undefined) {
+            const orphanOf = (row) => {
                 const envelope = readStoredCardEnvelope(row.cardJson);
-                if (envelope === undefined) {
-                    causeUnreadable += 1;
-                    recordFailOpen("server.approval-crash-convergence.cause-unreadable", `ask ${row.askId} (task ${row.taskId}): card envelope unreadable — cause defaulted to ${APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK}`);
+                if (envelope === undefined)
+                    return undefined;
+                const verdict = audit.holderGoneVerdict(envelope.approvalId);
+                return verdict.orphan ? { approvalId: envelope.approvalId, cause: verdict.cause } : undefined;
+            };
+            let voidedSiblings = [];
+            const gate = {
+                askStore: store,
+                checkpoints: input.checkpoints,
+                warn: (event, fields) => input.logger.warn(event, fields),
+                revoke: (_row, askIds) => {
+                    voidedSiblings = askIds;
+                },
+            };
+            await forEachRowInState(store, "PARKING", async (row) => {
+                const orphan = orphanOf(row);
+                if (orphan === undefined)
+                    return false;
+                voidedSiblings = [];
+                let bound;
+                try {
+                    bound = (await bindParkingAskAtGate(gate, row, now())).bound;
                 }
-                const reason = envelope !== undefined && input.audit !== undefined ? input.audit.causeFor(envelope.approvalId) : APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK;
+                catch (err) {
+                    throw refusingToStart("PARKING", row, err);
+                }
+                if (!bound)
+                    return false;
+                parkingBound += 1;
+                input.logger.warn("approval_crash_convergence_park_committed", {
+                    askId: row.askId,
+                    taskId: row.taskId,
+                    approvalId: orphan.approvalId,
+                    voidedSiblings,
+                    note: "the audit ledger saw no settlement for this approval ask (an orphan of the previous process), but its park row had committed — bound PARKED, decidable through the durable approval endpoint; the commit landed in the window between the park commit and its observation. Same-batch siblings still parking were voided as superseded by this park (batch_bound_elsewhere)",
+                });
+                return true;
+            });
+            await forEachRowInState(store, "PARKING", async (row) => {
+                const orphan = orphanOf(row);
+                if (orphan === undefined)
+                    return false;
                 let won;
                 try {
-                    won = await store.transitionAsk(row.askId, "STREAM_PENDING", "VOID", { deniedReason: reason, updatedAtMs: now() });
+                    won = await store.transitionAsk(row.askId, "PARKING", "VOID", { endingCause: orphan.cause, updatedAtMs: now() });
                 }
                 catch (err) {
-                    throw new Error(`approval crash convergence: could not close the previous process's pending approval ask ${row.askId} (task ${row.taskId}): ` +
-                        `${err instanceof Error ? err.message : String(err)} — refusing to start, because serving now would leave a card that nothing waits for ` +
-                        "decidable with a 200. Fix the data root (disk full / read-only?) and start again.");
+                    throw refusingToStart("PARKING", row, err);
                 }
                 if (won)
-                    asksVoided[reason] += 1;
-            }
+                    asksVoided[orphan.cause] += 1;
+                return true;
+            });
         }
     }
-    return { ...audited, asksVoided, causeUnreadable };
+    return { ...audited, asksVoided, causeUnreadable, parkingBound };
 }
 export async function runBootCrashConvergence(ctx) {
     const { backend, runStore, logger } = ctx;
     if (backend === undefined || runStore === undefined || writerGoneEvidenceFor(backend.kind, runStore).kind !== "exclusive_data_root")
         return undefined;
     const evidence = openAuditEvidenceForConvergence(ctx.liveAudit, ctx.localDataRoot);
-    const converged = await convergeCrashedAsksAtBoot({ askStore: backend.approvalAsk(), audit: evidence.audit }).finally(evidence.release);
-    if (converged.pending > 0 || converged.decided > 0 || converged.inconsistent > 0 || converged.corruptLines > 0 || totalAsksVoided(converged) > 0) {
+    const converged = await convergeCrashedAsksAtBoot({ askStore: backend.approvalAsk(), audit: evidence.audit, checkpoints: backend.checkpointReadView(), logger }).finally(evidence.release);
+    if (converged.pending > 0 || converged.decided > 0 || converged.inconsistent > 0 || converged.corruptLines > 0 || totalAsksVoided(converged) > 0 || converged.parkingBound > 0) {
         logger.warn("approval_ask_audit_crash_converged", {
             pending: converged.pending,
             decided: converged.decided,
             inconsistent: converged.inconsistent,
             corruptLines: converged.corruptLines,
             asksVoided: converged.asksVoided,
+            parkingBound: converged.parkingBound,
             causeUnreadable: converged.causeUnreadable,
-            note: "approval asks left pending by the previous process were converged: each such ask is now VOID in the ask ledger (the decision endpoint answers 410 gone.ask with this cause) and is listed under GET /v1/approvals crashConverged when the audit ledger saw it (cause crashed_before_park = the process crashed; cause shutdown_before_park = an orderly shutdown cut the leg off before it closed or before its park committed)",
+            note: "approval asks left by the previous process were converged: each pending ask, and each parking ask the audit ledger judged an orphan, is now VOID in the ask ledger (the decision endpoint answers 410 gone.ask with this cause) and is listed under GET /v1/approvals crashConverged when the audit ledger saw it (cause crashed_before_park = the process crashed; cause shutdown_before_park = the previous process completed its orderly shutdown wind-down while the ask was still unsettled); a parking ask whose park row had committed is bound PARKED instead",
         });
     }
     return converged;

package/dist/approval-deny-reasons.d.ts

@@ -3,10 +3,10 @@
  *
  * ## 它治的病(同一件事、四张词表、一词多义)
  * 一张卡没被人答就结束了,今天有四个读面各说各话:审计 settle 行(`expired` 一词盖 TTL 到期 / run 取消 / run 退出清理 / 广播全灭,批内兄弟被撤卡也是同一个词)、
- * 问账 VOID/DENIED 行(`denied_reason` 列)、晚答 404 的判别位、决断口 409 的码(多种成因借 `approval_binding_mismatch` 一个名)。壳读账写不出「已取消」,
+ * 问账 VOID/DENIED 行(成因列)、晚答 404 的判别位、决断口 409 的码(多种成因借 `approval_binding_mismatch` 一个名)。壳读账写不出「已取消」,
  * 也分不出「重取坐标再决」与「改答案再决」。收成**一张表、一个词、各面同读**:
  *  · 审计 settle 行的 `cause`(非人结局必填,人答缺席;`settle(verdict)` 判别联合逼每个非人调用点点名一个)与活卡结局帧 `tool_approval_complete` 的 additive `cause`(同一个词,同一条律);
- *  · 问账 VOID/DENIED 行的 `denied_reason` 列 → 决断口 410 `gone.ask` 体的 `cause` 与晚答 404 体的 `cause`(读同一列,经唯一读口 {@link causeOfAskRow});
+ *  · 问账 VOID/DENIED 行的 `ending_cause` 列 → 决断口 410 `gone.ask` 体的 `cause` 与晚答 404 体的 `cause`(读同一列,经唯一读口 {@link askRowEndingCause});
  *  · `GET /v1/approvals` `crashConverged[].cause`(本表的 {@link HolderGoneCause} 两词子集);
  *  · 决断口 409 的码:`binding_changed` / `answer_invalid` / `outcome_cell_invalid` 三词各归一个码。`retriable` 不由成因说 —— 三词都出自 core 的
  *    `checkpoint.invalid_outcome`,由 `http/resume-legs.ts` 的 core 码 → 处置一张表派生(一个意思:卡仍 pending、行重新 park)。
@@ -16,8 +16,9 @@
  *  · 成因**只从事实读**:run 行 `errorCode:"cancelled"`、钟到、emit 零接收、停车行 / 问账行的列、`detail.field`;不读拒句散文。
  *  · 「停驻行的格式比本引擎新」**不是**本表的词:它只有 core 一个来源(`checkpoint.unsupported_version` + `detail.reason:"version_newer"`,原码镜像);服务层不从续跑上下文的写者版本推断成因。
  *  · **人答的结局(`allowed` / `denied`)没有 cause**:`cause` 在场 ⇔ 非人结局。
- *  · 落列面:问账行的成因写进 `approval_ask.denied_reason`(VARCHAR(64)),一列按 `state` 承载两种意思 —— VOID / DENIED 行上是**终态成因**,PARKING / PARKED 行上是
- *    **转 park 的触发成因**;读它只经 {@link causeOfAskRow}(按 state 穷举分派,两张读词表只被它读)。列名将在下一个 DDL 窗按意义改名。
+ *  · 落列面:问账行的成因落**两列,一列一义**(各 VARCHAR(64)):`approval_ask.ending_cause` = **终态成因**(这一行为什么没被人答就结束了;到 `VOID` / `DENIED` 的转移带着它写),
+ *    `approval_ask.park_trigger` = **转 park 的触发成因**(这一行为什么被转进投递面;只由那一次 `claimTerminal(expire, { cause })` 写,此后不再被写 —— 终态不覆盖它)。
+ *    两只读口各读一列:{@link askRowEndingCause} / {@link askRowParkTrigger}(两张读词表各只被一只读)。
  *
  * ## 为什么 `routing_failure_fail_closed` 也在表里(归因诚实性)
  * 审计面唯一能证明「超时永不产生 denial」的东西是**终态 + 成因**的组合:人拒恒为 `DECIDED(decision=deny)`,路由失败恒为 `DENIED(routing_failure_fail_closed)`,
@@ -71,11 +72,15 @@ export declare const APPROVAL_ENDING_CAUSES: {
      */
     readonly ROUTING_FAILURE: "routing_failure_fail_closed";
     /**
-     * 启动收敛(`approval-crash-convergence.ts`,local 车道):**承载这一问的进程没了** —— 前世进程崩溃 / 被杀,留下的 `STREAM_PENDING` 行在下一次启动、任何卡能开始之前收成 VOID。
-     * 证据是数据根 `LOCK`(前世写者全死),不是「等够久了」。值与 `GET /v1/approvals` `crashConverged[].cause` 是**同一个词**。
+     * 启动收敛(`approval-crash-convergence.ts`,local 车道):**承载这一问的进程没了** —— 前世进程崩溃 / 被杀,留下的 `STREAM_PENDING` 行与审计判为孤儿的 `PARKING` 行
+     * (停车行没提交)在下一次启动、任何卡能开始之前收成 VOID。证据是数据根 `LOCK`(前世写者全死)+ 审计账的孤儿判定,不是「等够久了」。
+     * 值与 `GET /v1/approvals` `crashConverged[].cause` 是**同一个词**(一处判:审计店的 `holderGoneVerdict`)。
      */
     readonly CRASHED_BEFORE_PARK: "crashed_before_park";
-    /** 同上,但承载它的腿是被**有序关停**截断的(审计账本上有本腿的关停记号;关停收尾没能在宽限窗内把这张卡结清),或有序关停期间这张卡被改路停驻(settle 行的成因)。 */
+    /**
+     * 同上,但前世走完了**有序关停**的审批收尾(审计账本上那一世的进程级关停记录落在这张卡的末事件之后 —— 收尾没能在宽限窗内把它结清;是进程的事实,
+     * 不看承载它的腿在不在追踪视野里),或有序关停期间这张卡被改路停驻(settle 行 / 问账行 PARKING 的触发成因)。
+     */
     readonly SHUTDOWN_BEFORE_PARK: "shutdown_before_park";
     /** 判据 5:任何在 `STREAM_APPROVAL_ORPHAN_TTL_MS` 内仍未收敛的 `PARKING` 行(量 immutable 的 `createdAtMs`,§9 C5)—— 遗孤最终可判的最后兜底,带一条 warn。 */
     readonly ORPHAN_TTL_EXCEEDED: "orphan_ttl_exceeded";
@@ -117,7 +122,7 @@ export declare const SETTLE_CAUSE_WORDS: {
 };
 /** 一个值是不是非人结局的成因词(审计账读盘用这一只判词)。 */
 export declare function isSettleCause(v: unknown): v is SettleCause;
-/** 「承载这一问的进程没了」的两个成因词(启动收敛写进问账行 `denied_reason`,审计收敛行 `cause` 读同一型)。 */
+/** 「承载这一问的进程没了」的两个成因词(启动收敛写进问账行 `ending_cause`(前世的 `STREAM_PENDING` 与审计判孤儿的 `PARKING`),审计收敛行 `cause` 读同一型)。 */
 export type HolderGoneCause = typeof APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK | typeof APPROVAL_ENDING_CAUSES.SHUTDOWN_BEFORE_PARK;
 /** 对账器 `DENIED` 终态的成因(单员:全仓 DENIED 只有一个写点)。 */
 export type ReconcileDenyCause = typeof APPROVAL_ENDING_CAUSES.ROUTING_FAILURE;
@@ -128,7 +133,7 @@ export type ReconcileVoidCause = typeof APPROVAL_ENDING_CAUSES.RUN_CANCELLED | t
  * (取消赢下 VOID ⇒ `run_cancelled` / `run_exited`,兄弟被撤卡 ⇒ `batch_sibling_withdrawn`)。窗到期 / 广播全灭 / 决断类的词只落审计 settle 行或 409 码,不落这一列。
  */
 export type AskRowEndingCause = ReconcileDenyCause | ReconcileVoidCause | HolderGoneCause | typeof APPROVAL_ENDING_CAUSES.RUN_EXITED | typeof APPROVAL_ENDING_CAUSES.BATCH_SIBLING_WITHDRAWN;
-/** 问账行 `denied_reason` 列在 VOID / DENIED 行上的读词表({@link AskRowEndingCause} 的穷举,`satisfies` ⇒ 子集加词而本表没跟 = 编译红)。唯一读者 = {@link causeOfAskRow}。 */
+/** 问账行 `ending_cause` 列的读词表({@link AskRowEndingCause} 的穷举,`satisfies` ⇒ 子集加词而本表没跟 = 编译红)。唯一读者 = {@link askRowEndingCause}。 */
 export declare const ASK_ROW_ENDING_CAUSE_WORDS: {
     readonly routing_failure_fail_closed: true;
     readonly run_cancelled: true;
@@ -142,12 +147,12 @@ export declare const ASK_ROW_ENDING_CAUSE_WORDS: {
     readonly shutdown_before_park: true;
 };
 /**
- * `expire` 终局 claim(窗到期 / 广播全灭 / 有序关停把一张卡转投递面 = `PARKING`)赢下时写进这一行 `denied_reason` 的**触发成因**:这一行此后若走到 `DENIED` / `VOID`,终态成因会覆盖它
- * ({@link AskRowEndingCause});`PARKED` 行的这一格就是「它为什么被转 park」。跨副本的读者(另一进程的悬挂腿轮询、CAS 败方读数)读到 `PARKING` / `PARKED` 时靠它归因,
- * 不替没写的行猜一个词。
+ * `expire` 终局 claim(窗到期 / 广播全灭 / 断连 / 呈不出 / 有序关停把一张卡转投递面 = `PARKING`)赢下时写进这一行 `park_trigger` 的**触发成因**:此后不再被写 ——
+ * 这一行走到 `PARKED` / `DENIED` / `VOID` 之后它仍是「这一行为什么被转 park」(终态成因在另一列,{@link AskRowEndingCause})。跨副本的读者(另一进程的悬挂腿轮询、
+ * CAS 败方读数)读到 `PARKING` / `PARKED` 时靠它归因,不替没写的行猜一个词。
  */
 export type ParkTriggerCause = typeof APPROVAL_ENDING_CAUSES.TTL_EXPIRED | typeof APPROVAL_ENDING_CAUSES.BROADCAST_LOST | typeof APPROVAL_ENDING_CAUSES.STREAM_DISCONNECTED | typeof APPROVAL_ENDING_CAUSES.UNDELIVERABLE | typeof APPROVAL_ENDING_CAUSES.SHUTDOWN_BEFORE_PARK;
-/** 问账行 `denied_reason` 在 `PARKING` / `PARKED` 行上的读词表({@link ParkTriggerCause} 的穷举)。唯一读者 = {@link causeOfAskRow}。 */
+/** 问账行 `park_trigger` 列的读词表({@link ParkTriggerCause} 的穷举)。唯一读者 = {@link askRowParkTrigger}。 */
 export declare const PARK_TRIGGER_CAUSE_WORDS: {
     readonly ttl_expired: true;
     readonly broadcast_lost: true;
@@ -155,25 +160,24 @@ export declare const PARK_TRIGGER_CAUSE_WORDS: {
     readonly undeliverable: true;
     readonly shutdown_before_park: true;
 };
-/** 问账行成因的读数:`kind` 说这一个词在这一行上是哪种意思(终态成因 / 转 park 的触发成因)。 */
-export type AskRowCause = {
-    readonly kind: "ending";
-    readonly cause: AskRowEndingCause;
-} | {
-    readonly kind: "park_trigger";
-    readonly cause: ParkTriggerCause;
-};
 /**
- * 🔴 **问账行成因的唯一读口**:`denied_reason` 一列按 `state` 承载两种意思,本函数按 `state` 穷举分派(加状态 ⇒ 这里编译红),读者不自己先判 state 再查表:
- *  · `VOID` / `DENIED` ⇒ 终态成因({@link AskRowEndingCause};决断口 410、晚答 404、CAS 败方读数、悬挂腿的轮询读这一种);
- *  · `PARKING` / `PARKED` ⇒ 转 park 的触发成因({@link ParkTriggerCause};跨副本的悬挂腿与 CAS 败方读这一种);
- *  · `DECIDED` / `STREAM_PENDING` / `absent`(败方读数的「行不在」)⇒ 无成因。
- * 列值 `null` / 键缺席(没写归因的存量行)或与 state 不配的词(手改 / 将来版本写的词)⇒ `undefined`(读面缺席即缺席,不替没写的行编一个成因)。返回纯数据。
+ * 🔴 **终态成因的唯一读口**(决断口 410、晚答 404、`GET` 读面、CAS 败方读数、悬挂腿的轮询读这一只):只读 `ending_cause` 一列,不看别的列。
+ * 行不变式由本口守:终态成因只在 `VOID` / `DENIED` 上作数(写者只在到这两态的转移上写它;别的态上读到 ⇒ 不是这一行的事实)—— 按 `state` 穷举(加状态 ⇒ 这里编译红)。
+ * 列值 `null` / 键缺席(没写归因的行)、词表外的词(手改 / 将来版本写的词)或与 state 不配 ⇒ `undefined`(读面缺席即缺席,不替没写的行编一个成因)。返回纯数据。
+ */
+export declare function askRowEndingCause(row: {
+    readonly state: AskState;
+    readonly endingCause?: string | null;
+}): AskRowEndingCause | undefined;
+/**
+ * 🔴 **转 park 触发成因的唯一读口**(跨副本的悬挂腿、CAS 败方读数读这一只):只读 `park_trigger` 一列,不看别的列。
+ * 行不变式由本口守:触发成因只在**走过 `PARKING`** 的行上作数 —— `PARKING` / `PARKED`,以及从 `PARKING` 收成的 `DENIED` / `VOID`(终态不覆盖它);
+ * `STREAM_PENDING` / `DECIDED`(状态机上没有经 `PARKING` 到它们的边)上读到 ⇒ `undefined`。其余与 {@link askRowEndingCause} 同律。
  */
-export declare function causeOfAskRow(row: {
-    readonly state: AskState | "absent";
-    readonly deniedReason?: string | null;
-}): AskRowCause | undefined;
+export declare function askRowParkTrigger(row: {
+    readonly state: AskState;
+    readonly parkTrigger?: string | null;
+}): ParkTriggerCause | undefined;
 /** 非人**结局**的成因(审计 settle 行 `cause`、活卡结局帧 `tool_approval_complete.cause`):闭集去掉决断口 409 的三个词({@link DecisionRefusalCause})—— 那三个词不结束一张卡,只拒一次决议。 */
 export type SettleCause = Exclude<ApprovalEndingCause, DecisionRefusalCause>;
 /** 决断口 409 的成因子集(core 的 `detail.field` → 码;每词一个码,见 `http/resume-legs.ts`)。 */

package/dist/approval-deny-reasons.js

@@ -63,22 +63,37 @@ export const PARK_TRIGGER_CAUSE_WORDS = {
 function isParkTriggerCause(v) {
     return Object.hasOwn(PARK_TRIGGER_CAUSE_WORDS, v);
 }
-export function causeOfAskRow(row) {
-    const stored = row.deniedReason;
+export function askRowEndingCause(row) {
+    const stored = row.endingCause;
     switch (row.state) {
         case "VOID":
         case "DENIED":
-            return stored !== null && stored !== undefined && isAskRowEndingCause(stored) ? { kind: "ending", cause: stored } : undefined;
+            return stored !== null && stored !== undefined && isAskRowEndingCause(stored) ? stored : undefined;
         case "PARKING":
         case "PARKED":
-            return stored !== null && stored !== undefined && isParkTriggerCause(stored) ? { kind: "park_trigger", cause: stored } : undefined;
         case "DECIDED":
         case "STREAM_PENDING":
-        case "absent":
             return undefined;
         default: {
             const unhandled = row.state;
-            throw new Error(`causeOfAskRow: unhandled ask row state ${String(unhandled)}`);
+            throw new Error(`askRowEndingCause: unhandled ask row state ${String(unhandled)}`);
+        }
+    }
+}
+export function askRowParkTrigger(row) {
+    const stored = row.parkTrigger;
+    switch (row.state) {
+        case "PARKING":
+        case "PARKED":
+        case "DENIED":
+        case "VOID":
+            return stored !== null && stored !== undefined && isParkTriggerCause(stored) ? stored : undefined;
+        case "DECIDED":
+        case "STREAM_PENDING":
+            return undefined;
+        default: {
+            const unhandled = row.state;
+            throw new Error(`askRowParkTrigger: unhandled ask row state ${String(unhandled)}`);
         }
     }
 }