@sema-agent/server 7.4.0 → 7.6.0

package/dist/approval-reconciler.js

@@ -1,10 +1,11 @@
+import { isTerminalRunStatus } from "./plugins/store-contracts.js";
 import { DENY_REASONS, VOID_REASONS } from "./approval-deny-reasons.js";
 import { buildRevokeFrame } from "./approval-card.js";
 import { encodeCheckpointScope } from "./security.js";
-/** 判据 2 的「非 suspended 终局」词表(§8 A-1;`RunRecord["status"]` = `"running" | TaskStatus`,
- *  TaskStatus = completed|blocked|failed|suspended|needs_review)。`suspended`/`needs_review`/`running`
- *  都不是终局 ⇒ 落判据 3 保持。 */
-const TERMINAL_RUN_STATUS = new Set(["completed", "failed", "blocked"]);
+/* 判据 2 的「非 suspended 终局」判据 = `store-contracts.ts` 的 {@link isTerminalRunStatus}(词表属主处的
+ * 穷举 switch,core 加/删 `TaskStatus` 成员当场 tsc 红)。此处**不再手抄**一份 `ReadonlySet<string>`:
+ * 那份的门对象是 `string`,对词表增删两向都无钉,而这张词表真变过(core 5.8.0 删 `"timeout"`)。
+ * `suspended`/`needs_review`/`running` 都不是终局 ⇒ 落判据 3 保持。 */
 /** core 给「被取消」的 run 打的 `errorCode`(§9 C3 的取消判别键)。 */
 const CANCELLED_ERROR_CODE = "cancelled";
 /**
@@ -42,24 +43,82 @@ function withDeadline(op, label, timeoutMs = RECONCILE_STORE_TIMEOUT_MS) {
     ]);
 }
 /**
- * 判据 1 的**硬谓词**(纯函数,§9 C2 + §8 D-2)。
+ * 这只 ask 是不是**祖先冻结 approver 层**在委派 fold 中途铸的那一份(#168 件1④,黑板 [2912]③)。
  *
- * 返回选中的候选,或 `undefined` = 不命中。逐条:
+ * 判别位是**产品自己发的**,不是外部约定:core 的 `withDelegationProvenance` 只包**子代自己那条缝**,
+ * 祖先层那次走未包装的原函数 ⇒ `AskRequest.delegation` 在不在,就是「这一份是哪一层发的」。落到行上,
+ * `delegation.parentToolCallId` 是必填字段,铸行时逐字透传进 `parent_tool_call_id` 列 ⇒ **列非 NULL
+ * ⇔ delegation 在场**(不需要新列,也不需要回 `req` 里再读一次)。
+ *
+ * 第二维 `sourceTaskId !== sessionId` 把「根腿」摘出去:根腿的 `sourceTaskId` 恒等于会话锚(core 给
+ * `AskRequest.sourceTaskId` 填的就是该腿 sessionId),它根本不在任何 fold 里,`parent_tool_call_id`
+ * 为 NULL 是它的常态而不是信号。
+ *
+ * 命中 ⇒ 退出硬相等(判据 1 结构上不命中,行落 ②③④⑤)。实测(test AI 围栏)checkpoint 存的摘要**逐字
+ * 等于子代自己那条缝**、只不等于祖先层那一次 —— 所以收窄到这一层,子代自己的缝照常参与。
+ */
+export function isAncestorFoldMint(ask) {
+    return ask.parentToolCallId === null && ask.sourceTaskId !== ask.sessionId;
+}
+/**
+ * 判据 1 的**硬谓词**(纯函数,§9 C2 + §8 D-2;#168 件1 起返回分类而不是布尔)。
+ *
+ * 逐条:
+ *  - 祖先层 fold 中途铸点 ⇒ 直接退出(见 {@link isAncestorFoldMint});
  *  - `unparseable` 候选直接出局(读不出 ⇒ 不确定 ⇒ 不命中);
- *  - `boundCallId` 必须逐字等于 `ask.toolCallId`(读口已按它查,这里是纵深防御);
- *  - **因果下界**:`cp.createdAtMs >= ask.createdAtMs`(park 不可能早于它要 park 的那次 ask);
- *  - **hash 双等**:两侧都必须在场且相等 —— 任一侧缺席即不命中(禁「能取到时才比」的可选谓词)。
+ *  - **身份三元组**:`sourceTaskId` **相等** ∧ `toolCallId` **相等** ∧ 时间维的**因果下界**
+ *    `candidate.createdAtMs >= ask.createdAtMs`(⚠️ 第三维**不是等式** —— 把它读成等式会让合法的 park
+ *    几乎命不中,行随后落 ②③⑤ 被误判)—— 摘要**不是**身份([2897]③①:
+ *    同 args 的两次调用摘要天然相同,只靠摘要硬相等会把第二次投递并进第一次的票);任一维在候选侧
+ *    缺席(读不出的 blob 没有 `sourceTaskId`)即身份不成立;
+ *  - **hash 双等**:两侧都必须在场且相等,任一侧缺席一律不 bind;禁「能取到时才比」的可选谓词。
+ *    归因分两级(顺序即代码顺序):身份这一层先判 —— 同身份候选为空**且**候选集非空 ⇒ `identity_miss`;
+ *    走到 hash 这一层才把缺席记成**单铸** `single_mint`(见 {@link GateMatchOutcome})。
  *
  * 多候选时的取舍:优先 `status === "pending"`(活着的那张 gate),否则取最早的一条(读口按
  * `created_at ASC` 返回)。两者都满足全部硬谓词,选谁都不会错配;取 pending 只是让 `PARKED` 行落到
  * 一个还能被 resume 的坐标上,对壳更有用。
  */
