@sema-agent/server 7.141.0 → 7.142.0

package/dist/approval-ask-audit-store.d.ts

@@ -9,11 +9,11 @@
  * 当时:local 车道 ask 账进程内易失(`InMemoryApprovalAskStore`),活卡窗内崩溃 = **零痕迹**:重启后
  * `/v1/approvals` 两数组空,那次审批连一条审计行都没有。**[ref] 起 local 的 ask 账已是持久的**
  * (`FileApprovalAskStore`),所以「零痕迹」那句不再成立;本店今天还在的理由收窄成它**独有**的那一格:
- * `crashConverged` 这个 local-only 的 additive 读面(孤儿行的 `orphanState` / `resumeSafe` 两位)—— **腿证据只在这里**
- * (`legTracked` / `leg_closed` / 关停记号),ask 账没有。🔴 **「这一问还能不能决」不归本店答**:答案源是 ask 账的行状态
+ * `crashConverged` 这个 local-only 的 additive 读面(孤儿行的 `orphanState` / `resumeSafe` 两位)—— **腿证据与有序关停的进程事实只在这里**
+ * (`legTracked` / `leg_closed` / 进程级关停记录),ask 账没有。🔴 **「这一问还能不能决」不归本店答**:答案源是 ask 账的行状态
  * (决断口只读它)。启动收敛是**一只**函数(`approval-crash-convergence.ts`):先跑本店的收敛(下面「boot 收敛判据」),再把 ask 账里
- * 前世留下的 `STREAM_PENDING` 行收成 `VOID`,成因词取本店对同一 `approvalId` 的 {@link FileApprovalAskAuditStore.causeFor} —— 成因
- * 判一次、写两处(ask 行 `deniedReason` 与本店收敛行 `cause` 同词)。并账(把腿证据搬上 ask 行、本店退役)不是本形:本店在
+ * 前世留下的 `STREAM_PENDING` 行、以及本店判为孤儿的 `PARKING` 行收成 `VOID`,判定与成因词取本店对同一 `approvalId` 的
+ * {@link FileApprovalAskAuditStore.holderGoneVerdict} —— 成因判一次、写两处(ask 行 `ending_cause` 与本店收敛行 `cause` 同词)。并账(把腿证据搬上 ask 行、本店退役)不是本形:本店在
  * 协议不上场的 local 部署上也在,那里没有 ask 行可并。本店把 ask **铸造 / 决议 / 腿闭**三类事件
  * append 进磁盘账本(挂线点 = `ToolApprovalCoordinator`,见 `askAudit` ctor opt),boot 时收敛器把
  * 孤儿行标 `crashed_before_park` 终态成因注,`GET /v1/approvals` 的 additive 键 `crashConverged` 供
@@ -44,10 +44,12 @@
  *   `leg_closed`      腿闭点(`runWithContext` finally;只为铸过审计行的 taskId 落,防账本膨胀):
  *                     「决议之后腿有没有闭」是 decided 臂唯一的机械证据面 —— 没有它,「批完跑完」与
  *                     「批了、执行窗内崩」在账本字节上同形,收敛器只能二选一地撒谎。
- *   `interrupted_by_shutdown` **有序关停记号**([ref];`drainForShutdown` 在关停宽限窗满时落,只为铸过审计行、腿仍未闭的 taskId):
- *                     「这条腿是被**有序关停**截断的,不是进程崩了」。它**不是** `leg_closed`(腿没闭:工具可能正执行到一半),所以
- *                     不改变收敛判据,只改变收敛行的 `cause`(`"shutdown_before_park"` 而不是 `"crashed_before_park"`)—— `resumeSafe:false`
- *                     那句「确认上次操作再续跑」的提醒不许因为关停是有序的就丢掉。
+ *   `interrupted_by_shutdown` **有序关停记录**([ref] 引入;[ref] 起是**进程**的事实):`{kind, atMs}`,每一世至多一行 —— 审批收尾等待结束的那一拍
+ *                     (`drainForShutdown`:未决卡全部结清,或关停宽限窗到期),条件 = 本世铸过至少一张卡(零卡的一世不铸账本文件)。
+ *                     「这一世走完了有序收尾」—— 此刻还没结清的卡是被**有序关停**截断的,不是进程崩了。它**不是** `leg_closed`(腿没闭:工具可能正执行到一半),
+ *                     所以不改变收敛判据,只改变收敛行的 `cause`(`"shutdown_before_park"` 而不是 `"crashed_before_park"`)—— `resumeSafe:false`
+ *                     那句「确认上次操作再续跑」的提醒不许因为关停是有序的就丢掉。≤7.141.x 写的同名记录带 `taskId`(按腿、同一拍落):照读,`taskId` 不读 ——
+ *                     旧写点就在同一拍,每一条旧记号都是「这一世走完了有序收尾」的真实例(零迁移、零读臂)。
  *   `crash_converged` 收敛记录(boot 收敛器落,幂等锚):orphanState 两值分臂。
  *   `late_settle`     **迟到人工结算点**([ref];两条 HTTP decide 腿在**权威受理之后**落,受理谓词 =
  *                     `HTTP 200 ∧ errorCode ≠ "cancelled"`,[ref] 件②起 —— 见下):
