@sema-agent/server 7.80.2 → 7.81.0

package/USAGE.md

@@ -509,9 +509,13 @@ QUESTION_TTL_MS=300000
 # 回滚键是下面的 UNATTENDED_APPROVAL_POLICY=deny(两根旋钮正交,别当一根用);它也**不**再回滚窗长
 # (窗是活卡件不是协议件,见下一键——缺省值与旧硬编码窗同为 300000,没配过就仍然字节不变)
 STREAM_APPROVAL_ENABLED=true
-# 活卡窗(毫秒,默认 300000=5min)。**辖域=所有腿**:协议上不上场都按它计窗——local 后端 /
-# 无 checkpoint 店 / 关了协议的部署同样生效(此前那三形上本键一个字节都不生效、窗恒 5min,且没有任何
-# 一行说出来)。0 = 运维显式关窗 ⇒ **一张卡都不发**、恒走无人值守终局(不是"还原",还原用上面那个键;
+# 活卡窗(毫秒)。**辖域=所有腿**:协议上不上场都按它计窗——无 checkpoint 店 / 关了协议的部署同样
+# 生效(此前那几形上本键一个字节都不生效、窗恒 5min,且没有任何一行说出来)。
+# 🔴 **缺省值是 posture 派生的,不是一个数**(S-178):单机 turnkey(`REQUIRE_PRINCIPAL` 未设)=
+# **86400000(24 小时)**,多租户形 = 300000(5min)。**S-384 起这根旋钮在单机上是要读的那一根**:
+# local 后端自此有持久 ask 账、流内协议上场,受门 ask 先发一张活卡、**窗满才转 park**(升级前是铸造
+# 时刻立刻 park)⇒ 不配它的**无人值守**单机最多挂一天才落 park。无人值守机器请显式给几秒;
+# 有人值守的单机正是那一天窗口的受益者。0 = 运维显式关窗 ⇒ **一张卡都不发**、恒走无人值守终局(不是"还原",还原用上面那个键;
 # 缺省 park 政策 + park 设施在场 ⇒ 全落 durable park 经 /v1/approvals/:sessionId/decide 兑现;
 # 配了 UNATTENDED_APPROVAL_POLICY=deny 或没有 park 设施的部署这里是"恒当场拒"= 受门工具全关,
 # boot 期打一行 stream_ask_window_zero 点名)。负值**拒启**(此前静默等价于 0 还白发一张没人赢得了的卡)
@@ -570,7 +574,9 @@ UNREACHED_ASK_TTL_MS=3600000
   耗尽(十几分钟量级)才感知——这段时间内真正的兜底是**活卡窗到期转 park**(`STREAM_ASK_WINDOW_MS`,
   默认 5min),所以把窗改大等于把断连场景的最坏无人区拉长,改小前先看上面的跨旋钮不变量。half-open 的
   主动探测(写水位判死)在攻关排期。
-- **无 durable 前置的部署(五合取不满足:local backend / 无 checkpoint 能力)**:流内协议整个不上场
+- **无 durable 前置的部署(四合取不满足:无 backend / 无 checkpoint 能力 / 显式关协议 / 无活卡腿;
+  ⚠️ **S-384 起 `local` backend 不再是其中一项** —— 它有了文件形 ask 账,配齐 `DURABLE_APPROVAL=true`
+  + checkpoint 店的单机部署上协议**照常上场**,`GET /v1/capabilities` 的 `streamApproval` 报 true)**:流内协议整个不上场
   (启动一行 `stream_approval_disabled` 点名缺哪项),ask 走旧活卡腿——断连场景的最坏结局是活卡 TTL
   窗满**自动 deny(fail-closed)后 run 继续**,不会死锁在等一张没人能回的卡上;代价是断连期间用户的
   批准机会直接过期。(7.34.0 起这条 deny 由**引擎**在「没有可停靠的 durable 门」时给出——服务侧只报
@@ -580,6 +586,9 @@ UNREACHED_ASK_TTL_MS=3600000
   (卡挂过窗、人才按 Yes)不能走 `POST /v1/tool-approvals/:id/respond`(没有持久 ask 行 ⇒ 恒 404
   `tool_approval.not_pending`、不带 `cause`),要走 `POST /v1/approvals/:sessionId/decide`
   ——前提是配了 `DURABLE_APPROVAL=true`(local 车道有文件形 checkpoint 店),否则窗到期即 fail-closed 拒。
+  ⚠️ **上面这段「没有持久 ask 行 ⇒ 恒 404」自 S-384 起不再适用于 `DB_BACKEND=local` 本身**:local 的
+  ask 账已是文件形,配齐 park 设施的单机部署上迟到决议走 `respond` 的赎回席是通的;本段现在只说
+  那几条**真的**不上场的部署形(无 backend / 无 checkpoint 能力 / 显式关协议)。
   默认值(300s + 60s vs 7d)自然满足,只有显式改坏才会撞上。
 - **调参方向**:想让人有更长时间点审批卡 → 调大 `STREAM_ASK_WINDOW_MS`;卡太多刷屏 → 调小两个 `ADMIT_MAX_*`
   (代价是超限的 ask 走 park,要有人去审批队列捞);库压大 → 调小 `STREAM_APPROVAL_RECONCILE_BATCH`

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

@@ -6,18 +6,24 @@
  * 崩溃安全机制照 `orchestration/workflow-notify-journal.ts` 的 File 形:append-only JSONL、fsync 逐行、
  * 重放容忍撕尾行)。
  *
- * ## 它治的病([ref] / [ref]① 车定界钉)
- * local 车道 ask 账进程内易失(`InMemoryApprovalAskStore`),活卡窗内崩溃 = **零痕迹**:重启后
- * `/v1/approvals` 两数组空,那次审批连一条审计行都没有。本店把 ask **铸造 / 决议 / 腿闭**三类事件
+ * ## 它治的病([ref] / [ref]① 车定界钉;⚠️ **病因描述是 [ref] 当时的事实,S-384 起已变**)
+ * 当时:local 车道 ask 账进程内易失(`InMemoryApprovalAskStore`),活卡窗内崩溃 = **零痕迹**:重启后
+ * `/v1/approvals` 两数组空,那次审批连一条审计行都没有。**S-384 起 local 的 ask 账已是持久的**
+ * (`FileApprovalAskStore`),所以「零痕迹」那句不再成立;本店今天还在的理由收窄成它**独有**的那一格:
+ * `crashConverged` 这个 local-only 的 additive 读面(孤儿行的 `orphanState` / `resumeSafe` 两位),
+ * ask 账本身没有「boot 收敛孤儿」这条动词。两本同根账并存是已登记的抽象欠账。本店把 ask **铸造 / 决议 / 腿闭**三类事件
  * append 进磁盘账本(挂线点 = `ToolApprovalCoordinator`,见 `askAudit` ctor opt),boot 时收敛器把
  * 孤儿行标 `crashed_before_park` 终态成因注,`GET /v1/approvals` 的 additive 键 `crashConverged` 供
  * 操作员追溯。
  *
  * ## 它**不**做的事(裁 (c) 的边界,与稿 §1 (a) 臂的语义论证同源)
- *  - **不翻 `streamApproval` 能力位**:该位在 SQL 车道隐含「durable park 兜底(窗到期 park 可赎)」,
- *    local 给不了(park 凭据由引擎铸 checkpoint 时发,进程死后 run 不可复活)—— 同一位两义 = 消费方
- *    按位渲染「稍后可批」时做出错误承诺。`resolveStreamApprovalGate` 的 `volatile_ask_ledger` 臂
- *    一字不动(钉:`test/approval-ask-audit.test.ts` [ref]-⑧ + e2e 定界格新形)。
+ *  - **不翻 `streamApproval` 能力位**([ref] 当时的裁 (c);⚠️ **这一位已由 S-384 翻真,不是被本店翻的**):
+ *    当年不翻的理由是「该位在 SQL 车道隐含 durable park 兜底,local 给不了」+「local 的 ask 账是进程内
+ *    易失形」。后半条已由 `FileApprovalAskStore` 消掉(持久账落地);前半条的答案一直在谓词里 ——
+ *    `resolveStreamApprovalGate` 的 `parkFacility` 合取项要求 `backend.checkpoint` 在场 ∧ `DURABLE_APPROVAL`,
+ *    所以位报 true 的 local 部署**必然**配齐了 File 形 checkpoint 店(`durable-approval-local-e2e` 第一格
+ *    实证:park 行跨双 kill 存活、重启后 decide 驱动 resume 真跑完)。本店与那一位自此无关:它治的是
+ *    **活卡窗内崩溃**(park 还没落盘)那一格的零痕迹病,而那一格无论位真位假都不复活 run。
  *  - **不复活 run**:审计行不是 park 行,崩掉的 ask 不进 pending/livePending。恢复闭环真形 =
  *    core resume 既有补偿腿(悬空 tool_use 闭合「中断,工具未执行」⇒ 模型自然重发重弹卡),读面用
  *    `resumeSafe` 位指路(v1.1 §6 第二件)。

package/dist/boot/reapers.js

