@sema-agent/server 7.14.0 → 7.16.0-rc.1

package/dist/http/routes/runs.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { uuidv7, mintCheckpointToken, CheckpointError, validatePendingSteer } from "@sema-agent/core";
-import { isTerminalRunStatus } from "../../plugins/store-contracts.js";
+import { isTerminalRunStatus, isParkedRunStatus } from "../../plugins/store-contracts.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { HttpError, verifiedPrincipal, isUuidV7, encodeCheckpointScope } from "../../security.js";
 import { runInBackground } from "../../runs.js";
@@ -14,6 +14,7 @@ import { scopedIdempotencyKey } from "../idempotency.js";
 import { streamSseLog } from "../sse-log.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames } from "../../approval-card.js";
 import { resolveStreamApprovalGate } from "../../tool-approval.js";
+import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
 import { normalizeRunEventType } from "../../trace/project.js";
 import { sendJson, sendError, httpErrorCode, sseHeaders } from "../send.js";
 import { buildActiveRunConflict } from "../active-run-conflict.js";
@@ -89,7 +90,9 @@ const AskDecisionBodySchema = z
     decision: z.enum(["approve", "deny"]),
     /** 仅 approve 臂有意义;deny 带 = 宽收后忽略(与三条 respond 同姿势)。 */
     updatedInput: z.unknown().optional(),
-    note: z.string().max(2048).optional(),
+    /** 上限走**共享常量**(#229):live 腿的手写 parser 写同一列,两处各写一份 `2048` 字面量 =
+     *  同一列上两个口径,而分歧只会在「一条腿收下、另一条腿 400」的那天才暴露。 */
+    note: z.string().max(MAX_DECISION_NOTE_CHARS).optional(),
     idempotencyKey: z
         .string()
         .min(1)
@@ -519,7 +522,8 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                         // CAS lost — answer by the run's ACTUAL state, never pretend the cancel landed.
                         const now = await rs.getRun(taskId);
                         const st = now?.status;