@@ -94,18 +96,20 @@
  *     **decided 臂**:批了、执行窗内崩,工具可能有半截副作用 ⇒ `resumeSafe:false`(留人工确认)。
  *     判据方向刻意**保守**:腿闭是「本进程对该腿的守护结束」,晚于工具真完成 —— 误差方向是「把可能
  *     干净的批注成待人工确认」,绝不反向。
- *   - **腿证据只对被追踪行作数**([ref],[ref]):`leg_closed` 与 `interrupted_by_shutdown` 都只按 taskId 落,只对 `ask.legTracked` 的行作证据 ——
- *     委派 / 后台子代 ask 行的 taskId 是宿主 run,宿主腿的记录不证明子代那次调用的任何事(下面三条判据都经这一口读)。
+ *   - **腿证据只对被追踪行作数**([ref],[ref];[ref] 收窄射程):`leg_closed` 只按 taskId 落,只对 `ask.legTracked` 的行作证据 ——
+ *     委派 / 后台子代 ask 行的 taskId 是宿主 run,宿主腿的记录不证明子代那次调用的任何事(腿闭反证门 / decided 臂 / `resumeSafe` 都经这一口读)。
+ *     有序关停**不是**腿证据:它是进程的事实,对这一世的全部卡作数(见下「收敛行的 `cause`」)。
  *   - **腿闭反证门**(codex R1-F1 部分采):有 `ask`(被追踪)、无 `settle`、却有本 taskId 的后继 `leg_closed` ⇒
  *     这不是崩溃孤儿(settle 恒先于 ask() 返回、腿闭恒在其后),只能是「settle 行写丢在一条跑完了的
  *     腿上」的审计断档组 —— **不收敛**(标 pending = 把可能已执行的批注成 resumeSafe:true,方向反;
  *     标 decided = 凭空断言人批了),`inconsistent` 计数进 boot 日志。
- *   - **收敛行的 `cause`**([ref],两臂同一条):该组最后一个事件行(settle 行,缺席则 ask 行)之后、它的收敛行(重投影时)
- *     之前,有本 taskId 的 `interrupted_by_shutdown` 记号(被追踪行才认)⇒ `"shutdown_before_park"`(腿被有序关停截断);否则 `"crashed_before_park"`。
- *     记号**只改成因注,不改收敛判据**:有序关停下已批而腿未闭,工具照样可能半截副作用(decided 臂 `resumeSafe:false` 照留)。
+ *   - **收敛行的 `cause`**([ref];[ref] 起一处判、不看腿,{@link holderGoneCauseOf}):该组最后一个事件行(settle 行,缺席则 ask 行)之后、它的收敛行(重投影时)
+ *     之前,有一行 `interrupted_by_shutdown` 记录 ⇒ `"shutdown_before_park"`(这一世走完了有序收尾,这张卡是被它截断的);否则 `"crashed_before_park"`。
+ *     上界保证后几世的关停不改写前世已收敛组的词(起服收敛排在本进程铸出第一问之前,前世的孤儿组在下一世任何记录之前就已收敛)。
+ *     记录**只改成因注,不改收敛判据**:有序关停下已批而腿未闭,工具照样可能半截副作用(decided 臂 `resumeSafe:false` 照留)。
  *     有序关停下的**未决**活卡由 `drainForShutdown` 先落 settle(`cause:"shutdown_before_park"`)⇒ 不再是 pending 孤儿(本就不收敛);
  *     park 路由的卡须等**观察到 core 已处置这次调用**(停车行提交 / 承载它的腿退场)才落(F1)—— 宽限窗满仍两者皆无 ⇒ 无 settle 行 ⇒ 照样按 pending 孤儿收敛(有序关停中未提交的 park
- *     与崩溃同路,证据不丢;腿被打过记号 ⇒ `shutdown_before_park`,零活流 / 子代腿无记号 ⇒ `crashed_before_park`)。
+ *     与崩溃同路,证据不丢;成因 `shutdown_before_park`,被追踪腿与零活流 / 子代腿同一个词 —— 收尾等待走完是进程的事实)。
  *   - 其余(denied / expired / park 路由 / 已收敛)⇒ 不收敛。三条成文残留(fail-safe 方向,宁漏不误):
  *     ① `legTracked:false` 的 decided 行拿不到腿闭信号 ⇒ decided 臂对它不收(pending 臂不受此限 —— 但也因此没有腿闭反证门护着:
  *        子代卡照列 pending 孤儿但 `resumeSafe:false` —— 没有腿证据就不作「零执行」正断言([ref] ⑧,车 SO codex r2 [high];修前 true = 方向反))。
