@sema-agent/server 7.144.0 → 7.145.0

package/dist/http/submit-ctx.js

@@ -3,6 +3,17 @@ import { releaseClaimedRun } from "./claimed-run.js";
 import { buildCheckpointCtx, CheckpointCtxUnsealableError } from "./checkpoint-ctx.js";
 import { refusalBody } from "./refusal-body.js";
 import { limitFactsUnmeasured } from "../limit-refusal.js";
+import { serviceVersion } from "../service-version.js";
+import { recordFailOpen } from "../observability/fail-open.js";
+import { DEFAULT_MODEL_REF } from "../model-select.js";
+const WITHHELD_OBJECTIVE = "";
+export function objectiveWithheldIn(ctx) {
+    return ctx.promptScreened === true;
+}
+function withheldBody(body, picked) {
+    const pin = typeof body.model !== "string" && typeof picked === "string" && picked !== DEFAULT_MODEL_REF ? { model: picked } : {};
+    return { ...body, objective: WITHHELD_OBJECTIVE, ...pin };
+}
 function unsealableRefusal(e) {
     return {
         status: 409,
@@ -53,4 +64,16 @@ export async function persistSubmitCtx(store, deps, claim, sessionId, fields) {
         return rowTooLargeRefusal(tooLarge);
     }
 }
+export async function persistSubmissionCtx(store, deps, claim, prepared) {
+    const sessionId = prepared.spec.sessionId;
+    const screened = prepared.acceptance.objectiveAtSubmit === undefined;
+    if (screened && prepared.verify !== undefined)
+        recordFailOpen("server.objective-delivery.verify-replay-copy", `session=${sessionId}`);
+    return persistSubmitCtx(store, deps, claim, sessionId, {
+        body: screened && prepared.verify === undefined ? withheldBody(prepared.body, prepared.spec.model) : prepared.body,
+        memoryScope: prepared.auth?.memoryScope,
+        ...(screened || prepared.bodyFromScreenedCtx === true ? { promptScreened: true } : {}),
+        writerVersion: serviceVersion(),
+    });
+}
 //# sourceMappingURL=submit-ctx.js.map

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

@@ -21,7 +21,7 @@ export type FailOpenEntry = {
 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 note: "S-384(`plugins/approval-ask-store-file.ts` 的 `write()` 尾巴,与起服重放到删行记录时的那一次压实 —— 同一只 `compactOrRecord`;local 车道的 File 形 ask 账):账本**压实**(整本重写成行快照)失败 —— 盘满 / 只读挂载 / `.tmp` 不可写。压实是**纯管家动作**,走到它的时候这一次写**已经 append+fsync 落盘、也已经翻进内存** ⇒ 把它的 I/O 错误抛给调用方 = 把一次已生效的人类批准报成失败(客户端重试会拿到 `ask_not_pending`),正是本店存在的理由被反过来用。所以吞 + 留痕:账本继续长(core 的 `AppendLog` 在 `closeForSwap` 之后惰性重开,一次瞬时错误不会把它变成砖),下一次写再试压实(删行记录引起的压实失败,位 `removalRecordsOnDisk` 留着:下一次任何写、或下一次起服再试;起服那一次失败同样只留痕、不拒启)。放行的最坏后果 = 账本不再收缩(盘占用按写入量线性增长),**语义零影响**(行与转移一个不差)。计数非零 = 这台机器的数据根写不动了,运维要去看盘。";
     };
     readonly "server.approval-ask-journal.corrupt-record-skipped": {
         readonly cls: "F";
@@ -201,7 +201,11 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.approvals.park-row-blob-unreadable": {
         readonly cls: "F";
-        readonly note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:判官判决 `rowVerdict` 与技能卡两位共用的那一次**整行读**(`projectStoredRow`;按快照摘要记忆,未命中才读)—— 整行解不出 ⇒ 这一行不带判决与两位;体是对象但 core 摘要读不动 ⇒ 判决照给、只丢两位;两形逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)";
+        readonly note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:停驻行的**整行读**(`readStoredRow`;按快照摘要记忆,未命中才读)—— 运维队列行的判决 `rowVerdict` 与技能卡两位、7.145.0 起还有收件箱 / 任务视图 `listByScope` 的行投影,同经这一只读法、同一失败方向(行级隔离):整行解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`),行照列、带判决;体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)⇒ 判官对这只对象作答;两形都只丢摘要派生的位(队列行的技能卡两位 / 收件箱行的摘要键,收件箱行退回列组事实),逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。修前收件箱对同一行整张拒(500 / 503)。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)";
+    };
+    readonly "server.approvals.queue-row-agent-unreadable": {
+        readonly cls: "F";
+        readonly note: "S-3000(`routes/approvals-assistant.ts` 的 `sessionAgentsOf`):运维待批队列(`GET /v1/approvals` 的 `pending[]` 与 `/v1/approvals/stream` 的 `pending` 帧)每一只停驻行带它那只会话在委派树里的位置 `agent`(会话视图的同名键,唯一读口 `session-agent.ts` 的 `readSessionAgent` = 会话店的 `placementOf` 一读)。某一只会话那一读抛(店瞬断 / 超时 / local 后端的会话存档行头读不出)⇒ **这只会话的行**缺 `agent` 键,列表其余照常。放行的最坏后果 = 这一行这一次没有委派归属线索:壳的归属判官认不到它(行照列、人从队列照样决得了 —— 与本键存在之前同形);`agent` 不是授权事实(队列行本就只列调用方 scope 的卡,决断口另有属主门)。不放行的代价是一只读不出的会话打掉整张待批列表(订阅流上每一拍都是读失败)。故 F 类;必须留痕,否则「这一次没读成」与「这不是一只 placed 委派子代」在 wire 上同形。detail = 会话 id 与经出口座的错误句。计数按次(订阅流每一拍各计一次)。";
     };
     readonly "server.approvals.durable-row-checkpoint-id-missing": {
         readonly cls: "F";
@@ -373,7 +377,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.run-terminal.redact-threw": {
         readonly cls: "F";
-        readonly note: "三个发射座(errorMessage 终态文案 / 诊断文本 diag / 工件 artifact,probe 前缀判别;普查 56 行;补丁头 patch-head 那座随 7.83.0 / S-113 的 redactPatchHead 一并退役)+ 出口座(S-485 / RH-1:`trace/exit-seat.ts` 的 `seatText`,probe 前缀 `seat=<座表行>`;trace 帧自由文本位上抛 ⇒ 这一位换同一枚占位、投影不抛)+ 活面放行窗(`trace/model-segment.ts` 的 `createLiveModelText`,probe 前缀 `live-hold`:逐块放行口抛 ⇒ 这一拍不放、字节留在窗里;段末整段读法抛 ⇒ 余下的字节整段换同一枚占位):S-105 最终轮 [medium]:终态 errorMessage/blockedReason/remoteEnvFailures[].message 脱敏抛出(RangeError:关键字/前缀臂那一形由 S-219 的 atLeast 铸点闭掉;JSON 秘密字段臂的转义对循环与 PEM 栅栏臂的标签交替循环由 S-265 换成手写线性扫描器闭掉 —— 已知形全部闭掉,本臂留作结构性兜底,计数恒零是证据、不归零即新形)⇒ 落固定占位 «redacted:oversized»——绝不落原文(安全轴 fail-closed),也绝不阻断终态翻转与 claim 释放(可用性)。方向刻意:一条超大错误体不得把 run 卡在 running。";
+        readonly note: "三个发射座(errorMessage 终态文案 / 诊断文本 diag / 工件 artifact,probe 前缀判别;普查 56 行;补丁头 patch-head 那座随 7.83.0 / S-113 的 redactPatchHead 一并退役)+ 出口座(S-485 / RH-1:`trace/exit-seat.ts` 的 `seatText`,probe 前缀 `seat=<座表行>`;trace 帧自由文本位上抛 ⇒ 这一位换同一枚占位、投影不抛)+ 活面放行窗(`trace/model-segment.ts` 的 `createLiveModelText`,probe 前缀 `live-hold`:逐块放行口抛 ⇒ 这一拍不放、字节留在窗里;段末整段读法抛 ⇒ 余下的字节整段换同一枚占位;块界上扫描窗前移的认证扫描抛 ⇒ 窗不动,只是没省,交出的字节一个不变):S-105 最终轮 [medium]:终态 errorMessage/blockedReason/remoteEnvFailures[].message 脱敏抛出(RangeError:关键字/前缀臂那一形由 S-219 的 atLeast 铸点闭掉;JSON 秘密字段臂的转义对循环与 PEM 栅栏臂的标签交替循环由 S-265 换成手写线性扫描器闭掉 —— 已知形全部闭掉,本臂留作结构性兜底,计数恒零是证据、不归零即新形)⇒ 落固定占位 «redacted:oversized»——绝不落原文(安全轴 fail-closed),也绝不阻断终态翻转与 claim 释放(可用性)。方向刻意:一条超大错误体不得把 run 卡在 running。";
     };
     readonly "server.run-terminal.provider-echo-shaped": {
         readonly cls: "F";
@@ -439,6 +443,14 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "S-1874 / S-2137(`routes/approvals-assistant.ts` 的 `GET /v1/assistant/inbox`):每行的 `objective` = 这道门所属 run 的目标预览 —— 按 run id 直读那一行的 `objectivePreview` 列(写入时已脱敏 + 截断;`GET /v1/assistant/tasks` 读同一列)。门 → run 是按键直读:门所在会话的认领持有者 / 最近一条腿,委派子代的门读派它的那条 run(停驻子代行上的 `parentTaskId`,行经判别器 `findParkedAgentForCheckpoint` 取)。某一行这几次直读失败(店抖动 / 那一行 run 的 `result` 格读不出 —— SQL `getRun` 对坏格刻意抛)⇒ **这一行**的 `objective` 落 `null`,列表其余照常。放行的最坏后果 = inbox 上这一张卡这一次不显示它属于哪个任务(纯展示位;不参与任何决裁、续跑或门判)。不放行的代价是一行 run 读不出就打掉整个用户的待批列表(人看不到要批的卡)。故 F 类;必须留痕,否则「这一次没读成」与「这道门本来就没有 run」同形。detail = 那一行的会话 id 与错误句。前身(7.97.0–7.135.x):同一格读停驻上下文、坏体落 null 的那一只 tag(objective-ctx-corrupt),随 S-1874 退役(inbox 不再读续跑上下文)。";
     };
+    readonly "server.objective-delivery.face-fill-failed": {
+        readonly cls: "F";
+        readonly note: "`run-acceptance.ts` 的补写口(腿上装着 prompt 屏时,本服务存 / 转目标的面在提交时不写,引擎交付之后以交付的那一份补写):某一张面的补写抛错 —— `run-preview`(run 行预览列的写一次补写,店抖动 / 行已被收割删除)、`fleet-name`(进程内 fleet 行的名;不会抛,列在闭集里是为了词全)。放行的最坏后果 = 那张面保持提交时的**空**:预览缺席(列表 / 收件箱 / fleet 行不显示这条 run 是什么任务)—— 少写,不是写错:不会写出屏前原文,不参与任何门判、续跑决裁或模型输入。不放行的代价是一次展示面的写失败打断这条正在跑的 run。故 F 类;必须留痕,否则「补写失败」与「屏改写过、本来就没有可写的那一份」同形。detail = `face=<面> err=<错误句,经运维日志出口座>`。";
+    };
+    readonly "server.objective-delivery.verify-replay-copy": {
+        readonly cls: "P-DEBT";
+        readonly note: "`submit-ctx.ts` 的 `persistSubmissionCtx`:腿上装着 prompt 屏、且这次提交是 verify 形(只回结果的腿:宿主看不到受理帧,分不出屏改没改,也看不到有没有交付)⇒ 续跑输入照旧存请求原文的目标,不按「交付的那一份」写。理由:verify 形停驻后的续跑把续跑输入里的目标交给引擎的验证器(`resumeWithVerification` 的 `objective`),留空 = 验证器拿不到任务陈述;引擎自己的首跑验证器同样读请求原文。方向明知不对(屏丢弃 / 抛错 / 改写过的目标原文仍在 checkpoint ctx 里,直到这一行被收割),待引擎把交付的那一份交给宿主(含只回结果的腿)、验证器改读交付的目标之后修掉。每一次这样的提交记一次;计数非零 = 这台部署有「prompt 屏 + verify 形」的提交,它们的续跑输入里有屏前原文。detail = `session=<会话 id>`。";
+    };
     readonly "server.run-store.corrupt-record-skipped": {
         readonly cls: "F";
         readonly note: "S-582(`plugins/file-run-store.ts`,local 车道的 File 形 run 店;四个盘面同一只座):盘上一条记录读不出形 —— 一行 `42` / 缺本店必填键的对象 / 中间的半截 JSON(撕尾不走本 tag,那是崩溃的正常落盘形)⇒ 跳过它继续。前三个盘面各自的最坏后果:`run.json` 坏 ⇒ 那条 run 读成**缺席**(`GET /v1/runs/:id` 404,listRuns 少一行;它若占着 claim,EEXIST 路按「行不在」判残骸接管);`events.jsonl` 一行坏 ⇒ 回放少一个事件(其余照读、按 seq 去重不变);claim 记录坏 ⇒ 走既有的撕裂 claim 路(有非终局行就收编,否则隔离出 activeDir)。第四个盘面 `run-blobs/<会话>.jsonl`(`wiring_manifest` 行容器段的块账本,`plugins/wiring-section-codec.ts`)同一只座、两个检测点:① 重放时一条块记录形不合(`digest` 不是串 / `body` 不是容器)⇒ 跳过;② 读口(`getEvents`)装回时清单行引用的块不在本会话账本里(块缺:账本行被删 / 被跳过、断电丢尾、删会话时 run 目录删不掉留下的僵尸 run)⇒ 那一帧这一次不交出(永不交出缺段的清单),每个 `(taskId, seq)` 每进程计一次,`maxSeq` / `retainedFrom` 照旧按存位;明细 `kind=section-ref taskId= seq= sections=<段:摘要,…>`。块账本整份读不出(权限 / 挂载)不走本 tag,与 `events.jsonl` 读不出同一条路(strict 拒启,否则原样抛)。都是**可用性**损失,不开任何门 ⇒ F。修前三面全零披露(店自己的 `typeof … continue` 与 core 的静默跳过);计数让「这台机器的 run 账在腐」在遥测里显形。⚠️ `RUN_STORE_STRICT_HYDRATE=on` 的射程是「文件读不出」,不含「文件里有坏行」—— strict 档下坏行照走本 tag(未改 strict 语义,见普查表第 96 行)。";

package/dist/observability/fail-open.js

@@ -3,7 +3,7 @@ import { createLogger } from "./logger.js";
 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` 之后惰性重开,一次瞬时错误不会把它变成砖),下一次写再试压实。放行的最坏后果 = 账本不再收缩(盘占用按写入量线性增长),**语义零影响**(行与转移一个不差)。计数非零 = 这台机器的数据根写不动了,运维要去看盘。",