@@ -110,10 +110,9 @@ export function startReapers(ctx) {
     const approvalReconciler = (() => {
         if (!config.streamApproval.enabled || !backend)
             return undefined;
-        const cpPort = checkpointStore;
         return createApprovalReconciler({
             askStore: backend.approvalAsk(),
-            checkpoints: typeof cpPort?.findCheckpointCandidatesForAsk === "function" ? cpPort : undefined,
+            ...(checkpointStore !== undefined ? { checkpoints: checkpointStore } : {}),
             runs: runStore,
             logger,
             metrics,

package/dist/http/routes/diagnostics.d.ts

@@ -14,8 +14,9 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { WiringManifest } from "@sema-agent/core";
 import { type StreamApprovalGate, type StreamApprovalGateInput } from "../../tool-approval.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
-/** 流内审批门的读数形:上场即 `"active"`,否则是那五个合取项里**第一个**不满足的原因词
- *  (与 `resolveStreamApprovalGate` 同一闭集,新增 reason 在此处编译红)。 */
+/** 流内审批门的读数形:上场即 `"active"`,否则是那**四**个合取项里**第一个**不满足的原因词
+ *  (与 `resolveStreamApprovalGate` 同一闭集,词表**取型**自它 ⇒ 增删 reason 在此处自动跟随/编译红;
+ *  S-384 删掉第 5 项「账必须持久」时本行数字漏改过一次,**数字是手抄的那一半**)。 */
 export type StreamApprovalGateReading = "active" | Extract<StreamApprovalGate, {
     active: false;
 }>["reason"];

package/dist/observability/fail-open.d.ts

@@ -9,6 +9,14 @@ export interface FailOpenTagEntry {
 }
 /** 闭集 tag 词表。形=`<repo>.<domain>.<site>`(跨仓同形,便于三仓遥测并表)。 */
 export declare const FAIL_OPEN_TAGS: {
+    readonly "server.approval-ask-journal.compaction-failed": {
+        readonly cls: "F";
+        readonly note: "S-384(`plugins/approval-ask-store-file.ts` 的 `write()` 尾巴,local 车道的 File 形 ask 账):账本**压实**(整本重写成行快照)失败 —— 盘满 / 只读挂载 / `.tmp` 不可写。压实是**纯管家动作**,走到它的时候这一次写**已经 append+fsync 落盘、也已经翻进内存** ⇒ 把它的 I/O 错误抛给调用方 = 把一次已生效的人类批准报成失败(客户端重试会拿到 `ask_not_pending`),正是本店存在的理由被反过来用。所以吞 + 留痕:账本继续长(core 的 `AppendLog` 在 `closeForSwap` 之后惰性重开,一次瞬时错误不会把它变成砖),下一次写再试压实。放行的最坏后果 = 账本不再收缩(盘占用按写入量线性增长),**语义零影响**(行与转移一个不差)。计数非零 = 这台机器的数据根写不动了,运维要去看盘。";
+    };
+    readonly "server.approval-ask-journal.corrupt-record-skipped": {
+        readonly cls: "F";
+        readonly note: "S-384(`plugins/approval-ask-store-file.ts` 的启动重放,local 车道的 File 形 ask 账):账本**中间**有一行解析不出(位腐 / 被人手改 / 文件系统故障)⇒ core `readJsonlRecords` 跳过它,本店继续重放其余记录。**撕尾不走本 tag**(崩在半行是这个格式存在的理由,由 quarantine + warn 单独处置),**词表外动词也不走**(那是降级,直接拒启)。放行的最坏后果之所以有界,靠的是店的 CAS 形:每一条写都带 `WHERE state = <from>` 谓词 ⇒ 丢一条记录只能让**后续转移失败**(no-op),绝不可能让一条非法转移成功 —— 一条已决 ask 退回 STREAM_PENDING 的方向是 fail-closed(工具不会因此被放行),一条待决 ask 消失的方向是「等卡的那条腿窗到期走 park」= S-384 之前的行为。所以这条兜底丢的是**进度**,不是门。同批还有 quarantine 原件 + 一条点名路径的 warn;计数让「某台机器的 ask 账一直在腐」与「这台机器本来就没有审批」在遥测上分得开。";
+    };
     readonly "server.terminal.persisted-plane-malformed": {
         readonly cls: "F";
         readonly note: "S-136 合并重扫确认项(`terminal.ts persistedPlaneOf`,持久 blob 的平面读面):盘上一条 `terminal` 因由形不合(`paused` 缺 gate / 词出闭集)让 core 的 `terminalProjection` 抛 ⇒ 本读面对这一行答**全格缺席**而不是整只 500。放行的最坏后果=一条坏行在列表/舰队读面上显示为无终局词;计数 + probe 带原句,便于按行回溯。";

package/dist/observability/fail-open.js

@@ -1,5 +1,13 @@
 import { appendFileSync } from "node:fs";
 export const FAIL_OPEN_TAGS = {
+    "server.approval-ask-journal.compaction-failed": {
+        cls: "F",
+        note: "S-384(`plugins/approval-ask-store-file.ts` 的 `write()` 尾巴,local 车道的 File 形 ask 账):账本**压实**(整本重写成行快照)失败 —— 盘满 / 只读挂载 / `.tmp` 不可写。压实是**纯管家动作**,走到它的时候这一次写**已经 append+fsync 落盘、也已经翻进内存** ⇒ 把它的 I/O 错误抛给调用方 = 把一次已生效的人类批准报成失败(客户端重试会拿到 `ask_not_pending`),正是本店存在的理由被反过来用。所以吞 + 留痕:账本继续长(core 的 `AppendLog` 在 `closeForSwap` 之后惰性重开,一次瞬时错误不会把它变成砖),下一次写再试压实。放行的最坏后果 = 账本不再收缩(盘占用按写入量线性增长),**语义零影响**(行与转移一个不差)。计数非零 = 这台机器的数据根写不动了,运维要去看盘。",
+    },
+    "server.approval-ask-journal.corrupt-record-skipped": {
+        cls: "F",
+        note: "S-384(`plugins/approval-ask-store-file.ts` 的启动重放,local 车道的 File 形 ask 账):账本**中间**有一行解析不出(位腐 / 被人手改 / 文件系统故障)⇒ core `readJsonlRecords` 跳过它,本店继续重放其余记录。**撕尾不走本 tag**(崩在半行是这个格式存在的理由,由 quarantine + warn 单独处置),**词表外动词也不走**(那是降级,直接拒启)。放行的最坏后果之所以有界,靠的是店的 CAS 形:每一条写都带 `WHERE state = <from>` 谓词 ⇒ 丢一条记录只能让**后续转移失败**(no-op),绝不可能让一条非法转移成功 —— 一条已决 ask 退回 STREAM_PENDING 的方向是 fail-closed(工具不会因此被放行),一条待决 ask 消失的方向是「等卡的那条腿窗到期走 park」= S-384 之前的行为。所以这条兜底丢的是**进度**,不是门。同批还有 quarantine 原件 + 一条点名路径的 warn;计数让「某台机器的 ask 账一直在腐」与「这台机器本来就没有审批」在遥测上分得开。",
+    },
     "server.terminal.persisted-plane-malformed": {
         cls: "F",
         note: "S-136 合并重扫确认项(`terminal.ts persistedPlaneOf`,持久 blob 的平面读面):盘上一条 `terminal` 因由形不合(`paused` 缺 gate / 词出闭集)让 core 的 `terminalProjection` 抛 ⇒ 本读面对这一行答**全格缺席**而不是整只 500。放行的最坏后果=一条坏行在列表/舰队读面上显示为无终局词;计数 + probe 带原句,便于按行回溯。",

package/dist/plugins/approval-ask-store-file.d.ts

@@ -0,0 +1,171 @@
+import type { AskState } from "../approval-ask-machine.js";
+import type { AskRow, AskTerminalClaimIntent, AskTerminalClaimOutcome, AskTransitionPatch, ApprovalAskStore, BatchRow, BindGateInput, BindResult, DecideAskInput, DecideResult, EnsureAskResult, ExpireResult, NewAskRow } from "./approval-ask-store-sql.js";
+/** 数据根下的目录名。**按店命名**,与兄弟 File 店同规(`approval-nonces` / `approval-ask-audit` /
+ *  `approval-exemptions` / `resume-anchors` / `checkpoint-ctx` / …)—— 首版写的是族名 `approvals`,而那
+ *  正是读者会去找**持久 park 行**的地方(它们其实在 `checkpoint-ctx`),且持久数据面的名字按硬 breaking
+ *  三句是「不能靠编译红通知」的那一面,改名只在落地前廉价(替补对抗复审 F8,采纳)。 */
+export declare const APPROVAL_ASK_DIR = "approval-asks";
+/** 账本文件名。 */
+export declare const APPROVAL_ASK_JOURNAL_FILE = "asks.jsonl";
+/**
+ * 压实的**下界**:记录数不到这个数,压实的 I/O 不值得付(整本重写 + fsync)。
+ * 与 {@link ASK_JOURNAL_COMPACT_GROWTH} 一起构成闭形判据,零 env、零启发式。
+ */
+export declare const ASK_JOURNAL_COMPACT_MIN_RECORDS = 2000;
+/**
+ * 压实的**增长因子**:记录数必须同时超过「活行数 × 本因子」才压实。
+ * 少了它就是抖动 —— 一个稳定在 1_800 行的部署会在每条记录之后都把整本重写一遍。
+ */
+export declare const ASK_JOURNAL_COMPACT_GROWTH = 2;
+/**
+ * 账本的**动词闭集**([ref] 形)。运行期的词表判定与编译期的穷尽 `switch` 读同一份:
+ * 往这里加一个词,{@link FileApprovalAskStore.replayOp} 的 switch 立刻编译红(漏一口不可能发布)。
+ */
+declare const JOURNAL_OPS: readonly ["ensureAsk", "transitionAsk", "decideAsk", "claimTerminal", "expireAsk", "bindBatch", "abortBatch", "deferReconcile", "resolveProvisional", "deleteByTask"];
+type JournalOpWord = (typeof JOURNAL_OPS)[number];
+/** 运行期词表(上面的数组)与类型面动词维({@link JournalCall})的**双向**对表 —— 任一边加词而另一边
+ *  没跟上,这个别名解析成 `never`,{@link JOURNAL_OP_TABLE_GATE} 的赋值当场编译红。 */
+type JournalOpTableIsExhaustive = (JournalCall["op"] extends JournalOpWord ? (JournalOpWord extends JournalCall["op"] ? true : false) : false) extends true ? true : never;
+/** 上面那条对表的**执法位**(占位常量形,`core-keyset-guard.ts` 的占位元组同精神):运行期无用,
+ *  存在的唯一理由是让「词表与类型面分家」在编译期就红,而不是等到某条记录重放不出来。 */
+export declare const JOURNAL_OP_TABLE_GATE: JournalOpTableIsExhaustive;
+/** 一次写调用的实参(动词维判别式)——盘上记的就是它,重放时原样喂回内核。 */
+type JournalCall = {
+    op: "ensureAsk";
+    row: NewAskRow;
+} | {
+    op: "transitionAsk";
+    askId: string;
+    from: AskState;
+    to: AskState;
+    patch: AskTransitionPatch;
+} | {
+    op: "decideAsk";
+    askId: string;
+    batchId: string;
+    decision: DecideAskInput;
+} | {
+    op: "claimTerminal";
+    askId: string;
+    batchId: string;
+    intent: AskTerminalClaimIntent;
+} | {
+    op: "expireAsk";
+    askId: string;
+    batchId: string;
+} | {
+    op: "bindBatch";
+    batchId: string;
+    askId: string;
+    gate: BindGateInput;
+} | {
+    op: "abortBatch";
+    batchId: string;
+} | {
+    op: "deferReconcile";
+    askId: string;
+    expectedState: AskState;
+    expectedRev: number;
+    nowMs: number;
+} | {
+    op: "resolveProvisional";
+    askId: string;
+    from: AskState;
+    to: AskState;
+    patch: AskTransitionPatch;
+} | {
+    op: "deleteByTask";
+    taskId: string;
+};
+export declare class FileApprovalAskStore implements ApprovalAskStore {
+    /** 语义内核(转移判定的唯一真源)。本类对它只做两件事:重放、代理。 */
+    private readonly core;
+    private readonly path;
+    private readonly tmpDir;
+    private log;
+    /** 活文件里的记录数(重放读数 + 每次 append,压实后归为快照行数)。压实判据读它。 */
+    private records;
+    /**
+     * 钉住的钟(见 {@link InMemoryApprovalAskStore} 顶注的读钟纪律)。非 null 的窗口**恒是同步的** ——
+     * 从 append 之后到内核方法返回 promise 为止,其间没有任何 `await` ⇒ 两次并发调用不可能互相看见对方的钉。
+     */
+    private pinnedNow;
+    /** 重放期被内核拒掉的记录数(每条都已 warn;读面留给测试与将来的诊断)。 */
+    private replayRejectedCount;
+    /** 重放期被丢弃的坏行数(撕尾不计:那是本格式存在的理由,由 {@link corruptQuarantinePath} 单独说)。 */
+    private corruptLineCount;
+    /** 本次启动隔离出去的原件路径(无坏字节 ⇒ `undefined`)。 */
+    readonly corruptQuarantinePath: string | undefined;
+    /**
+     * boot 期 fail-stop(File 店族同律,`approval-ask-audit-store.ts` 的同段先例):mkdir / 重放失败
+     * **拒启** —— 一台「审批账写不进却照常发卡」的机器,比起不起来危险得多。
+     *
+     * @param root local 数据根(= `LocalBackend` 的 `FileStorageBackend.root`,零新 env)。
+     */
+    constructor(root: string);
+    /**
+     * 内核的钟。窗口外读 ⇒ **抛**(不静默回落 `Date.now()`):窗口外的读数按定义不在账本上,重放会得出
+     * 另一个时间戳 —— 那是一条**静默**的重放分岔,而本店的全部价值就是重放等价。今天内核的五个读钟点
+     * 全在同步前缀里;哪天有人挪到 `await` 之后,这里当场响。
+     */
+    private clockRead;
+    private logFor;
+    /**
+     * 一次写:**先 append + fsync,再翻内存**(顶注的崩溃序)。append 与内核调用之间零 `await` ⇒
+     * 盘上的记录序 == 内存的转移序(内核的写体全在同步前缀里),两副读数永远对得上。
+     *
+     * 🔴 **内核吃的是「盘上那一份」,不是调用方那一份**(替补对抗复审 F7,采纳):整条调用先过一次 JSON
+     * round-trip,再**把 round-trip 的产物**同时交给账本与内核。不这么做的话,凡是 JSON round-trip 会改形
+     * 的值(`Date` → ISO 串、函数值键被**静默丢掉**、`undefined` 键消失)都会造出一条真分岔:活路径上内核
+     * 手里是原对象、重启重放之后是另一份 —— 而这正是本店整个形所依赖的那条等式。首版只为 `updatedInput`
+     * 一格做了这件事(它另有「编出来什么都不是 ⇒ 响亮拒」的三态判据),其余键(`cardJson` / `patch` /
+     * `gate` / `decisionActor`)留了一条没写出来的例外。一条规则覆盖所有键,例外消失。
+     * 代价如实:不可编码的值(BigInt / 循环引用)在本形上**抛**,而 InMemory 形收得下 —— 那与 SQL 孪生
+     * 同向(它也存不下),是**介质事实**,写进顶注的边界段。
+     *
+     * 🔴 **压实失败不许落到调用方头上**(替补对抗复审 F3 [medium],实测后修):走到 `maybeCompact()` 时这
+     * 一次写**已经 fsync 落盘、也已经翻进内存**,把一次纯管家动作的 I/O 错误抛给调用方 = 把一次已生效的
+     * 人类批准报成失败(客户端重试会拿到 `ask_not_pending`)。压实是 F 类兜底:失败留痕、下一次写再试。
+     */
+    private write;
+    private maybeCompact;
+    /** 整本重写成行快照 + 原子替换。失败 ⇒ 原账本原样留着、`records` 不动(下一次写再试),日志由
+     *  core 的 [ref] 惰性重开接住 —— 一次瞬时 I/O 错误绝不把这条日志变成砖。 */
+    private compact;
+    private replayRecord;
+    /** 闭集穷尽派发(漏一口 = 编译红,[ref] 形)。返回内核的 promise —— 结果本身在重放期无人消费。 */
+    private replayOp;
+    ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
+    transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
+    /**
+     * 🔴 `updatedInput` 的编码必须在 **append 之前**、且走内核**同一只** {@link encodeDecideUpdatedInput}:
+     * 账本本身是 JSON,而 `JSON.stringify` 对顶层函数是**静默丢键**不是抛 —— 不先编码就会写出一条
+     * 「没带编辑」的记录,而活路径那一侧是抛。编码抛 ⇒ 账本一个字节没写、内核一个字节没动(与内核自己的
+     * 「先编码、编码成功才一次性提交」同一条原子性)。
+     */
+    decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;
+    claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent): Promise<AskTerminalClaimOutcome>;
+    expireAsk(askId: string, batchId: string): Promise<ExpireResult>;
+    bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;
+    abortBatch(batchId: string): Promise<string[]>;
+    deferReconcile(askId: string, expectedState: AskState, expectedRev: number, nowMs: number): Promise<boolean>;
+    resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
+    deleteByTask(taskId: string): Promise<void>;
+    listByState(state: AskState, limit: number): Promise<AskRow[]>;
+    listPendingByTask(taskId: string, signal?: AbortSignal): Promise<AskRow[]>;
+    listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
+    getAsk(askId: string): Promise<AskRow | null>;
+    getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
+    getBatch(batchId: string): Promise<BatchRow | null>;
+    /** 重放读数(测试与诊断):被内核拒掉的记录数 / 解析不出的坏行数 / 活文件当前的记录数。 */
+    replayStats(): {
+        rejected: number;
+        corruptLines: number;
+        records: number;
+    };
+    /** 释放追加 fd(`LocalBackend.close` → 优雅重启重开)。不包 try/catch 的理由同
+     *  {@link FileApprovalNonceStore.dispose}:core 的 `AppendLog.close()` 自己就是全函数。 */
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=approval-ask-store-file.d.ts.map

package/dist/plugins/approval-ask-store-file.js

@@ -0,0 +1,258 @@
+import { closeSync, copyFileSync, openSync, readSync, statSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { AppendLog, atomicWriteFile, ensureDir, readJsonlRecords } from "@sema-agent/core";
+import { recordFailOpen } from "../observability/fail-open.js";
+import { StoreBootRefusalError } from "./store-contracts.js";
+import { InMemoryApprovalAskStore, encodeDecideUpdatedInput, encodeStoreJsonPayload } from "./approval-ask-store-memory.js";
+export const APPROVAL_ASK_DIR = "approval-asks";
+export const APPROVAL_ASK_JOURNAL_FILE = "asks.jsonl";
+export const ASK_JOURNAL_COMPACT_MIN_RECORDS = 2_000;
+export const ASK_JOURNAL_COMPACT_GROWTH = 2;
+const JOURNAL_OPS = [
+    "ensureAsk",
+    "transitionAsk",
+    "decideAsk",
+    "claimTerminal",
+    "expireAsk",
+    "bindBatch",
+    "abortBatch",
+    "deferReconcile",
+    "resolveProvisional",
+    "deleteByTask",
+];
+const JOURNAL_OP_WORDS = new Set(JOURNAL_OPS);
+export const JOURNAL_OP_TABLE_GATE = true;
+function endsAtRecordBoundary(path) {
+    const size = statSync(path).size;
+    if (size === 0)
+        return true;
+    const fd = openSync(path, "r");
+    try {
+        const buf = Buffer.alloc(1);
+        readSync(fd, buf, 0, 1, size - 1);
+        return buf[0] === 0x0a;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export class FileApprovalAskStore {
+    core;
+    path;
+    tmpDir;
+    log;
+    records = 0;
+    pinnedNow = null;
+    replayRejectedCount = 0;
+    corruptLineCount = 0;
+    corruptQuarantinePath;
+    constructor(root) {
+        const dir = join(root, APPROVAL_ASK_DIR);
+        ensureDir(dir);
+        this.tmpDir = join(dir, ".tmp");
+        ensureDir(this.tmpDir);
+        this.path = join(dir, APPROVAL_ASK_JOURNAL_FILE);
+        this.core = new InMemoryApprovalAskStore({ now: () => this.clockRead() });
+        const tornTail = existsSync(this.path) && !endsAtRecordBoundary(this.path);
+        const records = readJsonlRecords(this.path, (info) => {
+            this.corruptLineCount += 1;
+            recordFailOpen("server.approval-ask-journal.corrupt-record-skipped", `path=${info.path} reason=${info.reason}`);
+        });
+        for (const rec of records)
+            this.replayRecord(rec);
+        this.records = records.length;
+        if (tornTail || this.corruptLineCount > 0) {
+            const quarantine = `${this.path}.corrupt-${Date.now()}`;
+            copyFileSync(this.path, quarantine);
+            this.corruptQuarantinePath = quarantine;
+            console.warn(`FileApprovalAskStore: approval ask journal ${this.path} had ${tornTail ? "a torn tail" : "no torn tail"} and ` +
+                `${this.corruptLineCount} unparseable line(s) — replayed every COMPLETE record, quarantined the original at ${quarantine}, ` +
+                `and rewrote the live journal from the replayed state. A dropped record is a LOST approval-ask transition: inspect the quarantined file.`);
+            this.compact();
+        }
+    }
+    clockRead() {
+        const pinned = this.pinnedNow;
+        if (pinned === null) {
+            throw new Error("FileApprovalAskStore: the in-memory core read its clock OUTSIDE a journalled window — a clock read after the " +
+                "first `await` cannot be replayed byte-identically. Move the read into the method's synchronous prefix " +
+                "(see the clock discipline in approval-ask-store-memory.ts).");
+        }
+        return pinned;
+    }
+    logFor() {
+        return (this.log ??= new AppendLog(this.path));
+    }
+    write(call, run) {
+        const t = Date.now();
+        const record = { v: 1, k: "op", t, ...call };
+        const encoded = encodeStoreJsonPayload(`${call.op} call`, record);
+        this.logFor().append(encoded, true);
+        this.records += 1;
+        this.pinnedNow = t;
+        let out;
+        try {
+            out = run(encoded);
+        }
+        finally {
+            this.pinnedNow = null;
+        }
+        try {
+            this.maybeCompact();
+        }
+        catch (e) {
+            recordFailOpen("server.approval-ask-journal.compaction-failed", `path=${this.path} err=${e instanceof Error ? e.message : String(e)}`);
+        }
+        return out;
+    }
+    maybeCompact() {
+        if (this.records < ASK_JOURNAL_COMPACT_MIN_RECORDS)
+            return;
+        const snapshot = this.core.exportRows();
+        if (this.records < (snapshot.asks.length + snapshot.batches.length) * ASK_JOURNAL_COMPACT_GROWTH)
+            return;
+        this.compact(snapshot);
+    }
+    compact(snapshot = this.core.exportRows()) {
+        const lines = [
+            ...snapshot.batches.map((row) => `${JSON.stringify({ v: 1, k: "batch", row })}\n`),
+            ...snapshot.asks.map((row) => `${JSON.stringify({ v: 1, k: "ask", row })}\n`),
+        ];
+        this.log?.closeForSwap();
+        atomicWriteFile(this.tmpDir, this.path, lines.join(""));
+        this.records = lines.length;
+    }
+    replayRecord(raw) {
+        if (raw === null || typeof raw !== "object") {
+            this.corruptLineCount += 1;
+            recordFailOpen("server.approval-ask-journal.corrupt-record-skipped", `path=${this.path} reason=record is not an object`);
+            return;
+        }
+        const probe = raw;
+        const refuse = (why) => {
+            throw new StoreBootRefusalError(`FileApprovalAskStore: approval ask journal ${this.path} carries a record this build cannot replay — ${why} ` +
+                `(v=${JSON.stringify(probe.v)} k=${JSON.stringify(probe.k)} op=${JSON.stringify(probe.op)}). ` +
+                "Replaying only the records it understands would resurrect decided asks or drop a human's approval. " +
+                "Run the server version that wrote this journal, or move the file aside (every approval on it is abandoned) to continue.");
+        };
+        if (probe.v !== 1)
+            refuse("unknown envelope version");
+        if (probe.k === "ask" || probe.k === "batch") {
+            const row = probe.row;
+            if (row === null || typeof row !== "object")
+                refuse("snapshot record without a row");
+            const key = probe.k === "ask" ? row.askId : row.batchId;
+            if (typeof key !== "string" || key.length === 0)
+                refuse(`snapshot record without a ${probe.k === "ask" ? "askId" : "batchId"}`);
+            if (probe.k === "ask")
+                this.core.importRows({ asks: [row] });
+            else
+                this.core.importRows({ batches: [row] });
+            return;
+        }
+        if (probe.k !== "op")
+            refuse("unknown record kind");
+        if (typeof probe.op !== "string" || !JOURNAL_OP_WORDS.has(probe.op))
+            refuse("verb outside this build's closed set (a DOWNGRADE: a newer server wrote it)");
+        if (typeof probe.t !== "number" || !Number.isFinite(probe.t))
+            refuse("call record without a clock reading");
+        const rec = raw;
+        this.pinnedNow = rec.t;
+        try {
+            void this.replayOp(rec).catch((e) => {
+                this.replayRejectedCount += 1;
+                console.warn(`FileApprovalAskStore: replaying ${rec.op} from ${this.path} was REFUSED by the store's own rules ` +
+                    `(${e instanceof Error ? e.message : String(e)}). The live call was refused the same way and changed nothing, ` +
+                    "so the state is faithful — but a record nobody can apply should not be on disk; inspect the journal.");
+            });
+        }
+        finally {
+            this.pinnedNow = null;
+        }
+    }
+    replayOp(rec) {
+        switch (rec.op) {
+            case "ensureAsk":
+                return this.core.ensureAsk(rec.row);
+            case "transitionAsk":
+                return this.core.transitionAsk(rec.askId, rec.from, rec.to, rec.patch);
+            case "decideAsk":
+                return this.core.decideAsk(rec.askId, rec.batchId, rec.decision);
+            case "claimTerminal":
+                return this.core.claimTerminal(rec.askId, rec.batchId, rec.intent);
+            case "expireAsk":
+                return this.core.expireAsk(rec.askId, rec.batchId);
+            case "bindBatch":
+                return this.core.bindBatch(rec.batchId, rec.askId, rec.gate);
+            case "abortBatch":
+                return this.core.abortBatch(rec.batchId);
+            case "deferReconcile":
+                return this.core.deferReconcile(rec.askId, rec.expectedState, rec.expectedRev, rec.nowMs);
+            case "resolveProvisional":
+                return this.core.resolveProvisional(rec.askId, rec.from, rec.to, rec.patch);
+            case "deleteByTask":
+                return this.core.deleteByTask(rec.taskId);
+            default: {
+                const unreachable = rec;
+                throw new Error(`FileApprovalAskStore: unreachable journal op ${JSON.stringify(unreachable)}`);
+            }
+        }
+    }
+    async ensureAsk(row) {
+        return this.write({ op: "ensureAsk", row }, (c) => this.core.ensureAsk(c.row));
+    }
+    async transitionAsk(askId, from, to, patch) {
+        return this.write({ op: "transitionAsk", askId, from, to, patch }, (c) => this.core.transitionAsk(c.askId, c.from, c.to, c.patch));
+    }
+    async decideAsk(askId, batchId, decision) {
+        const journalled = decision.updatedInput === undefined ? decision : { ...decision, updatedInput: encodeDecideUpdatedInput(decision.updatedInput) };
+        return this.write({ op: "decideAsk", askId, batchId, decision: journalled }, (c) => this.core.decideAsk(c.askId, c.batchId, c.decision));
+    }
+    async claimTerminal(askId, batchId, intent) {
+        return this.write({ op: "claimTerminal", askId, batchId, intent }, (c) => this.core.claimTerminal(c.askId, c.batchId, c.intent));
+    }
+    async expireAsk(askId, batchId) {
+        return this.write({ op: "expireAsk", askId, batchId }, (c) => this.core.expireAsk(c.askId, c.batchId));
+    }
+    async bindBatch(batchId, askId, gate) {
+        return this.write({ op: "bindBatch", batchId, askId, gate }, (c) => this.core.bindBatch(c.batchId, c.askId, c.gate));
+    }
+    async abortBatch(batchId) {
+        return this.write({ op: "abortBatch", batchId }, (c) => this.core.abortBatch(c.batchId));
+    }
+    async deferReconcile(askId, expectedState, expectedRev, nowMs) {
+        return this.write({ op: "deferReconcile", askId, expectedState, expectedRev, nowMs }, (c) => this.core.deferReconcile(c.askId, c.expectedState, c.expectedRev, c.nowMs));
+    }
+    async resolveProvisional(askId, from, to, patch) {
+        return this.write({ op: "resolveProvisional", askId, from, to, patch }, (c) => this.core.resolveProvisional(c.askId, c.from, c.to, c.patch));
+    }
+    async deleteByTask(taskId) {
+        return this.write({ op: "deleteByTask", taskId }, (c) => this.core.deleteByTask(c.taskId));
+    }
+    listByState(state, limit) {
+        return this.core.listByState(state, limit);
+    }
+    listPendingByTask(taskId, signal) {
+        return this.core.listPendingByTask(taskId, signal);
+    }
+    listPendingBySession(sessionId, owner, signal) {
+        return this.core.listPendingBySession(sessionId, owner, signal);
+    }
+    getAsk(askId) {
+        return this.core.getAsk(askId);
+    }
+    getByIdempotencyKey(taskId, key) {
+        return this.core.getByIdempotencyKey(taskId, key);
+    }
+    getBatch(batchId) {
+        return this.core.getBatch(batchId);
+    }
+    replayStats() {
+        return { rejected: this.replayRejectedCount, corruptLines: this.corruptLineCount, records: this.records };
+    }
+    dispose() {
+        this.log?.close();
+        this.log = undefined;
+    }
+}
+//# sourceMappingURL=approval-ask-store-file.js.map

package/dist/plugins/approval-ask-store-memory.d.ts

@@ -1,9 +1,22 @@
 /**
- * `InMemoryApprovalAskStore` —— [ref] 车1,`ApprovalAskStore` 的语义真源(twin 对拆基准)+ LOCAL
- * 车道占位(File 形不在本车,见设计定稿 §7)。单进程内两个 `Map`,方法体全同步(不含 `await` 中断点)——
+ * `InMemoryApprovalAskStore` —— [ref] 车1,`ApprovalAskStore` 的语义真源(twin 对拆基准)。单进程内两个
+ * `Map`,方法体全同步(不含 `await` 中断点)——
  * Node 单线程下这就是天然原子:`Promise.all` 发起的并发调用不会在方法体内部交错执行,与
  * `approval-ask-store-sql.ts` 的 CAS UPDATE 语义逐字段一致(SQL twin 对拆套件的基准就是这份实现）。
  *
+ * 🔴 **S-384:本类同时是 `FileApprovalAskStore` 的内核**(local 车道的持久形不再是「第二份手抄」——
+ * 它把本类**原样**包起来,每次写前先把**调用本身**落 JSONL、重放时用同一只内核重放同一串调用)。
+ * 为此本类多了三件、且**只**多这三件(全是数据面,零转移判定):
+ *  · {@link InMemoryApprovalAskStore.constructor} 的可注入钟 `now` —— 五个动词(decideAsk / claimTerminal /
+ *    expireAsk / bindBatch / abortBatch)原先直读 `Date.now()`,那是重放路上唯一的不确定源:同一串调用
+ *    重放出来的 `updatedAtMs`/`decidedAtMs` 必须与当初**逐字节**相同,否则「重放等价」是假的。
+ *    ⚠️ **钟只许在方法体的同步前缀里读**(第一个 `await` 之前)—— File 形据此把钟钉在一次调用的同步窗口
+ *    内,窗口外读钟会被它的钟函数**响亮拒**(不是静默回落 `Date.now()`)。今天五个动词全部满足;
+ *    哪天有人把读钟挪到 `await` 之后,File 形的钟当场抛,而不是悄悄写出一条重放不出来的行。
+ *  · {@link InMemoryApprovalAskStore.exportRows} / {@link InMemoryApprovalAskStore.importRows} —— 压实用的
+ *    整本快照口(纯搬行,不经任何谓词)。压实要把「一串调用」折成「一串终局行」,没有这一对就只能在
+ *    File 形里另写一套「哪些行还算数」的判据 —— 那才是第二份手抄。
+ *
  * 行为口径与 `SqlApprovalAskStore` 逐条对齐:
  *  - ensureAsk 幂等 upsert(ask_id 已在 ⇒ 返回既有行,不改写;batch 行若不存在则以 OPEN 补齐）。
  *  - transitionAsk 先过 machine 层 `canAskTransition`(非法转移 throw，不返回 false）。
@@ -13,9 +26,54 @@
  */
 import { type AskState, type BatchState } from "../approval-ask-machine.js";
 import type { AskDecision, AskRow, AskTerminalClaimIntent, AskTerminalClaimOutcome, AskTransitionPatch, ApprovalAskStore, BatchRow, BindGateInput, BindResult, DecideAskInput, EnsureAskResult, DecideResult, ExpireResult, NewAskRow } from "./approval-ask-store-sql.js";
+/**
+ * [ref] 的 `updatedInput` **入店编码**——两 twin 共用的那一只(本函数是唯一真源)。
+ *
+ * 语义:镜像 SQL twin 的「存 JSON 文本再解回来」(`dialectJsonEncoder` → `parseJsonColumn`)。BigInt /
+ * 循环引用 ⇒ `JSON.stringify` 抛(两侧同抛);顶层函数 / `undefined` ⇒ `stringify` 交出 `undefined`
+ * (「编出来什么都不是」)⇒ 本函数**响亮拒**,而不是让它在库里变成 NULL、在内存里变成活函数。
+ *
+ * 🔴 为什么必须是一只**导出**函数而不是 `decideAsk` 里的内联段(S-384):`FileApprovalAskStore` 要在
+ * **落日志之前**把这一步做掉 —— 它的日志本身就是 JSON,而 `JSON.stringify` 对顶层函数是**静默丢键**
+ * 不是抛。内联在 decideAsk 里的话,File 形只能在自己那侧再写一遍同样的判定(第二份手抄),或者
+ * 让「活路径抛 / 重放路径成功 DECIDE」这条真分岔活下来。
+ *
+ * ⚠️ 它与 File 形对**整条调用**做的那次 JSON round-trip 是两件事,别合并:round-trip 保证的是
+ * 「内核看见的 == 重放看见的」(把静默丢键变成两边一致);本函数保证的是「编出来什么都不是 ⇒ 响亮拒」,
+ * 而那条判据只在 `updatedInput` 这一格上成立 —— 它的**缺席**与**值为 null** 在 wire 上是两回事
+ * (`AskRow.updatedInput` 三态),所以「被 round-trip 静默丢成缺席」在这一格上不是无害的归一。
+ */
+export declare function encodeStoreJsonPayload(what: string, value: unknown): unknown;
+/** [ref] `updatedInput` 的入店编码 = 上面那只的一次具名调用(词固定在一处,两 twin 与 File 形账本共用)。 */
+export declare function encodeDecideUpdatedInput(updatedInput: unknown): unknown;
+/** {@link InMemoryApprovalAskStore.exportRows} 的产出 / {@link InMemoryApprovalAskStore.importRows} 的入参
+ *  —— **纯行**,零判定。压实(S-384 File 形)与测试的状态对拆共用。 */
+export interface ApprovalAskRowsSnapshot {
+    asks: readonly AskRow[];
+    batches: readonly BatchRow[];
+}
 export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     private readonly asks;
     private readonly batches;
+    /** 店钟(S-384)。缺省 = 本进程墙钟,与本类落地以来逐字同值;File 形注入一只**钉住的**钟,让
+     *  「同一串调用重放出同一份状态」成立。读钟纪律见类顶注(只许在同步前缀里读)。 */
+    private readonly now;
+    constructor(opts?: {
+        now?: () => number;
+    });
+    /**
+     * S-384:整本行快照(压实用)。**深拷到行级**(与每个读口交出 `{ ...row }` 同一条纪律:交出去的行
+     * 不再是店内那一份,调用方改它碰不到店)。行内的 `cardJson`/`updatedInput`/`decisionActor` 仍是引用 ——
+     * 与 `getAsk`/`listByState` 逐字同宽,不在这一口上单独加深拷(那会让快照口与读口对同一份 blob 给出
+     * 两种可变性)。
+     */
+    exportRows(): ApprovalAskRowsSnapshot;
+    /** S-384:把快照里的行**原样**装回两张 Map(同键覆盖)。零谓词、零状态机 —— 它不是一条转移,是重放
+     *  的起手状态。压实产物与本口是一对:压实写出 {@link exportRows} 的行,启动时由本口装回。 */
+    importRows(snapshot: {
+        asks?: readonly AskRow[];
+        batches?: readonly BatchRow[];
+    }): void;
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;

package/dist/plugins/approval-ask-store-memory.js

@@ -20,9 +20,32 @@ function applyPatch(row, patch) {
     if (patch.provisional !== undefined)
         row.provisional = patch.provisional;
 }
+export function encodeStoreJsonPayload(what, value) {
+    const text = JSON.stringify(value);
+    if (text === undefined)
+        throw new Error(`approval-ask-store: ${what} is not JSON-encodable (encodes to nothing) — the SQL twin cannot hold it either`);
+    const decoded = JSON.parse(text);
+    return decoded;
+}
+export function encodeDecideUpdatedInput(updatedInput) {
+    return encodeStoreJsonPayload("updatedInput", updatedInput);
+}
 export class InMemoryApprovalAskStore {
     asks = new Map();
     batches = new Map();
+    now;
+    constructor(opts) {
+        this.now = opts?.now ?? Date.now;
+    }
+    exportRows() {
+        return { asks: [...this.asks.values()].map((r) => ({ ...r })), batches: [...this.batches.values()].map((b) => ({ ...b })) };
+    }
+    importRows(snapshot) {
+        for (const r of snapshot.asks ?? [])
+            this.asks.set(r.askId, { ...r });
+        for (const b of snapshot.batches ?? [])
+            this.batches.set(b.batchId, { ...b });
+    }
     async ensureAsk(row) {
         assertIntegralEpochMs("expiresAtMs", row.expiresAtMs);
         assertIntegralEpochMs("createdAtMs", row.createdAtMs);
@@ -90,7 +113,7 @@ export class InMemoryApprovalAskStore {
     async decideAsk(askId, batchId, decision) {
         if (decision.idempotencyKey != null)
             assertIdempotencyKeyShape(decision.idempotencyKey);
-        const now = Date.now();
+        const now = this.now();
         const batch = this.batches.get(batchId);
         if (!batch || batch.state !== "OPEN") {
             const row = this.asks.get(askId);
@@ -108,13 +131,8 @@ export class InMemoryApprovalAskStore {
             }
         }
         let encodedUpdatedInput;
-        if (decision.updatedInput !== undefined) {
-            const text = JSON.stringify(decision.updatedInput);
-            if (text === undefined)
-                throw new Error("approval-ask-store(memory): updatedInput is not JSON-encodable (encodes to nothing) — the SQL twin cannot hold it either");
-            const decoded = JSON.parse(text);
-            encodedUpdatedInput = decoded;
-        }
+        if (decision.updatedInput !== undefined)
+            encodedUpdatedInput = encodeDecideUpdatedInput(decision.updatedInput);
         batch.rev += 1;
         batch.updatedAtMs = now;
         ask.state = "DECIDED";
@@ -141,7 +159,7 @@ export class InMemoryApprovalAskStore {
             const scoped = this.asks.get(askId);
             if (scoped !== undefined && scoped.batchId !== batchId)
                 return { claimed: false, current: { state: "absent" } };
-            const won = await this.transitionAsk(askId, "STREAM_PENDING", "VOID", { updatedAtMs: Date.now() });
+            const won = await this.transitionAsk(askId, "STREAM_PENDING", "VOID", { updatedAtMs: this.now() });
             if (won)
                 return { claimed: true, voidedSiblings: [] };
         }
@@ -149,7 +167,7 @@ export class InMemoryApprovalAskStore {
         return { claimed: false, current: projectAskTerminalClaimTruth(cur !== undefined && cur.batchId === batchId ? { ...cur } : null) };
     }
     async expireAsk(askId, batchId) {
-        const now = Date.now();
+        const now = this.now();
         const batch = this.batches.get(batchId);
         if (!batch)
             return { won: false, voidedSiblings: [] };
@@ -176,7 +194,7 @@ export class InMemoryApprovalAskStore {
         return { won: true, voidedSiblings: voided };
     }
     async bindBatch(batchId, askId, gate) {
-        const now = Date.now();
+        const now = this.now();
         const batch = this.batches.get(batchId);
         if (!batch)
             return { ok: false, batchState: "MISSING" };
@@ -216,7 +234,7 @@ export class InMemoryApprovalAskStore {
         return true;
     }
     async abortBatch(batchId) {
-        const now = Date.now();
+        const now = this.now();
         const batch = this.batches.get(batchId);
         if (!batch || (batch.state !== "OPEN" && batch.state !== "ROUTING_UNBOUND"))
             return [];

package/dist/plugins/checkpoint-store-sql.d.ts

@@ -369,6 +369,28 @@ export declare const DECIDED_REPLAY_SCAN_CAP = 8;
  *     (plan_review / dry_run_review)的判词,那些门的决议入口不是本腿,回放它们等于跨门作答。
  */
 export declare function approvalDecisionOfWinner(winner: ResolvedOutcome | undefined, boundCallId: string): "approve" | "deny" | null;
+/**
+ * checkpoint blob → `pendingAction.toolCallId`。
+ *
+ * 🔴 三态、**不是**两态(真双库实跑抓到的缺陷,2026-08-06):「读不出」与「读出来了、但这条 park 本来就
+ * 没有 toolCallId」是两件事,压成同一个 `undefined` 会把每一条 `plan_review`/`task_done`/`resource_limit`
+ * 腿(core 的 `PendingAction` 联合里三个成员结构上就没有 toolCallId)都误报成坏行。前者应标 `unparseable`
+ * 交给收敛器当「不确定」,后者是**确定的不匹配**——干净地不是候选。
+ *  - `{ readable: false }`        —— JSON 坏 / 形状根本不是对象:真的读不出。
+ *  - `{ readable: true, toolCallId: null }` —— 读出来了,这条 park 无工具动作:确定不匹配。
+ *  - `{ readable: true, toolCallId: "…" }`  —— 读出来了,拿去比。
+ *
+ * 逐层 `typeof` 收窄,不做裸 `as` 断言:blob 是持久层读回来的 `unknown`,是信任边界(宪法 [ref])。
+ */
+export declare function pendingActionToolCallId(blob: unknown): {
+    readable: true;
+    toolCallId: string | null;
+    boundInputHash: string | null;
+    kind: string | null;
+    sourceTaskId: string | null;
+} | {
+    readable: false;
+};
 /** `pending_steer_queue` 列承载的 CheckpointState 字段(= core `appendPendingSteer` / `readPendingSteerQueue`
  *  的入参形)。列是**唯一**权威(suspend 时写的 blob 从不带它)。 */
 type SteerColumnState = Pick<CheckpointState, "pendingSteerQueue">;

package/dist/plugins/checkpoint-store-sql.js

@@ -166,7 +166,7 @@ export function approvalDecisionOfWinner(winner, boundCallId) {
         }
     }
 }
-function pendingActionToolCallId(blob) {
+export function pendingActionToolCallId(blob) {
     let parsed;
     try {
         parsed = typeof blob === "string" ? JSON.parse(blob) : blob;

package/dist/plugins/file-run-store.d.ts

@@ -1,6 +1,6 @@
 import { type UsageRow } from "../usage-analytics.js";
 import type { TaskStatus } from "@sema-agent/core";
-import type { RunRecord, SessionSummary, RunEvent, PersistedTaskResult, LatestRunRef } from "./store-contracts.js";
+import { StoreBootRefusalError, type RunRecord, type SessionSummary, type RunEvent, type PersistedTaskResult, type LatestRunRef } from "./store-contracts.js";
 import type { RunStoreCheckpointProbe } from "./memory-run-store.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
 /**
@@ -13,8 +13,12 @@ import type { LedgerEventType } from "../trace/ledger-events.js";
  * catch 吞掉:operator 明确要的 **fail-closed 反而变成 fail-open**,而且丢的正是持久 run 账本(这根旋钮
  * 存在的全部理由)。判据锚在**类型**上,不在文案上 —— 文案会改,类型不会(同文件族先例:`AdoptionError`
  * 在同一个降级臂里也是按类型无条件重抛)。
+ *
+ * 🔴 **S-384:本类自此 `extends StoreBootRefusalError`**(族规基类,见那条顶注)。上面这段论证对
+ * **每一只**会在 `LocalBackend` 构造器里拒启的 File 店逐字成立,而逐个 `if instanceof` 手工登记会漏 ——
+ * S-384 的 ask 账本拒启就漏过一次。继承 = 自动落在正确的一侧。
  */
-export declare class RunStoreStrictHydrateError extends Error {
+export declare class RunStoreStrictHydrateError extends StoreBootRefusalError {
     readonly name = "RunStoreStrictHydrateError";
 }
 export declare class FileRunStore {

package/dist/plugins/file-run-store.js

@@ -6,6 +6,7 @@ import { randomBytes } from "node:crypto";
 import { terminalProjection } from "@sema-agent/core";
 import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprint, readJsonlRecords, sanitizePathComponent, writeThenLink } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
+import { StoreBootRefusalError } from "./store-contracts.js";
 import { notifyRunTerminal } from "../observability/run-terminal-log.js";
 import { migrateRetiredAskOrigin } from "./one-time-migrations.js";
 const ownerEq = (a, b) => (a ?? null) === (b ?? null);
@@ -21,7 +22,7 @@ function readClaimRecord(recs, sessionId) {
     return c;
 }
 const PARK_ORPHAN_SETTLE_MS = 30_000;
-export class RunStoreStrictHydrateError extends Error {
+export class RunStoreStrictHydrateError extends StoreBootRefusalError {
     name = "RunStoreStrictHydrateError";
 }
 export class FileRunStore {

package/dist/plugins/local-checkpoint-store.d.ts

@@ -1,5 +1,5 @@
 import { type Checkpoint, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
-import { type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
+import { type CheckpointAskCandidate, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
 export interface LocalCheckpointStoreOptions {
     /** taskId join for the pending card (the local FileRunStore's `getActiveTaskId`). Absent ⇒ `taskId: null`. */
     getActiveTaskId?: (sessionId: string) => Promise<string | undefined>;
@@ -130,6 +130,34 @@ export declare class LocalCheckpointStore {
      *    投了就是「SQL 车道有、local 车道没有」的键集分岔。
      */
     findDecidedApprovalsForBinding(sessionId: string, boundCallId: string): Promise<DecidedApprovalRecord[]>;
+    /**
+     * S-384 —— 对账收敛器**判据 1**(身份三元组 ∧ hash 双等 ⇒ `bindBatch`)的读口在 local 车道的形。
+     * 语义、判别纪律、`unparseable` 的含义,唯一属主 = SQL 孪生 `findCheckpointCandidatesForAsk` 的顶注与
+     * `CheckpointAskCandidate` 的字段注;这里只记**本形自己的三处差别**。
+     *
+     * 🔴 **为什么必须有这一口**(不是锦上添花):S-384 让 local 车道有了持久 ask 账,于是收敛器在这条车道上
+     * 第一次真的有行可扫。缺这一口 ⇒ 判据 1 结构性不命中 ⇒ **窗到期 park 的 ask 行永远停在 `PARKING`**,
+     * 而那个态在 wire 上是有后果的:`POST /v1/tool-approvals/:id/respond` 的 `PARKING` 臂答的是
+     * `202 parking_in_progress + retryAfterMs`(它的前提是「`bindBatch` 毫秒级就到」),在一台绑不了的机器上
+     * 那句「再试一次」**永远不会兑现**;run 跑到终局后判据 2 还会把它收成
+     * `DENIED(routing_failure_fail_closed)` ⇒ 迟到答拿到的判别位是 `denied` —— 对一条**人真的批准过**的 ask
+     * 撒谎。两条都是相对 7.80.2 的回归,根因同一个:**判据 1 的读口只有 SQL 孪生有**。修在源头 = 把这一口
+     * 补齐,而不是给下游那两处各加一条「这台机器绑不了」的特判。
+     *
+     * 形差(逐条,如实):
+     *  · **枚举面**走 [ref] 的 `sessionTokens` 索引(与 `hasExpiredBySession` / `findDecidedApprovalsForBinding`
+     *    同一条路),所以它那条**存量限制**在这里逐字同样成立:索引建立之前 put 的老行对本口不可见 ⇒ 判据 1
+     *    不命中 ⇒ 行落判据 ②③④⑤(保守方向,与读口缺席时的既有降级同向)。
+     *  · **没有列,所以没有列/blob 一致性门**:SQL 孪生的两道矛盾门(`tool_call_id` 与 `bound_input_hash`
+     *    的列 vs blob)在本形结构上不存在 —— 本形只有 blob 这一个真源,谈不上两份互相矛盾。判别力因此**不弱**:
+     *    那两道门防的是「外部改库 / schema 偏斜让列与 blob 分家」,而本形没有可分家的第二份。
+     *  · **没有行级版本闸**:本类 `peekScopeByToken` 顶注已亲核过这条事实 —— 本形的 `get()` 没有行级版本闸,
+     *    唯一的读不动形是账本重放级(整店同时读不动)。所以 SQL 孪生那道 `version > MAX_SUPPORTED` 的
+     *    `unparseable` 臂在这里没有对应物;本口的 `unparseable` 只由**窄读器**判(blob 形不合)。
+     *  · **窄读器是同一只** `pendingActionToolCallId`(与 SQL 孪生共用,零第二份手抄):身份三元组的第一维
+     *    `sourceTaskId`、`boundInputHash`、以及「读不出 vs 确定不匹配」的三态,全部由它一家判。
+     */
+    findCheckpointCandidatesForAsk(scope: string, sessionId: string, toolCallId: string, sinceMs: number): Promise<CheckpointAskCandidate[]>;
     /**
      * [ref]:按 token 的 scope 读 —— 与 SQL 孪生**同一条契约**(`undefined` 无行 / `null` 匿名 / 属主串),
      * 语义与存在理由的唯一属主 = SQL 侧 `peekScopeByToken` 顶注。

package/dist/plugins/local-checkpoint-store.js

@@ -4,7 +4,7 @@ import { existsSync, readFileSync, readdirSync, renameSync, unlinkSync, mkdirSyn
 import { join } from "node:path";
 import { isApprovalGateKind } from "../tool-approval.js";
 import { FileCheckpointStore, atomicWriteFile, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
-import { approvalDecisionOfWinner, approvalPayloadFingerprint, boundedRuleOffers, boundedToolInput, pendingRowPrecedes, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-sql.js";
+import { approvalDecisionOfWinner, approvalPayloadFingerprint, boundedRuleOffers, boundedToolInput, pendingActionToolCallId, pendingRowPrecedes, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-sql.js";
 import { UNMANAGED_RETENTION } from "./retention-store-sql.js";
 function terminalAtOf(cp) {
     return Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS);
@@ -236,6 +236,29 @@ export class LocalCheckpointStore {
         }
         return out;
     }
+    async findCheckpointCandidatesForAsk(scope, sessionId, toolCallId, sinceMs) {
+        const tokens = this.sessionTokens.get(sessionId);
+        if (!tokens)
+            return [];
+        const out = [];
+        for (const t of [...tokens]) {
+            const cp = await this.inner.get(t);
+            if (!cp)
+                continue;
+            if (cp.scope !== scope || cp.sessionId !== sessionId || cp.createdAt < sinceMs)
+                continue;
+            const base = { token: t, status: cp.status, createdAtMs: cp.createdAt };
+            const derived = pendingActionToolCallId(cp);
+            if (!derived.readable) {
+                out.push({ ...base, sourceTaskId: null, boundCallId: null, boundInputHash: null, unparseable: true });
+                continue;
+            }
+            if (derived.toolCallId !== toolCallId)
+                continue;
+            out.push({ ...base, sourceTaskId: derived.sourceTaskId, boundCallId: derived.toolCallId, boundInputHash: derived.boundInputHash });
+        }
+        return out.sort((a, b) => a.createdAtMs - b.createdAtMs || (a.token < b.token ? -1 : a.token > b.token ? 1 : 0));
+    }
     async peekScopeByToken(token) {
         return (await this.inner.get(token))?.scope;
     }

package/dist/plugins/store-backend.d.ts

@@ -154,15 +154,16 @@ export interface StoreBackend {
      *  **不能**退化成进程内易失形:一次重启若把记录抹掉,JWT TTL 窗内的重放就复活了,而那正是本店要关的洞。 */
     approvalNonce(): ApprovalNonceStore;
     /** [ref]([ref] §3.0-§3.2)流内审批协议持久层:每个流内工具调用一行的 ask 状态机 + 批行。
-     *  REQUIRED on all backends — tidb/pg = SQL 双方言 twin;local = {@link InMemoryApprovalAskStore}。
+     *  REQUIRED **且持久** on all backends — tidb/pg = SQL 双方言 twin;local = {@link FileApprovalAskStore}。
      *
-     *  🔴 local 形的代价必须在这里说清楚(而不是留给读者自己发现):InMemory 的 STREAM_PENDING/DECIDED/
-     *  PARKING 全在两个进程内 Map 里 ⇒ **重启同时丢重放基准、丢已接受的决议、丢审计**——「一次真实的人类
-     *  批准凭空消失」和「对账便利丢失」不是一个量级。因此协议在 local 车道**默认不上场**:能力面
-     *  (`streamApproval`)的判据带一条「ask 账必须是持久的」合取项,local 不报 true(诚实缺席,同
-     *  `park 设施缺席 ⇒ 协议不上场` 的姿势)。要在 local 真上协议,先落 File 形(现成模子 =
-     *  {@link FileApprovalExemptionStore}:core `AppendLog`/`readJsonlRecords`,内存索引 + 追加日志即可
-     *  满足单实例 boot-lock 下的 CAS),那时这里换成 File twin、能力面自然翻真。
+     *  🔴 **「持久」是本口的契约,不是某条腿的巧合**(S-384):`resolveStreamApprovalGate` 自此**不再**
+     *  单独判一次 ask 账的持久性 —— 那条合取项(旧 `volatile_ask_ledger`)存在的唯一理由是 local 车道
+     *  当年交的是 `InMemoryApprovalAskStore`(两个进程内 Map ⇒ 重启同时丢重放基准、丢已接受的决议;
+     *  「一次真实的人类批准凭空消失」与「对账便利丢失」不是一个量级)。File 形落地后三条腿全是持久店,
+     *  那条合取项没有任何可以让它为假的输入 ⇒ 按「修完让规则更少」删掉,持久性的义务搬到**这里**。
+     *  ⇒ **新加一条 backend 腿时必须给持久店**:进程内易失形会让能力面 `streamApproval` 对消费方撒谎
+     *  (它承诺的是「稍后还能批、崩了行还在」)。机器钉 = `wiring-governance-operator.test.ts` 的
+     *  「三腿 approvalAsk 全持久」格。
      *
      *  无 backend 的 env-only worker 压根没有 `StoreBackend` ⇒ 协调器拿到 undefined askStore ⇒ 车2 的
      *  D1 逐字现行为(store 缺席 = 现行 `tool_approval` 活卡腿一字不变)。 */

package/dist/plugins/store-backend.js

@@ -6,7 +6,8 @@ import { fileSessionCaptureRecordStore } from "@sema-agent/core";
 import { TiDBOutcomeLedger, PgOutcomeLedger } from "./outcome-ledger-sql.js";
 import { FileOutcomeSink } from "./file-outcome-sink.js";
 import { TiDBWorkflowRunStore, TiDBWorkflowCompletionInbox, TiDBWorkflowNotifyJournalStore, TiDBWorkflowAgentSessionIndex, PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore, PgWorkflowAgentSessionIndex } from "./workflow-run-store-sql.js";
-import { FileRunStore, RunStoreStrictHydrateError } from "./file-run-store.js";
+import { FileRunStore } from "./file-run-store.js";
+import { StoreBootRefusalError } from "./store-contracts.js";
 import { NO_SQL_MIGRATIONS, runSqlOneTimeMigrations } from "./one-time-migrations.js";
 import { LocalSessionStore } from "./local-session-store.js";
 import { LocalCheckpointStore } from "./local-checkpoint-store.js";
@@ -14,7 +15,7 @@ import { FileResumeAnchorStore } from "./file-resume-anchor-store.js";
 import { TiDBApprovalExemptionStore, PgApprovalExemptionStore, FileApprovalExemptionStore } from "./approval-exemption-store.js";
 import { TiDBApprovalNonceStore, PgApprovalNonceStore, FileApprovalNonceStore } from "./approval-nonce-store.js";
 import { TiDBApprovalAskStore, PgApprovalAskStore } from "./approval-ask-store-sql.js";
-import { InMemoryApprovalAskStore } from "./approval-ask-store-memory.js";
+import { FileApprovalAskStore } from "./approval-ask-store-file.js";
 import { TiDBMemoryOptOutGrantStore, PgMemoryOptOutGrantStore } from "./memory-optout-grant-store-sql.js";
 import { TiDBSessionCaptureRecordStore, PgSessionCaptureRecordStore } from "./session-capture-record-store-sql.js";
 import { TiDBSendFileLedger, PgSendFileLedger, FileSendFileLedger } from "./send-file-ledger.js";
@@ -204,7 +205,7 @@ class LocalBackend {
     resumeAnchorStore;
     approvalExemptionStore;
     approvalNonceStore;
-    approvalAskStore = new InMemoryApprovalAskStore();
+    approvalAskStore;
     sendFileLedgerStore;
     workflowJournalStore;
     outcomeSinkInst;
@@ -243,6 +244,7 @@ class LocalBackend {
         this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root);
         this.approvalExemptionStore = new FileApprovalExemptionStore(this.fileBackend.root);
         this.approvalNonceStore = new FileApprovalNonceStore(this.fileBackend.root);
+        this.approvalAskStore = new FileApprovalAskStore(this.fileBackend.root);
         this.sendFileLedgerStore = new FileSendFileLedger(this.fileBackend.root);
         this.workflowJournalStore = new FileWorkflowJournalStore(this.fileBackend.root);
         this.outcomeSinkInst = new FileOutcomeSink(this.fileBackend.root);
@@ -261,6 +263,7 @@ class LocalBackend {
         this.resumeAnchorStore.dispose();
         this.approvalExemptionStore.dispose();
         this.approvalNonceStore.dispose();
+        this.approvalAskStore.dispose();
         this.sendFileLedgerStore.dispose();
         this.workflowJournalStore.dispose();
         this.checkpointStoreInst?.close();
@@ -336,7 +339,7 @@ export async function openStoreBackendWithFallback(config, logger) {
     catch (err) {
         if (err instanceof AdoptionError)
             throw err;
-        if (err instanceof RunStoreStrictHydrateError)
+        if (err instanceof StoreBootRefusalError)
             throw err;
         if (!mayFallback)
             throw err;

package/dist/plugins/store-contracts.d.ts

@@ -15,6 +15,26 @@
  *    code should import from this file.
  */
 import type { TaskResult, TaskStatus } from "@sema-agent/core";
+/**
+ * **File 店族的 boot 期拒启基类**(S-384;把 `RunStoreStrictHydrateError` 的那条论证升成一条族规)。
+ *
+ * 🔴 **为什么必须是一个可判别的类型,而且必须是一个共同基类**:`openStoreBackendWithFallback` 对
+ * **默认推导**的 local(`DB_BACKEND` 未设 —— 也就是绝大多数单机部署)有一条既有降级臂:mkdir / 只读盘
+ * 那类「这台机器存不了盘」的失败降级到内存继续起。而 `LocalBackend` 构造器里的每一只 File 店都可能抛出
+ * 一条**完全不同**的句子——「这份数据有主 / operator 要了 fail-closed / 这份账本我重放不了」——它们从那个
+ * catch 看长得一模一样。不给身份 ⇒ 被同一条降级臂吞掉:一次**明确的 fail-closed 表态被翻译成 fail-open**,
+ * 整只 `StoreBackend` 被丢掉(持久 run 账本、`/v1/approvals`、park 全没),而唯一的痕迹是一行
+ * 「DB 不可达,已退回内存」把运维支去查连通性。
+ *
+ * 此前这条纪律是**逐个 `if instanceof` 手工登记**的(`AdoptionError` / `RunStoreStrictHydrateError`),
+ * 于是「下一只会拒启的 File 店」默认是**漏的** —— S-384 的 ask 账本拒启就这么漏了一次(替补对抗复审
+ * F1 [high] 实测:`DB_BACKEND` 未设时坏账本 ⇒ `{backend: undefined, degraded: true}`,不是拒启)。
+ * 收法:**一个基类,一条重抛**。新 File 店的拒启只要 `extends StoreBootRefusalError` 就自动落在正确的
+ * 一侧;忘了继承是**可见**的(它是一个必须显式选择的父类),而忘了往 if 链里加一行是不可见的。
+ * (core 的 `AdoptionError` 不在本仓,改不了它的继承链 ⇒ 降级臂保留它那一条 `instanceof`,共两条。)
+ */
+export declare class StoreBootRefusalError extends Error {
+}
 /**
  * 取消便签里的**大脑相位**快照 —— core `BrainStatus` 帧经 `brainStatusEventData` 投影后的五键子集。
  *

package/dist/plugins/store-contracts.js

@@ -1,4 +1,6 @@
 import { parseJsonOr, toIso as iso, normalizeIsoOrNull as isoOrNull } from "./sql-row-helpers.js";
+export class StoreBootRefusalError extends Error {
+}
 export const RUN_STATUS_CLASS = {
     running: "live",
     completed: "succeeded",

package/dist/tool-approval.d.ts

@@ -574,24 +574,29 @@ export type UnattendedApprovalPolicy = "park" | "deny";
  * 于是「能力面说 true」⟺「协调器真拿到了 askStore」⟺「回决端点真有账可 CAS」是**结构成立**的,
  * 不再靠三处注释互相提醒。
  *
- * 五个合取项,缺一即不上场(每一项的缺席都有它自己的 `reason`,供启动期 info 与诊断分辨):
+ * 四个合取项,缺一即不上场(每一项的缺席都有它自己的 `reason`,供启动期 info 与诊断分辨):
  *  1. `toolApprovalEnabled` —— 连活卡腿都没有,谈不上流内协议;
  *  2. `streamApprovalEnabled` —— 协议总开关(`STREAM_APPROVAL_ENABLED`,树上已**默认 ON**;显式 `false`
  *     是唯一干净还原键。默认极性与版本坐标的属主口径见 `config.ts` 的 `streamApprovalConfig()` 头注);
  *  3. `backend` 在场 —— env-only worker 没有 `StoreBackend` 本体;
- *  4. **账必须是持久的**(`kind !== "local"`)—— InMemory 形重启即丢**已接受的决议**,那与「对账便利
- *     丢失」不是一个量级(§2.2(b));File 形 ask 店落地后这一项自然翻真;
- *  5. **park 设施在场**(§8.4)—— 缺席时「窗到期 ⇒ unavailable」在 core 侧没有降级目的地,结局是
+ *  4. **park 设施在场**(§8.4)—— 缺席时「窗到期 ⇒ unavailable」在 core 侧没有降级目的地,结局是
  *     fail-closed deny,**比现状(5min 活卡、人能批)更差**。所以自检不满足 ⇒ **协议不上场**、现行
  *     `tool_approval` 活卡腿逐字保留,而不是「把 ask 推向一个不存在的目的地」(§14 属主照准,core [ref]
  *     回帖确认即原意)。
+ *
+ * 🔴 **S-384:第 5 项(旧第 4 项 `volatile_ask_ledger` = 「账必须是持久的」,判据 `kind !== "local"`)
+ * 已整条删除,词也从闭集里删了(零别名)**。它当年成立的唯一输入是 local 车道交的 `InMemoryApprovalAskStore`;
+ * `FileApprovalAskStore` 落地后 `StoreBackend.approvalAsk()` 的三条腿全是持久店 ⇒ 这条合取项**没有任何
+ * 能让它为假的输入**,留着就是一条永不触发的规则(「修完让规则集更小」)。持久性的义务搬到
+ * `StoreBackend.approvalAsk()` 的接口契约上(那条注 + `wiring-governance-operator.test.ts` 的三腿机器钉)——
+ * 它是**装配面**的事实,而本谓词能看见的只有 `kind`,拿 `kind` 当持久性的代理正是这次要拆掉的那层间接。
  */
 export type StreamApprovalGate = {
     active: true;
     askStore: ApprovalAskStore;
 } | {
     active: false;
-    reason: "no_tool_approval" | "protocol_disabled" | "no_backend" | "volatile_ask_ledger" | "no_park_facility";
+    reason: "no_tool_approval" | "protocol_disabled" | "no_backend" | "no_park_facility";
 };
 /** {@link resolveStreamApprovalGate} 的入参。`backend` 用**结构形**(不 import `StoreBackend`):本模块是
  *  协调器的家,不该为一个布尔判据把整棵 store 依赖树拖进类型面。 */
@@ -656,7 +661,7 @@ export interface ApprovalLegAssembly {
      *  🔴 **[ref] 起它与 `active` 解耦**(旧文「`active` 为假时恒 false —— 协议都没上场,谈不上关窗」已
      *  作废):`STREAM_ASK_WINDOW_MS` 是**部署级**旋钮,`0` 的语义(运维显式关窗 ⇒ 恒走
      *  {@link ToolApprovalCoordinator.unattendedAskOutcome},连卡都不发)在两条车道上必须是同一个意思。
-     *  旧形下 local 车道(`volatile_ask_ledger`)/ 无 park 设施 / 显式关协议的部署配了 `0`,拿到的是一张
+     *  旧形下 local 车道(S-384 之前的「账不持久」臂)/ 无 park 设施 / 显式关协议的部署配了 `0`,拿到的是一张
      *  等满 5min 的活卡 —— 与它自己的域注正好相反,且没有任何一行说出来。
      *  ⚠️ 「窗**缺席**」(`windowMs: undefined` = 这份装配根本没有 streamApproval 段,只出现在 stub-harness)
      *  **不是**关窗:那时逐字保持活卡腿。 */

package/dist/tool-approval.js

@@ -167,8 +167,6 @@ export function resolveStreamApprovalGate(input) {
         return { active: false, reason: "protocol_disabled" };
     if (!input.backend)
         return { active: false, reason: "no_backend" };
-    if (input.backend.kind === "local")
-        return { active: false, reason: "volatile_ask_ledger" };
     if (!input.parkFacility)
         return { active: false, reason: "no_park_facility" };
     return { active: true, askStore: input.backend.approvalAsk() };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.80.2",
+  "version": "7.81.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",