@@ -143,7 +147,7 @@
  * 本身,不是静默降级。本店的静默降级臂有两条:① 运行期 append 失败(审批可用性不押在审计盘上),已按
  * [ref] 律走 `recordFailOpen("server.approval-ask-audit.append-failed")`(census 第 53 行);② boot 重放跳过中间坏行
  * ([ref] 起由重放属主逐条披露 + `server.approval-ask-audit.corrupt-record-skipped`,census 第 106 行;此前只计 `corruptLines`)。
- * boot 期(mkdir/重放的读错)失败则**拒启**(与 File 店族同律:`FileStorageBackend` ctor 同 root 同姿态)——
+ * boot 期(mkdir/重放的读错;起服收敛写收敛行,[ref] 起 —— 见 {@link FileApprovalAskAuditStore.convergeCrashedAsks})失败则**拒启**(与 File 店族同律:`FileStorageBackend` ctor 同 root 同姿态)——
  * 一台「审计写不进却继续批」的机器 = [ref] 换个皮回来。
  *
  * ## 追加 / 重放口([ref]:一只追加日志实现,不留两份)
@@ -169,7 +173,8 @@
  * 只在真出卡时写(人批一次 = 3 行),量级 = 人的手速。保留 = 审批账本的留存律(律一处成文在 `approval-ask-retention.ts`;维护 tick 按
  * `APPROVAL_ASK_RETENTION_MS` 调 {@link FileApprovalAskAuditStore.rotateOlderThan}):**整问**删 —— 一问不再欠下一次起服收敛一个答案
  * (下面的收敛判官此刻不会把它收成孤儿)且它所有记录里最晚的时刻早于 cutoff,它的全部行(铸造 / 决议 / 收敛 / 迟到结算)一起离开文件;
- * 腿记录(按 taskId)只在没有任何留下的问还认它、且它自己也过窗时才删,于是留下的问的收敛投影(成因 / `resumeSafe`)一字不变;
+ * 腿闭记录(按 taskId)只在没有任何留下的问还认它、且它自己也过窗时才删;有序关停记录(进程级)只在它自己过窗、且没有任何留下的问的末事件行在它之前时才删
+ * —— 于是留下的问的收敛投影(成因 / `resumeSafe`)一字不变;
  * 认不出的行证不出到期,原样留;发起它的 run 还能动(跑着 / 停驻)的问也留。**只删不改**:留下的行逐字节写回(原子换文件,0o600),删了多少进读数行。
  * 读面列表按收敛时刻新前旧后、上限 {@link CRASH_CONVERGED_LIST_MAX}(有界 wire)。
  */
@@ -222,7 +227,7 @@ export type AuditSettleInput = (AuditSettleBase & {
     cause: SettleCause;
 });
 /** 收敛行 `cause` 的闭集(`GET /v1/approvals` `crashConverged[].cause`):崩溃孤儿 / 有序关停截断的腿([ref] +1;与 `crashed_before_park` 同形)。
- *  🔴 **词表属主 = `approval-deny-reasons.ts` 的 {@link HolderGoneCause}**(本表两词的子集):启动收敛把同一问的问账行收成 VOID 时 `denied_reason` 写的就是这两个词 ——
+ *  🔴 **词表属主 = `approval-deny-reasons.ts` 的 {@link HolderGoneCause}**(本表两词的子集):启动收敛把同一问的问账行收成 VOID 时 `ending_cause` 写的就是这两个词 ——
  *  同一问在 `crashConverged` 与决断口 410 体上只有一个成因词。wire 值闭集登记在 `trace/self-minted-wire.ts` 的 `crashConvergedCause`
  *  (`satisfies Record<HolderGoneCause, …>` 双向绑定 ⇒ 加词不登记 = tsc 红,wire 变更清单从那张表 diff —— F3)。 */
 /**
@@ -265,9 +270,8 @@ export interface ApprovalAskAuditSink {
     recordSettle(input: AuditSettleInput): void;
     /** 腿闭点(`runWithContext` finally)。只为铸过审计行的 taskId 真落行(店内去重)。 */
     noteLegClosed(taskId: string): void;