+        note: "S-384(`plugins/approval-ask-store-file.ts` 的 `write()` 尾巴,与起服重放到删行记录时的那一次压实 —— 同一只 `compactOrRecord`;local 车道的 File 形 ask 账):账本**压实**(整本重写成行快照)失败 —— 盘满 / 只读挂载 / `.tmp` 不可写。压实是**纯管家动作**,走到它的时候这一次写**已经 append+fsync 落盘、也已经翻进内存** ⇒ 把它的 I/O 错误抛给调用方 = 把一次已生效的人类批准报成失败(客户端重试会拿到 `ask_not_pending`),正是本店存在的理由被反过来用。所以吞 + 留痕:账本继续长(core 的 `AppendLog` 在 `closeForSwap` 之后惰性重开,一次瞬时错误不会把它变成砖),下一次写再试压实(删行记录引起的压实失败,位 `removalRecordsOnDisk` 留着:下一次任何写、或下一次起服再试;起服那一次失败同样只留痕、不拒启)。放行的最坏后果 = 账本不再收缩(盘占用按写入量线性增长),**语义零影响**(行与转移一个不差)。计数非零 = 这台机器的数据根写不动了,运维要去看盘。",
     },
     "server.approval-ask-journal.corrupt-record-skipped": {
         cls: "F",
@@ -183,7 +183,11 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.park-row-blob-unreadable": {
         cls: "F",
-        note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:判官判决 `rowVerdict` 与技能卡两位共用的那一次**整行读**(`projectStoredRow`;按快照摘要记忆,未命中才读)—— 整行解不出 ⇒ 这一行不带判决与两位;体是对象但 core 摘要读不动 ⇒ 判决照给、只丢两位;两形逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)",
+        note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:停驻行的**整行读**(`readStoredRow`;按快照摘要记忆,未命中才读)—— 运维队列行的判决 `rowVerdict` 与技能卡两位、7.145.0 起还有收件箱 / 任务视图 `listByScope` 的行投影,同经这一只读法、同一失败方向(行级隔离):整行解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`),行照列、带判决;体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)⇒ 判官对这只对象作答;两形都只丢摘要派生的位(队列行的技能卡两位 / 收件箱行的摘要键,收件箱行退回列组事实),逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。修前收件箱对同一行整张拒(500 / 503)。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)",
+    },
+    "server.approvals.queue-row-agent-unreadable": {
+        cls: "F",
+        note: "S-3000(`routes/approvals-assistant.ts` 的 `sessionAgentsOf`):运维待批队列(`GET /v1/approvals` 的 `pending[]` 与 `/v1/approvals/stream` 的 `pending` 帧)每一只停驻行带它那只会话在委派树里的位置 `agent`(会话视图的同名键,唯一读口 `session-agent.ts` 的 `readSessionAgent` = 会话店的 `placementOf` 一读)。某一只会话那一读抛(店瞬断 / 超时 / local 后端的会话存档行头读不出)⇒ **这只会话的行**缺 `agent` 键,列表其余照常。放行的最坏后果 = 这一行这一次没有委派归属线索:壳的归属判官认不到它(行照列、人从队列照样决得了 —— 与本键存在之前同形);`agent` 不是授权事实(队列行本就只列调用方 scope 的卡,决断口另有属主门)。不放行的代价是一只读不出的会话打掉整张待批列表(订阅流上每一拍都是读失败)。故 F 类;必须留痕,否则「这一次没读成」与「这不是一只 placed 委派子代」在 wire 上同形。detail = 会话 id 与经出口座的错误句。计数按次(订阅流每一拍各计一次)。",
     },
     "server.approvals.durable-row-checkpoint-id-missing": {
         cls: "F",
@@ -355,7 +359,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.run-terminal.redact-threw": {
         cls: "F",
-        note: "三个发射座(errorMessage 终态文案 / 诊断文本 diag / 工件 artifact,probe 前缀判别;普查 56 行;补丁头 patch-head 那座随 7.83.0 / S-113 的 redactPatchHead 一并退役)+ 出口座(S-485 / RH-1:`trace/exit-seat.ts` 的 `seatText`,probe 前缀 `seat=<座表行>`;trace 帧自由文本位上抛 ⇒ 这一位换同一枚占位、投影不抛)+ 活面放行窗(`trace/model-segment.ts` 的 `createLiveModelText`,probe 前缀 `live-hold`:逐块放行口抛 ⇒ 这一拍不放、字节留在窗里;段末整段读法抛 ⇒ 余下的字节整段换同一枚占位):S-105 最终轮 [medium]:终态 errorMessage/blockedReason/remoteEnvFailures[].message 脱敏抛出(RangeError:关键字/前缀臂那一形由 S-219 的 atLeast 铸点闭掉;JSON 秘密字段臂的转义对循环与 PEM 栅栏臂的标签交替循环由 S-265 换成手写线性扫描器闭掉 —— 已知形全部闭掉,本臂留作结构性兜底,计数恒零是证据、不归零即新形)⇒ 落固定占位 «redacted:oversized»——绝不落原文(安全轴 fail-closed),也绝不阻断终态翻转与 claim 释放(可用性)。方向刻意:一条超大错误体不得把 run 卡在 running。",
+        note: "三个发射座(errorMessage 终态文案 / 诊断文本 diag / 工件 artifact,probe 前缀判别;普查 56 行;补丁头 patch-head 那座随 7.83.0 / S-113 的 redactPatchHead 一并退役)+ 出口座(S-485 / RH-1:`trace/exit-seat.ts` 的 `seatText`,probe 前缀 `seat=<座表行>`;trace 帧自由文本位上抛 ⇒ 这一位换同一枚占位、投影不抛)+ 活面放行窗(`trace/model-segment.ts` 的 `createLiveModelText`,probe 前缀 `live-hold`:逐块放行口抛 ⇒ 这一拍不放、字节留在窗里;段末整段读法抛 ⇒ 余下的字节整段换同一枚占位;块界上扫描窗前移的认证扫描抛 ⇒ 窗不动,只是没省,交出的字节一个不变):S-105 最终轮 [medium]:终态 errorMessage/blockedReason/remoteEnvFailures[].message 脱敏抛出(RangeError:关键字/前缀臂那一形由 S-219 的 atLeast 铸点闭掉;JSON 秘密字段臂的转义对循环与 PEM 栅栏臂的标签交替循环由 S-265 换成手写线性扫描器闭掉 —— 已知形全部闭掉,本臂留作结构性兜底,计数恒零是证据、不归零即新形)⇒ 落固定占位 «redacted:oversized»——绝不落原文(安全轴 fail-closed),也绝不阻断终态翻转与 claim 释放(可用性)。方向刻意:一条超大错误体不得把 run 卡在 running。",
     },
     "server.run-terminal.provider-echo-shaped": {
         cls: "F",
@@ -397,6 +401,14 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-1874 / S-2137(`routes/approvals-assistant.ts` 的 `GET /v1/assistant/inbox`):每行的 `objective` = 这道门所属 run 的目标预览 —— 按 run id 直读那一行的 `objectivePreview` 列(写入时已脱敏 + 截断;`GET /v1/assistant/tasks` 读同一列)。门 → run 是按键直读:门所在会话的认领持有者 / 最近一条腿,委派子代的门读派它的那条 run(停驻子代行上的 `parentTaskId`,行经判别器 `findParkedAgentForCheckpoint` 取)。某一行这几次直读失败(店抖动 / 那一行 run 的 `result` 格读不出 —— SQL `getRun` 对坏格刻意抛)⇒ **这一行**的 `objective` 落 `null`,列表其余照常。放行的最坏后果 = inbox 上这一张卡这一次不显示它属于哪个任务(纯展示位;不参与任何决裁、续跑或门判)。不放行的代价是一行 run 读不出就打掉整个用户的待批列表(人看不到要批的卡)。故 F 类;必须留痕,否则「这一次没读成」与「这道门本来就没有 run」同形。detail = 那一行的会话 id 与错误句。前身(7.97.0–7.135.x):同一格读停驻上下文、坏体落 null 的那一只 tag(objective-ctx-corrupt),随 S-1874 退役(inbox 不再读续跑上下文)。",
     },
+    "server.objective-delivery.face-fill-failed": {
+        cls: "F",
+        note: "`run-acceptance.ts` 的补写口(腿上装着 prompt 屏时,本服务存 / 转目标的面在提交时不写,引擎交付之后以交付的那一份补写):某一张面的补写抛错 —— `run-preview`(run 行预览列的写一次补写,店抖动 / 行已被收割删除)、`fleet-name`(进程内 fleet 行的名;不会抛,列在闭集里是为了词全)。放行的最坏后果 = 那张面保持提交时的**空**:预览缺席(列表 / 收件箱 / fleet 行不显示这条 run 是什么任务)—— 少写,不是写错:不会写出屏前原文,不参与任何门判、续跑决裁或模型输入。不放行的代价是一次展示面的写失败打断这条正在跑的 run。故 F 类;必须留痕,否则「补写失败」与「屏改写过、本来就没有可写的那一份」同形。detail = `face=<面> err=<错误句,经运维日志出口座>`。",
+    },
+    "server.objective-delivery.verify-replay-copy": {
+        cls: "P-DEBT",
+        note: "`submit-ctx.ts` 的 `persistSubmissionCtx`:腿上装着 prompt 屏、且这次提交是 verify 形(只回结果的腿:宿主看不到受理帧,分不出屏改没改,也看不到有没有交付)⇒ 续跑输入照旧存请求原文的目标,不按「交付的那一份」写。理由:verify 形停驻后的续跑把续跑输入里的目标交给引擎的验证器(`resumeWithVerification` 的 `objective`),留空 = 验证器拿不到任务陈述;引擎自己的首跑验证器同样读请求原文。方向明知不对(屏丢弃 / 抛错 / 改写过的目标原文仍在 checkpoint ctx 里,直到这一行被收割),待引擎把交付的那一份交给宿主(含只回结果的腿)、验证器改读交付的目标之后修掉。每一次这样的提交记一次;计数非零 = 这台部署有「prompt 屏 + verify 形」的提交,它们的续跑输入里有屏前原文。detail = `session=<会话 id>`。",
+    },
     "server.run-store.corrupt-record-skipped": {
         cls: "F",
         note: "S-582(`plugins/file-run-store.ts`,local 车道的 File 形 run 店;四个盘面同一只座):盘上一条记录读不出形 —— 一行 `42` / 缺本店必填键的对象 / 中间的半截 JSON(撕尾不走本 tag,那是崩溃的正常落盘形)⇒ 跳过它继续。前三个盘面各自的最坏后果:`run.json` 坏 ⇒ 那条 run 读成**缺席**(`GET /v1/runs/:id` 404,listRuns 少一行;它若占着 claim,EEXIST 路按「行不在」判残骸接管);`events.jsonl` 一行坏 ⇒ 回放少一个事件(其余照读、按 seq 去重不变);claim 记录坏 ⇒ 走既有的撕裂 claim 路(有非终局行就收编,否则隔离出 activeDir)。第四个盘面 `run-blobs/<会话>.jsonl`(`wiring_manifest` 行容器段的块账本,`plugins/wiring-section-codec.ts`)同一只座、两个检测点:① 重放时一条块记录形不合(`digest` 不是串 / `body` 不是容器)⇒ 跳过;② 读口(`getEvents`)装回时清单行引用的块不在本会话账本里(块缺:账本行被删 / 被跳过、断电丢尾、删会话时 run 目录删不掉留下的僵尸 run)⇒ 那一帧这一次不交出(永不交出缺段的清单),每个 `(taskId, seq)` 每进程计一次,`maxSeq` / `retainedFrom` 照旧按存位;明细 `kind=section-ref taskId= seq= sections=<段:摘要,…>`。块账本整份读不出(权限 / 挂载)不走本 tag,与 `events.jsonl` 读不出同一条路(strict 拒启,否则原样抛)。都是**可用性**损失,不开任何门 ⇒ F。修前三面全零披露(店自己的 `typeof … continue` 与 core 的静默跳过);计数让「这台机器的 run 账在腐」在遥测里显形。⚠️ `RUN_STORE_STRICT_HYDRATE=on` 的射程是「文件读不出」,不含「文件里有坏行」—— strict 档下坏行照走本 tag(未改 strict 语义,见普查表第 96 行)。",

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

@@ -130,6 +130,11 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
     private journalV1Records;
     /** 盘上还有 v1 信封记录(随 M34):重放到 v1 记录时置位,任何一次压实(整本重写成 v2)清位 —— 已被压实过的账本不再为升级重写第二次。 */
     private journalV1OnDisk;
+    /**
+     * 盘上还有删行记录({@link ROW_REMOVAL_OPS}):写下一条 / 重放到一条时置位,任何一次压实(整本重写成快照)清位 —— 与 {@link journalV1OnDisk} 同形。
+     * 置位期间压实到期(顶注「压实」段的起因 ②):同一拍压实;压实失败 ⇒ 位留着,下一次写(或下一次起服)再试。
+     */
+    private removalRecordsOnDisk;
     /** 本次启动隔离出去的原件路径(无坏字节 ⇒ `undefined`)。 */
     readonly corruptQuarantinePath: string | undefined;
     /**
@@ -159,11 +164,16 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
      * 代价如实:不可编码的值(BigInt / 循环引用)在本形上**抛**,而 InMemory 形收得下 —— 那与 SQL 孪生
      * 同向(它也存不下),是**介质事实**,写进顶注的边界段。
      *
-     * 🔴 **压实失败不许落到调用方头上**(替补对抗复审 F3 [medium],实测后修):走到 `maybeCompact()` 时这
+     * 🔴 **压实失败不许落到调用方头上**(替补对抗复审 F3 [medium],实测后修):走到 {@link compactOrRecord} 时这
      * 一次写**已经 fsync 落盘、也已经翻进内存**,把一次纯管家动作的 I/O 错误抛给调用方 = 把一次已生效的
      * 人类批准报成失败(客户端重试会拿到 `ask_not_pending`)。压实是 F 类兜底:失败留痕、下一次写再试。
+     * 两个起因同一条:删行记录引起的压实失败,位({@link removalRecordsOnDisk})留着,下一次**任何**写(与下一次起服)再试 ——
+     * 不是等下一次真删了行的调用。三只删行动词的内核体全是同步前缀,所以走到这里时被删的行已经不在内存里,快照里没有它们。
      */
     private write;
+    /** 压实到期就压实;失败 ⇒ 登记过的 F 类兜底(计数 + 留痕),不上抛 —— `write()` 尾段与起服各调一次,同一句话。 */
+    private compactOrRecord;
+    /** 压实是否到期(顶注「压实」段两个起因)。到期 ⇒ 压实;失败原样抛给 {@link compactOrRecord}。 */
     private maybeCompact;
     /** 整本重写成行快照 + 原子替换。失败 ⇒ 原账本原样留着、`records` 不动(下一次写再试),日志由
      *  core 的 [ref] 惰性重开接住 —— 一次瞬时 I/O 错误绝不把这条日志变成砖。 */
@@ -193,8 +203,12 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
     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>;
+    /** 删一个 run 名下的全部问行与批行。与两只留存动词同律:内核的纯读选择为空 ⇒ 不落账本、不压实;否则「先落账、再翻内存」并同拍压实(顶注「压实」段起因 ②)。 */
     deleteByTask(taskId: string): Promise<void>;
-    /** 留存律的问行半场(谓词在内核,见接口注)。空的一次(内核的纯读选择为空)不落账本、不碰内存;否则照常「先落账、再翻内存」。 */
+    /**
+     * 留存律的问行半场(谓词在内核,见接口注)。空的一次(内核的纯读选择为空)不落账本、不碰内存、不压实;否则照常「先落账、再翻内存」,
+     * 并在 `write()` 尾段同一拍压实(顶注「压实」段起因 ②)—— 选择非空 ⇒ 内核同步前缀里必删 ≥ 1 行,被删行的字节不留在盘上。
+     */
     reapSettledAsks(cutoffMs: number, limit: number, keepAnchors: ReadonlySet<string>): Promise<number>;
     /** 留存律的批行半场(同上)。 */
     reapEmptyBatches(cutoffMs: number, limit: number): Promise<number>;

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

@@ -28,6 +28,7 @@ const JOURNAL_OPS = [
 ];
 const JOURNAL_OP_WORDS = new Set(JOURNAL_OPS);
 export const JOURNAL_OP_TABLE_GATE = true;
+const ROW_REMOVAL_OPS = new Set(["reapSettledAsks", "reapEmptyBatches", "deleteByTask"]);
 const JOURNAL_V1_CLAIM_INTENTS = ["expire", "cancel"];
 const JOURNAL_V1_CLAIM_INTENT_WORDS = new Set(JOURNAL_V1_CLAIM_INTENTS);
 const JOURNAL_ENVELOPE = 2;
@@ -94,6 +95,7 @@ export class FileApprovalAskStore {
     corruptLineCount = 0;
     journalV1Records = 0;
     journalV1OnDisk = false;
+    removalRecordsOnDisk = false;
     corruptQuarantinePath;
     constructor(root) {
         const dir = join(root, APPROVAL_ASK_DIR);
@@ -117,6 +119,9 @@ export class FileApprovalAskStore {
                 `and rewrote the live journal from the replayed state. A dropped record is a LOST approval-ask transition: inspect the quarantined file.`);
             this.compact();
         }
+        else if (this.removalRecordsOnDisk) {
+            this.compactOrRecord();
+        }
     }
     clockRead() {
         const pinned = this.pinnedNow;
@@ -136,6 +141,8 @@ export class FileApprovalAskStore {
         const onDisk = { v: JOURNAL_ENVELOPE, k: "op", t, ...callToDisk(encoded) };
         this.logFor().append(onDisk, true);
         this.records += 1;
+        if (ROW_REMOVAL_OPS.has(call.op))
+            this.removalRecordsOnDisk = true;
         this.pinnedNow = t;
         let out;
         try {
@@ -144,15 +151,22 @@ export class FileApprovalAskStore {
         finally {
             this.pinnedNow = null;
         }
+        this.compactOrRecord();
+        return out;
+    }
+    compactOrRecord() {
         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.removalRecordsOnDisk) {
+            this.compact();
+            return;
+        }
         if (this.records < ASK_JOURNAL_COMPACT_MIN_RECORDS)
             return;
         const snapshot = this.core.exportRows();
@@ -168,6 +182,7 @@ export class FileApprovalAskStore {
         this.log?.closeForSwap();
         atomicWriteFile(this.tmpDir, this.path, lines.join(""));
         this.journalV1OnDisk = false;
+        this.removalRecordsOnDisk = false;
         this.records = lines.length;
     }
     replayRecord(disk) {
@@ -203,6 +218,8 @@ export class FileApprovalAskStore {
             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.op === "string" && ROW_REMOVAL_OPS.has(probe.op))
+            this.removalRecordsOnDisk = true;
         if (typeof probe.t !== "number" || !Number.isFinite(probe.t))
             refuse("call record without a clock reading");
         if (probe.op === "claimTerminal" && !JOURNAL_V1_CLAIM_INTENT_WORDS.has(String(raw.intent)))
@@ -301,6 +318,9 @@ export class FileApprovalAskStore {
         return this.write({ op: "resolveProvisional", askId, from, to, patch }, (c) => this.core.resolveProvisional(c.askId, c.from, c.to, c.patch));
     }
     async deleteByTask(taskId) {
+        const plan = this.core.planDeleteByTask(taskId);
+        if (plan.askIds.length === 0 && plan.batchIds.length === 0)
+            return;
         return this.write({ op: "deleteByTask", taskId }, (c) => this.core.deleteByTask(c.taskId));
     }
     async reapSettledAsks(cutoffMs, limit, keepAnchors) {

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

@@ -16,8 +16,9 @@
  *  · {@link InMemoryApprovalAskStore.exportRows} / {@link InMemoryApprovalAskStore.importRows} —— 压实用的
  *    整本快照口(纯搬行,不经任何谓词)。压实要把「一串调用」折成「一串终局行」,没有这一对就只能在
  *    File 形里另写一套「哪些行还算数」的判据 —— 那才是第二份手抄。
- *  · {@link InMemoryApprovalAskStore.planReapSettledAsks} / {@link InMemoryApprovalAskStore.planReapEmptyBatches} —— 两只留存动词的
- *    **纯读选择**(删哪些行)。File 形据它判「这一次有没有东西可删」,空的一次不落账本;删除本身仍是接口动词,与选择共用这一只。
+ *  · {@link InMemoryApprovalAskStore.planReapSettledAsks} / {@link InMemoryApprovalAskStore.planReapEmptyBatches} /
+ *    {@link InMemoryApprovalAskStore.planDeleteByTask} —— 三只删行动词的**纯读选择**(删哪些行)。File 形据它判「这一次有没有东西可删」,空的一次不落账本;
+ *    删除本身仍是接口动词,与选择共用这一只。
  *  · {@link InMemoryApprovalAskStore.peekAsk} —— 一行的**同步**点读(纯读,零判定)。File 形在写口的同步前缀里据它判「这次决议在不在
  *    属主域内」(出域的一次不落账本)、重放时据它喂行自己的属主([ref],理由在 File 形的 `decideAsk`)。
  *
@@ -118,6 +119,11 @@ export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
     resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     deleteByTask(taskId: string): Promise<void>;
+    /** {@link deleteByTask} 会删哪些行(纯读,零写;选择与删除共用这一只,没有第二份谓词)。 */
+    planDeleteByTask(taskId: string): {
+        readonly askIds: readonly string[];
+        readonly batchIds: readonly string[];
+    };
     getBatch(batchId: string): Promise<BatchRow | null>;
     /**
      * 留存律的问行半场(谓词见接口注,与 SQL twin 的 `DELETE … LIMIT` 同答)。方法体全同步(零 `await`)⇒ File 形把它当一次落账的调用

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

@@ -365,14 +365,17 @@ export class InMemoryApprovalAskStore {
         return true;
     }
     async deleteByTask(taskId) {
-        for (const [id, r] of this.asks) {
-            if (r.taskId === taskId)
-                this.asks.delete(id);
-        }
-        for (const [id, b] of this.batches) {
-            if (b.taskId === taskId)
-                this.batches.delete(id);
-        }
+        const plan = this.planDeleteByTask(taskId);
+        for (const id of plan.askIds)
+            this.asks.delete(id);
+        for (const id of plan.batchIds)
+            this.batches.delete(id);
+    }
+    planDeleteByTask(taskId) {
+        return {
+            askIds: [...this.asks.values()].filter((r) => r.taskId === taskId).map((r) => r.askId),
+            batchIds: [...this.batches.values()].filter((b) => b.taskId === taskId).map((b) => b.batchId),
+        };
     }
     async getBatch(batchId) {
         const b = this.batches.get(batchId);

package/dist/plugins/caching-session-store.d.ts

@@ -116,6 +116,9 @@ export declare class CachingSessionStore implements SessionStore {
      *  裸店、不经本包装,但 security.ts 的 OwnerAwareSessionStore 契约列了它 —— 经 sessionStorage 消费的
      *  未来调用方不该静默 no-op,与 beginImportStaging 同批补齐(同一类白名单缺口)。 */
     readonly sweepStagingSessions?: () => Promise<number>;
+    /** 带戳存档的早拒口(local 店独有;`OwnerAwareSessionStore.assertArchiveAnonymous`),读持久存档头、不经暖缓存。
+     *  🔴 必须转发(与 staging 族同一条教训):默认部署把真店包进本类,会话同步第一阶段的路由读到的是包装层 —— 不转发 = 这一口在默认部署上静默不发(第一阶段仍答通用冲突),没有任何一处报错。 */
+    readonly assertArchiveAnonymous?: (sessionId: string) => Promise<void>;
     /** 2c session-sync (§7/§8) — delegated IDEMPOTENT replace; like importEntries it writes durable state under
      *  `sessionId`, so a stale warm handle for that id is evicted on success (next acquire re-wakes from the new log). */
     readonly replaceEntries?: (sessionId: string, owner: string | null, entries: SessionTreeEntry[]) => Promise<void>;

package/dist/plugins/caching-session-store.js

@@ -29,6 +29,7 @@ export class CachingSessionStore {
     importEntries;
     beginImportStaging;
     sweepStagingSessions;
+    assertArchiveAnonymous;
     replaceEntries;
     retention;
     placements;
@@ -85,6 +86,8 @@ export class CachingSessionStore {
             this.listEntryIds = ownerAware.listEntryIds.bind(inner);
         if (ownerAware.exportEntriesStream)
             this.exportEntriesStream = ownerAware.exportEntriesStream.bind(inner);
+        if (ownerAware.assertArchiveAnonymous)
+            this.assertArchiveAnonymous = ownerAware.assertArchiveAnonymous.bind(inner);
         this.forget = (sessionId) => {
             this.evict(sessionId);
             return inner.forget?.(sessionId);

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

@@ -178,8 +178,10 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
      * 这一行**本引擎续不续得了** —— core 判官 `judgeCheckpointRow` 对这一行盘上字节的判决(core 7.62.0 [ref];与助手收件箱行的 `rowVerdict`、
      * 续跑在第一级读到的拒同一个读者、同一答),逐字投、本服务不重算不筛。判官要整行:SQL 孪生按 (库内算的 `checkpoint` 文本 sha256, 引擎构建)
      * 记忆({@link StoredRowProjectionMemo}),未命中才按令牌批读整行;LOCAL 孪生取 core 店摘要上的同一位。
-     * **在场 ⇔ 这一次列表判过这一行**:缺席只在 SQL 孪生上出现 —— 整行解不出(行照列,计 `server.approvals.park-row-blob-unreadable`,续跑面
-     * 对同一行响亮拒)、两次读之间行已离开待决,或两次读之间行的字节变了(判过的是另一份,不拼到这一行上;下一次列表即带)。缺席**不是** `ok`。非 `ok` 的行照列(人要看到它停在哪)。
+     * 盘上字节读不成一只检查点的行(体是 `{}`、缺 `state`、JSON 字面 `null` / 标量 / 数组 / 非 JSON)同样判:判官对任何值都答,这种行答 `damaged`,
+     * 行照列(计 `server.approvals.park-row-blob-unreadable`)—— 一行坏字节只坏它自己那一行,见 {@link SqlCheckpointStore.readStoredRow}。
+     * **在场 ⇔ 这一次列表判过这一行**:缺席只在 SQL 孪生上出现 —— 两次读之间行已离开待决,或两次读之间行的字节变了(判过的是另一份,
+     * 不拼到这一行上;下一次列表即带)。缺席**不是** `ok`。非 `ok` 的行照列(人要看到它停在哪)。
      */
     rowVerdict?: CheckpointRowVerdict;
 }
@@ -444,7 +446,7 @@ export type CandidateIdentity = {
  * 收敛器读口的**身份判词**(两只孪生同一只;`findCheckpointCandidatesForAsk` 的 SQL / LOCAL 两形都只经这里):先问 core 判官 `judgeCheckpointRow`
  * (core 7.62.0 [ref],[ref])—— 判 `lacking`(更新的引擎能续它、本引擎缺读法:格式版本超上限,或要求表点名了本引擎不认的读法词)⇒ `{ readable: false }`:
  * 本副本读不准这一行,交给收敛器当「不确定」,留给能续它的副本去绑(修前 SQL 孪生按 `version` 列比 `MAX_SUPPORTED_CHECKPOINT_VERSION`,
- * 射程只有版本一轴,LOCAL 孪生没有这一臂)。`damaged` **不是**这一臂:没有哪个副本续得了它,身份读得出就照常判 —— 绑上之后续跑由判官给那句固定的拒,
+ * 射程只有版本一轴,LOCAL 孪生没有这一臂)。`damaged` **不是**这一臂:本引擎不续这些字节(别的副本续不续,引擎没有说、本服务不替它们断言),身份读得出就照常判 —— 绑上之后续跑由判官给那句固定的拒,
  * 比让 ask 停在 PARKING 诚实。其余三态见 {@link pendingActionToolCallId}。
  */
 export declare function candidateIdentityOf(cp: Checkpoint): CandidateIdentity;
@@ -725,22 +727,38 @@ export declare class SqlCheckpointStore implements CheckpointStore, KindlessBatc
      * 交回的事实只许出自主读读到的同一份字节(一行一个字节版本;修前按令牌拼,B 的判决与清单配 A 的行),这一行本次不带判决与清单(与「离开待决」同一种缺席),
      * 下一次列表主读读到新字节即命中记忆。
      *
-     * 失败方向(展示 / 分诊材料、行级容忍 + 响亮,与 {@link readParkRowActionCell} 同一条判据同一个 tag):整行解不出 ⇒ 这一行不在返回里(调用方行照列、
-     * 不带判决与清单),计 `server.approvals.park-row-blob-unreadable`;体是对象但 core 的摘要读不动(缺 `pendingAction` / `gate` 的手改行)⇒ 判决照给
-     * (判官是全函数),清单与成因词丢、同一个 tag 计数;两种都不进记忆(下一次列表重读、再计)。行已离开待决(两次读之间被决 / 过期)⇒ 不在返回里。
-     * `not-text`(读腿漏了投影)与摘要格形不对原样抛(码坏)。授予绑定那一臂(摘要 / 缺席词)不在这里:由 {@link parkRowFacts} 读子树投出,本读口失败时它照在。
+     * 失败方向 = 本店停驻行读者的那一条律({@link SqlCheckpointStore.readStoredRow}):摘要读不动的行(字节解不出 / 体是对象但 core 的摘要读不动)
+     * 判决照给、清单与成因词缺席,计 `server.approvals.park-row-blob-unreadable`,不进记忆(下一次列表重读、再计)。行已离开待决(两次读之间被决 / 过期)⇒ 不在返回里。
+     * `not-text`(读腿漏了投影)与摘要格形不对原样抛(码坏)。授予绑定那一臂(摘要 / 缺席词)不在这里:由 {@link parkRowFacts} 读子树投出。
      */
     private storedRowProjections;
-    /** 一行整行读回 → 它的 {@link StoredRowProjection}(完整的入记忆;失败方向见 {@link SqlCheckpointStore.storedRowProjections})。 */
+    /** 一行整行读回 → 它的 {@link StoredRowProjection}(摘要读得动的入记忆;失败方向见 {@link SqlCheckpointStore.readStoredRow})。 */
     private projectStoredRow;
+    /**
+     * 🔴 **本店停驻行读者的那一条律:一行的字节只坏它自己那一行**(运维队列 / 订阅流的整行读与收件箱 / 任务视图的 `listByScope` 同经这里)。
+     *
+     * 一行停驻行的整行读 = `checkpoint` 列那一份字节 → core 判官 `judgeCheckpointRow` 的判决 + (读得动时)core 的摘要 `summarizeCheckpoint`。
+     * 判决**恒在**:判官对任何值都答(core:pure and total),字节读不成一只检查点(JSON 字面 `null` / 标量 / 数组 / 非 JSON)⇒ 交给它的是这一格**原样的文本**
+     * (不是本店编的一行),它答 `damaged`;体是对象而摘要读不动(`{}`、缺 `state` / `pendingAction` / `gate` 的手改行)⇒ 判官对这只对象答 ——
+     * 🚧 判官与摘要对「缺 `pendingAction`」不同答(摘要抛、判官答 `ok`:core 判官不查这一位),这一形的行照列而判决是 `ok`;本店不另判(判官的缺口归 core)。
+     * 摘要读不动的两种都计 `server.approvals.park-row-blob-unreadable`(每次列表都计)、不进记忆;**不抛** —— 修前收件箱 / 任务视图对这种行整张拒
+     * (`{}` / 缺 `state` 落 503「请重试」,坏行不修同路径恒失败),运维队列对字节解不出的行不带判决:同一张坏行两个读者两个方向。
+     * 读腿漂(`not-text`:SELECT 没投影这一列)与摘要格形不对照旧原样抛 —— 那是码坏,不是一行数据坏。
+     *
+     * 判决按 (这份字节, 引擎构建) 记忆({@link StoredRowProjectionMemo}):命中交给摘要不重判;摘要读得动的那一份由调用方 / 这里记下。
+     */
+    private readStoredRow;
     /**
      * [ref] #2 (scheduler seam, core 1.105): a scope's PENDING checkpoints as lightweight
      * {@link CheckpointSummary} rows in ONE query — the cross-task triage view a supervisor scheduler needs
      * (gate kind + risk severity + budget spent + deadline per suspended task), no N+1 `get`s. The projection is
      * core's shared {@link summarizeCheckpoint} run over the persisted blob (the `checkpoint` column = the same full
-     * {@link Checkpoint} `get()` parses), so this stays byte-identical to core's InMemory/Pg/File impls. Order =
-     * created_at_ms ASC; callers (the inbox/scheduler) sort by severity. The COLUMN `status` is authoritative (the blob
-     * is the suspend-time snapshot), so it overrides the blob's status before the summary is derived.
+     * {@link Checkpoint} `get()` parses), so a readable row stays byte-identical to core's InMemory/Pg/File impls. Order =
+     * created_at_ms ASC; callers (the inbox/scheduler) sort by severity.
+     *
+     * 一行读不出摘要(字节解不出 / 体是对象而摘要读不动)⇒ 这一行**照列**,判决由判官给(缺 `pendingAction` 那一形判官答 `ok`,见 {@link SqlCheckpointStore.readStoredRow}),其余几位取本店在字节**之外**握着的事实:
+     * 令牌 / 会话 / scope / 建行时刻 / 截止 / 门型(`gate_kind` 列,与运维队列同一只判官 {@link queueRowGateKind}:读不出 ⇒ 不列、计数)/
+     * `checkpointId` 成员(是串才带;入 wire 前过信任边界由路由判)。失败方向与运维队列同一条律({@link SqlCheckpointStore.readStoredRow})。
      *
      * LIMIT bounds the fan-out (review w16yqkkxv): a triage view never needs more than a few — 500 is a generous
      * ceiling that still protects memory/latency if a scope ever accumulates pathologically many pending gates.

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

@@ -153,6 +153,9 @@ const readRiskDescriptorBody = createObjectColumnReader();
 function decodeCheckpointColumn(cell, where) {
     return decodeJsonColumn(cell, readCheckpointBlobBody, `checkpoint.checkpoint ${where}`);
 }
+function verdictOfUnreadableBody(cell) {
+    return judgeCheckpointRow(cell);
+}
 function decodeOutcomeColumn(cell, where) {
     return decodeNullableJsonColumn(cell, readResumeOutcomeBody, `checkpoint.outcome ${where}`);
 }
@@ -653,47 +656,66 @@ export class SqlCheckpointStore {
                 const token = String(r.token);
                 const sha256 = readJsonColumnTextSha256(r[CHECKPOINT_SHA256_AS], "checkpoint.checkpoint_sha256 (whole-row read)");
                 const projection = this.projectStoredRow(r, sha256);
-                if (projection !== undefined && sha256 === expected.get(token))
+                if (sha256 === expected.get(token))
                     out.set(token, projection);
             }
         }
         return out;
     }
     projectStoredRow(r, sha256) {
+        const read = this.readStoredRow(r, "(operator queue row, whole-row read)", sha256);
+        return read.summary === undefined ? { rowVerdict: read.rowVerdict, skillCardFacts: {} } : { rowVerdict: read.rowVerdict, skillCardFacts: skillCardFacts(read.summary) };
+    }
+    readStoredRow(r, where, sha256, discloseFor) {
+        const memo = this.storedRowMemo.get(sha256);
         let cp;
         try {
-            cp = decodeCheckpointColumn(r.checkpoint, "(operator queue row, whole-row read)");
+            cp = decodeCheckpointColumn(r.checkpoint, where);
         }
         catch (e) {
             if (!isJsonColumnBodyProblem(e))
                 throw e;
             recordFailOpen("server.approvals.park-row-blob-unreadable");
-            return undefined;
+            return { rowVerdict: verdictOfUnreadableBody(r.checkpoint) };
         }
         let summary;
         try {
-            summary = summarizeCheckpoint(cp);
+            summary = summarizeCheckpoint(cp, discloseFor?.(cp), memo?.rowVerdict);
         }
         catch {
             recordFailOpen("server.approvals.park-row-blob-unreadable");
-            return { rowVerdict: judgeCheckpointRow(cp), skillCardFacts: {} };
+            return { rowVerdict: judgeCheckpointRow(cp) };
         }
-        const projection = { rowVerdict: summary.rowVerdict, skillCardFacts: skillCardFacts(summary) };
-        this.storedRowMemo.set(sha256, projection);
-        return projection;
+        if (memo === undefined)
+            this.storedRowMemo.set(sha256, { rowVerdict: summary.rowVerdict, skillCardFacts: skillCardFacts(summary) });
+        return { rowVerdict: summary.rowVerdict, summary };
     }
     async listByScope(scope) {
-        const { rows } = await this.db.query(this.q(`SELECT ${jsonColumnText("mysql", "checkpoint")}, ${jsonColumnTextSha256("mysql", "checkpoint", CHECKPOINT_SHA256_AS)}, status FROM checkpoint WHERE status = 'pending' AND scope = ? ORDER BY created_at_ms ASC LIMIT 500`, `SELECT ${jsonColumnText("pg", "checkpoint")}, ${jsonColumnTextSha256("pg", "checkpoint", CHECKPOINT_SHA256_AS)}, status FROM checkpoint WHERE status = 'pending' AND scope = $1 ORDER BY created_at_ms ASC LIMIT 500`), [scope]);
+        const d = this.db.dialect;
+        const { rows } = await this.db.query(`SELECT ${jsonColumnText(d, "checkpoint")}, ${jsonColumnTextSha256(d, "checkpoint", CHECKPOINT_SHA256_AS)}, ${jsonColumnText(d, "checkpoint", PARK_ROW_CHECKPOINT_ID)}, ` +
+            `token, session_id, scope, created_at_ms, deadline, gate_kind FROM checkpoint WHERE status = 'pending' AND scope = ${this.q("?", "$1")} ORDER BY created_at_ms ASC LIMIT 500`, [scope]);
         const out = [];
         for (const r of rows) {
             const sha256 = readJsonColumnTextSha256(r[CHECKPOINT_SHA256_AS], `checkpoint.checkpoint_sha256 in the ${scope} scheduler view`);
-            const cp = refusing("a checkpoint nobody can resume", () => decodeCheckpointColumn(r.checkpoint, `in the ${scope} scheduler view`));
-            cp.status = r.status;
-            const memo = this.storedRowMemo.get(sha256);
-            const summary = summarizeCheckpoint(cp, (sentence) => recordFailOpen("server.checkpoint.inbox-risk-axes-damaged", withoutCheckpointToken(sentence, cp.token)), memo?.rowVerdict);
-            if (memo === undefined)
-                this.storedRowMemo.set(sha256, { rowVerdict: summary.rowVerdict, skillCardFacts: skillCardFacts(summary) });
-            out.push(summary);
+            const read = this.readStoredRow(r, `in the ${scope} scheduler view`, sha256, (cp) => (sentence) => recordFailOpen("server.checkpoint.inbox-risk-axes-damaged", withoutCheckpointToken(sentence, cp.token)));
+            if (read.summary !== undefined) {
+                out.push(read.summary);
+                continue;
+            }
+            const gateKind = queueRowGateKind(r.gate_kind);
+            if (gateKind === undefined)
+                continue;
+            const checkpointId = readCheckpointIdCell(r[PARK_ROW_CHECKPOINT_ID.as]);
+            out.push({
+                token: String(r.token),
+                rowVerdict: read.rowVerdict,
+                ...(typeof checkpointId === "string" ? { checkpointId } : {}),
+                sessionId: String(r.session_id),
+                scope: String(r.scope),
+                gateKind,
+                createdAt: Number(r.created_at_ms),
+                ...(r.deadline == null ? {} : { deadline: Number(r.deadline) }),
+            });
         }
         return out;
     }

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

@@ -118,7 +118,13 @@ export declare class FileRunStore implements InProcessClaimFence {
      */
     private refuseIfUnreadable;
     private hydrate;
-    /** Commit a RunRow to disk (whole-file atomic replace) AND the index — the single write path for every status change. */
+    /** run.json 的整文件原子替换 —— {@link persist} 的落盘那一半,不碰索引。 */
+    private writeRunFile;
+    /** Commit a RunRow to disk (whole-file atomic replace) AND the index — the single write path for every status change.
+     *  落盘在前、`runs.set` 在后:落盘抛 ⇒ 索引原样。要「全有或全无」的写口因此不在索引里那只行上原地先改再调 —— 原地改过的行,落盘一抛就是「内存已改、盘上没改」。
+     *  两种不原地的写法:对**副本**调本口(索引里换成副本:`releaseIdemKey` / `bindIdemBodyFingerprint` / `takeOverClaim`);或副本只走 {@link writeRunFile},
+     *  落成之后把改动**合回索引里的同一只行**(`fillObjectivePreview`)——后一种用在会撞进收割腿 await 窗的写口上:`reapSuspended` 等收割腿在 probe 的 await 之间手里持着索引里的行对象,
+     *  await 之后的复核读的就是这只对象,索引里的行被换成副本,它们就看不见之后的认领 / 取消了。 */
     private persist;
     private eventLogFor;
     /** Create a run iff the session has no active run (the task_active unique-key claim) AND no submission key of this
@@ -136,6 +142,12 @@ export declare class FileRunStore implements InProcessClaimFence {
      *  Synchronous from the key check to the index write ⇒ two same-key creates in this process (different sessions,
      *  different claim locks) cannot both pass the check: the loser observes the winner's row. */
     private commitNewRun;
+    /** run 行预览的写一次补写(SQL 孪生同义:列仍是 null 才写,建行写过 / 已补过的不动;行不在 ⇒ 无事)。
+     *  **副本判改 → 落盘 → 合回**:先把改动落在副本上写盘,落盘抛 ⇒ 内存里的行一字未动(预览仍是 null)、盘上也原样,下一次补写照常再试;
+     *  落成之后再把预览合回索引里的**同一只**行对象(不换对象:跨 await 持着行的收割腿复核读的是手上这只对象)。
+     *  原地先改再落盘,抛的那一拍就把内存和盘劈成两半(内存带预览、盘上 null),且「列已有值」的早退让这一分叉再也补不回来。
+     *  本体同步执行到底,中间没有 await ⇒ 副本落盘与合回之间没有别的写者插进来。 */
+    fillObjectivePreview(taskId: string, preview: string): Promise<void>;
     requestCancel(taskId: string, owner: string | null): Promise<boolean>;
     isCancelRequested(taskId: string, owner: string | null): Promise<boolean>;
     requestPreempt(taskId: string, owner: string | null): Promise<boolean>;