-                        if (st === "suspended" || st === "needs_review" || st === "running") {
+                        // 判据取词表属主(合并码重扫):park 是两个词,手抄形对 core 的词表增删两向都没有编译期钉。
+                        if (st !== undefined && (isParkedRunStatus(st) || st === "running")) {
                             // 文案中性覆盖两因(复验镜头:输家可能是 decide 也可能是 reaper 的 expire——后者无人 resuming)
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
@@ -541,7 +545,8 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     if (!claimed) {
                         const now = await rs.getRun(taskId);
                         const st = now?.status;
-                        if (st === "running" || st === "suspended" || st === "needs_review") {
+                        // 同上:词表属主判据(手抄形绕开 isParkedRunStatus 的 `never` 执法点)。
+                        if (st !== undefined && (st === "running" || isParkedRunStatus(st))) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
                         else {
@@ -606,15 +611,36 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             // Durable flag FIRST (only flips a still-running row), abort after: if the run suspended/terminal'd
             // between the getRun above and here, the flag write affects 0 rows — re-read and answer by the run's
             // ACTUAL state instead of lying "cancelling" about a run nothing will cancel.
-            const flagged = await deps.runStore.requestCancel(taskId, run.owner); // owner guard: single-DB defense-in-depth (HTTP gate already passed runOwnerOk)
-            if (!flagged) {
+            let flagged = await deps.runStore.requestCancel(taskId, run.owner); // owner guard: single-DB defense-in-depth (HTTP gate already passed runOwnerOk)
+            // 抢跑输了(旗打空 0 行)⇒ 按 run 的**真实**状态重判。三向,而且 `running` 那一向必须**重挂旗**
+            // 而不是回答:
+            //  · **park**(🔴 判据取词表属主 `store-contracts.ts` 的穷举 `isParkedRunStatus`,扫描P2):原地手抄的
+            //    `=== "suspended"` 漏掉 `needs_review`(plan_review / dry-run 门的 park 落名),一条抢跑停到计划
+            //    评审上的 run 会掉进 no-op 臂被谎报终局,而行还活着、`task_active` claim 一根手指都没动 ——
+            //    [868] 会话锁死指纹的同族第二例(直连分支早已认两个词,codex M1;这条孪生臂当时漏了)。
+            //  · **running**(codex 复审 round1 [high] 二,验真):`requestCancel` 只对 running 行生效,而
+            //    park→running 的**二次跃迁**真实存在——并发 approve 的 `markResuming` 会把行从 park 翻回
+            //    running。旧码只处理「重读到 park」,重读到 running 掉进 no-op 臂:旗没挂上、腿没 abort,
+            //    **被批准的活继续跑**,而调用方以为取消是空操作。行活过来正是该重挂旗的时刻,不是该撒谎的时刻。
+            //  · 真终局 ⇒ 照旧幂等 no-op(带真实状态)。
+            // 有界(park↔running 反复跳时不许把请求钉在这):次数用尽仍 running ⇒ 如实 409 让调用方重试。
+            const CANCEL_RECLASSIFY_ATTEMPTS = 3;
+            for (let attempt = 0; !flagged; attempt++) {
                 const now = await deps.runStore.getRun(taskId);
-                if (now?.status === "suspended") {
-                    await cancelSuspended(); // [868] lost race INTO suspended — same recovery handle as the direct branch
+                if (now !== undefined && isParkedRunStatus(now.status)) {
+                    await cancelSuspended(); // [868] lost race INTO a park — same recovery handle as the direct branch
+                    return;
                 }
-                else {
-                    sendJson(res, 202, { taskId, status: now?.status ?? "failed", note: "run already terminal — cancel is a no-op" });
+                if (now?.status === "running" && attempt < CANCEL_RECLASSIFY_ATTEMPTS) {
+                    flagged = await deps.runStore.requestCancel(taskId, run.owner); // 行又活了 ⇒ 重挂 durable 旗(赢了就走下面的快路)
+                    continue;
                 }
+                if (now?.status === "running") {
+                    // 文案与 cancelSuspended 的 CAS 输臂同源(同一件事:并发决议赢了,它的恢复腿正在跑)。
+                    sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: now.status });
+                    return;
+                }
+                sendJson(res, 202, { taskId, status: now?.status ?? "failed", note: "run already terminal — cancel is a no-op" });
                 return;
             }
             // fast path: cancel landed on the running instance → abort now. Label FIRST ([1.207 codex H2]) so the
@@ -625,10 +651,11 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             }
             sendJson(res, 202, { taskId, status: "cancelling" });
         }
-        else if (run.status === "suspended" || run.status === "needs_review") {
+        else if (isParkedRunStatus(run.status)) {
             // [868] settle the pending gate + terminalize + unlock (was a flat 409 dead-end). needs_review rides the
             // SAME handle (codex M1): a plan-review park holds the claim identically and the old else branch lied
-            // "already terminal" about it (claim never released).
+            // "already terminal" about it (claim never released). 判据同上取属主(扫描P2:两处原地手抄的同一张
+            // park 词表已收敛到 `isParkedRunStatus`,再加词由 tsc 逼人表态)。
             await cancelSuspended();
         }
         else {
@@ -787,7 +814,13 @@ async function handleRunsBody(req, res, url, ctx, miss) {
         };
         const sendQueueFull = () => sendError(res, 409, "steering.queue_full", parkQueueFull ?? "the parked steering queue on this checkpoint is full");
         const sendDuplicateKey = () => sendError(res, 409, "steering.duplicate_input_id", parkDuplicateKey ?? "this Idempotency-Key is already parked with different steering content — reissue with a fresh key");
-        const sendParked = () => sendJson(res, 202, { taskId, status: "suspended", delivery: "queued", messageId, ...(priority ? { priority } : {}), note: "steer parked on the checkpoint — injected when the run resumes" });
+        /**
+         * 202 park 回执。`status` 是**入参**而不是字面量(合并码重扫):park 是两个词,`403a841` 把 (b) 支的
+         * 判据拓成 `isParkedRunStatus` 之后 `needs_review` 行首次走进这条支,而回执还硬报 `"suspended"` ⇒ 同一
+         * 时刻 `GET /v1/runs/:id` 报 `needs_review`,按回执刷新本地行的消费端把「待评审」渲成「已挂起」。
+         * 姊妹位早就读真词(preempt 的 `extras.status`、本文件终局 cancel 与 wake-park 两处回执)。
+         */
+        const sendParked = (status) => sendJson(res, 202, { taskId, status, delivery: "queued", messageId, ...(priority ? { priority } : {}), note: "steer parked on the checkpoint — injected when the run resumes" });
         const sendNotRunning = (error) => sendError(res, 409, "steering.not_running", error);
         // (a) Same-replica live path: the run is streaming here → inject now (drained at the next turn boundary).
         const live = steerableRuns.get(taskId);
@@ -808,9 +841,21 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 // Raced: the stream finished between the map lookup and steer(). It may have durably SUSPENDED in the SAME
                 // tick (core already wrote the pending checkpoint) — fall through to the durable park rather than a spurious
                 // 409 (the live→suspended transition window). Only a genuinely-terminal run → not_running.
+                // 🔴 回执的 status 要报「投递时刻 server 看到的行状态」,而手里那份快照是**进 handler 时**读的
+                // (这条腿上多半还是 `running`,park 发生在它之后)。所以在这里重读一次 —— 且**必须在 park 之前**
+                // (codex 复审二/三轮合并处置):
+                //  · 提交**后**再读 = 给一个已成功的写加提交后依赖。库降级时那次读可以永远挂着(`.catch` 只接
+                //    拒绝、接不住不返回),客户端拿不到 202 就重试,而不带 `Idempotency-Key` 的重试会**再追加一条**
+                //    同样的指令(队列只有 3 个位子)——把「回执更准」换成「指令重复入队」,方向反了。
+                //  · 提交**前**读则没有这个代价:此刻还没有任何东西入队,读挂了 = 这次请求超时,与 park 之前任何
+                //    一步超时同形,重试语义不变。
+                // 读不到(理论不可达:行必在)⇒ 退回快照,绝不硬编码一个 park 词。残余如实说:行的翻面与 core
+                // 写 checkpoint 不在同一步,所以这一腿仍可能读到 `running` ——判别键是 `delivery`(SDK/openapi 逐字
+                // 「branch on `delivery`, not the status」),不是 status。
+                const freshBeforePark = await deps.runStore.getRun(taskId).catch(() => undefined);
                 const raced = await tryPark();
                 if (raced === "parked") {
-                    sendParked();
+                    sendParked(freshBeforePark?.status ?? run.status);
                     return;
                 }
                 if (raced === "queue-full") {
@@ -825,15 +870,18 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 return;
             }
         }
-        // (b) Durably suspended → park the steer on the pending checkpoint (drained on resume).
-        if (run.status === "suspended") {
+        // (b) Durably PARKED → park the steer on the pending checkpoint (drained on resume). 判据取词表属主
+        // isParkedRunStatus(扫描P2 顺带件):只认 suspended 会把 needs_review park 漏到 (d) 终局支——消息
+        // 虽也 park 上同一张卡,但回执是 parked_for_wake+「run already ended,用 /wake 送」,指路错人
+        // (真相是本支的「injected when the run resumes」)。
+        if (isParkedRunStatus(run.status)) {
             const outcome = await tryPark();
             if (outcome === "no-store") {
                 sendError(res, 501, "capability.checkpoint_store_required", "steering a suspended run requires the checkpoint store");
                 return;
             }
             if (outcome === "parked") {
-                sendParked();
+                sendParked(run.status);
                 return;
             }
             if (outcome === "queue-full") {
@@ -844,7 +892,8 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 sendDuplicateKey();
                 return;
             }
-            sendNotRunning("run is no longer suspended (resolved or expired)");
+            // 文案按 park **两个词**中性化(旧句只说 suspended,对一条 needs_review park 说的是别人的事)。
+            sendNotRunning("run is no longer parked on a pending decision (resolved or expired)");
             return;
         }
         // (c) running-elsewhere (cross-replica, fast-follow seam) → not_running.
@@ -1748,6 +1797,18 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             deps.toolApproval?.notifyExternalDecision(row.askId, row.decision === "approve");
             return true;
         };
+        /**
+         * #229(设计稿 233 稿B v2 §2):回决理由的**读面**投影 —— 三个回体共用这一份,行上有才发。
+         *
+         * 🔴 **裁定翻面,原样记账**:本 handler 原先明写「`note` 不回显(以请求者可见权限为界的最窄安全形)」。
+         * 那条最窄形的实测代价是 `decisionNote` 全仓**只写不读** —— 一个零读面的「审计位」对任何按审计面
+         * 接它的消费端都是当场落空。现行裁定:三回体一律 additive 投,**从不发 null / 空键**(缺席 = 这条
+         * 决议没留理由,与 `updatedInputForwarded` 的「从不发 false」同族)。
+         * 读权前提没有放宽:能走到这条口的调用方本来就有权决这只 ask(属主门在本 handler 上游),而 409 支
+         * 回显的**首决**理由与它同支已经在回显的 `decision`/`decidedAtMs`/`actor` 是同一份首决投影 ——
+         * 多这一格不新开任何一条越权读路径。
+         */
+        const decisionNoteEcho = (row) => (row.decisionNote === null ? {} : { decisionNote: row.decisionNote });
         /** 200 回放形:与首决 200 同键集,只差 `updatedInputForwarded`(§12-A 明写回放不承诺字节等同)。
          *  调用前提 = 已过 {@link syncLiveFromDecidedRow}(行合形且活体窗已同步)。 */
         const replayDecided = (row) => {
@@ -1758,6 +1819,7 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                 decision: row.decision,
                 decidedAtMs: row.decidedAtMs,
                 ...(storedActor ? { actor: storedActor } : {}),
+                ...decisionNoteEcho(row),
             });
         };
         // 终局分派 —— **一律按传进来的这一行**投影,不重读(§12-A:`DecideResult.row` 已是新鲜行;
@@ -1775,11 +1837,13 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
                         return;
                     }
                     const first = projectDecisionActor(row.decisionActor);
-                    // 首决回显三件;`note` **不回显**(以请求者可见权限为界的最窄安全形,稿 §5)。
+                    // 首决回显四件(#229 起含 `decisionNote`;翻面理由见 {@link decisionNoteEcho})——回显的恒是
+                    // **首决**那条理由,不是本次请求带来的那条(本次请求压根没落地)。
                     sendError(res, 409, "conflict.ask_decided", "this ask was already decided — the first decision stands and is echoed here", {
                         decision: row.decision,
                         decidedAtMs: row.decidedAtMs,
                         ...(first ? { actor: first } : {}),
+                        ...decisionNoteEcho(row),
                     });
                     return;
                 }
@@ -1935,6 +1999,9 @@ async function handleRunVerbsBody(req, res, url, ctx, miss) {
             decidedAtMs: outcome.row.decidedAtMs,
             actor,
             ...(forwarded ? { updatedInputForwarded: true } : {}),
+            // #229:同上,**按行**投(不按 `body.note`)——赢者行才是这次回决的真相,而 `decideAsk` 的提交与
+            // 回读之间那条行仍可能被版本化收敛改写(同一条「每个入参都取自行」的纪律)。
+            ...decisionNoteEcho(outcome.row),
         });
         return;
     }

