@sema-agent/server 7.147.0 → 7.149.0

package/scripts/drain-check-local.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * 换钉前的**排空检查 —— `DB_BACKEND=local`(File 店)车道**,只读。随 npm 包出(`scripts/drain-check-local.mjs`)。
- * 一次跑**七条判据**(判据表 {@link DRAIN_CRITERIA},每条一行末行、各自的命中行;SQL 车道的同一判据是同目录随包的 `drain-check.mysql.sql` / `drain-check.pg.sql`,
+ * 一次跑**八条判据**(判据表 {@link DRAIN_CRITERIA},每条一行末行、各自的命中行;SQL 车道的同一判据是同目录随包的 `drain-check.mysql.sql` / `drain-check.pg.sql`,
  * 每条判据一段、段首标记 `-- drain-check:<判据名>:<后端>`,判据名与本表的 `name` 同一个词):
  *  · `skill-grants-rollback`(**回滚**到 7.115.x 前,即引擎从 7.41 退回 7.40):四样任一 ——
  *    ① pending 行带 `state.skillGrants`(本次 run 冻结在行上的技能授予行:模型激活 / 子代捕获写下的放行与禁止);
@@ -24,6 +24,7 @@
  *    本判据(窗在 7.117.0)与随包 SQL 孪生**仍只数技能两层**,不覆盖那几张清单(续跑时的 409 是它们的响亮道);
  *  · `parked-tool-lists`(升级到 7.132.0 前)/ `own-tool-lists-rollback`(从 7.132.0 回滚前):停驻行记下的工具名清单 / 7.52 写下的 `ownToolLists`(判据与出路见判据表那两条的注);
  *  · `sealed-credentials-rollback`(从 7.134.0 回滚前;从 7.135.0 / 7.136.0 回滚到上一版前同用):续跑上下文的凭据位上带封签的 pending 行(7.133.x 读不懂封签,续跑时把这些位当没有;判据与出路见判据表那一条的注);
+ *  · `prompt-lean-rollback`(从 7.137.0 及以后回滚到 7.136.x 前):续跑上下文的提交体里 `promptLean` 为 `false`(要长形提示词)的 pending 行(7.136.x 不认这个键,续跑时回到缺省形;判据与出路见判据表那一条的注);
  *  · `retired-mode-seed`(换钉 7.113.0 前,core 7.39.0 删掉退役 mode-seed 的一次性迁移):pending 行的 `state.inheritedGate` 仍带退役成员;
  * 扫描骨架(快照 + 账本折成当前行、一致性重读、数据根判定)各条判据共用;判据只回答「这一条 pending 行算不算命中」。
  *
@@ -32,23 +33,23 @@
  *     `shellGate` **不是 `"always"`**(含 JSON null)。`"always"` 是 7.34.0 起的合法新形,grep 表达不了「值不是 always」;
  *  ② core 的 File 店是**快照 + 账本**两只文件(`checkpoints/checkpoints.snapshot.jsonl` 每行一条行,`checkpoints/checkpoints.jsonl` 是快照之后的事件):
  *     压实之后旧行**只在快照里**,只扫账本会把最该排的那批(≤7.105.0 停放的老行)整批漏掉;
- *  ③ 账本是追加写:同一条行先 `put` 后 `resolve` / `expire` / `reopen`,只有折叠到**当前状态**才知道它还 pending 没有。
- * ⇒ 本脚本照 core 的同一组事件把两只文件折成当前行,再按上面三条成员判 pending 行。
+ *  ③ 账本是追加写:同一条行先 `put` 后 `resolve` / `expire` / `reopen` / `delete`,只有折叠到**当前状态**才知道它还 pending 没有。
+ * ⇒ 当前行由引擎包根的 `readCheckpointLedger` 给(引擎自己的折叠 + 快照换新时的有界重读);本脚本不自带事件词表、不自己折叠,只按上面三条成员判它给出的 pending 行。
  *
- * ## 与 core 同判 —— 判据坐标(core 7.39.1 安装树 `node_modules/@sema-agent/core/dist/`;core 改了这些,本脚本要跟着改)
- *  · 行形:`stores/file/checkpoint-store.js:61` `isCheckpointRow`(`token` / `scope` / `status` 三个串)。快照行(`:70` `judgeRow`)与账本 `put` 的 `cp`(`:71-78` `judgeEvent`)
- *    **同一只判**。不合形的记录 core **跳过并披露、保留旧行**(`stores/file/fs-atomic.js:122` `readJsonlRecords`)—— 升级后那张旧卡照样在、照样被拒;所以本脚本对不合形的 `put`
- *    **不覆盖**旧行、计入 `corrupt`(⇒ rc 2),旧卡仍被数到;不合形的快照行(含缺 `scope`)不当行数、计入 `corrupt`。
- *  · 事件词:`stores/file/checkpoint-store.js:7-14` 注册表六词(put / resolve / reopen / execution / expire / steer_append);不认的词 core **拒绝重放**
- *    (`:16-19` `applyCheckpointEvent` 抛 `ledger_event_unknown`)⇒ 本脚本计入 `unknownEvents`(⇒ rc 2),不替它猜。
- *  · 重放序:`stores/file/shared-ledger.js:20-31` 先快照、后账本。压实 `stores/file/shared-ledger.js:63-72` `compact()` 先**原子换新快照**、再**清空账本**。
- *  · 退役成员:`core/checkpoint-store.js:739-756` `RETIRED_MODE_SEED_MEMBERS` / `refuseRetiredModeSeed`。
+ * ## 账本的读法只有一只 —— 引擎包根的 `readCheckpointLedger`(坐标:引擎安装树 `node_modules/@sema-agent/core/dist/` 的 `stores/file/checkpoint-store.js`,符号 `readCheckpointLedger` / `CHECKPOINT_LEDGER_EVENT_KINDS`)
+ *  · 行形与事件词是引擎的:快照行与账本 `put` 的 `cp` 同一只行形判,不合形的记录引擎**跳过并披露、保留旧行**(升级后那张旧卡照样在、照样被拒)—— 经读口的 `onCorruptRead` 回调
+ *    计入 `corrupt`(⇒ rc 2),旧卡仍被数到;崩在半行的**尾**行(无换行结尾、读不成)引擎不当记录 —— 那是非优雅退出的正常落盘形,不计 `corrupt`(与店的重放同判)。
+ *  · 不认的事件词(新版 worker 写下的,或引擎已退役的词)引擎**拒绝这次读**(`checkpoint.unsupported_version`,`detail.reason` 为 `ledger_event_unknown`)⇒ rc 2 + `reason=ledger-event-unknown`,
+ *    句子里列的「引擎认得的词」读自 `CHECKPOINT_LEDGER_EVENT_KINDS`;本脚本不替它猜、不抄这张词表。
+ *  · 退役成员:`core/checkpoint-store.js:739-756` `RETIRED_MODE_SEED_MEMBERS` / `refuseRetiredModeSeed`(本脚本里 `retiredMember` 是它的逐字投影)。
  *
  * ## 只读、不取锁;服务运行中也可以跑,但脚本只对**一致的**快照 + 账本组合下结论
- * 不打开 core 的店(那会取 `checkpoints/LOCK`、与在跑的服务争锁),只读两只 JSONL。服务在写时,两次读之间可能发生压实 ——
+ * 读口不打开 core 的店(不取 `checkpoints/LOCK`、与在跑的服务不争锁、不建任何东西),只读两只 JSONL。服务在写时,两次读之间可能发生压实 ——
  * 先读快照(旧)、压实(新快照含账本里的行,账本清空)、再读账本(空)⇒ 只在账本里的 pending 退役卡两边都读不到,读出一个假的「干净」。
- * 所以读前读后各取两文件的身份(dev / ino / size / mtimeNs),任一变了(压实 = 原子替换 ⇒ ino 变;追加 ⇒ size 变)就**重读**,至多 3 次;
- * 仍不稳 ⇒ rc 2 + 一句话(服务在写:停写或重跑),不给结论。
+ * 读口自己在读前读后比快照的身份,变了就**重读**,至多 3 次;仍不稳(`settled:false`)⇒ rc 2 + 一句话(服务在写:停写或重跑),不给结论。
+ * 账本只追加:读期间服务追加的行不使这一次读不一致(读到的是读那一刻的前缀),所以追加本身不再逼出 rc 2(旧脚本连账本的身份也比,追加也算「变了」);
+ * rc 0 / 1 是读那一刻的一致视图,不是对此后写入的担保 —— 换钉 / 回滚前仍要先停写、排空。
+ * 数据根上有一次进行中的收编(adoption)⇒ 读口按店同样拒 ⇒ rc 2 + `reason=read-error`,句子带引擎的原话。
  *
  * ## 数据根
  *  · 带参:`node scripts/drain-check-local.mjs <数据根>` —— 读那个目录;
@@ -65,17 +66,18 @@
  *    `SEALED-CREDENTIALS-ROW token=<token> sessionId=<id> createdAt=<ms> field=<第一处带封签的凭据位>|runId=<workflow 子代卡:点它的 run>` /
  *    `RETIRED-ROW token=<token> sessionId=<id> createdAt=<ms> member=<成员>`;
  *  · 每条判据一行末行(表序;`RETIRED-MODE-SEED` 那一行恒在最后,7.113.0 起读「最后一行」的下游不受影响):
- *    `SKILL-GRANTS rows=<命中数> pending=<pending 行数> total=<行数> unknownEvents=<n> corrupt=<n> root=<实际读的数据根>`,
- *    `RETIRED-SKILL-MANIFEST rows=<命中数> pending=<pending 行数> total=<行数> unknownEvents=<n> corrupt=<n> root=<实际读的数据根>`,
- *    `SKILL-DENY-INERT rows=<命中数> pending=<pending 行数> total=<行数> unknownEvents=<n> corrupt=<n> root=<实际读的数据根>`,
- *    `PARKED-TOOL-LISTS rows=<命中数> pending=<pending 行数> total=<行数> unknownEvents=<n> corrupt=<n> root=<实际读的数据根>`,
- *    `OWN-TOOL-LISTS-ROLLBACK rows=<命中数> pending=<pending 行数> total=<行数> unknownEvents=<n> corrupt=<n> root=<实际读的数据根>`,
- *    `SEALED-CREDENTIALS-ROLLBACK rows=<命中数> pending=<pending 行数> total=<行数> unknownEvents=<n> corrupt=<n> root=<实际读的数据根>`,
- *    `RETIRED-MODE-SEED rows=<命中数> pending=<pending 行数> total=<行数> unknownEvents=<n> corrupt=<n> root=<实际读的数据根>`;
+ *    `SKILL-GRANTS rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`,
+ *    `RETIRED-SKILL-MANIFEST rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`,
+ *    `SKILL-DENY-INERT rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`,
+ *    `PARKED-TOOL-LISTS rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`,
+ *    `OWN-TOOL-LISTS-ROLLBACK rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`,
+ *    `SEALED-CREDENTIALS-ROLLBACK rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`,
+ *    `PROMPT-LEAN-ROLLBACK rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`,
+ *    `RETIRED-MODE-SEED rows=<命中数> pending=<pending 行数> total=<行数> corrupt=<n> root=<实际读的数据根>`;
  *    `corrupt` = 共用扫描的坏记录 + 这条判据自己读不懂的旁路输入(读不懂的 ctx 档,文件名进 stderr —— 一份读不懂的 ctx 可能正是让某条 pending 行命中的那一份;
  *    `sealed-credentials-rollback` 另读 workflow park 索引:索引账本里读不出的行,行号进 stderr);
- *    没读成 / 不能下结论(rc 2 的几种缺席与不稳形)时前五个计数是 `-`、多一个 `reason=<词>`,**不会出现 `rows=0`**(下游读 `rows=0` 即「干净」);
- *  · rc 0 = 每条判据都零命中(可换钉 / 可回滚)· rc 1 = 有命中(逐行列出;答完或取消再跑)· rc 2 = 读不懂 / 没读成 / 不能下结论(账本里有本脚本不认的事件词 / 不合形的记录 / 读不懂的 ctx 档 /
+ *    没读成 / 不能下结论(rc 2 的几种缺席与不稳形)时前四个计数是 `-`、多一个 `reason=<词>`,**不会出现 `rows=0`**(下游读 `rows=0` 即「干净」);
+ *  · rc 0 = 每条判据都零命中(可换钉 / 可回滚)· rc 1 = 有命中(逐行列出;答完或取消再跑)· rc 2 = 读不懂 / 没读成 / 不能下结论(账本里有引擎不认的事件词 / 不合形的记录 / 读不懂的 ctx 档 /
  *    数据根缺席 / 缺省根解析不可用 / 判据模块不可用(脚本隔壁没有 `dist/`:源码树没 build)/ 读期间文件一直在变 / 读文件出错 / 用法错)—— 不给结论(缺席 ≠ 干净:一条读不懂的记录可能正是让某行回到 pending 的那一条)。
  *    rc 2 与 rc 1 同时成立时(有命中、也有读不懂的记录)报 rc 2,命中行照列。
  */
@@ -84,14 +86,13 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+/** 引擎包根的账本读口(`readCheckpointLedger`)的形;`onCorruptRead` 收引擎披露的每条被跳过的记录(`kind: "record"`,带 `path` / `line`)。
+ * @typedef {import("@sema-agent/core").CheckpointLedgerReading} CheckpointLedgerReading
+ * @typedef {(root: string, opts?: { onCorruptRead?: (info: { kind: string, path: string, line?: number }) => void }) => CheckpointLedgerReading} LedgerReader */
+
 /** 从脚本隔壁的编译产物取来的服务判据(脚本不持第二份实现)。
  * @typedef {{ sealedCredentialFieldOf: (ctx: unknown) => string | undefined, retiredSkillManifestLayerOf: (body: unknown) => "skills" | "agents.skills" | undefined, skillDenyInertEntryOf: (body: unknown) => { layer: "skills" | "agents.skills", message: string } | undefined, readAgentSessionLedgerLine: (v: unknown) => { runId: string, rows: Array<{ sessionId: string }> } | undefined }} ServiceCriteria */
 
-/** 读期间文件在变时的有界重读次数(含第一次)。 */
-const STABLE_READ_ATTEMPTS = 3;
-/** core 账本事件注册表(`stores/file/checkpoint-store.js:7-14`)。 */
-const KNOWN_LEDGER_EVENTS = new Set(["put", "resolve", "reopen", "execution", "expire", "steer_append"]);
-
 /** @param {string} path */
 const dirKind = (path) => {
   try {
@@ -112,9 +113,6 @@ const textOf = (path) => {
   }
 };
 
-/** @param {string} path */
-const linesOf = (path) => textOf(path).split("\n").filter((l) => l.trim().length > 0);
-
 /** @param {string} line */
 const parse = (line) => {
   try {
@@ -125,112 +123,6 @@ const parse = (line) => {
   }
 };
 
-/** core `isCheckpointRow`(`stores/file/checkpoint-store.js:61`)逐字:`token` / `scope` / `status` 三个串。快照行与账本 `put` 的 `cp` 同一只判。
- * @param {unknown} x
- * @returns {x is Record<string, unknown> & { token: string, scope: string, status: string }} */
-const isCheckpointRow = (x) =>
-  x !== null && typeof x === "object" && typeof (/** @type {Record<string, unknown>} */ (x).token) === "string" && typeof (/** @type {Record<string, unknown>} */ (x).scope) === "string" && typeof (/** @type {Record<string, unknown>} */ (x).status) === "string";
-
-/** 一只文件的身份;不存在 = `absent`(账本可以合法不存在);其余 stat 错误抛出。
- * @param {string} path */
-const identityOf = (path) => {
-  try {
-    const st = statSync(path, { bigint: true });
-    return `${st.dev}:${st.ino}:${st.size}:${st.mtimeNs}`;
-  } catch (e) {
-    if (/** @type {NodeJS.ErrnoException} */ (e).code === "ENOENT") return "absent";
-    throw e;
-  }
-};
-
-/** 两只文件的身份(快照 | 账本)。
- * @param {string} dir */
-const identitiesOf = (dir) => `${identityOf(join(dir, "checkpoints.snapshot.jsonl"))}|${identityOf(join(dir, "checkpoints.jsonl"))}`;
-
-/**
- * 读一遍(不判一致性):快照 → 钩子 → 账本,折成当前行。
- * @param {string} dir
- * @param {() => void | Promise<void>} betweenReads
- * @returns {Promise<{ rows: Map<string, Record<string, unknown>>, corrupt: number, unknownEvents: number }>}
- */
-async function foldOnce(dir, betweenReads) {
-  /** @type {Map<string, Record<string, unknown>>} token → 行(当前状态) */
-  const rows = new Map();
-  let corrupt = 0;
-  let unknownEvents = 0;
-
-  // ① 快照:每行一条行;不合形(core `isCheckpointRow`)⇒ core 跳过 ⇒ 本脚本也不当行数,计 corrupt
-  for (const line of linesOf(join(dir, "checkpoints.snapshot.jsonl"))) {
-    const r = parse(line);
-    if (r === undefined || !isCheckpointRow(r)) {
-      corrupt++;
-      continue;
-    }
-    rows.set(r.token, r);
-  }
-
-  await betweenReads();
-
-  // ② 账本:快照之后的事件,照 core `applyCheckpointEvent` 的同一组词折叠(状态相关的三词改 status;其余两词与 pending 判定无关)
-  for (const line of linesOf(join(dir, "checkpoints.jsonl"))) {
-    const ev = parse(line);
-    if (ev === undefined || typeof ev.t !== "string") {
-      corrupt++;
-      continue;
-    }
-    if (!KNOWN_LEDGER_EVENTS.has(ev.t)) {
-      unknownEvents++; // 新版本写的事件词:本脚本不替它猜(core 对未知词拒绝重放)
-      continue;
-    }
-    if (typeof ev.token !== "string") {
-      corrupt++;
-      continue;
-    }
-    if (ev.t === "put") {
-      // core:`put` 的 cp 不合形 ⇒ 跳过该事件、保留旧行。本脚本同:不覆盖,计 corrupt(⇒ rc 2),旧行照数。
-      if (!isCheckpointRow(ev.cp)) {
-        corrupt++;
-        continue;
-      }
-      rows.set(ev.token, ev.cp);
-      continue;
-    }
-    const row = rows.get(ev.token);
-    switch (ev.t) {
-      case "resolve":
-        if (row) row.status = "resolved";
-        break;
-      case "reopen":
-        if (row) row.status = "pending";
-        break;
-      case "expire":
-        if (row) row.status = "expired";
-        break;
-      default:
-        break; // execution / steer_append:不改 status
-    }
-  }
-  return { rows, corrupt, unknownEvents };
-}
-
-/**
- * 把 `<dir>` 下的快照 + 账本折成当前行,**只对一致的组合交结果**(导出:测试与 CLI 共用同一只;CLI 不传钩子)。
- * 读前读后各取两文件身份,变了就重读,至多 {@link STABLE_READ_ATTEMPTS} 次;仍变 ⇒ `stable:false`(不交行)。
- * @param {string} dir `<数据根>/checkpoints`
- * @param {{ afterSnapshotRead?: (attempt: number) => void | Promise<void> }} [opts] 测试钩子:快照读完、账本还没读的那一刻(`attempt` 从 1 起)
- * @returns {Promise<{ stable: true, attempts: number, rows: Map<string, Record<string, unknown>>, corrupt: number, unknownEvents: number } | { stable: false, attempts: number }>}
- */
-export async function scanCheckpointDir(dir, opts = {}) {
-  for (let attempt = 1; attempt <= STABLE_READ_ATTEMPTS; attempt++) {
-    const before = identitiesOf(dir);
-    const folded = await foldOnce(dir, async () => {
-      await opts.afterSnapshotRead?.(attempt);
-    });
-    if (identitiesOf(dir) === before) return { stable: true, attempts: attempt, ...folded };
-  }
-  return { stable: false, attempts: STABLE_READ_ATTEMPTS };
-}
-
 /** core `refuseRetiredModeSeed` 的三条成员(`core/checkpoint-store.js:739-756` 逐字):前两条任何值都算(含 null),`shellGate` 不是 "always" 才算。
  * @param {unknown} gate
  * @returns {string | undefined} */
@@ -339,6 +231,12 @@ function readParkIndex(root, readLine) {
   return { bySession, corrupt: unreadable.length, unreadable };
 }
 
+/** 续跑上下文的提交体要不要长形提示词(`body.promptLean === false`;`prompt-lean-rollback` 的判据)。
+ * @param {Record<string, unknown>} ctx */
+function asksLongPromptForm(ctx) {
+  return isObject(ctx.body) && /** @type {Record<string, unknown>} */ (ctx.body).promptLean === false;
+}
+
 /**
  * 判据表 —— 「哪些 pending 行算命中」。扫描骨架(快照 + 账本折成当前行、一致性重读、数据根判定)各条共用,判据只管这一问:
  *  · `tail` / `hit`:末行前缀 / 命中行前缀;
@@ -461,6 +359,31 @@ export const DRAIN_CRITERIA = [
       return runs !== undefined && anySealed ? ` runId=${runs.join(",")}` : undefined;
     },
   },
+  {
+    // 从 7.137.0 及以后回滚到 7.136.x 之前:pending 行所在会话的续跑上下文里,提交体的 `promptLean` 恰为 `false`(长的 classic 提示词形)。7.136.x 读的是退役键 `promptProfile`、
+    // 不认 `promptLean`(续跑重放存下的请求体时不过键闭集门)⇒ 回滚后这些行续跑时回到模型声明的缺省形,不报错。一次性迁移 M30 把 7.136.x 停驻、带 `"classic"` 的行改写成
+    // `promptLean: false`(不留记号),所以 M30 改写过的行全在其中;7.137.0 起新提交时就带 `promptLean: false` 的行同样在。`true` / 缺席不数(回滚后读法不变)。
+    // 判据是请求体上的一个值形事实(与 `own-tool-lists-rollback` 同:本服务运行期没有「回滚后会丢」这只判据的函数),所以写在这一张表里;精确。出路:回滚前把它们决掉或取消(随包 `MIGRATION.md` 7.137.0 节)。
+    // 读哪一份续跑上下文与续跑腿同(同 `sealed-credentials-rollback` 那一条的注):workflow 子代卡读**发起会话**那一份 ⇒ 子代卡数的是真超集 —— 自己那一份命中,
+    // 或子会话被 park 索引点名、而数据根里任一份 ctx 命中,即记为候选并点名点它的 run(`runId=`);读不懂的 ctx 档 / 索引账本行计入 `corrupt`(rc 2)。
+    name: "prompt-lean-rollback",
+    tail: "PROMPT-LEAN-ROLLBACK",
+    hit: "PROMPT-LEAN-ROW",
+    load: (root, service) => {
+      const idx = readCtxIndex(root);
+      const parks = readParkIndex(root, service.readAgentSessionLedgerLine);
+      const anyLongForm = [...idx.bySession.values()].some((ctx) => asksLongPromptForm(ctx));
+      return { input: { bySession: idx.bySession, parkedBy: parks.bySession, anyLongForm }, corrupt: idx.corrupt + parks.corrupt, unreadable: [...idx.unreadable, ...parks.unreadable] };
+    },
+    judge: (row, input) => {
+      const { bySession, parkedBy, anyLongForm } = /** @type {{ bySession: Map<string, Record<string, unknown>>, parkedBy: Map<string, string[]>, anyLongForm: boolean }} */ (input);
+      if (typeof row.sessionId !== "string") return undefined;
+      const ctx = bySession.get(row.sessionId);
+      if (ctx !== undefined && asksLongPromptForm(ctx)) return "";
+      const runs = parkedBy.get(row.sessionId);
+      return runs !== undefined && anyLongForm ? ` runId=${runs.join(",")}` : undefined;
+    },
+  },
   {
     name: "retired-mode-seed",
     tail: "RETIRED-MODE-SEED",
@@ -479,7 +402,7 @@ export const DRAIN_CRITERIA = [
  * @param {string} sentence
  * @param {string} rootEcho */
 function unreadableReport(reason, sentence, rootEcho) {
-  return { rc: /** @type {const} */ (2), stdout: DRAIN_CRITERIA.map((c) => `${c.tail} rows=- pending=- total=- unknownEvents=- corrupt=- reason=${reason} root=${rootEcho}`), stderr: [sentence] };
+  return { rc: /** @type {const} */ (2), stdout: DRAIN_CRITERIA.map((c) => `${c.tail} rows=- pending=- total=- corrupt=- reason=${reason} root=${rootEcho}`), stderr: [sentence] };
 }
 
 /**
@@ -520,10 +443,40 @@ async function loadServiceCriteria(rootEcho) {
   return /** @type {ServiceCriteria} */ (fns);
 }
 
+/**
+ * 引擎包根的账本读法(动态导入的具名解构:引擎是本包的依赖,随包安装时恒在脚本隔壁的 `node_modules`;取不到 / 导出缺席 ⇒ 同一条 `criterion-unavailable` 不给结论,
+ * 不退回自抄的读法 —— 装载期崩出去的话 Node 的退出码是 1,与「有命中」同码)。
+ * @param {string} rootEcho
+ * @returns {Promise<{ readCheckpointLedger: LedgerReader, eventKinds: readonly string[] } | ReturnType<typeof unreadableReport>>} */
+async function loadLedgerApi(rootEcho) {
+  try {
+    const { readCheckpointLedger, CHECKPOINT_LEDGER_EVENT_KINDS } = await import("@sema-agent/core");
+    if (typeof readCheckpointLedger !== "function" || !Array.isArray(CHECKPOINT_LEDGER_EVENT_KINDS)) {
+      return unreadableReport(
+        "criterion-unavailable",
+        "cannot use the engine's checkpoint-ledger reader (@sema-agent/core loaded but does not export readCheckpointLedger / CHECKPOINT_LEDGER_EVENT_KINDS — the installed engine is older than this script needs) — no verdict: reinstall @sema-agent/server and run the copy inside the installed package",
+        rootEcho,
+      );
+    }
+    return { readCheckpointLedger, eventKinds: CHECKPOINT_LEDGER_EVENT_KINDS };
+  } catch (e) {
+    return unreadableReport(
+      "criterion-unavailable",
+      `cannot load the engine's checkpoint-ledger reader (@sema-agent/core is not loadable from next to scripts/: ${e instanceof Error ? e.message : String(e)}) — no verdict: run the copy inside an installed @sema-agent/server package`,
+      rootEcho,
+    );
+  }
+}
+
+/** 引擎认的「这次读被拒:账本里有它不认的事件词」(`checkpoint.unsupported_version` + `detail.reason: "ledger_event_unknown"`,引擎读口的契约句)。
+ * @param {unknown} e */
+const isUnknownLedgerEvent = (e) =>
+  e instanceof Error && /** @type {{ code?: unknown }} */ (e).code === "checkpoint.unsupported_version" && /** @type {{ detail?: { reason?: unknown } }} */ (e).detail?.reason === "ledger_event_unknown";
+
 /**
  * 一次排空检查的完整报告(导出:CLI 与测试共用)。
  * @param {string} root 数据根
- * @param {{ afterSnapshotRead?: (attempt: number) => void | Promise<void> }} [opts]
+ * @param {{ readLedger?: LedgerReader }} [opts] 测试缝:换掉账本读口(缺省 = 引擎包根的 `readCheckpointLedger`;CLI 不传)
  * @returns {Promise<{ rc: 0 | 1 | 2, stdout: string[], stderr: string[] }>}
  */
 export async function drainReport(root, opts = {}) {
@@ -548,24 +501,42 @@ export async function drainReport(root, opts = {}) {
   // 不许在没有行可判时读成 rows=0,也不许等到调用处抛出(未捕获异常的退出码是 1 = 「有命中」)。
   const service = await loadServiceCriteria(root);
   if ("rc" in service) return service;
-  let scan;
+  const ledgerApi = await loadLedgerApi(root);
+  if ("rc" in ledgerApi) return ledgerApi;
+  /** 引擎读口披露的坏记录(按「文件:行」去重 —— 快照中途换新时读口会重读,同一条坏记录不记两次)。 */
+  const damaged = new Set();
   /** @type {Array<{ input: unknown, corrupt: number, unreadable: string[] }>} */
   let inputs;
+  /** @type {CheckpointLedgerReading} */
+  let reading;
   try {
-    scan = await scanCheckpointDir(dir, opts);
+    reading = (opts.readLedger ?? ledgerApi.readCheckpointLedger)(root, {
+      onCorruptRead: (info) => {
+        if (info.kind === "record") damaged.add(`${info.path}:${info.line}`);
+        else if (info.kind === "file") damaged.add(info.path);
+      },
+    });
     inputs = DRAIN_CRITERIA.map((c) => c.load(root, service));
   } catch (e) {
-    // 读文件出错(权限 / 路径是目录 / …)⇒ 不给结论。未捕获异常的退出码是 1 = 「有命中」,会被下游读成有停放行。
+    if (isUnknownLedgerEvent(e)) {
+      return unreadableReport(
+        "ledger-event-unknown",
+        `the checkpoint ledger under ${dir} holds an event kind the installed engine does not know (it knows: ${ledgerApi.eventKinds.join(" / ")}) — it was written by a newer worker, or the kind was retired: no verdict; run this script from a package whose engine is at least as new as the worker that wrote the ledger`,
+        root,
+      );
+    }
+    // 读文件出错(权限 / 路径是目录 / 收编进行中 / …)⇒ 不给结论。未捕获异常的退出码是 1 = 「有命中」,会被下游读成有停放行。
     return unreadableReport("read-error", `cannot read the checkpoint files under ${root}: ${e instanceof Error ? e.message : String(e)} — no verdict`, root);
   }
-  if (!scan.stable) {
+  if (!reading.settled) {
     return unreadableReport(
       "unstable-read",
-      `the checkpoint files under ${dir} changed while being read (${scan.attempts} reads in a row) — the service is writing to its checkpoint store, so no consistent snapshot + ledger could be read: no verdict; stop the service (or its checkpoint traffic) and rerun`,
+      `the checkpoint files under ${dir} kept changing while being read (the engine's bounded re-read ran out) — the service is writing to its checkpoint store, so no consistent snapshot + ledger could be read: no verdict; stop the service (or its checkpoint traffic) and rerun`,
       root,
     );
   }
-  const { rows, corrupt, unknownEvents } = scan;
+  const rows = /** @type {ReadonlyMap<string, Record<string, unknown>>} */ (reading.rows);
+  const corrupt = damaged.size;
   /** @type {string[]} */
   const stdout = [];
   /** @type {string[]} */
@@ -573,7 +544,7 @@ export async function drainReport(root, opts = {}) {
   /** @type {string[]} */
   const tails = [];
   let anyHit = false;
-  let anyUnreadable = unknownEvents > 0 || corrupt > 0;
+  let anyUnreadable = corrupt > 0;
   DRAIN_CRITERIA.forEach((criterion, i) => {
     const { input, corrupt: ownCorrupt, unreadable } = inputs[i];
     let hits = 0;
@@ -589,7 +560,7 @@ export async function drainReport(root, opts = {}) {
     if (unreadable.length > 0) stderr.push(`${criterion.name}: unreadable input files (no verdict — one of them may be what makes a pending row count): ${unreadable.join(", ")}`);
     if (ownCorrupt > 0) anyUnreadable = true;
     if (hits > 0) anyHit = true;
-    tails.push(`${criterion.tail} rows=${hits} pending=${pending} total=${rows.size} unknownEvents=${unknownEvents} corrupt=${corrupt + ownCorrupt} root=${root}`);
+    tails.push(`${criterion.tail} rows=${hits} pending=${pending} total=${rows.size} corrupt=${corrupt + ownCorrupt} root=${root}`);
   });
   return { rc: anyUnreadable ? 2 : anyHit ? 1 : 0, stdout: [...stdout, ...tails], stderr };
 }

package/scripts/drain-check.mysql.sql

@@ -8,15 +8,16 @@
 --   sessions   命中行所在的会话 id,逗号连接,新的在前。以 hit_rows 为准:这一列被会话变量 group_concat_max_len(缺省 1024 字节)截断时,列出的会话数会少于 hit_rows ——
 --              先处理列出的再跑一次,或先在同一个会话里 SET SESSION group_concat_max_len = 1048576; 再跑本文件(本文件自己只含 SELECT)。
 -- 每段只数 pending 行(已决 / 已过期的行不数);判据只看**键在不在 / 值形**,不读行的其余内容。
--- DB_BACKEND=local(File 店)没有 SQL:用同目录的 drain-check-local.mjs,七条判据同名。
+-- DB_BACKEND=local(File 店)没有 SQL:用同目录的 drain-check-local.mjs,八条判据同名。
 --
--- 七条判据(顺序同 drain-check-local.mjs 的判据表):
+-- 八条判据(顺序同 drain-check-local.mjs 的判据表):
 --   skill-grants-rollback   回滚到 7.115.x(引擎 7.40)之前:7.116.0 停驻的行带 7.40 不读的技能授予节 / 卡绑定 / 会话上下文里的人点名技能 / 还没被激活的技能声明的禁止清单。
 --   retired-skill-manifest  升级到 7.116.0 之前:停驻、持久化提交体里技能(顶层 skills[] 或子代 agents[].skills[])还带已退役的 manifest 键。
 --   skill-deny-inert        换钉 7.117.0 之前:停驻、提交体里技能(顶层 skills[] 或子代 agents[].skills[])的 disallowedTools 有引擎会读成空的条目的**候选**(见该段注)。
 --   parked-tool-lists       升级到 7.132.0 之前:停驻行记着子代工具天花板 / 冻结的父约束链 / Skill 卡的清单绑定(7.52 在认领前按规范拼写读它们)的**候选**(见该段注)。
 --   own-tool-lists-rollback 从 7.132.0 回滚到 7.131.x 之前:7.132.0 停驻、带 state.ownToolLists 的行(7.131.x 读不了)。
 --   sealed-credentials-rollback 从 7.134.0 回滚到 7.133.x(或从 7.135.0 回滚到 7.134.x、从 7.136.0 回滚到 7.135.x)之前:停驻、续跑上下文里提交体的凭据位上带封签的行(7.133.x 读不懂封签,续跑时把这些位当没有)的**候选**(见该段注)。
+--   prompt-lean-rollback    从 7.137.0 及以后回滚到 7.136.x 之前:停驻、续跑上下文里提交体的 promptLean 为 false(要长形提示词)的行 —— 7.136.x 不认这个键,续跑时回到缺省形(一次性迁移 M30 改写过的行全在其中)。
 --   retired-mode-seed       换钉 7.113.0 之前:检查点的 inheritedGate 里仍带退役 mode-seed 成员。
 
 -- drain-check:skill-grants-rollback:mysql —— 期望 hit_rows = 0;每一行 = 一条回滚到 7.115.x 后续跑会丢技能禁止行 / 不核卡绑定的停驻行。
@@ -120,6 +121,25 @@ WHERE k.status = 'pending'
               WHERE kk.token = k.token
                 AND LOCATE('"checkpoint-ctx-sealedbox-v1"', CAST(JSON_EXTRACT(c.ctx, '$.body') AS CHAR)) > 0);
 
+-- drain-check:prompt-lean-rollback:mysql —— 期望 hit_rows = 0;每一行 = 一条从 7.137.0 及以后回滚到 7.136.x 后续跑会丢掉长形提示词的停驻行。
+-- 在**回滚之前**、对当前版本的数据跑:7.137.0 起请求体的提示词形是布尔 promptLean(false = 长的 classic 形),7.136.x 读的是退役键 promptProfile、不认 promptLean
+-- (续跑重放存下的请求体时不过键闭集门)⇒ 回滚后这些行续跑时回到模型声明的缺省形(短形),不报错。一次性迁移 M30 把 7.136.x 停驻、带 "classic" 的行改写成
+-- promptLean: false(不留记号),所以 M30 改写过的行全在这里;7.137.0 起新提交时就带 promptLean: false 的停驻行同样在(回滚后同样丢长形)。
+-- 判据 = 续跑腿读的那一份续跑上下文(连接形与 skill-deny-inert 段逐字同,理由见该段注)的提交体里 promptLean 恰为 JSON false(值判精确;true / 缺席不数 —— 回滚后读法不变)。
+-- workflow 子代卡按全部指针数(历史指针的发起会话要长形也数)⇒ 对它们是真超集,与 skill-deny-inert / sealed-credentials-rollback 两段同。
+-- 出路:回滚前把它们决掉或取消(见随包 MIGRATION.md 7.137.0 节「回滚到 7.136.x 前先决完或取消停驻任务」)。
+SELECT 'prompt-lean-rollback' AS criterion, COUNT(*) AS hit_rows,
+       COALESCE(GROUP_CONCAT(k.session_id ORDER BY k.created_at_ms DESC SEPARATOR ','), '') AS sessions
+FROM checkpoint k
+WHERE k.status = 'pending'
+  AND EXISTS (SELECT 1
+              FROM checkpoint kk
+              LEFT JOIN workflow_agent_session w ON w.session_id = kk.session_id
+              LEFT JOIN workflow_run r ON r.id = w.run_id
+              JOIN checkpoint_ctx c ON c.session_id = COALESCE(JSON_UNQUOTE(JSON_EXTRACT(r.run, '$.originatingSessionId')), kk.session_id)
+              WHERE kk.token = k.token
+                AND JSON_TYPE(JSON_EXTRACT(c.ctx, '$.body.promptLean')) = 'BOOLEAN' AND CAST(JSON_EXTRACT(c.ctx, '$.body.promptLean') AS CHAR) = 'false');
+
 -- drain-check:retired-mode-seed:mysql —— 期望 hit_rows = 0;每一行 = 一条升级后会被拒的停放行。
 -- 判据逐字照引擎 refuseRetiredModeSeed:inheritedGate 带 autoModeRequested / approverPosture(任何值,含 JSON null),或 shellGate 不是 "always"(含 JSON null)。
 SELECT 'retired-mode-seed' AS criterion, COUNT(*) AS hit_rows,

package/scripts/drain-check.pg.sql

@@ -7,15 +7,16 @@
 --   hit_rows   命中的停驻行数(pending 行里算命中的那些);**全部为 0 才算排空**,非 0 ⇒ 逐条答完或取消(各判据对应的升级 / 回滚说明见随包 MIGRATION.md);
 --   sessions   命中行所在的会话 id,逗号连接,新的在前。
 -- 每段只数 pending 行(已决 / 已过期的行不数);判据只看**键在不在 / 值形**,不读行的其余内容。
--- DB_BACKEND=local(File 店)没有 SQL:用同目录的 drain-check-local.mjs,七条判据同名。
+-- DB_BACKEND=local(File 店)没有 SQL:用同目录的 drain-check-local.mjs,八条判据同名。
 --
--- 七条判据(顺序同 drain-check-local.mjs 的判据表):
+-- 八条判据(顺序同 drain-check-local.mjs 的判据表):
 --   skill-grants-rollback   回滚到 7.115.x(引擎 7.40)之前:7.116.0 停驻的行带 7.40 不读的技能授予节 / 卡绑定 / 会话上下文里的人点名技能 / 还没被激活的技能声明的禁止清单。
 --   retired-skill-manifest  升级到 7.116.0 之前:停驻、持久化提交体里技能(顶层 skills[] 或子代 agents[].skills[])还带已退役的 manifest 键。
 --   skill-deny-inert        换钉 7.117.0 之前:停驻、提交体里技能(顶层 skills[] 或子代 agents[].skills[])的 disallowedTools 有引擎会读成空的条目的**候选**(见该段注)。
 --   parked-tool-lists       升级到 7.132.0 之前:停驻行记着子代工具天花板 / 冻结的父约束链 / Skill 卡的清单绑定(7.52 在认领前按规范拼写读它们)的**候选**(见该段注)。
 --   own-tool-lists-rollback 从 7.132.0 回滚到 7.131.x 之前:7.132.0 停驻、带 state.ownToolLists 的行(7.131.x 读不了)。
 --   sealed-credentials-rollback 从 7.134.0 回滚到 7.133.x(或从 7.135.0 回滚到 7.134.x、从 7.136.0 回滚到 7.135.x)之前:停驻、续跑上下文里提交体的凭据位上带封签的行(7.133.x 读不懂封签,续跑时把这些位当没有)的**候选**(见该段注)。
+--   prompt-lean-rollback    从 7.137.0 及以后回滚到 7.136.x 之前:停驻、续跑上下文里提交体的 promptLean 为 false(要长形提示词)的行 —— 7.136.x 不认这个键,续跑时回到缺省形(一次性迁移 M30 改写过的行全在其中)。
 --   retired-mode-seed       换钉 7.113.0 之前:检查点的 inheritedGate 里仍带退役 mode-seed 成员。
 
 -- drain-check:skill-grants-rollback:pg —— 期望 hit_rows = 0;每一行 = 一条回滚到 7.115.x 后续跑会丢技能禁止行 / 不核卡绑定的停驻行。
@@ -128,6 +129,25 @@ WHERE k.status = 'pending'
               WHERE kk.token = k.token
                 AND strpos((c.ctx -> 'body')::text, '"checkpoint-ctx-sealedbox-v1"') > 0);
 
+-- drain-check:prompt-lean-rollback:pg —— 期望 hit_rows = 0;每一行 = 一条从 7.137.0 及以后回滚到 7.136.x 后续跑会丢掉长形提示词的停驻行。
+-- 在**回滚之前**、对当前版本的数据跑:7.137.0 起请求体的提示词形是布尔 promptLean(false = 长的 classic 形),7.136.x 读的是退役键 promptProfile、不认 promptLean
+-- (续跑重放存下的请求体时不过键闭集门)⇒ 回滚后这些行续跑时回到模型声明的缺省形(短形),不报错。一次性迁移 M30 把 7.136.x 停驻、带 "classic" 的行改写成
+-- promptLean: false(不留记号),所以 M30 改写过的行全在这里;7.137.0 起新提交时就带 promptLean: false 的停驻行同样在(回滚后同样丢长形)。
+-- 判据 = 续跑腿读的那一份续跑上下文(连接形与 skill-deny-inert 段逐字同,理由见该段注)的提交体里 promptLean 恰为 JSON false(值判精确;true / 缺席不数 —— 回滚后读法不变)。
+-- workflow 子代卡按全部指针数(历史指针的发起会话要长形也数)⇒ 对它们是真超集,与 skill-deny-inert / sealed-credentials-rollback 两段同。
+-- 出路:回滚前把它们决掉或取消(见随包 MIGRATION.md 7.137.0 节「回滚到 7.136.x 前先决完或取消停驻任务」)。
+SELECT 'prompt-lean-rollback' AS criterion, count(*) AS hit_rows,
+       coalesce(string_agg(k.session_id, ',' ORDER BY k.created_at_ms DESC), '') AS sessions
+FROM checkpoint k
+WHERE k.status = 'pending'
+  AND EXISTS (SELECT 1
+              FROM checkpoint kk
+              LEFT JOIN workflow_agent_session w ON w.session_id = kk.session_id
+              LEFT JOIN workflow_run r ON r.id = w.run_id
+              JOIN checkpoint_ctx c ON c.session_id = COALESCE(r.run::json->>'originatingSessionId', kk.session_id)
+              WHERE kk.token = k.token
+                AND (c.ctx #> '{body,promptLean}') = 'false'::jsonb);
+
 -- drain-check:retired-mode-seed:pg —— 期望 hit_rows = 0;每一行 = 一条升级后会被拒的停放行。
 -- 判据逐字照引擎 refuseRetiredModeSeed:inheritedGate 带 autoModeRequested / approverPosture(任何值,含 JSON null),或 shellGate 不是 "always"(含 JSON null)。
 SELECT 'retired-mode-seed' AS criterion, count(*) AS hit_rows,