-    /** [ref] 有序关停记号点(`drainForShutdown` 宽限窗满时调一次):铸过审计行、腿仍未闭的每个 taskId 各落一条
-     *  `interrupted_by_shutdown`。 */
-    noteLegsInterruptedByShutdown(): void;
+    /** 有序关停记录点([ref] 起进程级;`drainForShutdown` 收尾等待结束那一拍调):本世铸过卡 ⇒ 落一行 `interrupted_by_shutdown {atMs}`;再调幂等。 */
+    noteInterruptedByShutdown(): void;
     /** [ref] 迟到人工结算点(HTTP decide 两腿)。**纯观察**:自吞一切失败,不返回受否,绝不改变结算面。 */
     recordLateSettle(input: AuditLateSettleInput): void;
 }
@@ -296,7 +300,7 @@ export interface CrashConvergedRow {
     ts: number;
     expiresAtMs: number;
     /**
-     * 收敛行的判别常量:这张卡**已不可再决**(wire 形不变)。⚠️ 协议上场的部署上,同一问在 ask 账里是 `VOID` + `deniedReason` = 本行 `cause`
+     * 收敛行的判别常量:这张卡**已不可再决**(wire 形不变)。⚠️ 协议上场的部署上,同一问在 ask 账里是 `VOID` + `ending_cause` = 本行 `cause`
      * (决断口 410 `gone.ask` 读的是那一行)—— 「能不能决」两面一致,但终态的**名字**这里是 `denied`、ask 行是 `VOID`:这是登记在案的残留,
      * 不是语义(改这个值会让把它当闭集判别式读的消费端整行丢弃,须与消费端同窗改)。
      */
@@ -339,14 +343,16 @@ export declare class FileApprovalAskAuditStore implements ApprovalAskAuditSink,
     private readonly replayed;
     /** 前世账本里的腿闭事件(taskId + 行序;decided 臂按「决议行之后」判)。 */
     private readonly replayedLegClosed;
-    /** [ref]:前世账本里的有序关停记号(taskId + 行序;收敛行 `cause` 的判据,见头注)。 */
-    private readonly replayedShutdownMarks;
+    /** 前世账本里的进程级有序关停记录的行序(收敛行 `cause` 的判据,见 {@link holderGoneCauseOf})。 */
+    private readonly replayedShutdownLines;
     /** 已收敛行(读面数据源;含前世已收敛 + 本次 boot 新收敛)。owner 只做 scope 门,不上 wire。 */
     private readonly convergedRows;
     /** 本进程铸过审计行、且腿闭信号可达的 taskId(腿闭去重 + 防无关腿刷账本)。 */
     private readonly openLegTasks;
-    /** [ref]:本进程已落过有序关停记号的 taskId(记号去重;与腿追踪集分开 —— 记号之后的真实腿闭照落)。 */
-    private readonly shutdownMarkedLegs;
+    /** 本世铸过卡(有序关停记录的落行条件:零卡的一世不铸账本文件)。 */
+    private mintedThisProcess;
+    /** 本世已落过有序关停记录(一世一行;再调幂等)。 */
+    private shutdownNoted;
     private convergedOnce;
     /**
      * [ref] 反查索引 ①:**checkpoint 锚 → 铸造行身份**。与 {@link replayed} 刻意分家 —— 那张表是
@@ -390,6 +396,8 @@ export declare class FileApprovalAskAuditStore implements ApprovalAskAuditSink,
      *  {@link recordSettle})。没有这个返回值,索引会把一条**只在内存里**的 ask/park 事实当证据,
      *  后来铸出的 `late_settle` 行在同一个账本文件里无法复核。 */
     private append;
+    /** 写口本体(append + fsync),失败照抛。失败方向由调用方按阶段定、只有两处:运行期 {@link append}(响亮不阻断)· 起服收敛 {@link convergeCrashedAsks}(拒启)。 */
+    private appendOrThrow;
     /** [ref] 锚键 A(精确):会话 + 工具调用 id。会话轴登记**两把** —— 见 {@link indexAsk}。 */
     private static callAnchorKey;
     /**
@@ -405,11 +413,11 @@ export declare class FileApprovalAskAuditStore implements ApprovalAskAuditSink,
     recordAsk(input: AuditAskInput): void;
     recordSettle(input: AuditSettleInput): void;
     noteLegClosed(taskId: string): void;
-    /** [ref]:有序关停宽限窗满时仍未闭的腿各落一条记号。只为铸过审计行、腿仍开着的 taskId 落;记号有**自己的**去重集 ——
-     *  腿追踪集 `openLegTasks` **不动**:进程在记号之后仍可能活几秒(server / backend 收尾),期间真跑完的腿照常落 `leg_closed`
-     *  (codex r1 F1 [high]:清空追踪集会吞掉这份真实证据,而「settle 写丢 + 腿跑完」时正是它让腿闭反证门判 inconsistent,
-     *  吞掉就把一次已执行的批投影成 pending / `resumeSafe:true`)。迟到的腿闭落在记号之后 ⇒ 收敛判据照常认它(腿跑完了,不是孤儿)。 */
-    noteLegsInterruptedByShutdown(): void;
+    /** [ref]:这一世走完了有序收尾 ⇒ 落**一行**进程级 `interrupted_by_shutdown {atMs}`(收尾等待结束那一拍;本世没铸过卡就不落;再调幂等,位先置后写 ——
+     *  写失败走 append 的 F 类留痕,不重试)。腿追踪集 `openLegTasks` **不动**:进程在这一行之后仍可能活几秒(server / backend 收尾),期间真跑完的腿照常落
+     *  `leg_closed`(codex r1 F1 [high]:吞掉这份真实证据会让「settle 写丢 + 腿跑完」的组被投影成 pending / `resumeSafe:true`)。迟到的腿闭落在这一行之后 ⇒
+     *  收敛判据照常认它(腿跑完了,不是孤儿)。 */
+    noteInterruptedByShutdown(): void;
     /**
      * [ref] **迟到人工结算点**(判据的唯一属主;两条 HTTP decide 腿只交锚,不自己推)。
      *
@@ -436,6 +444,9 @@ export declare class FileApprovalAskAuditStore implements ApprovalAskAuditSink,
     /**
      * boot 崩溃收敛器的**本店半场**(由 `approval-crash-convergence.ts` 的启动收敛在任何卡开始之前调一次;幂等跨 boot)。
      * 判据 = 头注「boot 收敛判据」段(一处成文,不复述)。返回两分臂计数 + 坏行数供 boot 日志。
+     * 🔴 收敛行写不进 ⇒ **抛**(调用方拒启;[ref] codex r1 F4):它不只是幂等锚,还是这一组成因判据的**上界**({@link holderGoneCauseOf})—— 写丢了,之后任何一世的
+     * 有序关停记录都落在这一组「末事件之后、无收敛行」的窗里,重投影就把它改写成 `shutdown_before_park`,而问账行早已按这一拍的词收了 `VOID`,两本账分家。
+     * 这是 boot 期写(头注「boot 期失败则拒启」同律),不是运行期的「审计不押审批」那一类;抛在问账半场之前 ⇒ 问账一字未动,盘修好再起照收、同一个词。
      */
     convergeCrashedAsks(): {
         pending: number;
@@ -444,14 +455,18 @@ export declare class FileApprovalAskAuditStore implements ApprovalAskAuditSink,
         corruptLines: number;
     };
     /**
-     * 一问的**成因词**(启动收敛的唯一判点,`approval-crash-convergence.ts` 读它写 ask 行的 `deniedReason`;本店收敛行的 `cause` 走同一只
-     * {@link causeOf})。前世账本里没有这只 `approvalId` 的铸造行(崩在 ask 账落行之后、本店铸造行之前,或本店那时不在)⇒ `crashed_before_park`:
-     * 没有有序关停的证据,就不说它是有序关停。判据读的是构造时冻结的前世账本 ⇒ 同一份账本跨几次启动恒得同一个词。
+     * 一问的**持有者没了**判定(启动收敛的唯一判点,`approval-crash-convergence.ts` 读它决定收哪些问账行、写什么词;本店收敛行的 `cause` 走同一只
+     * {@link holderGoneCauseOf}):
+     *  · `orphan` = 这一组是本店的崩溃收敛孤儿(`crashConverged` 列出的那些:前几次起服已收敛的,或此刻 {@link judgeOrphan} 判 pending / decided 的)——
+     *    问账里它的 `PARKING` 行由启动收敛收(审计断档组 `inconsistent` 不算:它没被收敛,不作「持有者没了」的断言);
+     *  · `cause` = 成因词。前世账本里没有这只 `approvalId` 的铸造行(崩在 ask 账落行之后、本店铸造行之前,或本店那时不在)⇒ `{orphan:false, crashed_before_park}`:
+     *    没有有序关停的证据,就不说它是有序关停。
+     * 判据读的是构造时冻结的前世账本(纯函数,不依赖 {@link convergeCrashedAsks} 先跑没跑)⇒ 同一份账本跨几次启动恒得同一个判定、同一个词。
      */
-    causeFor(approvalId: string): HolderGoneCause;
-    /** [ref] 收敛行的成因注(判据见头注「收敛行的 `cause`」):组的最后一个事件行之后、收敛行(若已收敛)之前,有本 taskId 的
-     *  有序关停记号 ⇒ `shutdown_before_park`;否则 `crashed_before_park`。 */
-    private causeOf;
+    holderGoneVerdict(approvalId: string): {
+        orphan: boolean;
+        cause: HolderGoneCause;
+    };
     private projectRow;
     /** scope 门与 `listLivePending` 逐字同律(同一只 checkpoint scope 解码):`undefined` = operator 全量(含 owner null 行);
      *  `_` = 匿名那一组 = owner null 的行;其余串 = 只见 `owner === scope` 的行(null-owner 行对具名主体不列,宁少列不超范围)。 */
@@ -464,7 +479,8 @@ export declare class FileApprovalAskAuditStore implements ApprovalAskAuditSink,
      * 后台子代账列出)∧ {@link judgeOrphan} 此刻不欠它答案 —— 停驻 run / 能动子代的问(窗到期转 durable、迟到结算还要这组前置事实)、活卡
      * (铸了没决)与批了腿没闭的问多老都留。删的单位是**整问**:
      *  · 一问的最后动静 = 它所有记录(铸造 / 决议 / 收敛 / 迟到结算)里最晚的时刻;早于 cutoff ∧ 不欠答案 ⇒ 这一问的全部行删;