-export function selectGateCandidate(ask, candidates) {
+export function classifyGateMatch(ask, candidates) {
+    const outcome = classifyGateMatchBeforeFoldVeto(ask, candidates);
+    // 🔴 祖先层否决**排在最后**、而且只否决已经成立的命中(纯减法)。放在最前面判会让这条谓词的每一次
+    // 假阳性(`sourceTaskId ≠ sessionId` 还有别的成因,例如 session-less 的 adhoc 腿)都白白关掉判据 1,
+    // 并把一条本该记成 `single_mint`/`identity_miss` 的行错记成「祖先层铸点」。放在这里,它最坏只是**不
+    // 命中**(与判据 1 的既有 fail-safe 同向),而计数从此只统计「本来会 bind、被这条裁定拦下」的行 ——
+    // 非零读数因此是真信号,不是噪声底。
+    if (outcome.kind === "match" && isAncestorFoldMint(ask))
+        return { kind: "ancestor_fold_mint" };
+    return outcome;
+}
+function classifyGateMatchBeforeFoldVeto(ask, candidates) {
+    // 身份三元组的前两维 + 因果下界(摘要不参与这一层——它是身份之外的**第二道**等式)。
+    const sameIdentity = candidates.filter((c) => c.unparseable !== true && c.sourceTaskId !== null && c.sourceTaskId === ask.sourceTaskId && c.boundCallId === ask.toolCallId && c.createdAtMs >= ask.createdAtMs);
     const askHash = ask.boundInputHash;
+    if (sameIdentity.length === 0) {
+        // 「同身份的 checkpoint 一条都没有」有两种成因,不能混:
+        //  · 候选集**空** ⇒ 这条弧上根本没有对家,只有 ask 侧铸过(或两侧都没铸)= 单铸;
+        //  · 候选集非空 ⇒ 有对家、只是不是这一只(别的 sourceTaskId/callId),或者读不出(`unparseable`,
+        //    「不确定」)。两者都**不是**「只有一侧铸过」这个事实陈述,一律记 `identity_miss`——
+        //    把一条读不出的坏行说成「对家从来不存在」是拿不确定冒充确定。
+        if (candidates.length > 0)
+            return { kind: "identity_miss" };
+        return { kind: "single_mint", side: askHash === null ? "neither" : "ask_only" };
+    }
+    const withHash = sameIdentity.filter((c) => c.boundInputHash !== null);
     if (askHash === null)
-        return undefined; // hash 缺席 = 结构上永不满足判据 1(见 AskRow.boundInputHash 顶注)
-    const matches = candidates.filter((c) => c.unparseable !== true && c.boundCallId === ask.toolCallId && c.createdAtMs >= ask.createdAtMs && c.boundInputHash !== null && c.boundInputHash === askHash);
-    return matches.find((c) => c.status === "pending") ?? matches[0];
+        return { kind: "single_mint", side: withHash.length > 0 ? "checkpoint_only" : "neither" };
+    if (withHash.length === 0)
+        return { kind: "single_mint", side: "ask_only" }; // 同身份的 park 一条摘要都没有
+    const matches = withHash.filter((c) => c.boundInputHash === askHash);
+    const picked = matches.find((c) => c.status === "pending") ?? matches[0];
+    if (picked !== undefined)
+        return { kind: "match", candidate: picked };
+    return { kind: "hash_mismatch", candidates: withHash.length };
+}
+/** {@link classifyGateMatch} 的布尔面(判据 1 命中即返回那条候选)。分类信息由调用方按需另取。 */
+export function selectGateCandidate(ask, candidates) {
+    const outcome = classifyGateMatch(ask, candidates);
+    return outcome.kind === "match" ? outcome.candidate : undefined;
 }
 /** 判据表 v2 的判定(纯函数;顺序 = 设计稿 §9 尾的五臂汇总,注见文件头)。 */
 export function decideReconcileAction(input) {
@@ -82,7 +141,7 @@ export function decideReconcileAction(input) {
         return { kind: "void", reason: VOID_REASONS.BATCH_BOUND_ELSEWHERE };
     }
     // ② run 终局分臂
-    if (run !== null && TERMINAL_RUN_STATUS.has(run.status)) {
+    if (run !== null && isTerminalRunStatus(run.status)) {
         if (run.status === "failed" && run.errorCode === CANCELLED_ERROR_CODE) {
             return { kind: "void", reason: VOID_REASONS.RUN_CANCELLED };
         }
@@ -119,7 +178,8 @@ export function createApprovalReconciler(deps) {
             }
         }
     };
-    /** 一条 `PARKING` 行的收敛(读事实 → 纯判定 → 一次 CAS)。返回本行落到哪一臂(供统计)。 */
+    /** 一条 `PARKING` 行的收敛(读事实 → 纯判定 → 一次 CAS)。返回本行落到哪一臂 + 判据 1 的分类(供统计;
+     *  `match` 缺席 = 本轮压根没走到判据 1,与「走了但没命中」是两回事,不能记成同一格)。 */
     const reconcileOne = async (ask, nowMs) => {
         // ⓪ 批态**先读**(codex round3 R3-2):它是唯一一个能让本行「结构上再也不可能 bind」的事实,而且是
         //    一次主键读。批已 `ABORTED` 或已绑给**别人** ⇒ 判据 1 的 `bindBatch` 谓词(`ROUTING_UNBOUND`)
@@ -133,9 +193,42 @@ export function createApprovalReconciler(deps) {
         // 判据 1:窄谓词精确查(scope 必填 —— 租户门是读口自己的责任,§8 D-3)。因果下界直接下推成
         // `sinceMs`,SQL 侧就把早于本 ask 的 checkpoint 排掉了(`selectGateCandidate` 里还会再判一次,
         // 纵深防御)。
+        let gateMatch;
         if (checkpoints && !irreversibleBatch) {
+            // 🔴 **已知缺口,登记而不假称已解**(codex 交叉复审 2026-08-07 [high] 一,验真;**先存**,不是本批
+            // 引入):这里的 session 维传的是 `ask.sessionId` = **投递上下文**的会话(`tool-approval.ts` 铸行时
+            // 取 `primary.sessionId`),而委派子代那条腿的 checkpoint 落在**子代自己**的 sessionId 上
+            // (core 铸 `cp.sessionId = 该腿 sessionId`,同值也写进 `cp.sourceTaskId`)。⇒ 子代自己那条 approver
+            // 缝的 park 在 SQL 谓词这一层就被滤掉了,判据 1 对委派腿结构上够不着 —— 黑板 [2912]③「子代自己那条
+            // 缝可以参与硬相等」的那一半,在本仓当前接线下还落不了地(行改走 ②③④⑤,fail-safe)。
+            //
+            // 顺带说清本批**改善**了什么:三元组把 `cp.sourceTaskId === ask.sourceTaskId` 变成硬谓词之后,
+            // 一只子代 ask 再也不可能认领**宿主**腿的 park(同 session 查出来的候选,callId 撞车 + 同 args 摘要
+            // 相同就够了,而 `PARKED` 不可回滚)——那是本批之前真实存在的错配面。
+            //
+            // 修法(未做,需自带判据):把 session 维换成「铸 park 的那条腿的会话」。风险在于 `ask.sourceTaskId`
+            // 有 `?? origin.taskId` 兜底,core 万一不填就会把一个 taskId 当 session 去查(比今天更差),所以
+            // **必须**配一条用真 checkpoint 店、宿主/子代两个不同 sessionId 的端到端钉才动。开题上报。
             const candidates = await withDeadline(checkpoints.findCheckpointCandidatesForAsk(encodeCheckpointScope(ask.owner), ask.sessionId, ask.toolCallId, ask.createdAtMs), "findCheckpointCandidatesForAsk");
-            const match = selectGateCandidate(ask, candidates);
+            gateMatch = classifyGateMatch(ask, candidates);
+            if (gateMatch.kind === "hash_mismatch") {
+                // 留痕不拒(见 ReconcileStats.hashMismatch 顶注):warn 说清成因方向,行继续按 ②③④⑤ 判。
+                try {
+                    logger.warn("approval_reconcile_hash_mismatch", {
+                        askId: ask.askId,
+                        taskId: ask.taskId,
+                        toolCallId: ask.toolCallId,
+                        candidates: gateMatch.candidates,
+                        reason: "ask and checkpoint minted the same bound input under the same (sourceTaskId, toolCallId) identity but the digests differ — " +
+                            "the known causes are deployment-side (a hook/policy mutating an object it still holds a reference to between the two mints, " +
+                            "or a stateful getter returning a fresh value per read), not tampering; this ask keeps its fail-safe route (no park, no denial)",
+                    });
+                }
+                catch {
+                    /* 可观测面绝不成为故障源 */
+                }
+            }
+            const match = gateMatch.kind === "match" ? gateMatch.candidate : undefined;
             if (match) {
                 // 🔴 `bindBatch` 内部**一次**完成 `PARKING→PARKED` + gate 落行 + 兄弟连坐 VOID(§8 A-2:正文
                 // 「先 transitionAsk 再 bindBatch」是死锁形,已作废)。只调它一次。
@@ -146,7 +239,7 @@ export function createApprovalReconciler(deps) {
                 }), "bindBatch");
                 if (res.ok) {
                     revoke(ask, res.voidedSiblings, "superseded_by_park", nowMs);
-                    return "parked";
+                    return { outcome: "parked", match: gateMatch };
                 }
                 // 判别式失败臂(§9 C3):拿到批的**真实**态 + 中选者,降级续判 —— `ABORTED` ⇒ VOID(abort 语义),
                 // `ROUTING_BOUND` 且中选者是兄弟 ⇒ VOID(bind-once 落选者,R2-3),其余按 ②③④⑤。
@@ -162,13 +255,13 @@ export function createApprovalReconciler(deps) {
             case "bind": {
                 // `allowBind: false` 下结构上不可达;留一条防御性 hold,绝不在这里第二次调 bindBatch。
                 await withDeadline(askStore.deferReconcile(ask.askId, "PARKING", ask.version, nowMs), "deferReconcile");
-                return "held";
+                return { outcome: "held", match: gateMatch };
             }
             case "deny": {
                 // 🔴 全仓唯一的 `DENIED` 写点(grep 钉)。归因是判据 2 的**终局证据**,不是超时推断。
                 // CAS 输(行在本轮判定期间被别人收走)= 正常,如实记成 held(没动过行),下轮重扫。
                 const won = await withDeadline(askStore.transitionAsk(ask.askId, "PARKING", "DENIED", { deniedReason: action.reason, updatedAtMs: nowMs }), "transitionAsk(DENIED)");
-                return won ? "denied" : "held";
+                return { outcome: won ? "denied" : "held", match: gateMatch };
             }
             case "void": {
                 // 🔴 codex 交叉复审 C3(2026-08-06 真缺陷):**必须看 CAS 的返回值**。原先无条件记账 + 发撤卡帧
@@ -177,7 +270,7 @@ export function createApprovalReconciler(deps) {
                 // 壳会清掉一张仍然有效、还在等 gate 的卡。输 ⇒ 什么都不做,下轮按新态重判。
                 const won = await withDeadline(askStore.transitionAsk(ask.askId, "PARKING", "VOID", { deniedReason: action.reason, updatedAtMs: nowMs }), "transitionAsk(VOID)");
                 if (!won)
-                    return "held";
+                    return { outcome: "held", match: gateMatch };
                 if (action.reason === VOID_REASONS.ORPHAN_TTL_EXCEEDED) {
                     logger.warn("approval_ask_orphan_voided", { askId: ask.askId, taskId: ask.taskId, ageMs: nowMs - ask.createdAtMs, ttlMs: orphanTtlMs });
                 }
@@ -190,19 +283,34 @@ export function createApprovalReconciler(deps) {
                 // 落选者(R2-3)是**真的**被别人的 park 顶掉 ⇒ 用 `superseded_by_park`;其余单行 VOID 用 `"aborted"`
                 // (两员闭集里唯一诚实的那个,见上注)。
                 revoke(ask, [ask.askId], action.reason === VOID_REASONS.BATCH_BOUND_ELSEWHERE ? "superseded_by_park" : "aborted", nowMs);
-                return "voided";
+                return { outcome: "voided", match: gateMatch };
             }
             case "hold": {
                 // 队列轮转(§8 D-4 / §9 C5):推 `updated_at_ms` 排到队尾。CAS 输(版本已被别人推进)= 正常,
                 // 本轮判定已过期,下轮重来。
                 await withDeadline(askStore.deferReconcile(ask.askId, "PARKING", ask.version, nowMs), "deferReconcile");
-                return "held";
+                return { outcome: "held", match: gateMatch };
             }
         }
     };
     return {
         async runOnce(nowMs) {
-            const stats = { scanned: 0, unmatchableNoHash: 0, parked: 0, denied: 0, voided: 0, held: 0, failed: 0, budgetExhausted: 0, orphansExpired: 0 };
+            const stats = {
+                scanned: 0,
+                unmatchableNoHash: 0,
+                hashMismatch: 0,
+                singleMintAskOnly: 0,
+                singleMintCheckpointOnly: 0,
+                singleMintNeither: 0,
+                ancestorFoldMint: 0,
+                parked: 0,
+                denied: 0,
+                voided: 0,
+                held: 0,
+                failed: 0,
+                budgetExhausted: 0,
+                orphansExpired: 0,
+            };
             // ── 段一:PARKING 判据表 ────────────────────────────────────────────────────────────────
             const parking = await withDeadline(askStore.listByState("PARKING", batchLimit), "listByState(PARKING)");
             stats.scanned = parking.length;
@@ -221,7 +329,7 @@ export function createApprovalReconciler(deps) {
                 if (ask.boundInputHash === null)
                     stats.unmatchableNoHash += 1; // 判据 1 盲区(见字段顶注)
                 try {
-                    const outcome = await reconcileOne(ask, nowMs);
+                    const { outcome, match } = await reconcileOne(ask, nowMs);
                     if (outcome === "parked")
                         stats.parked += 1;
                     else if (outcome === "denied")
@@ -230,6 +338,26 @@ export function createApprovalReconciler(deps) {
                         stats.voided += 1;
                     else
                         stats.held += 1;
+                    // 判据 1 的分类计数(#168 件1②③④)——`match` 缺席 = 本轮没走到判据 1(无 checkpoint 面 /
+                    // 批已不可逆),那既不是 mismatch 也不是单铸,一格都不记。
+                    switch (match?.kind) {
+                        case "hash_mismatch":
+                            stats.hashMismatch += 1;
+                            break;
+                        case "ancestor_fold_mint":
+                            stats.ancestorFoldMint += 1;
+                            break;
+                        case "single_mint":
+                            if (match.side === "ask_only")
+                                stats.singleMintAskOnly += 1;
+                            else if (match.side === "checkpoint_only")
+                                stats.singleMintCheckpointOnly += 1;
+                            else
+                                stats.singleMintNeither += 1;
+                            break;
+                        default:
+                            break; // match / identity_miss / 未走到判据 1:无计数格
+                    }
                 }
                 catch (err) {
                     // 🔴 per-row 隔离(邻居 bg-agent per-scope 先例):一条行的坏 blob / 一次瞬时错误不许饿死同批

package/dist/boot/config-center.js

@@ -450,8 +450,21 @@ export async function createConfigCenterRuntime(ctx) {
                     const cfgModels = (r.effective.models?.models ?? []).filter((m) => m.enabled !== false).length;
                     const cfgDir = configProvider.kind === "local" ? { dir: configProvider.root } : {};
                     logger.info("config_loaded", { source: configProvider.kind, version: r.effective.version, worker: cc?.worker ?? "(global)", models: cfgModels, ...cfgDir });
-                    if (configProvider.kind === "local" && cfgModels === 0)
-                        logger.warn("config_local_no_models", { ...cfgDir, hint: "config.d/models.json 空或 CONFIG_LOCAL_DIR 指错目录(选目录旋钮是 CONFIG_LOCAL_DIR,不是 LOCAL_DATA_ROOT)— 模型继续走 env 兜底" });
+                    if (configProvider.kind === "local" && cfgModels === 0) {
+                        // [3073]#204④ hint 真因三臂:域判形失败(文件在场却喊「空/指错」=对排障者说谎,真因在
+                        // config_domain_invalid 里但 hint 不指路)/ 全 enabled:false / 真空缺,三态分开点名。
+                        const modelsDomainErr = (r.domainErrors ?? []).find((de) => de.domain === "models");
+                        const totalModels = (r.effective.models?.models ?? []).length;
+                        logger.warn("config_local_no_models", {
+                            ...cfgDir,
+                            ...(modelsDomainErr ? { domainError: modelsDomainErr.error } : {}),
+                            hint: modelsDomainErr
+                                ? "config.d/models.json 在场但 models 域判形失败落 default(真因见本行 domainError)— 模型继续走 env 兜底"
+                                : totalModels > 0
+                                    ? `config.d/models.json 有 ${totalModels} 条模型但全部 enabled:false — 模型继续走 env 兜底`
+                                    : "config.d/models.json 空或 CONFIG_LOCAL_DIR 指错目录(选目录旋钮是 CONFIG_LOCAL_DIR,不是 LOCAL_DATA_ROOT)— 模型继续走 env 兜底",
+                        });
+                    }
                 }
             }
         }

package/dist/boot/coordinators.js

@@ -43,7 +43,11 @@ export function createLiveCoordinators(ctx) {
         parkFacility: durableEnabled,
     });
     // §8.4:协议**开着**却上不了场 = 合法部署形(不是配置错误)⇒ 一行 **info**(不是 warn),把原因说明白。
-    // 反过来「开关本来就没开」不打日志:那是默认形,每次启动刷一行噪音没有信息量。
+    // 反过来「开关本来就没开」不打日志:显式关掉的部署自己知道为什么关,一行噪音没有信息量。
+    // ⚠️ 读数已反转:总开关默认在树上已是 ON(版本坐标见 config.ts 的 `streamApprovalConfig()` 头注),
+    // 所以这一行在**默认部署**上是常态 —— 任何没有 durable
+    // backend / park 设施的默认部署每次启动都会打一行 `stream_approval_disabled`(每次启动一行,不是每
+    // tick)。写这条判据时的前提「默认形绕开本路径」已不成立;要收紧,收紧点在本 if 而不是在开关处。
     if (config.streamApproval.enabled && !streamApprovalGate.active) {
         logger.info("stream_approval_disabled", {
             reason: streamApprovalGate.reason,
@@ -55,8 +59,12 @@ export function createLiveCoordinators(ctx) {
     }
     const toolApproval = config.toolApprovalEnabled
         ? new ToolApprovalCoordinator({
-            // 协议上场 ⇒ 持久层 + 60s 窗(§7:`STREAM_ASK_WINDOW_MS` **只在开关内**生效,
+            // 协议上场 ⇒ 持久层 + 配置窗(§7:`STREAM_ASK_WINDOW_MS` **只在开关内**生效,
             // `DEFAULT_APPROVAL_TTL_MS` 一个字不动);不上场 ⇒ 两者都不传,窗保持既有 5min(D1 逐字不变)。
+            // ⚠️ 两臂的窗**默认已同长**:窗默认自 7.5.0 起 = 300000 = `DEFAULT_APPROVAL_TTL_MS`(clay 同裁把
+            // 「窗变短」从翻真里摘出去)。原注画的「上场 = 60s / 不上场 = 5min」这个对比在默认配置下不存在
+            // 了,别据它得出「开了协议窗会缩短」的运维结论:上场与否改变的是**持久层与协议帧**,窗只有在
+            // 部署显式设了 `STREAM_ASK_WINDOW_MS` 时才分叉。
             ...(streamApprovalGate.active ? { askStore: streamApprovalGate.askStore, ttlMs: config.streamApproval.windowMs } : {}),
             // 余量旋钮恒传(既有键,窗长三元公式的第二项;legDeadlineMonotonic 缺席时它不参与计算)。
             windowMarginMs: config.streamAskWindowMarginMs,

package/dist/boot/execution-env.js

@@ -365,7 +365,7 @@ export function createExecutionEnv(ctx) {
     // LSP sidecar (design/64 §13.1, the 1.86.2 seam): ONE stateless manager on RunnerDeps — core passes each
     // task's env into sessionFor at the tool mount point, so the manager reaches the SAME sandbox the agent edits
     // (no sessionId registry / per-task construction). Opt-in (LSP_ENABLED — the SANDBOX lane's knob; the host lane
-    // below has its own, LSP_HOST_ENABLED, because its default is the opposite); with the baked `sema-code-lsp`
+    // below has its own, LSP_HOST_ENABLED, because its default is the opposite); with the baked `ai-agent-code-lsp`
     // template the first call is fast, without it the language server installs on first use (slow once per sandbox).
     // k8s lane (gate#2 alignment): same manager/bridge over the pod network — `ws://podIP:port` instead of E2B's
     // public wss proxy, so it needs an IN-CLUSTER worker and a sandbox image with node + the language servers baked

package/dist/boot/org-memory.d.ts

@@ -26,9 +26,15 @@ import type { RunnerDeps } from "@sema-agent/core";
 import type { ServiceConfig } from "../config.js";
 import type { Logger } from "../observability/logger.js";
 import type { Metrics } from "../observability/metrics.js";
+import { type OrgMemoryDirectory } from "../org-memory-admission.js";
 export interface OrgMemoryAdmissionWiring {
     memoryScopeAdmission: RunnerDeps["memoryScopeAdmission"];
     deploymentMemoryScopes: RunnerDeps["deploymentMemoryScopes"];
+    /** §7 第二消费者收编:同一个目录实例也喂 memory-policy 面的 `org:` 属主门(`ServiceDeps.orgMemoryDirectory`)。
+     *  **同实例**是这条收编的全部意义——「谁属于 org:acme」在一个进程里必须只有一个答案,两面共享同一份
+     *  TTL 缓存/退避窗/gen 高水位;各建各的目录会让准入门与策略面在吊销窗内公开分歧。缺席=无目录源
+     *  (单用户/无 center 且无 env 表)⇒ 策略面逐字保持收编前的 operator-only 行为。 */
+    directory: OrgMemoryDirectory | undefined;
 }
 /** 依赖收窄到真实消费面(warn/inc 各一手)——接口隔离让测试用真形字面量,零铸形([2704] §1)。 */
 export declare function createOrgMemoryAdmissionWiring(opts: {

package/dist/boot/org-memory.js

@@ -82,6 +82,6 @@ export function createOrgMemoryAdmissionWiring(opts) {
             },
         })
         : undefined;
-    return { memoryScopeAdmission, deploymentMemoryScopes };
+    return { memoryScopeAdmission, deploymentMemoryScopes, directory };
 }
 //# sourceMappingURL=org-memory.js.map

package/dist/boot/parked-revive-gate.d.ts

@@ -0,0 +1,78 @@
+import { type BackgroundAgentRecord, type ToolExecuteContext } from "@sema-agent/core";
+import type { ServiceConfig } from "../config.js";
+import { type ApprovalBaselineConfigView, type DeploymentGovernanceConfigView, type LiveQuestionFace } from "../deployment-governance.js";
+import { type SandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
+/** 本腿读的配置切面(`ServiceConfig` 结构满足)。两个构造口各自的切面 + lane 判别式读的 `remoteExec`。 */
+export interface ParkedReviveGateConfigView extends DeploymentGovernanceConfigView, ApprovalBaselineConfigView {
+    readonly remoteExec?: ServiceConfig["remoteExec"];
+    /** host 腿裁决 env 的 cwd 占位根(见下方 `hostGateCwd`)。 */
+    readonly localDataRoot?: ServiceConfig["localDataRoot"];
+}
+/** 会话豁免探针店的所需切面(canonical toolName 键空间;`StoreBackend.approvalExemption()` 结构满足)。 */
+export interface ApprovalExemptionProbe {
+    has(sessionId: string, toolName: string): Promise<boolean>;
+}
+export interface ParkedReviveGateDeps {
+    /** ⚠️ **活引用**:热改字段(autonomy/commandPolicy/守卫集/审批四旋钮)每次赎回现读,见下方「禁 memoize」。 */
+    readonly config: ParkedReviveGateConfigView;
+    /** #152:活体 AskUserQuestion 面。赎回腿今天无 ALS ctx ⇒ 判 ask,与原形同判。 */
+    readonly question: LiveQuestionFace | undefined;
+    readonly approvalExemptionStore: ApprovalExemptionProbe | undefined;
+    readonly logger: {
+        info(event: string, fields?: Record<string, unknown>): void;
+        warn(event: string, fields?: Record<string, unknown>): void;
+    };
+    /** host 腿 cwd 占位的落地根(main.ts 的 `localRoot`;`config.localDataRoot` 优先)。 */
+    readonly localRoot: string;
+    /** 沙箱 lane 的真 env 登记簿。缺省 = 进程内唯一那只(工厂装饰器写的同一个);测试注入自建实例。 */
+    readonly slots?: SandboxPathEnvSlots;
+}
+/**
+ * core 1.396 的父约束席位形(`parkedResume.inheritedGate`)—— 从**载体自己的签名位推导**,绝不手写。
+ *
+ * 🔴 手写这个形状会**藏住轴**(codex 对抗复审 R1-高2 的真回归):第一版在这里手抄了一个只有
+ * `parentConstraints` 的接口,于是 core 载体上那个 `shellGate` 槽在类型层面根本看不见,「shellGate 轴
+ * 也要交回」这件事就无声地漏了一整刀。推导形让「core 又加了一条能收紧的轴」变成本仓的编译期/钉子面
+ * 事件(载体键集钉见 test/parked-revive-gate-wiring.test.ts)。
+ */
+export type RebuiltInheritedGate = NonNullable<NonNullable<NonNullable<ToolExecuteContext["reviveClaim"]>["parkedResume"]>["inheritedGate"]>;
+/**
+ * 赎回腿的父约束链重建(design/181 件二)。
+ *
+ * 语义:**同/跨副本一致地重建「部署 ⊇ 操作员」两层完整链**——审批基线(durable question 门 + F4 高危写
+ * 审批门 + 会话豁免探针)作 base 的 `toolPolicy` 座,经**折叠属主** `applyRuntimeGovernance`
+ * (→ core `tightenTaskSpec`)叠上部署治理段(autonomy / commandPolicy / MANUAL_MODE_SHELL_GATE /
+ * 守卫集),取其 `toolPolicy` 装进单层 `parentConstraints`。
+ *
+ * 🔴 **禁 memoize**:构造整体在 per-row lambda **内**。`autonomy`/`commandPolicy`/守卫集/审批四旋钮都是
+ * 热改字段(registry 热应用换 config 引用),boot 期铸一次 = 把治理冻在启动那一刻的值上,而 resume 腿的
+ * 书面语义是「按**当前** config 重折」(与 resolve-spec 的审批基线读活 config 同一姿势)。
+ *
+ * 🔴 **单层链是正确的响亮拒**(design/181 §2.5 特征化格):本腿恒建 count=1。嵌套子代(孙代 park,
+ * count≥2)的重建本腿做不到——跨副本连「祖先各层分别是什么」都没有持久化——于是 core 的 pre-CAS
+ * `resume.parent_constraint_mismatch` 会响亮拒绝,checkpoint 留 pending。**不许**顺手把它补齐成静默单层:
+ * 那等于让孙代在一条比它挂起时更松的祖先链下复活。
+ *
+ * 交回**两条轴**(载体上本仓供得出的全部,见 {@link RebuiltInheritedGate} 的推导注):
+ *  · `parentConstraints` —— 上面那条重建链;
+ *  · `shellGate` —— 治理段折出来的 shell 门档位。**必须交**:core 按 rank 取 `max(live, seed)`,不交
+ *    等于 `live` 缺席、max 恒等于 park 时的旧种子,于是「挂起期间运维收紧 AUTONOMY/MANUAL_MODE_SHELL_GATE」
+ *    在赎回腿上整条失效(codex R1-高2 的真回归,红先复现)。交了之后收紧被兑现、放松不被兑现(fail-safe)。
+ *
+ * 载体上**故意不供**的三个槽(都不是本腿产得出的):`ancestorRules`(会话权限规则,属会话面)、
+ * `admittedOrgScopes` / `orgAdmissionGoverned`(组织记忆准入,属 memory 面)—— 交一个瞎猜的值比不交更坏
+ * (core 对这三个都是 seed 兜底)。
+ *
+ * 时点语义(成文进 docs/ASSISTANT-WIRE-CONTRACT.md,免运维当 bug 报):
+ *  · toolPolicy 轴 = **当前** config(与 resume 重折一致,收紧与放松都被兑现——放松是一次显式运维动作);
+ *  · shellGate 轴 = core 取 max(live, park 时 seed)—— 收紧兑现、放松**不**兑现(fail-safe)。
+ *  · `onAsk` 不供,但**这不等于 auto-deny**(codex R3-中1 验真纠正):带 `durableMandate` 的继承层
+ *    判 `ask` 时,core 只要还看得见 checkpoint 店 + durable 审批配置就把它**重新浮回 durable 门**
+ *    (再 park 一次,人再批一次);deny 只是「durable 设施不在场」的兜底臂。⛔ 但**不是无条件**
+ *    (codex R4-中1):core 对挂起链计 `suspendCount`,到 `maxSuspends`(默认 5)即终止任务而不再 park。
+ *  · 客户端每请求 settings 折出来的层(`settings.permissions` 的 allow/deny/ask、模式派生的 fs-write
+ *    ask 门、scratchpad 豁免……整类)park 时未持久化 ⇒ 重建不出。§2.3 已披露的残余,机制面有特征化钉
+ *    (test/parked-revive-e2e.test.ts);真 settings→park→赎回的端到端钉未建(候件,随收口件一起)。
+ */
+export declare function createParkedReviveInheritedGate(deps: ParkedReviveGateDeps): (row: BackgroundAgentRecord) => RebuiltInheritedGate;
+//# sourceMappingURL=parked-revive-gate.d.ts.map

package/dist/boot/parked-revive-gate.js

@@ -0,0 +1,114 @@
+/**
+ * [1596]/[1597] 跨副本父约束重供席工厂 —— durable park 的**赎回腿**(design/181 件二 / #179)。
+ *
+ * 从 main.ts 的装配体里提出来的**唯一理由不是内聚,是可测**:main.ts 顶层 `void main()`,谁 import 它
+ * 谁就启动一整个服务,所以那条腿的**运行期**语义在原地一格都钉不住(此前只有源码字符串钉)。提出来之后
+ * 「重建出来的链到底裁决成什么样」变成可断言的事实(test/parked-revive-gate-wiring.test.ts 运行期钉 +
+ * 治理矩阵的第三维消费腿)。装配次序契约不变:main.ts 仍在同一位置构造,构造条件逐字保持。
+ */
+import { join } from "node:path";
+import { NodeExecutionEnv } from "@sema-agent/core";
+import { createApprovalBaselinePolicy, createDeploymentGovernanceInputs, } from "../deployment-governance.js";
+import { applyRuntimeGovernance } from "../runtime-governance.js";
+import { DeferredSandboxPathEnv, isSandboxPathAdjudicationLane, sandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
+/**
+ * host 腿裁决 env 的 cwd:**从不创建**的占位目录(resolve-spec 的 `fs-write-gate-unrooted` 同族)。
+ *
+ * 赎回腿拿不到子代的工作目录(park 时未持久化,design/181 §2.2 的 v2 候件票),而 `NodeExecutionEnv`
+ * 的构造要求一个 cwd。占位形的语义:**绝对形写目标照常按真身裁决**(cwd 与它们无关),相对形则在
+ * 一个不存在的根上 canonicalize —— 段匹配照旧命中(守卫段是路径**段**判据),方向 fail-closed。
+ * 真正兜住相对形的是构造口内的 `RelativeTargetLexicalEnv` 词法臂(`PathAdjudication.cwd` 缺席即自动补层)。
+ * ⚠️ core 5.19.0(#108)后这句话的射程变窄了:守卫改按 `ToolCallRequest.cwd ?? rootPath` 解析写目标,
+ * 引擎盖了戳的调用**根本走不到**本占位根(戳优先),词法臂也随之让位给真身裁决(全文见
+ * `deployment-governance.ts` 的 `RelativeTargetLexicalEnv` 类注)。本占位根今天只在缺戳形上承重,
+ * 语义不变、方向仍 fail-closed,故保留不动。
+ * 绝不回落 `process.cwd()`:那是**服务自己的**启动目录,把它当成子代的盘是拿错基准(resolve-spec W4 同案)。
+ */
+function hostGateCwd(config, localRoot) {
+    return join(config.localDataRoot ?? localRoot, "parked-revive-unrooted");
+}
+/**
+ * 赎回腿的父约束链重建(design/181 件二)。
+ *
+ * 语义:**同/跨副本一致地重建「部署 ⊇ 操作员」两层完整链**——审批基线(durable question 门 + F4 高危写
+ * 审批门 + 会话豁免探针)作 base 的 `toolPolicy` 座,经**折叠属主** `applyRuntimeGovernance`
+ * (→ core `tightenTaskSpec`)叠上部署治理段(autonomy / commandPolicy / MANUAL_MODE_SHELL_GATE /
+ * 守卫集),取其 `toolPolicy` 装进单层 `parentConstraints`。
+ *
+ * 🔴 **禁 memoize**:构造整体在 per-row lambda **内**。`autonomy`/`commandPolicy`/守卫集/审批四旋钮都是
+ * 热改字段(registry 热应用换 config 引用),boot 期铸一次 = 把治理冻在启动那一刻的值上,而 resume 腿的
+ * 书面语义是「按**当前** config 重折」(与 resolve-spec 的审批基线读活 config 同一姿势)。
+ *
+ * 🔴 **单层链是正确的响亮拒**(design/181 §2.5 特征化格):本腿恒建 count=1。嵌套子代(孙代 park,
+ * count≥2)的重建本腿做不到——跨副本连「祖先各层分别是什么」都没有持久化——于是 core 的 pre-CAS
+ * `resume.parent_constraint_mismatch` 会响亮拒绝,checkpoint 留 pending。**不许**顺手把它补齐成静默单层:
+ * 那等于让孙代在一条比它挂起时更松的祖先链下复活。
+ *
+ * 交回**两条轴**(载体上本仓供得出的全部,见 {@link RebuiltInheritedGate} 的推导注):
+ *  · `parentConstraints` —— 上面那条重建链;
+ *  · `shellGate` —— 治理段折出来的 shell 门档位。**必须交**:core 按 rank 取 `max(live, seed)`,不交
+ *    等于 `live` 缺席、max 恒等于 park 时的旧种子,于是「挂起期间运维收紧 AUTONOMY/MANUAL_MODE_SHELL_GATE」
+ *    在赎回腿上整条失效(codex R1-高2 的真回归,红先复现)。交了之后收紧被兑现、放松不被兑现(fail-safe)。
+ *
+ * 载体上**故意不供**的三个槽(都不是本腿产得出的):`ancestorRules`(会话权限规则,属会话面)、
+ * `admittedOrgScopes` / `orgAdmissionGoverned`(组织记忆准入,属 memory 面)—— 交一个瞎猜的值比不交更坏
+ * (core 对这三个都是 seed 兜底)。
+ *
+ * 时点语义(成文进 docs/ASSISTANT-WIRE-CONTRACT.md,免运维当 bug 报):
+ *  · toolPolicy 轴 = **当前** config(与 resume 重折一致,收紧与放松都被兑现——放松是一次显式运维动作);
+ *  · shellGate 轴 = core 取 max(live, park 时 seed)—— 收紧兑现、放松**不**兑现(fail-safe)。
+ *  · `onAsk` 不供,但**这不等于 auto-deny**(codex R3-中1 验真纠正):带 `durableMandate` 的继承层
+ *    判 `ask` 时,core 只要还看得见 checkpoint 店 + durable 审批配置就把它**重新浮回 durable 门**
+ *    (再 park 一次,人再批一次);deny 只是「durable 设施不在场」的兜底臂。⛔ 但**不是无条件**
+ *    (codex R4-中1):core 对挂起链计 `suspendCount`,到 `maxSuspends`(默认 5)即终止任务而不再 park。
+ *  · 客户端每请求 settings 折出来的层(`settings.permissions` 的 allow/deny/ask、模式派生的 fs-write
+ *    ask 门、scratchpad 豁免……整类)park 时未持久化 ⇒ 重建不出。§2.3 已披露的残余,机制面有特征化钉
+ *    (test/parked-revive-e2e.test.ts);真 settings→park→赎回的端到端钉未建(候件,随收口件一起)。
+ */
+export function createParkedReviveInheritedGate(deps) {
+    const { config, question, approvalExemptionStore, logger, localRoot } = deps;
+    const slots = deps.slots ?? sandboxPathEnvSlots;
+    return (row) => {
+        // lane 分形与 resolve-spec 同一判别式(单一属主,取值处只此一个)。
+        // 🔑 沙箱腿的 slot 键 = **row.sessionId**(子代自己的会话,design/181 §2.2 裁定):revive 后 core 以
+        //    该 sessionId 铸 env 并注册 slot(subagent → prepare-task → 工厂装饰器),这个键真能绑上。
+        //    键 rootSessionId 跨副本恒 unbound ⇒ 每一次结构化写 fail-closed ⇒ 整条腿瘫痪。
+        //    未绑时转发面报错 → core 读成 unresolvedSymlink → 守卫策略 deny(成文的 fail-closed 行为)。
+        const pathAdjudication = isSandboxPathAdjudicationLane(config.remoteExec?.provider)
+            ? {
+                env: new DeferredSandboxPathEnv({
+                    sessionId: row.sessionId,
+                    slots,
+                    logger: { warn: (event, fields) => logger.warn(event, { ...(fields ?? {}), lane: config.remoteExec?.provider, leg: "parked_revive" }) },
+                }),
+            }
+            : { env: createHostAdjudicationEnv(config, localRoot) };
+        // 审批基线:durable 轴(问答门 + F4 审批门 + 会话豁免探针)。exempt 锚 = row.rootSessionId
+        // ——与 /decide 的 remember grant 同键([1591] 候裁②),重建链上的豁免语义与原链一致。
+        const rootSessionId = row.rootSessionId;
+        const baseline = createApprovalBaselinePolicy(config, {
+            question,
+            ...(approvalExemptionStore && rootSessionId
+                ? {
+                    exempt: (toolName) => approvalExemptionStore.has(rootSessionId, toolName),
+                    onExempted: (toolName, rawToolName) => logger.info("approval_exempted", { sessionId: rootSessionId, toolName, rawToolName, leg: "parked_revive" }),
+                }
+                : {}),
+        });
+        // 折叠属主 = applyRuntimeGovernance → core tightenTaskSpec(本腿一条 policy 都不自己合成)。
+        // `objective: ""` 只是折叠所需的最小 TaskSpec 座——本腿只取回 toolPolicy,spec 的其余面不出本函数。
+        const governed = applyRuntimeGovernance({ objective: "", toolPolicy: baseline }, createDeploymentGovernanceInputs(config, pathAdjudication));
+        // 治理段无可施加时 applyRuntimeGovernance 原样返回 base ⇒ 基线本身即为链(恒非 undefined,无需断言)。
+        // shellGate 只在治理段真产出档位时出现在载体上(缺席 = 本次没有 live 值可交,core 用 seed 兜底)。
+        return {
+            parentConstraints: [{ policy: governed.toolPolicy ?? baseline, durableMandate: true }],
+            ...(governed.shellGate !== undefined ? { shellGate: governed.shellGate } : {}),
+        };
+    };
+}
+/** host 腿的裁决 env(真 fs;构造是纯字段赋值,不 spawn)。**每次赎回现铸**——与「禁 memoize」同因:
+ *  cwd 占位读的是活 config 的 `localDataRoot`。 */
+function createHostAdjudicationEnv(config, localRoot) {
+    return new NodeExecutionEnv({ cwd: hostGateCwd(config, localRoot) });
+}
+//# sourceMappingURL=parked-revive-gate.js.map

package/dist/boot/reapers.d.ts

@@ -68,6 +68,8 @@ export interface ReapersCtx {
     imageBakes: ImageBake | undefined;
     worktreeReap: (() => Promise<void>) | undefined;
     workflowNotifyGate: WorkflowNotifyGate | undefined;
+    /** [2995]/[2999] recover 的两半 opts(boot 与周期扫描共用,单点合成在 workflow-orchestration)。 */
+    workflowRecoverOpts: Parameters<WorkflowNotifyGate["recover"]>[0];
     workflowJournalStore: ServiceWorkflowJournalStore | undefined;
     sqlWorkflowRunStore: WorkflowRunStore | undefined;
     workflowNotifyJournal: WorkflowNotifyJournalStore | undefined;

package/dist/boot/reapers.js

@@ -74,7 +74,7 @@ export function createThrottledReaperCatch(name, logger, threshold = REAPER_FAIL
 }
 /** 起后台维护 tick,返回定时器 handle(收尾段 clearInterval 用)。 */
 export function startReapers(ctx) {
-    const { config, logger, metrics, localRoot, backend, subRunner, runStore, checkpointStore, rateLimiter, costQuota, toolResultStore, fileSnapshotStore, taskAttachmentStore, imageBakes, worktreeReap, workflowNotifyGate, workflowJournalStore, sqlWorkflowRunStore, workflowNotifyJournal, rosterStore, backgroundAgentStore, mailboxStore, toolApproval, getRunDenySweep, } = ctx;
+    const { config, logger, metrics, localRoot, backend, subRunner, runStore, checkpointStore, rateLimiter, costQuota, toolResultStore, fileSnapshotStore, taskAttachmentStore, imageBakes, worktreeReap, workflowNotifyGate, workflowRecoverOpts, workflowJournalStore, sqlWorkflowRunStore, workflowNotifyJournal, rosterStore, backgroundAgentStore, mailboxStore, toolApproval, getRunDenySweep, } = ctx;
     // S7 (SILENT-FALLBACK P0-d): the sweeps' return counts were discarded — an instance death that batch-fails
     // N orphans was indistinguishable from organic failures. Count + log ONLY when a sweep flipped rows (>0),
     // so healthy ticks stay silent. Tolerant of void-returning stores (typeof guard).
@@ -112,8 +112,15 @@ export function startReapers(ctx) {
     const scratchpadSweepStaleGuard = createThrottledReaperCatch("scratchpad_sweep_stale", logger);
     const approvalReconcileGuard = createThrottledReaperCatch("approval_reconcile", logger);
     let approvalReconcileInFlight = false; // 车5 §8 C-8:重入守卫(邻居四先例同形——本腿时长随 PARKING 行数增长)
-    // #151 车5(design/172 §3.0 对账收敛器 + 崩溃恢复扫描):**总开关默认 OFF ⇒ 本腿根本不注册**
-    // (`STREAM_APPROVAL_ENABLED=false` 的部署一行库都不扫,零新增查询)。开且有 durable backend 时才建。
+    // #151 车5(design/172 §3.0 对账收敛器 + 崩溃恢复扫描):建腿条件 = 开关开 ∧ **有 `StoreBackend`**
+    // (见下方判据行 —— 是**任意** backend,不限 SQL twins:`local` 车道也算,它的 `approvalAsk()` 是进程内
+    // `InMemoryApprovalAskStore`,扫的是内存不是库)。无 backend 或显式关 ⇒ 本腿根本不注册,零扫描。
+    // ⚠️ 运维读数已反转:总开关默认**在树上已是 ON**(发布线上落在 7.4.0 之后的下一发布;版本坐标与
+    // 「别按 /health 版本号推默认」的告诫见属主 config.ts 的 `streamApprovalConfig()` 头注),
+    // 所以「零新增扫描」从**默认态**变成了 **opt-out 态** —— 任何配了 backend 的部署(含单用户 local)
+    // 默认都会注册本腿并每 tick 扫两段(PARKING + 孤儿 STREAM_PENDING,每段
+    // `STREAM_APPROVAL_RECONCILE_BATCH` 行,默认 200);SQL twins 上这就是**真新增的周期性查询**,local 上
+    // 只是内存遍历。存量部署升级后要回到零扫描,需显式把开关关掉。
     // 判据 1/2 的两个读口按能力面接:checkpoint 店的窄读口只有 SQL twins 有(local 车道的店没有这个面),
     // 缺席 ⇒ 判据 1 恒不命中(诚实降级,行落 ②③④⑤),不是「假装没 checkpoint 就该 DENY」。
     const approvalReconciler = (() => {
@@ -354,7 +361,7 @@ export function startReapers(ctx) {
         // run whose in-process notify was lost, AND finalizes-as-abandoned a `running` run orphaned past the grace
         // window (core never resumes/reaps a prior `running` row, so nothing else would). Idempotent; best-effort.
         void workflowNotifyGate
-            ?.recover({ orphanGraceMs: config.workflowOrphanGraceMs })
+            ?.recover(workflowRecoverOpts)
             .then(() => workflowNotifyRecoverGuard.onSuccess(), workflowNotifyRecoverGuard.onError);
         // SVC-2 (adversarial-review HIGH): time-based GC of the workflow_journal table (the heaviest, TaskResult-bearing
         // one) — the per-run deleteByRun has no run-store reap hook, so this bounded sweep is what stops unbounded