package/dist/http/routes/side-query.js

@@ -1,5 +1,6 @@
-import { isThinkingLevel } from "@sema-agent/core";
+import { expandTiers, isThinkingLevel } from "@sema-agent/core";
 import { HttpError } from "../../security.js";
+import { isModelAllowlisted } from "../../model-select.js";
 import { cacheFamilyOfMirror } from "../../budget.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { sendJson, sendError, httpErrorCode, msg } from "../send.js";
@@ -135,6 +136,19 @@ async function handleSideQueryBody(req, res, url, ctx, miss) {
                 sendError(res, 400, "request.field_invalid", `invalid modelRole (expected one of: ${Object.keys(MODEL_ROLE_TABLE).join(", ")}) — a role only resolves a model when 'model' is absent`);
                 return;
             }
+            // #233 / A-002.8 第三执法点 —— side-query 的 `body.model` 是**计费提交面**上的用户逐 turn 选择
+            // 通道(直透传给 core 的路由),与任务面 `body.model` 同名单同拒形。归一走同一只
+            // `isModelAllowlisted`(增广目录:档位词/CC 别名/id 与 name 指同一只模型时不许绕门)。
+            // 不受限的是 `modelRole`(operator 的角色表选路,不是用户点的模型)——两者的辖域线与任务面一致。
+            // 本路由无 resume 腿(一次性问答),故只有 fresh 拒这一支。
+            if (typeof body.model === "string" && body.model.length > 0) {
+                const bare = deps.config.models ?? {};
+                const catalog = expandTiers(bare, deps.config.tiers ?? {}) ?? bare;
+                if (!isModelAllowlisted(body.model, catalog, deps.config.atModelAllowlist)) {
+                    sendError(res, 400, "request.model_not_allowed", `model is not in this deployment's @-mention allowlist: "${body.model.slice(0, 120)}" — the allowlist is configured by the operator (config-center models.atModelAllowlist)`);
+                    return;
+                }
+            }
             if (ac.signal.aborted)
                 return; // client already gone — don't start the brain call at all
             const spec = {

package/dist/http/routes/tasks.js

@@ -20,6 +20,12 @@ import { failOpenTagForDroppedFrame, recordFailOpen } from "../../observability/
  *  前缀 `id: <eventId>` 行(SSE 游标=账本 eventId,壳/SDK 拿它锚进账本或断线换道 events tail 续读);
  *  无 eventId 的帧**不发行**,EventSource 沿用上一游标 —— 绝不合成占位 id(那会把不可锚的位置伪装成可锚)。
  *  durable 腿的 `id:` 行在 sse-log.ts(同一契约的另半);行为钉=test/live-sse-cursor.test.ts(规则式全流判据)。 */
+/** #241([3731] 裁定 A):断连转 park 的有界宽限——ask 已被强转 park 路由后,给 core 从「收到
+ *  "unavailable"」走到「铸 checkpoint + done(suspended)」的时间。到点仍没收到 done ⇒ 照旧 abort,
+ *  交断连支既有的 findPendingTokenBySession 竞态卫兵兜底(checkpoint 已落盘则仍 park)。
+ *  取值:core 的 park 是本地 IO(checkpoint 写盘/写库)+一次 done 帧,秒级富余;不设旋钮——它不是
+ *  行为面选择,只是竞态兜底的等待上限(设长了唯一代价是极端卡死时 abort 晚到)。 */
+const DISCONNECT_PARK_GRACE_MS = 10_000;
 function sseData(res, payload) {
     const anchor = payload.eventId;
     const idLine = typeof anchor === "string" && anchor.length > 0 ? `id: ${anchor}\n` : "";
@@ -161,6 +167,8 @@ async function handleTasksBody(req, res, url, ctx, miss) {
             // 🔴 stoppedBy 归因的注册点在**下面**(createRun 认领成功之后),不在这里 —— #168 件3,见那里的注。
             let closed = false;
             let detachLogged = false; // [854]①b:detach 断连 info 只打一条(req/res 两个 close listener 都可能进来)
+            // #241([3731] 裁定 A):断连转 park 的宽限表——非空 = 已触发过 ask 转 park,断连支不再二次进臂。
+            let disconnectParkGrace;
             const onDisconnect = () => {
                 // [854]①b:detach opt-in 的断连分支 —— 不置 closed(for-await 继续消费到 done,终态走既有
                 // setTerminal 路径落 durable 账本)、不 abort(run 不杀)。断连后的 res.write 落在已 destroy 的
@@ -180,6 +188,26 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                     }
                     return;
                 }
+                // #241([3731] 裁定 A「park 应跨壳死存活」,[3730] core 零改动承运;cli [3729] L3 真机复现=本臂
+                // 缺席时的行为):断连瞬间本 run 有**流内未决 ask** 且 park 设施在场 ⇒ 不立即 abort——先把 ask 按
+                // 窗到期同路强转 park(coordinator 交 `"unavailable"` ⇒ core 走 durable park ⇒ done(suspended)),
+                // 给 core 一个**有界宽限**走完 park:宽限内 done 到 ⇒ 循环自然收束、走上面的 setSuspended 臂
+                // (行 park、卡存活、resume 重呈闭环);宽限用尽(park 卡在半路)⇒ 照旧 closed+abort,下面既有的
+                // findPendingTokenBySession 竞态卫兵接手(checkpoint 已落盘则仍 park)。真算力中断(无未决 ask)
+                // 语义**不变**:立即 abort——那是这个断连臂存在的原始理由(dropped relay 不烧 token)。
+                if (deps.checkpointStore && earlyDurableTid && disconnectParkGrace === undefined) {
+                    const parked = deps.toolApproval?.parkOpenAsksForTask(earlyDurableTid) ?? 0;
+                    if (parked > 0) {
+                        res.on("error", () => undefined); // 断连后循环继续消费,死 socket 上的 write 错误按 detach 同形吞
+                        deps.logger?.info("stream_disconnect_ask_parked", { taskId: earlyDurableTid, sessionId: prepared.spec.sessionId, asks: parked, graceMs: DISCONNECT_PARK_GRACE_MS });
+                        disconnectParkGrace = setTimeout(() => {
+                            closed = true;
+                            ac.abort();
+                        }, DISCONNECT_PARK_GRACE_MS);
+                        disconnectParkGrace.unref?.();
+                        return;
+                    }
+                }
                 closed = true;
                 ac.abort();
             };
@@ -1054,7 +1082,7 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                         if (finalResult?.status === "suspended" && deps.checkpointStore)
                             await deps.runStore.setSuspended(durableTaskId);
                         else if (finalResult?.status === "needs_review" && deps.checkpointStore)
-                            await deps.runStore.setNeedsReview(durableTaskId); // D-B: park a review pause, keep the lock (resumable via /plan_review)
+                            await deps.runStore.setNeedsReview(durableTaskId); // D-B: park a review pause, keep the lock (a plan_review GATE resumes via /plan_review; a needs_review gate = dry-run review has no resolution endpoint today — [3683]-1, don't copy this comment as "needs_review → /plan_review")
                         else if (finalResult)
                             await deps.runStore.setTerminal(durableTaskId, finalResult.status, finalResult, finalResult.errorMessage ?? null);
                         else {
@@ -1345,8 +1373,9 @@ async function handleTasksBody(req, res, url, ctx, miss) {
                     return { status: 200, body: { taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "suspended" } };
                 }
                 // design/80 D-B: a review pause (plan_review / dry_run_review) on the sync path — PARK it like a suspend
-                // (keep task_active) + return a pollable taskId so the /v1/assistant/tasks/:id/plan_review resume can
-                // claim it. NEVER the capability token (parity with the suspended branch above).
+                // (keep task_active) + return a pollable taskId. For a plan_review GATE the /v1/assistant/tasks/:id/plan_review
+                // resume claims it; a needs_review gate (dry-run review) has no resolution endpoint today ([3683]-1).
+                // NEVER the capability token (parity with the suspended branch above).
                 if (result.status === "needs_review" && deps.checkpointStore && deps.runStore && prepared.spec.sessionId) {
                     if (durableTaskId)
                         await deps.runStore.setNeedsReview(durableTaskId);

package/dist/http/routes/trace-usage.js

@@ -1,4 +1,3 @@
-import { buildToolResultRef } from "@sema-agent/core";
 import { projectEvents, taskSummary, mapTraceEvent } from "../../trace/project.js";
 import { projectArtifacts } from "../../trace/artifacts.js";
 import { usageSummary, usageSeries, usageBreakdown } from "../../usage-analytics.js";
@@ -235,7 +234,11 @@ async function handleTaskArtifacts(res, runStore, taskId) {
  *    「坏 query + 已知 ref = 400」而「坏 query + 未知 ref = 404」,状态码之差立刻成了存在性 oracle。
  *    query 的合法性只取决于 query 自身,与调用方看不看得见这个 ref 无关,所以先判是安全的。
  *
- * ② **归属绑定 = 对本 task 的耐久日志做精确成员判定**,不解析 ref、不复制段转义规则。
+ * ② **归属绑定 = 店里记的出处(`ownerOf`)与本 run 的 session/task 精确相等**(实现见 ②-a),不解析 ref、
+ *    不复制段转义规则,**且没有第二条腿**。
+ *
+ *    下面这一大段是这条判据的**病历**(前缀形 → 本 task 日志作证形 → 出处形),留着是因为「为什么不
+ *    照 ref 的字面去判」每隔一阵就被重新问一次;当前生效的判据只有 🟡 段之后的那一条。
  *
  *    先说为什么**不是**前缀判定([3321]② 的字面形、[3322] 的指定形):core 的 ref 形是
  *    `tr_<seg(session)>_<seg(toolCallId)>`,而 `_` 在两段里都合法 ⇒ session `team` 的前缀 `tr_team_`
@@ -247,7 +250,7 @@ async function handleTaskArtifacts(res, runStore, taskId) {
  *    跨租户**拒绝**面(别人注册一个 `<你的 session>_toolu` 就能让你自己的 ref 永远 404)——R2 复审两条
  *    中标,已撤回该启发式。
  *
- *    改判据:ref **必须由本 task 自己的耐久事件日志作证**。日志里每条 tool_start/tool_end 都带
+ *    当年的改判据(**已被 ②-a 取代,见下**):ref **必须由本 task 自己的耐久事件日志作证**。日志里每条 tool_start/tool_end 都带
  *    `toolCallId`(`trace/project.ts` 的 toolStartEventData / toolEndEventData 是唯一铸造点),用 core
  *    的**同一个** `buildToolResultRef` 把它们铸成 ref 集合,再要求 `ref` 是其中一员 —— 精确相等,
  *    零解析、零转义规则复制,歧义面结构上不存在(A 的 taskId 只作证 A 自己的 toolCallId)。
@@ -255,10 +258,18 @@ async function handleTaskArtifacts(res, runStore, taskId) {
  *    trace 的 tool-result 块与本判据读的是同一份日志,所以「trace 上看得见 ⇒ 这里读得到」成立;
  *    同 session 里**别的 task** 的 ref(或日志已过保留窗被逐出的)按 404 同形拒,请到那条 task 上读。
  *
- *    🟢 **两条残余已随 core 5.26.0 #119 销账**(下面原文保留作病历)。core 按当年这里写的方向动了刀:
- *    `put` 带出处落库 + `ownerOf` 读回,读面改用出处判定(实现见 ②-a),于是 (a) 合成 id 铸的 ref 不再
- *    读不到、(b) 拼接非单射的越权面结构上消失(ref 铸法本身也换成 `~` 四段单射)。日志重铸只剩**存量
- *    兜底**一条腿(无出处的旧行),新写入一律经出处。
+ *    🟡 **两条残余的现状(7.14.0 合并窗复扫改口,下面原文保留作病历)**。core 按当年这里写的方向动了刀:
+ *    `put` 带出处落库 + `ownerOf` 读回,读面改用出处判定(实现见 ②-a)。逐条对账:
+ *      · (b) 拼接非单射的越权面**已彻底消失** —— ref 铸法换成 `~` 多段,`~` 不在段的合法字符集里。
+ *      · (a) 合成 id 铸的 ref **只销了一半**:offload / budget / compaction 三个写点的出处只声明
+ *        session ⇒ 现在读得到;而 `task-registry-monitor` 的 spill(`<stream>_seg<n>`)与
+ *        `task-registry-agent` 的 spill(`c<cycle>`)在出处里**点名了 taskId,填的是 core TaskRegistry
+ *        的 handle id**(`b/w/a/m` 前缀 + 16 hex,见 core `task-registry.js`),与本路由段里的 server
+ *        run id(uuidv7)是两个命名空间,恒不相等 ⇒ 这两族 ref 在本面**恒 404**(改前也 404,不是回归)。
+ *        而它们恰恰是 core 在成品文本里明写「call ReadToolResult with ref …」露给调用方的那批。
+ *        真解仍在 core 侧(出处该声明的是**调用方认得的** task 坐标,或干脆只声明 session);本仓不自行
+ *        放宽 taskId 那条腿 —— 那是单方面改判定语义,归属判据会与上游各漂一份。
+ *    日志重铸那条腿**已删**(见 ②-b:它对任何真实行都不可达,且每次未命中还要付一次全量日志读)。
  *
  *    ⚠️ 两处**已知残余**,都要 core 侧动刀才能消,写在明处而不是让下一个人自己撞(codex 复审 R3):
  *
@@ -276,7 +287,7 @@ async function handleTaskArtifacts(res, runStore, taskId) {
  *        铸出那一枚精确的 toolCallId(provider 铸,本服务不控也不产)。同样只有 core 换成单射编码才真消。
  *        这里**不留特征化测试**去钉这条通路 —— 把缺陷钉成契约是另一种病。
  *
- * ③ **同形 404**(unknown ref / 未获本 task 日志作证 / 本部署没有 durable store)。任何可区分的响应都是
+ * ③ **同形 404**(unknown ref / 出处判不过(含无属主行)/ 本部署没有 durable store)。任何可区分的响应都是
  *    缺陷:前两者之差会告诉调用方「这枚 ref 存在,只是不是你的」;第三者若回 501 则会把部署形告诉一个
  *    连自己的 ref 都读不到的 caller。文案恒定且**不回显 ref**(回显=把输入原样反射进错误面)。
  *    残余面(诚实写明):响应字节同形,**时序**并不同形 —— 三条臂到达的后端调用数不同。要抹平时序得让
@@ -322,10 +333,12 @@ ref, query) {
         return notFound();
     // ②-a 出处判定(#119,core 5.26.0 —— 上面 (a)/(b) 两条残余的**正解到货**)。
     // 店里现在自己记着「这枚 ref 属于谁」(`put` 的第三参落库,`ownerOf` 读回),读面拿**自己已知的字段**
-    // 比对即可:零解析、零段转义规则复制,合成 id 铸的 ref 与拼接歧义两条残余同时消失。
+    // 比对即可:零解析、零段转义规则复制,拼接歧义那条残余彻底消失,合成 id 那条**消了一半**
+    // (monitor/agent spill 两族的出处点名的 taskId 是 core handle id,与本函数收到的 server run id 不同
+    //  命名空间 ⇒ 恒判假;详见头注 🟡 段)。
     //
-    // 🔴 为什么必须改而不是"锦上添花":5.26.0 起 offload ref 是四段单射形(内容坐标进 ref),服务端手里
-    // 没有内容 ⇒ 下面那条重铸判据**重铸不出来** ⇒ 每一枚真 offload ref 都会 404。读面整死。
+    // 🔴 为什么必须改而不是"锦上添花":5.26.0 起 offload ref 是多段单射形(内容坐标进 ref),服务端手里
+    // 没有内容 ⇒ 原来那条重铸判据**重铸不出来** ⇒ 每一枚真 offload ref 都会 404。读面整死。
     //
     // ⚠️ 辖域(有意的口径变化,写在明处):出处的粒度由 core 定 —— offload/budget/projection 三个写点只声明
     // session,把 taskId 钉在那里会把「一个 session 的两条 task 共用一枚 ref」这个**设计内**的共享形变成拒绝
@@ -334,32 +347,20 @@ ref, query) {
     // 之前已过,session 的属主就是这个 caller),换来的是这条读面在 5.26.0 上还活着。
     const owner = store?.ownerOf ? await store.ownerOf(ref) : undefined;
     const ownedByThisCaller = owner !== undefined && owner.sessionId === run.sessionId && (owner.taskId === undefined || owner.taskId === taskId);
-    // ②-b 无出处兜底:**没声明属主**的行按老判据走 —— 本 task 耐久日志作证过的 toolCallId,经 core 同一个
-    // 铸造点变成 ref 再精确相等。unowned 本身不是授权(core:读面对 unowned 一律 fail-closed),日志作证才是。
-    //
-    // ⚠️ 这条**不是**「读得到升级前的存量行」(codex 复审 medium,已核真并改口):5.26.0 的
-    // `buildToolResultRef` 铸的是 `~` 分隔形,重铸不出旧引擎的 `tr_<sid>_<call>`,而按旧规则手写一个 legacy
-    // 编码器 = 复制上游规则(本文件头注自己禁掉的那件事)。真正的处置在别处 —— 本批要求**删表重建**
-    // `tool_result`(见 CHANGELOG),所以升级后库里根本没有旧行。这一支覆盖的是「5.26.0 引擎写下、但写点
-    // 没声明出处」的行(core 自家的 offload 写点都带出处,所以现实里几乎为空),留着是纵深不是承诺。
-    // 成本口径:整份日志一读一扫,与同域的 `/turns`、`/artifacts` 同款;有出处时**根本不读日志**。
-    if (!ownedByThisCaller) {
-        if (owner !== undefined)
-            return notFound(); // 出处在,但不是这位 —— 不给第二次机会(日志重铸绕不过出处)
-        const events = await runStore.getEvents(taskId, 0);
-        let attested = false;
-        for (const ev of events) {
-            // 取键姿势与同域的 `trace/artifacts.ts` 逐字同款(同一份日志、同一个字段,读法不该有第二种)。
-            const { toolCallId: id } = (ev.data ?? {});
-            // 逐条比对而不是先建全集:命中即停,长日志上不必把整份集合物化。
-            if (typeof id === "string" && id.length > 0 && buildToolResultRef(run.sessionId, id) === ref) {
-                attested = true;
-                break;
-            }
-        }
-        if (!attested)
-            return notFound();
-    }
+    // ②-b **没有**第二条腿:出处判不过就是 404(unowned 行也在内 —— core 的口径就是「读面对 unowned
+    // fail-closed」)。这里曾有一条「用本 task 耐久日志作证过的 toolCallId 经 `buildToolResultRef` 重铸再
+    // 精确相等」的兜底,7.14.0 合并窗复扫判定为**结构性死支**并整条删除,证据链写在明处:
+    //   · 重铸只喂得起两个参数(服务端手里没有内容)⇒ 铸出的是**两段**形 `tr_<sid>~<callId>`;
+    //   · core 5.27.0 的**每一个**落库写点铸的都是 ≥3 段(offload/budget/compaction 三段带内容摘要、
+    //     detail 卸载四段、monitor/agent spill 三段带 `<stream>_seg<n>`/`c<cycle>`),而 `~` 不在段的合法
+    //     字符集里 ⇒ **段数不同的 ref 恒不相等** ⇒ 该判据对库里任何真实行都不可能成立;
+    //   · 旧引擎(≤5.25.0)的 `tr_<sid>_<call>` 同样重铸不出来(分隔符换了),而按旧规则手写一个 legacy
+    //     编码器 = 复制上游规则(本文件头注自己禁掉的那件事);存量行的真处置是**删表重建**(见 CHANGELOG)。
+    // 删的另一半理由是**代价**:走到这条腿的前提是「出处缺席」,而任意乱写的未知 ref 恰好也落在这里,
+    // 于是每个必然 404 的请求都要付一次整份耐久事件日志读(已鉴权调用方可用随机 ref 放大后端读),
+    // 换不到任何放行。行为面只收窄不放宽:能放行的集合原本就是空集。
+    if (!ownedByThisCaller)
+        return notFound();
     if (!store)
         return notFound(); // durable store 缺席:404 同形,不 501(不泄露部署形)
     const slice = await store.get(ref, { ...(offset !== undefined ? { offset } : {}), ...(limit !== undefined ? { limit } : {}) });

package/dist/http/server.js

@@ -3,7 +3,7 @@ import { once } from "node:events";
 import { createHash } from "node:crypto";
 import { uuidv7, isThinkingLevel, expandTiers, resumeWithVerification, CheckpointError, HAND_TOOL_EFFECTS, RETIRED_TOOL_NAMES, defaultTaskRegistry, validatePendingSteer, subscribeWorkflow, GLOBAL_USAGE_KEY, usageRetryAfterMs } from "@sema-agent/core";
 import { decideParkedAgent, findParkedAgentForCheckpoint } from "../parked-decide.js";
-import { matchCatalogModel } from "../model-select.js";
+import { isModelAllowlisted, matchCatalogModel } from "../model-select.js";
 import {} from "../config-center/facade.js";
 import { HttpError, principalFrom, verifiedPrincipal, setSsoPrincipal, ssoVerifiedPrincipal, setSsoScope, isUuidV7, isDestructiveSessionWrite, decodeCheckpointScope, CHECKPOINT_PUBLIC_SCOPE, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../security.js";
 import { verifyDirectDoorProof } from "../principal-jwt.js";
@@ -117,6 +117,13 @@ const MAX_IMAGE_BASE64_BYTES = 6 * 1024 * 1024; // a single inline image's base6
 // name is never mounted, so keeping it here would let the pre-check claim satisfiability for a tool that
 // cannot exist (same derivation hygiene as hands-lane.ts HANDS_BAND_TOOL_NAMES).
 const HAND_TOOL_NAMES = Object.keys(HAND_TOOL_EFFECTS).filter((n) => !RETIRED_TOOL_NAMES.has(n));
+/** #233 / A-002.8 —— 未知模型 400 里 `available` 列表的**名单过滤**:不给用户广告他点不了的模型。
+ *  名单缺席/空 ⇒ 与本件之前逐字同集(全目录去 `default` 别名);名单在场 ⇒ 只留名单准的那些。
+ *  判定单源 `isModelAllowlisted`(与三个执法点同一只),所以"列出来的"与"点了不被拒的"恒为同一批。 */
+function mentionableNames(config, catalog) {
+    const allowlist = config.atModelAllowlist ?? [];
+    return Object.keys(catalog).filter((n) => n !== "default" && isModelAllowlisted(n, catalog, allowlist));
+}
 /** [1245] codex-3/4 — the REOPEN-class resume failures: core's runtask reopened the checkpoint (store.reopen,
  *  dist-read) BEFORE returning this failed result, so the park is STILL PENDING and decidable. Everything
  *  downstream must treat these as a re-park, never terminal: the durable event log writes `suspended` (not
@@ -125,6 +132,37 @@ const HAND_TOOL_NAMES = Object.keys(HAND_TOOL_EFFECTS).filter((n) => !RETIRED_TO
 function isCheckpointReopenedFailure(r) {
     return r.status === "failed" && (r.errorCode === "resume.env_failed" || r.errorCode === "resume.tool_unavailable");
 }
+/**
+ * 一条 verify/cascade 腿的结果**是不是嵌套 durable park**,以及 park 落在哪个词上(扫描P2 + codex 复审
+ * round1 [high] 一,2026-08-12 亲读 core 验真)。`undefined` = 不是 park(照常走终局)。
+ *
+ * 🔴 判据是 **errorCode**,不是 `verification.unverifiedReason` —— 后者**不覆盖修复轮**:
+ *  · `verify.js:201/208`(runWithVerification / resumeWithVerification 的**立即** park)铸的 outcome 带
+ *    `unverifiedReason: status === "needs_review" ? "needs_review" : "suspended"`;
+ *  · 但 `verify.js:191`(verifier 判 FAIL 后的**修复轮** `runTask` 又停在门上)返回的是
+ *    `{ ...mapNestedSuspend(current), verification: outcome }`,那个 `outcome` 是**上一轮验证器的
+ *    FAIL 判决** —— `verdict:"FAIL"` 的臂根本不填 `unverifiedReason`(`verify.js:166` 只在
+ *    no_verdict / PARTIAL 两种情况填)。于是「按 reason 判 park」对修复轮恒为假,而结果里
+ *    checkpointToken 还活着 ⇒ 写 `done` + setTerminal ⇒ 释放 task_active 锁 + 孤儿化那张卡。
+ *
+ * `mapNestedSuspend`(core `agents/suspend-guard.js`)是**每一条**嵌套 park 的必经点,它无条件盖这两个
+ * 码之一,并且码本身就带 park 的词 —— 所以它同时是「是不是 park」和「是哪个 park」的单一真源。
+ * 两个字面量在 core 的 index 里没有导出,只能照字面锚(与 `runs.ts` / `resource-suspend.ts` 顶注同姿势)。
+ *
+ * ⚠️ 边界:`checkpoint.reopen_failed` 与 `resume.*` 两类 reopen 失败**不在**这里(它们不是 gate 再停,
+ * 由 {@link isCheckpointReopenedFailure} + 店内复核那条腿处置);`verifier_paused` 也不在(那是验证器
+ * 自己的会话与凭据,本 run 的活已经做完)。
+ */
+function nestedParkStatusOf(r) {
+    switch (r.errorCode) {
+        case "unexpected.needs_review": // core UNEXPECTED_NEEDS_REVIEW —— 内层 status 是 needs_review 的 park
+            return "needs_review";
+        case "unexpected.suspended": // core UNEXPECTED_SUSPENDED —— 内层 status 是 suspended 的 park
+            return "suspended";
+        default:
+            return undefined;
+    }
+}
 /** The TRUSTED end-user principal for an owner-gated / per-tenant request. On a direct-door worker the
  *  trusted-header path is OFF (x-agent-principal is client-spoofable), so identity comes from the crypto-VERIFIED
  *  principal JWT (`x-approval-principal-token`, principal-only proof — no cnf.bnd action binding); otherwise the
@@ -1191,7 +1229,7 @@ export function createHttpServer(rawDeps) {
             const bare = deps.config.models ?? {}; // 防御:极简 stub deps 可无 models 域(真 loadConfig 恒有)
             const catalog = expandTiers(bare, deps.config.tiers ?? {}) ?? bare;
             if (matchCatalogModel(body.model, catalog) === undefined) {
-                sendError(res, 400, "request.unknown_reference", `unknown model "${body.model.slice(0, 120)}" — not in the configured catalog (name, tier word, or id)`, { available: Object.keys(catalog).filter((n) => n !== "default") });
+                sendError(res, 400, "request.unknown_reference", `unknown model "${body.model.slice(0, 120)}" — not in the configured catalog (name, tier word, or id)`, { available: mentionableNames(deps.config, catalog) });
                 return null;
             }
         }
@@ -1207,7 +1245,7 @@ export function createHttpServer(rawDeps) {
             const bare = deps.config.models ?? {};
             const catalog = expandTiers(bare, deps.config.tiers ?? {}) ?? bare;
             if (matchCatalogModel(body.compactionModel, catalog) === undefined) {
-                sendError(res, 400, "request.unknown_reference", `unknown compactionModel "${body.compactionModel.slice(0, 120)}" — not in the configured catalog (name, tier word, or id)`, { available: Object.keys(catalog).filter((n) => n !== "default") });
+                sendError(res, 400, "request.unknown_reference", `unknown compactionModel "${body.compactionModel.slice(0, 120)}" — not in the configured catalog (name, tier word, or id)`, { available: mentionableNames(deps.config, catalog) });
                 return null;
             }
         }
@@ -1384,9 +1422,15 @@ export function createHttpServer(rawDeps) {
         if (!isApprovalGateKind(decideGateKind)) { // A-002.1 单一属主
             // [2400] HITL-6(clay 裁 2026-08-03,不做兼容):补机读指路——与 [2255]① 的 409 材料同形
             // (pendingGate{kind, decidePath},resumeEntryForGate 单源表),客户端凭 decidePath 直达对的
-            // resume 入口,不再解析人话文案。taskId 源=cp.sourceTaskId;缺席 ⇒ 只带 kind,诚实不铸假路径。
-            const gnPath = decideGateKind && cp.sourceTaskId
-                ? resumeEntryForGate(decideGateKind, { sessionId, taskId: cp.sourceTaskId })
+            // resume 入口,不再解析人话文案。taskId 源=账本活行(getActiveTaskId,与 active-run-conflict.ts
+            // 的 409 材料同源)——cp.sourceTaskId 是 core 契约里 issuing worker 的 **session id**(ECHO-ONLY
+            // triage,checkpoint-store.d.ts),拿它当 run taskId 铸路径=打出去必 404([3683]-1 同病族,
+            // 扫描 P1 修)。账本无活行 ⇒ 只带 kind,诚实不铸假路径。
+            const activeForPath = decideGateKind
+                ? await deps.runStore?.getActiveTaskId(sessionId).catch(() => undefined)
+                : undefined;
+            const gnPath = decideGateKind && activeForPath
+                ? resumeEntryForGate(decideGateKind, { sessionId, taskId: activeForPath })
                 : null;
             return {
                 status: 409,
@@ -1811,11 +1855,20 @@ export function createHttpServer(rawDeps) {
                     const vr = await resumeWithVerification(legRunner, token, outcome, { ...taskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, resumeObjective, verifyRounds); // 快审 F1:整对象直传
                     let safe = stripCheckpointToken(vr);
                     // 🔴 A re-suspend on a LATER gate is NOT terminal: core maps it to status:"failed" +
-                    // verification.unverifiedReason:"suspended" with the checkpoint token still live. Treat it exactly like
-                    // the stream path's suspended branch — write a "suspended" event and return status:"suspended" so the
-                    // outer block calls setSuspended (keeps the session lock + resumable row). Driving it terminal would
-                    // release the lock and orphan the second checkpoint (next /decide → 409, task abandoned).
-                    const reSuspended = vr.verification?.unverifiedReason === "suspended";
+                    // verification.unverifiedReason with the checkpoint token still live. Treat it exactly like
+                    // the stream path's park branches — write the matching park event and return the park status so the
+                    // outer block calls setSuspended/setNeedsReview (keeps the session lock + resumable row). Driving it
+                    // terminal would release the lock and orphan the second checkpoint (next /decide → 409, task abandoned).
+                    //
+                    // 🔴 park 是**两个词**(扫描P2,status/kind 同名词混淆病族),而且判据必须取 **errorCode** 而不是
+                    // `verification.unverifiedReason` —— 完整理由(含修复轮那条 reason 恒缺席的腿)见
+                    // {@link nestedParkStatusOf} 的顶注,它是这条判据的唯一属主。只认 `unverifiedReason === "suspended"`
+                    // 会漏掉两类真 park:plan_review / dry_run 的 `needs_review` 再停,以及 verifier 判 FAIL 后修复轮
+                    // 的**任一**再停 —— 两类都会被写成 `done` + setTerminal:锁被释放、活卡成孤儿。
+                    // ⚠️ `verifier_paused` 不进这个集合:那是**验证器自己**的会话/凭据(见 core `VerificationOutcome
+                    // .verifierPause`),本 run 的活已经做完,与「本 run 再停在自己的门上」是两件事。
+                    const reParkStatus = nestedParkStatusOf(vr);
+                    const reSuspended = reParkStatus !== undefined;
                     // [1245] codex-4: reopen-class twin of the stream path (store-confirmed, codex-5) — the checkpoint
                     // is pending again, so the durable log must record a park, never `done` (the outer row drive
                     // re-parks via checkpointReopened; the response keeps status:"failed"+retriable, unlike reSuspended
@@ -1834,7 +1887,8 @@ export function createHttpServer(rawDeps) {
                             await appendPromptManifest(ap, deps.promptManifests, taskId); // [998]②: the verified-resume leg has no stream — persist the re-fired manifest before its terminal/suspend event
                             if (reSuspended || vrReopened) {
                                 await appendModelUsageDelta(ap, deps.modelUsage, taskId); // E8: persist pre-re-suspend per-model usage
-                                await ap("suspended", { gate: vr.checkpointGate ?? null, ...(vrReopened ? { reopened: vr.errorCode ?? null } : {}) });
+                                // reopen 腿恒落 `suspended`(它不是 gate 再停,是同一张卡被重开);reSuspended 腿按真 park 词落名。
+                                await ap(reSuspended ? reParkStatus : "suspended", { gate: vr.checkpointGate ?? null, ...(vrReopened ? { reopened: vr.errorCode ?? null } : {}) });
                             }
                             else {
                                 // E8: this verified-resume leg is the run's final done → flush the last delta + SUM model_usage into stats.modelUsage
@@ -1848,7 +1902,7 @@ export function createHttpServer(rawDeps) {
                         }
                     }
                     if (reSuspended)
-                        return { ...safe, status: "suspended" };
+                        return { ...safe, status: reParkStatus };
                     // Count the gate verdict only when the verifier actually ran (a re-suspend never reached it).
                     if (vr.verification?.verdict)
                         deps.metrics?.inc("verifications_total", { verdict: vr.verification.verdict });