-     *  · 腿记录(按 taskId)只在它自己也早于 cutoff ∧ 没有任何留下的问是这个 taskId ∧ 这个 taskId 不在挂靠集时才删 —— 留下的问的收敛投影(成因 / `resumeSafe`)读得到的腿证据一条不少;
+     *  · 腿闭记录(按 taskId)只在它自己也早于 cutoff ∧ 没有任何留下的问是这个 taskId ∧ 这个 taskId 不在挂靠集时才删 —— 留下的问的 `resumeSafe` 读得到的腿证据一条不少;
+     *  · 有序关停记录(进程级)只在它自己也早于 cutoff ∧ 没有任何留下的问的末事件行({@link lastEventLineOf})在它之前时才删 —— 留下的问的成因读得到的关停事实一条不少;
      *  · 身份说不清的迟到结算(`approvalId:null`)按它自己的时刻;认不出的行(腐行 / 词表外)证不出到期 ⇒ 原样留;
      *    末尾没换行的那一段原样留在末尾(不补换行),由追加口下次打开时按 core 的同一只判词修(解析成对象补换行、撕尾截断)。
      * 只删不改:留下的每一行按**原字节**写回(按换行字节切段,不经解码 —— 非 UTF-8 的字节一个不变),原子换文件({@link replaceFileBytes}:

package/dist/approval-ask-audit-store.js

@@ -5,7 +5,7 @@ import { AppendLog, ensureDir, isHostDecider, writeThenLink } from "@sema-agent/
 import { recordFailOpen } from "./observability/fail-open.js";
 import { ownerOfCheckpointScope } from "./security.js";
 import { replayJsonlSkipping } from "./observability/corrupt-read-seat.js";
-import { isSettleCause, SETTLE_OUTCOME } from "./approval-deny-reasons.js";
+import { APPROVAL_ENDING_CAUSES, isSettleCause, SETTLE_OUTCOME } from "./approval-deny-reasons.js";
 export const APPROVAL_ASK_AUDIT_DIR = "approval-ask-audit";
 export const APPROVAL_ASK_AUDIT_LEDGER = "ledger.jsonl";
 export const CRASH_CONVERGED_LIST_MAX = 200;
@@ -98,11 +98,10 @@ function readLedgerRecord(u, noteOutOfSetSeat) {
             return { kind: "leg_closed", taskId, closedAtMs };
         }
         case "interrupted_by_shutdown": {
-            const taskId = s("taskId");
             const atMs = num("atMs");
-            if (taskId === undefined || atMs === undefined)
+            if (atMs === undefined)
                 return undefined;
-            return { kind: "interrupted_by_shutdown", taskId, atMs };
+            return { kind: "interrupted_by_shutdown", atMs };
         }
         case "crash_converged": {
             const approvalId = s("approvalId");
@@ -173,7 +172,7 @@ const LEDGER_SHAPE = {
 function foldLedger(records) {
     const groups = new Map();
     const legClosed = [];
-    const shutdownMarks = [];
+    const shutdownLines = [];
     const group = (approvalId, line) => {
         let g = groups.get(approvalId);
         if (!g) {
@@ -206,7 +205,7 @@ function foldLedger(records) {
                 legClosed.push({ taskId: rec.taskId, line });
                 break;
             case "interrupted_by_shutdown":
-                shutdownMarks.push({ taskId: rec.taskId, line });
+                shutdownLines.push(line);
                 break;
             case "crash_converged": {
                 const g = group(rec.approvalId, line);
@@ -220,13 +219,21 @@ function foldLedger(records) {
             }
         }
     }
-    return { groups, legClosed, shutdownMarks };
+    return { groups, legClosed, shutdownLines };
 }
-function legEvidenceOf(g, records, afterLine, beforeLine = Number.POSITIVE_INFINITY) {
+function legEvidenceOf(g, legClosed, afterLine) {
     const ask = g.ask;
     if (!ask.legTracked)
         return undefined;
-    return records.some((r) => r.taskId === ask.taskId && r.line > afterLine && r.line < beforeLine);
+    return legClosed.some((r) => r.taskId === ask.taskId && r.line > afterLine);
+}
+function lastEventLineOf(g) {
+    return g.settleLine ?? g.askLine ?? g.firstLine;
+}
+function holderGoneCauseOf(g, shutdownLines) {
+    const after = lastEventLineOf(g);
+    const before = g.convergedLine ?? Number.POSITIVE_INFINITY;
+    return shutdownLines.some((l) => l > after && l < before) ? APPROVAL_ENDING_CAUSES.SHUTDOWN_BEFORE_PARK : APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK;
 }
 function judgeOrphan(g, legClosed) {
     if (g.ask === undefined || g.converged !== undefined)
@@ -323,10 +330,11 @@ export class FileApprovalAskAuditStore {
     fsyncDir;
     replayed = new Map();
     replayedLegClosed = [];
-    replayedShutdownMarks = [];
+    replayedShutdownLines = [];
     convergedRows = [];
     openLegTasks = new Set();
-    shutdownMarkedLegs = new Set();
+    mintedThisProcess = false;
+    shutdownNoted = false;
     convergedOnce = false;
     askByCallAnchor = new Map();
     askBySessionOnly = new Map();
@@ -349,8 +357,8 @@ export class FileApprovalAskAuditStore {
             this.replayed.set(approvalId, g);
         for (const r of fold.legClosed)
             this.replayedLegClosed.push(r);
-        for (const r of fold.shutdownMarks)
-            this.replayedShutdownMarks.push(r);
+        for (const l of fold.shutdownLines)
+            this.replayedShutdownLines.push(l);
         for (const { rec } of records) {
             if (rec.kind === "ask")
                 this.indexAsk(rec);
@@ -360,8 +368,7 @@ export class FileApprovalAskAuditStore {
     }
     append(rec) {
         try {
-            this.log ??= this.openLog(this.ledgerPath);
-            this.log.append(rec, true);
+            this.appendOrThrow(rec);
             return true;
         }
         catch (err) {
@@ -369,6 +376,10 @@ export class FileApprovalAskAuditStore {
             return false;
         }
     }
+    appendOrThrow(rec) {
+        this.log ??= this.openLog(this.ledgerPath);
+        this.log.append(rec, true);
+    }
     static callAnchorKey(session, toolCallId) {
         return `${session}\u0000${toolCallId}`;
     }
@@ -395,6 +406,7 @@ export class FileApprovalAskAuditStore {
             this.parkExpired.add(rec.approvalId);
     }
     recordAsk(input) {
+        this.mintedThisProcess = true;
         if (input.legTracked)
             this.openLegTasks.add(input.taskId);
         if (this.append({ kind: "ask", ...input }))
@@ -410,14 +422,11 @@ export class FileApprovalAskAuditStore {
         this.openLegTasks.delete(taskId);
         this.append({ kind: "leg_closed", taskId, closedAtMs: Date.now() });
     }
-    noteLegsInterruptedByShutdown() {
-        const atMs = Date.now();
-        for (const taskId of this.openLegTasks) {
-            if (this.shutdownMarkedLegs.has(taskId))
-                continue;
-            this.shutdownMarkedLegs.add(taskId);
-            this.append({ kind: "interrupted_by_shutdown", taskId, atMs });
-        }
+    noteInterruptedByShutdown() {
+        if (!this.mintedThisProcess || this.shutdownNoted)
+            return;
+        this.shutdownNoted = true;
+        this.append({ kind: "interrupted_by_shutdown", atMs: Date.now() });
     }
     recordLateSettle(input) {
         const candidates = input.toolCallId !== undefined
@@ -454,7 +463,7 @@ export class FileApprovalAskAuditStore {
             if (g.ask === undefined)
                 continue;
             if (g.converged !== undefined) {
-                this.convergedRows.push({ row: this.projectRow(g, g.converged.orphanState, g.converged.convergedAtMs, this.causeOf(g)), owner: g.ask.owner });
+                this.convergedRows.push({ row: this.projectRow(g, g.converged.orphanState, g.converged.convergedAtMs, holderGoneCauseOf(g, this.replayedShutdownLines)), owner: g.ask.owner });
                 continue;
             }
             const verdict = judgeOrphan(g, this.replayedLegClosed);
@@ -466,8 +475,15 @@ export class FileApprovalAskAuditStore {
             if (orphanState === undefined)
                 continue;
             const convergedAtMs = Date.now();
-            this.append({ kind: "crash_converged", approvalId, orphanState, convergedAtMs });
-            this.convergedRows.push({ row: this.projectRow(g, orphanState, convergedAtMs, this.causeOf(g)), owner: g.ask.owner });
+            try {
+                this.appendOrThrow({ kind: "crash_converged", approvalId, orphanState, convergedAtMs });
+            }
+            catch (err) {
+                throw new Error(`approval ask audit: could not write the crash convergence record of approval ${approvalId} to ${this.ledgerPath}: ${err instanceof Error ? err.message : String(err)} — ` +
+                    "refusing to start, because the record is this approval's convergence anchor and the upper bound of its cause word (without it a later process's orderly " +
+                    "shutdown record would re-attribute it while its ask row keeps this boot's word). Fix the data root (disk full / read-only?) and start again.");
+            }
+            this.convergedRows.push({ row: this.projectRow(g, orphanState, convergedAtMs, holderGoneCauseOf(g, this.replayedShutdownLines)), owner: g.ask.owner });
             if (orphanState === "pending")
                 pending += 1;
             else
@@ -477,14 +493,12 @@ export class FileApprovalAskAuditStore {
         this.convergedRows.length = Math.min(this.convergedRows.length, CRASH_CONVERGED_LIST_MAX);
         return { pending, decided, inconsistent, corruptLines: this.corruptLines };
     }
-    causeFor(approvalId) {
+    holderGoneVerdict(approvalId) {
         const g = this.replayed.get(approvalId);
-        return g?.ask === undefined ? "crashed_before_park" : this.causeOf(g);
-    }
-    causeOf(g) {
-        const after = g.settleLine ?? g.askLine ?? 0;
-        const before = g.convergedLine ?? Number.POSITIVE_INFINITY;
-        return legEvidenceOf(g, this.replayedShutdownMarks, after, before) === true ? "shutdown_before_park" : "crashed_before_park";
+        if (g?.ask === undefined)
+            return { orphan: false, cause: APPROVAL_ENDING_CAUSES.CRASHED_BEFORE_PARK };
+        const verdict = judgeOrphan(g, this.replayedLegClosed);
+        return { orphan: g.converged !== undefined || verdict === "pending" || verdict === "decided", cause: holderGoneCauseOf(g, this.replayedShutdownLines) };
     }
     projectRow(g, orphanState, convergedAtMs, cause) {
         const ask = g.ask;
@@ -556,10 +570,14 @@ export class FileApprovalAskAuditStore {
             dropped.add(id);
         }
         const claimedTasks = new Set();
-        for (const [id, g] of fold.groups)
-            if (!dropped.has(id) && g.ask !== undefined)
-                claimedTasks.add(g.ask.taskId);
-        const keep = (rec) => {
+        let earliestKeptLastEvent = Number.POSITIVE_INFINITY;
+        for (const [id, g] of fold.groups) {
+            if (dropped.has(id) || g.ask === undefined)
+                continue;
+            claimedTasks.add(g.ask.taskId);
+            earliestKeptLastEvent = Math.min(earliestKeptLastEvent, lastEventLineOf(g));
+        }
+        const keep = (rec, line) => {
             if (rec === undefined)
                 return true;
             switch (rec.kind) {
@@ -570,15 +588,16 @@ export class FileApprovalAskAuditStore {
                 case "late_settle":
                     return rec.approvalId !== null ? !dropped.has(rec.approvalId) : rec.settledAtMs >= cutoffMs;
                 case "leg_closed":
+                    return rec.closedAtMs >= cutoffMs || claimedTasks.has(rec.taskId) || keepAnchors.has(rec.taskId);
                 case "interrupted_by_shutdown":
-                    return atMsOf(rec) >= cutoffMs || claimedTasks.has(rec.taskId) || keepAnchors.has(rec.taskId);
+                    return rec.atMs >= cutoffMs || earliestKeptLastEvent < line;
                 default: {
                     const unreachable = rec;
                     throw new Error(`approval-ask-audit rotate: unreachable record ${String(unreachable)}`);
                 }
             }
         };
-        const kept = entries.filter((e) => keep(e.rec));
+        const kept = entries.filter((e, i) => keep(e.rec, i + 1));
         const droppedRecords = entries.length - kept.length;
         if (droppedRecords === 0)
             return { droppedAsks: 0, droppedRecords: 0, keptRecords: entries.length };

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";
@@ -571,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>>;
@@ -598,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";
@@ -617,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";
@@ -725,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>>;
@@ -752,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";
@@ -771,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-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;