@thincoder/core 0.10.12 → 0.11.1

package/embedding.mjs

@@ -7,6 +7,7 @@
 
 import { RETRYABLE_STATUS } from "./provider/index.mjs"
 import { resolveEnvRefs } from "./env-ref.mjs"
+import { withUserAgent } from "./client-identity.mjs"
 // #859（MEMORY.md §6.3 ∥ §7 D-MEM31）：嵌入路径发送前净化孤立 UTF-16 代理——sanitize 单源复用
 import { sanitizeLoneSurrogates } from "./escape.mjs"
 const MAX_RETRIES = 3
@@ -111,6 +112,7 @@ async function requestWithRetry(embedder, input, signal) {
       response = await fetch(`${embedder.baseURL}/embeddings`, {
         method: "POST",
         headers: {
+          ...withUserAgent(), // 产品标识头（embedding 无定制头字段——PROVIDER.md §6.17）
           "Content-Type": "application/json",
           Authorization: `Bearer ${embedder.apiKey}`,
         },

package/explore-distill.mjs

@@ -103,7 +103,7 @@ async function distillExplorations(history, start, provider, signal, agent, dept
       logCtx: {
         stage: "distill", child: agent?._logId ?? null, kind: "distill",
         role: agent?._role ?? null, depth: depth ?? null,
-        session: agent?._sessionStart ?? null, cwd: agent?.cwd ?? process.cwd(),
+        session: agent?._sessionStart ?? null, cwd: agent?.cwd,
         traces: agent?.config?.traces?.enabled !== false,
       },
     })

package/generate-title.mjs

@@ -9,6 +9,7 @@
  */
 
 import { proxyFetch } from "./proxy.mjs"
+import { withUserAgent } from "./client-identity.mjs"
 import { resolveProviderSecrets } from "./env-ref.mjs"
 // D7（2026-09-21 块标题行对齐批——标题链单源）：首条真实 user 消息谓词收核单源
 // （`isRealUserMsg`——纯函数零依赖，无环）。
@@ -97,8 +98,8 @@ export async function generateTitle(userContent, provider) {
       body = JSON.stringify(bodyObj)
       extract = (data) => data.choices?.[0]?.message?.content
     }
-    // 定制头展开（PROVIDER.md §6.17）——定制头在前、内置头在后：内置头胜出；三格式各自内置头。
-    const headers = { ...(provider.headers ?? {}), "Content-Type": "application/json" }
+    // 定制头 + 产品标识头（UA 不可被渠道覆盖——PROVIDER.md §6.17）——定制头在前、内置头在后：内置头胜出；三格式各自内置头。
+    const headers = { ...withUserAgent(provider.headers), "Content-Type": "application/json" }
     if (provider.format === "anthropic") {
       headers["x-api-key"] = provider.apiKey
       headers["anthropic-version"] = "2023-06-01"

package/i18n.mjs

@@ -43,7 +43,7 @@ export const CORE_MESSAGES = Object.freeze({
   "digest.capStop": { en: "[auto-turn stopped at ${turns} turns — partial digest; finished reports stay in history]", zh: "自动回合在 ${turns} 轮处停止——部分消化；已完成的报告保留在历史中" },
   // 消化账务批 · 2026-10-05 · 台账 #930（§6.31.6 端面残余行——判据 = `unsettledCount(carrier)`；
   // 消费面 = CLI 痕行 ∥ 桌面 / VSC 行元素；三端共读本键）
-  "digest.residue": { en: "${n} background report(s) not accounted — they will be re-delivered", zh: "有 ${n} 份后台报告未销账——将自动重投" },
+  "digest.residue": { en: "${n} background report(s) not accounted — no automatic re-delivery; escalates to UNSETTLED", zh: "有 ${n} 份后台报告未销账——不再自动重投，未签收满额即升级 UNSETTLED" },
   // ── 限流 / 供应商状态行 ──
   "status.rateWait": { en: "TPM throttle wait ~${s}s", zh: "TPM 限流等待 ~${s}s" },
   "status.rateLimited": { en: "Rate-limited 429, retry in ${s}s", zh: "限流 429，${s}s 后重试" },

package/index-discover.mjs

@@ -16,6 +16,10 @@
 import { readdirSync } from "node:fs"
 import { join, relative } from "node:path"
 import { DEFAULT_DECLARATION, loadProjectDeclaration } from "./conventions.mjs"
+// 排除名单单源（零依赖叶档 `skip-dirs.mjs`——2026-10-27 四份名单合一）：本档不再持本地副本，
+// 同名再导出保既有 import 面（`SKIP_DIRS` 的旧消费面零改）。
+import { SKIP_DIRS } from "./skip-dirs.mjs"
+export { SKIP_DIRS } from "./skip-dirs.mjs"
 
 const CODE_EXTS = new Set([
   ".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx", ".py", ".rs", ".go", ".java", ".c", ".cpp", ".h", ".hpp",
@@ -25,7 +29,6 @@ const CODE_EXTS = new Set([
   ".scala", ".pl", ".pm", ".r", ".jl", ".zig", ".groovy", ".ps1", ".proto", ".graphql", ".tf", ".hcl",
 ])
 const DOC_EXTS = new Set([".md", ".markdown", ".txt", ".rst", ".adoc", ".mdx", ".org", ".wiki", ".tex"])
-export const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".turbo", "coverage", "__pycache__", ".next"])
 
 /** Lower-cased ".ext" of a path/name ("" when it has no extension). */
 function extensionOf(p) {

package/ledger-close-proof.mjs

@@ -0,0 +1,62 @@
+/**
+ * ledger-close-proof.mjs — 台账核销机检单源（F-LX4 · 2026-10-26 批 §2；台账 #1807）。
+ *
+ * 判据（需求档 §② 功能点 11 / AC-M2-34）：凡写 `已核销` 的语句，写库前判三件——① 行的 `task_book`
+ * 所指批档在盘 ② 该档 §1 状态行 = `已收口` ③ 该批档的 `§3` 状态行 = `评审通过`；缺一即拒、
+ * **一次报全缺项**、行零改。**判据只有目标值一条**——闸挂在写这个值的两处逐行共函数
+ * （`ledger-cmd.mjs` 的 `applyRowUpdate` / `applyRowClose`）之前，不判来源态。
+ *
+ * ③ 为什么能去运行态（2026-10-27 三链统一批 · R6）：`§3` 只能由**绑在该档上的评审实例**写
+ * （`batch` 工具的 review 绑定），所以「§3 有 pass」本身就证明了「有一次绑本档的评审跑过并给了 pass」，
+ * 与 token 槽归属同义，而且换会话、重启进程、隔天补账都成立。旧判据（槽内有归属）在需要「换会话核销」
+ * 时给出假拒——它判的是**谁在跑**，不是**评审过没过**。
+ * 代价：评审自报 pass 的信任面不变（今天也是评审自己写 §3）。
+ *
+ * 住本档的理由（拆分件——先例 = `ledger-tools.mjs` 自 `ledger-cmd.mjs` 拆出）：`ledger-cmd.mjs` 收尾
+ * 446 行，机检本体 + 三形拒因入册即越单档 500 顾问线（设计 §五「实落超 500 ⇒ 主动拆分」）。两枚指针
+ * 值谓词（`filePartOf`——设计档 §6.1 口径 1 单源 ∥ `namesPointer`）随迁本档，`ledger-cmd` 反向 import
+ * 取用——方向单向、无静态环。
+ *
+ * 只读：三件都只读档面与行值，不读任何 token 槽状态（`_engDesignTokens` / `unionBatches` 不入本档）。
+ */
+import { readFileSync } from "node:fs"
+
+import { resolveDeclaredRef } from "./declaration.mjs"
+import { isBatchRecord, readBatchStatusLine, readSectionStatusWord, STATUS_WORDS } from "./agent-tools/batch-skeleton.mjs"
+
+/** 指针 ∥ 批档值 → 文件部分（首个 `§` 前子串，trim——设计档 §6.1 口径 1 单源；`task_book` 与
+ *  `batch` 同形同口径）。 */
+export const filePartOf = (v) => (v == null ? "" : String(v).split("§")[0].trim())
+
+/** 本笔指名谓词（设计档 §6.1 口径 3）：显式空值（`null` / 空串 / 全空白） ≡ **未指名**——臂② 不触。 */
+export const namesPointer = (v) => v != null && String(v).trim() !== ""
+
+/** 核销机检（F-LX4 · 需求档 §② 功能点 11 / AC-M2-34）：写 `已核销` 前判三件——① `task_book` 所指档在盘
+ *  ② 该档 §1 = `已收口` ③ 该档 §3 = `评审通过`；**判据只有目标值一条**（两处写这个值的 SQL 之前同挂），
+ *  三件各判、**一次报全缺项**、行零改（只判不写；2026-10-27 起 ③ = 档面事实，零运行态）。 */
+export function assertCloseOutProof(fnName, { base, row }) {
+  const missing = [] // 每项 = 一条拒因行（首字 = 缺项号）
+  let abs = null
+  if (!namesPointer(row?.task_book)) {
+    missing.push("  ① 行无 task_book 指针：核销须先挂批档（update 写 task_book），再跑全链")
+  } else {
+    const hit = resolveDeclaredRef(base, filePartOf(row.task_book))
+    if (!hit.ok) missing.push(`  ① 批档不在盘（task_book = ${row.task_book}）：先补指针，或恢复该档`)
+    else {
+      abs = hit.abs
+      const src = readFileSync(abs, "utf8")
+      if (!isBatchRecord(src)) missing.push(`  ② 指针所指档不是批档（${abs} 无 §1 段）：先把 task_book 改指批档`)
+      else {
+        const state = readBatchStatusLine(src)
+        if (state !== "closed") missing.push(`  ② 批档未收口（${abs} §1 = ${state}）：该批须先跑全链收口`)
+        else {
+          const s3 = readSectionStatusWord(src, 3)
+          if (s3 !== STATUS_WORDS[3].done) {
+            missing.push(`  ③ 批档 §3 未通过评审（§3 状态行 = ${s3 ?? "（无状态行）"}，须 = 评审通过）：重开该档补评审结论，或另起批次`)
+          }
+        }
+      }
+    }
+  }
+  if (missing.length > 0) throw new Error(`${fnName}：核销机检未过（行 ${row?.id} 零改）——缺：${missing.map((t) => t.trim()[0]).join(" ")}\n${missing.join("\n")}`)
+}

package/ledger-cmd.mjs

@@ -1,29 +1,37 @@
 /**
  * ledger-cmd.mjs — 台账核心函数档（查询 = 只读全角色 / 写 = 仅主 agent 装配）。
  * 工具定义 + 工具层参数守卫 = 拆分件 `thincoder-core/ledger-tools.mjs`（2026-09-28 守卫族微修批 ·
- * 台账 #473——纯搬移、语义零变；拆分触发 = 本档 298 行贴 300 顾问线，本批读面守卫增量必越线）；
- * 核函数（`ledgerQuery` / `ledgerCount` / `ledgerAdd` / `ledgerUpdate` / `ledgerClose` + 批级批量
- *  `ledgerUpdateBatch` / `ledgerCloseBatch`）留本档，工具档消费之。
+ * 台账 #473——纯搬移、语义零变）；逐行写核 + 两个批级写点 = 拆分件 `thincoder-core/ledger-write-ops.mjs`
+ * （2026-10-27 三链统一批——本档收尾 455 行，新增两枚批级写点会越 500 顾问线，故外提；本档反向 import
+ * 取用并 re-export，公共面逐字不变）。核函数（`ledgerQuery` / `ledgerCount` / `ledgerAdd` /
+ * `ledgerUpdate` / `ledgerClose` + 批级批量 `ledgerUpdateBatch` / `ledgerCloseBatch` + 重锚单源
+ * `ledgerReanchorBatch`）留本档，工具档消费之；`ledgerBindBatch` / `ledgerReclaimBatch` 由本档
+ * re-export（设计档 §2.4 / §2.13 的公共面落点不变）。
  *
- * 读数面（逐行携、不入库、不入 `DATA_COLUMNS`——先例 = `aged`）：`evidenceOversize`（§5 P4）∥
+ * 读数面（逐行携、不入库、不入 `DATA_COLUMNS`——先例 = `aged`）：`evidenceTooLong`（§5 P4 文字太长）∥
  * `overdue`（§3.7 出口态——机判单源 `overdueOf`）∥ `taskBookOnDisk`（§7.1 B——指针在盘读数）。
  * 三枚皆**读数非闸门**（不拒任何写入）。
  * 指针判据重锚面（§6.1 两臂写门 ∥ §6.2 收口重锚 · 台账 #1550）：写门判**本笔写入面**、只判本笔新指名；
  * 「档此刻在不在盘」降为读数——读面导出 `ledgerBatchRows`、收口重锚单源 `ledgerReanchorBatch`。
  * 批量面（§3.3 P1）：选行单源 `resolveBatchRows` + 逐行落笔 `applyRowUpdate` / `applyRowClose`
  * （与单行形共函数——迁移表判 / 写门 / evidence 门逐行照判）。
- * 核销标记门（LIGHT-CHANNEL.md §2.5 · 台账 #1780）：写入 `已核销` 的三径（close 单行 ∥ close 批量 ∥
- *  update 迁移——均经两逐行共函数）判**结果行标题**携 `ROUND_MARKER` ⇒ 拒；判据只认标题标记
- * （不查批档 ∥ 不查评审实跑），撤回（→ 已废弃）不拦。
+ * 核销机检（F-LX4 · 2026-10-26 批 §2；2026-10-27 改判 ③ = 档面）：同一两逐行共函数在写 `已核销` 前判
+ * 三件（批档在盘 ∥ §1 = 已收口 ∥ §3 = 评审通过），缺一即拒、一次报全缺项、行零改；判据只有目标值一条。
+ * 本体住拆分件 `ledger-close-proof.mjs`（同 `ledger-tools.mjs` 先例）。
  *
  * 接线（设计档 §2.2 命令面接线）：族出口 = `ledger.mjs`（re-export 两源——KD-M2-3）；查询命令 ←
  * tools/index.mjs（assembleBuiltinTools 全角色面）；写命令 ← agent/family-tools.mjs（assembleFamilyTools
  * 的 depthOnly 分支）——一律**动态 import** 本模块链（ledger-db.mjs 静态 import node:sqlite ⇒
  * 消费侧静态 import 会破 W8 契约②）。
  */
-import { resolve } from "node:path"
-import { AGING_DAYS, ALLOWED_MIGRATIONS, EVIDENCE_SOFT_LIMIT, nowIso, openLedger, PENDING_STATUSES, resolveLedgerRoot, ROUND_MARKER } from "./ledger-db.mjs"
+import { AGING_DAYS, EVIDENCE_TOO_LONG_MAX, PENDING_STATUSES, nowIso, openLedger, resolveLedgerRoot } from "./ledger-db.mjs"
 import { resolveDeclaredRef } from "./declaration.mjs"
+import { filePartOf, namesPointer } from "./ledger-close-proof.mjs"
+import {
+  applyRowClose, applyRowUpdate, assertBatchArg, assertTaskBookGate, baseOf, evidenceValue, resolveBatchRows,
+} from "./ledger-write-ops.mjs"
+
+export { ledgerBindBatch, ledgerReclaimBatch } from "./ledger-write-ops.mjs"
 
 /** 逐行老化判真（LEDGER.md §13.4 · 2026-10-07 批 ledger-tool）：未决四态（`PENDING_STATUSES`）∧
  *  行龄 > `AGING_DAYS` 天；行龄源 = `updated_at ?? created_at`（§5 同源）；时间戳缺 / 不可解析
@@ -36,17 +44,9 @@ function isRowAged(row, now) {
   return Number.isFinite(ms) && (now - ms) / 86400000 > AGING_DAYS
 }
 
-/** 指针 ∥ 批档值 → 文件部分（首个 `§` 前子串，trim——设计档 §6.1 口径 1 单源；`task_book` 与
- *  `batch` 同形同口径）。 */
-const filePartOf = (v) => (v == null ? "" : String(v).split("§")[0].trim())
-
-/** 解析基准（设计档 §6.1 口径 2 同一子表达式——与台账库键同源）：`resolveLedgerRoot(cwd, boundary)?.root
- *  ?? resolve(cwd ?? ".")`。`boundary` = 会话锚（与 `openLedger` 同一枚上界——同一笔动作的判据不能两界）。 */
-const baseOf = (cwd, boundary) => resolveLedgerRoot(cwd, boundary)?.root ?? resolve(cwd ?? ".")
-
-/** `evidence` 超限读数（设计档 §5 P4——**读数非闸门**）：缺 / 空 ⇒ false；`query` 逐行携（含归档行——
- *  行值事实）；`count` 的统计集 = 未决四态（§7.1）。 */
-const isEvidenceOversize = (row) => row?.evidence != null && String(row.evidence).length > EVIDENCE_SOFT_LIMIT
+/** `evidence` 文字太长读数（设计档 §5 P4——**读数非闸门**）：缺 / 空 ⇒ false；`query` 逐行携（含归档
+ *  行——行值事实）；`count` 的统计集 = 未决四态（§7.1）。 */
+const isEvidenceTooLong = (row) => row?.evidence != null && String(row.evidence).length > EVIDENCE_TOO_LONG_MAX
 
 /** 本地日界（`YYYY-MM-DD`）——`resume_due` 比较粒度（设计档 §3.7：本地日界，当日锚当日即到期）。 */
 const localDay = (ms) => { const d = new Date(ms); const p = (n) => String(n).padStart(2, "0"); return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}` }
@@ -73,7 +73,7 @@ const pointerOnDisk = (row, base) => { const part = filePartOf(row?.task_book);
  *  四类出口态**首中优先**（序 = `resume_due` → `dangling` → `unlabeled` → `aged`）；返回出口态字串
  *  ∥ `null`。`unlabeled`（`trigger IS NULL` ∧ 超龄）⊆ `aged` ⇒ 必先于 `aged` 判（否则永不返回）。
  *  `resume_due` 比较粒度 = 本地日界（锚日 ≤ 当地日 ⇒ 到期；不按时刻比）。 */
-export function overdueOf(row, { now = Date.now(), base = process.cwd() } = {}) {
+export function overdueOf(row, { now = Date.now(), base } = {}) {
   if (!PENDING_STATUSES.includes(row?.status)) return null
   if (row.trigger === "条件") {
     const anchor = resumeAnchor(row.resume_when)
@@ -88,7 +88,7 @@ export function overdueOf(row, { now = Date.now(), base = process.cwd() } = {})
 /** 查询（只读，全角色）：SELECT 行集（status / kind / board / trigger / task_book 等值过滤并取，缺省 =
  *  全部行；id 升序）。库不在 = 空账。只读开库（readOnly 句柄 + 零 DDL/ALTER——read-data-interface 批
  *  FR2③）；库档非台账库 ⇒ 空账。逐行携计算字段（均不入库、不入导出白名单 `DATA_COLUMNS`）：
- *  `aged`（§13.4）∥ `evidenceOversize`（§5 P4 超限读数）∥ `taskBookOnDisk`（§7.1 B 在盘读数）∥ `overdue`
+ *  `aged`（§13.4）∥ `evidenceTooLong`（§5 P4 文字太长读数）∥ `taskBookOnDisk`（§7.1 B 在盘读数）∥ `overdue`
  *  （§3.7 出口态字串 ∥ null——机判单源 `overdueOf`）；`task_book` = 第 5 枚等值过滤（**原值等值**——列串直比，与 §3.3 选行的
  *  「文件部分解析同址」两径口径不同、各自单源）；`trigger` 过滤仅三枚举等值（`NULL` 不过滤）；
  *  `now` = 注入缝（确定性用例）。 */
@@ -104,62 +104,36 @@ export function ledgerQuery({ cwd, boundary, status = null, kind = null, board =
     if (task_book) { where.push("task_book = ?"); args.push(task_book) }
     const rows = db.prepare(`SELECT * FROM items${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY id`).all(...args)
     const base = baseOf(cwd, boundary)
-    return rows.map((r) => ({ ...r, aged: isRowAged(r, now), evidenceOversize: isEvidenceOversize(r), taskBookOnDisk: pointerOnDisk(r, base), overdue: overdueOf(r, { now, base }) }))
+    return rows.map((r) => ({ ...r, aged: isRowAged(r, now), evidenceTooLong: isEvidenceTooLong(r), taskBookOnDisk: pointerOnDisk(r, base), overdue: overdueOf(r, { now, base }) }))
   } finally { db.close() }
 }
 
-/** 计数单源（只读，全角色）：回报 `{ count, overdue, evidenceOversize }`（设计档 §7.1——原裸数出参
+/** 计数单源（只读，全角色）：回报 `{ count, overdue, evidenceTooLong }`（设计档 §7.1——原裸数出参
  *  改对象形，消费面同批改）。`count` = 未决四态行数；`overdue` = 其中命中出口态的行数（`overdueOf`
- *  机判单源）；`evidenceOversize` = 其中 `evidence` 超限行数（§5）。**一次 SELECT + 逐行判**——
- *  `evidenceOversize` 与 `overdue` 同一次遍历（零额外 IO；成本模型 = §7.2）；不设缓存（读数须反映
+ *  机判单源）；`evidenceTooLong` = 其中 `evidence` 文字太长的行数（§5）。**一次 SELECT + 逐行判**——
+ *  `evidenceTooLong` 与 `overdue` 同一次遍历（零额外 IO；成本模型 = §7.2）；不设缓存（读数须反映
  *  即时盘面）。库不在 = 三零。 */
 export function ledgerCount({ cwd, boundary, task_book = null } = {}) {
   const db = openLedger(cwd, { readOnly: true, boundary })
-  if (!db) return { count: 0, overdue: 0, evidenceOversize: 0 }
+  if (!db) return { count: 0, overdue: 0, evidenceTooLong: 0 }
   try {
     const where = [`status IN (${PENDING_STATUSES.map(() => "?").join(",")})`], args = [...PENDING_STATUSES]
     if (task_book) { where.push("task_book = ?"); args.push(task_book) }
     const rows = db.prepare(`SELECT * FROM items WHERE ${where.join(" AND ")}`).all(...args)
     const now = Date.now(), base = baseOf(cwd, boundary)
-    let overdue = 0, oversize = 0
+    let overdue = 0, tooLong = 0
     for (const r of rows) {
       if (overdueOf(r, { now, base }) !== null) overdue++
-      if (isEvidenceOversize(r)) oversize++
+      if (isEvidenceTooLong(r)) tooLong++
     }
-    return { count: rows.length, overdue, evidenceOversize: oversize }
+    return { count: rows.length, overdue, evidenceTooLong: tooLong }
   } finally { db.close() }
 }
 
-/** `evidence` 超限行数（设计档 §7.1 导出面——`count` 回报读数**同一单源**：本函数为其薄委托，
+/** `evidence` 文字太长的行数（设计档 §7.1 导出面——`count` 回报读数**同一单源**：本函数为其薄委托，
  *  不另立第二判定面）。 */
-export function ledgerEvidenceOversize({ cwd, boundary, task_book = null } = {}) {
-  return ledgerCount({ cwd, boundary, task_book }).evidenceOversize
-}
-
-/** 本笔指名谓词（设计档 §6.1 口径 3）：显式空值（`null` / 空串 / 全空白） ≡ **未指名**——臂② 不触。 */
-const namesPointer = (v) => v != null && String(v).trim() !== ""
-
-/** 写门·指针点名（设计档 §6.1 两臂 · AC-M2-10 ∥ AC-M2-29）：判**本笔写入面**——两臂之外零判。
- *  臂①（点名非空）：结果行 `status ∈ {在途, 待核销}` ∨ 结果行 `trigger = 归批` ⇒ `task_book` 非空
- *  （缺 / 空串 / 全空白 ⇒ 拒「必填」）；**不判在盘**（列值事实，不随盘面翻转——DDL 咬合 CHECK 为该半幅防线）。
- *  臂②（本笔新指名）：本笔新写 `task_book`（非空值）∥ 本笔新写 `trigger = 归批` ⇒ 绑定指针非空 ∧ 文件部分
- *  可解析 ∧ 解析出的档**在盘**（判定单源 = `resolveDeclaredRef`，零二写）。
- *  **「档此刻在不在盘」不入臂①**：批档可随时整体清理 ⇒ 当结果行判据则合法账务被拒、而出路正是被拒字段
- *  （死锁）；存量指针失效只体现为读数 `taskBookOnDisk = false`（§7.1）。
- *  判位 = 与迁移表判同层（落盘前）；文案前缀 = 调用函数名；基准 = §6.1 口径 2（根推导单源同子表达式）。
- *  @param {{status:string, trigger:string|null, taskBook:string|null, wroteTaskBook:boolean, wroteBatchTrigger:boolean}} face 本笔写入面
- */
-function assertTaskBookGate(cwd, fnName, face, boundary) {
-  const { status, trigger, taskBook, wroteTaskBook, wroteBatchTrigger } = face
-  if ((status === "在途" || status === "待核销" || trigger === "归批") && !namesPointer(taskBook)) {
-    throw new Error(`${fnName}：task_book 必填（在途 / 待核销 / 归批 须携任务书指针）`)
-  }
-  if (!wroteTaskBook && !wroteBatchTrigger) return // 臂② 之外零判：旧指针所指档已清不阻任何此类写入
-  const part = filePartOf(taskBook)
-  if (!part) throw new Error(`${fnName}：task_book 不可解析（缺文件部分）：${taskBook}`)
-  const base = baseOf(cwd, boundary) // §6.1 口径 2 同一子表达式（单源 = 本档 `baseOf`）
-  const { ok, abs } = resolveDeclaredRef(base, part)
-  if (!ok) throw new Error(`${fnName}：task_book 指向的档不存在：${taskBook}（解析 = ${abs}）`)
+export function ledgerEvidenceTooLong({ cwd, boundary, task_book = null } = {}) {
+  return ledgerCount({ cwd, boundary, task_book }).evidenceTooLong
 }
 
 /** 新增（写命令，仅主 agent）：INSERT——入待讨论（六态状态机入口）。`row.resume_when` 可空（§3.4）。 */
@@ -181,112 +155,30 @@ export function ledgerAdd({ cwd, row, boundary }) {
   } finally { db.close() }
 }
 
-/** executor 目标值计算（设计档 docs/core/design/LEDGER.md §3.1——判位在 ledgerUpdate 体内：迁移表判 → 本语义 → 写门 → UPDATE）。
- *  优先级 = patch 显式 > 自动语义（进边 = executorSessionId / 出边 = NULL）> 行现值兜底 > NULL。
- *  进边集（2026-10-07 批 ledger-tool 扩面——§13.3 / KD-LT1）：`待讨论 → 待设计`（批点火边）∥
- *  `待设计 → 在途`（实施入边）——两枚同式。 */
-function resolveExecutorTarget(row, to, patch, executorSessionId) {
-  if ((row.status === "待讨论" && to === "待设计") || (row.status === "待设计" && to === "在途")) {
-    return patch.executor ?? executorSessionId ?? row.executor ?? null
-  }
-  if (row.status === "在途" && (to === "待核销" || to === "已废弃")) {
-    return null // 出边自动语义压 patch——显式传 executor 也不复活
-  }
-  return patch.executor ?? row.executor ?? null
-}
-
-/** `evidence` 值计算（设计档 LEDGER.md §13.9——update / close 两函数同源一处落）：追加缺省（旧值非空 ⇒
- *  `旧 + "｜" + 新`——「｜」两侧零空格直接相接；旧空（`null` ∥ 空串 ∥ 全空白）⇒ 直写，零分隔符残留）；
- *  `evidenceReplace === true` 与值同传 ⇒ 整段替换（旧文零保留）；`evidence` 缺 / `null` ≡ 略去（零变）。
- *  拒面①（旗独传——无新文可算）判于本阶段（close 侧先于追认门）；核内旗判只认 `=== true`（类型严判在
- *  工具层）。两值逐字落行（不裁 / 不判内容）。 */
-function evidenceValue(fnName, oldValue, evidence, evidenceReplace) {
-  if (evidenceReplace === true && evidence == null) throw new Error(`${fnName}：evidenceReplace 须与 evidence 同传（缺新文）`)
-  if (evidence == null) return oldValue
-  const old = oldValue == null || String(oldValue).trim() === "" ? "" : String(oldValue)
-  return evidenceReplace === true || old === "" ? evidence : `${old}｜${evidence}`
-}
-
-/** 拒面②（新值全空白——追加 ∥ 覆盖两径同判）判点（§13.9 判序）：update 随值计算同拍 ∥ close 落
- *  追认门之后；`evidence` 未传（`null` / 略去）⇒ 不判。 */
-function assertEvidenceValue(fnName, evidence) {
-  if (evidence != null && String(evidence).trim() === "") throw new Error(`${fnName}：evidence 为空（非空字符串）`)
-}
-
-/** 单行落笔·update（**单行形 ∥ 批量形共函数**——设计档 §3.3「逐行语义单源」）：迁移表判 → 核销标记门
- *  （目标 = `已核销` ∧ 结果标题携标记 ⇒ 拒——判序 = LIGHT-CHANNEL.md §2.5）→ executor / evidence 值计算
- *  （含两拒面）→ 写门 → UPDATE（判序 = §13.9 逐字未变）。`to` = `patch.status ?? 行现态`
- *  ——批量形纯字段补丁（不携 `status`）时 `to === row.status` ⇒ 迁移表不判、`status` 零写（§3.3）。
- *  `resume_when` = 普通可空字段补丁（`patch.resume_when ?? 行值`——§3.4）。 */
-function applyRowUpdate(db, cwd, row, patch, executorSessionId, boundary) {
-  const to = patch.status ?? row.status
-  if (to !== row.status && !(ALLOWED_MIGRATIONS[row.status] ?? []).includes(to)) {
-    throw new Error(`ledgerUpdate：迁移 ${row.status} → ${to} 不在允许迁移表`)
-  }
-  // 核销标记门（LIGHT-CHANNEL.md §2.5）：判**结果标题**——一笔同携清标记 title + status=已核销 ⇒ 放行
-  if (to === "已核销" && String(patch.title ?? row.title ?? "").includes(ROUND_MARKER)) {
-    throw new Error(`ledgerUpdate：行标题仍携「${ROUND_MARKER}」——收尾链未跑完，不许核销（先跑收尾全链，再由父侧清标记）`)
-  }
-  const nextExecutor = resolveExecutorTarget(row, to, patch, executorSessionId)
-  const nextEvidence = evidenceValue("ledgerUpdate", row.evidence, patch.evidence, patch.evidenceReplace)
-  assertEvidenceValue("ledgerUpdate", patch.evidence)
-  const nextTaskBook = patch.task_book ?? row.task_book
-  assertTaskBookGate(cwd, "ledgerUpdate", {
-    status: to,
-    trigger: patch.trigger ?? row.trigger,
-    taskBook: nextTaskBook,
-    wroteTaskBook: namesPointer(patch.task_book),
-    wroteBatchTrigger: patch.trigger === "归批",
-  }, boundary) // → 写门 → UPDATE
-  const now = nowIso()
-  db.prepare(`UPDATE items SET status = ?, title = ?, board = ?, req_doc = ?, task_book = ?, evidence = ?, trigger = ?, resume_when = ?, executor = ?, updated_at = ? WHERE id = ?`)
-    .run(to, patch.title ?? row.title, patch.board ?? row.board, patch.req_doc ?? row.req_doc, nextTaskBook, nextEvidence, patch.trigger ?? row.trigger, patch.resume_when ?? row.resume_when, nextExecutor, now, row.id)
-  return { id: Number(row.id), status: to }
-}
-
 /** 更新（写命令，仅主 agent）：UPDATE——状态迁移前判允许迁移表（不在表内 → 拒，行不变）。
  *  executor 目标值随同一 UPDATE 落列（LEDGER.md §3.1）；executorSessionId = 调用会话（函数参数注入——K-LX1
  *  纯函数可测；工具层动态 import getSessionId() 供值，零新静态边）。
  *  `evidence` 传值 = 追加缺省、`patch.evidenceReplace` = 布尔覆盖旗（§13.9——值计算 / 两拒面 = `evidenceValue`
- *  / `assertEvidenceValue`；判位 = 本语义段，随 executor 目标值同拍）。**单行形**（`id`）——逐行落笔 = `applyRowUpdate`。 */
-export function ledgerUpdate({ cwd, id, patch, executorSessionId, boundary }) {
+ *  / `assertEvidenceValue`；判位 = 本语义段，随 executor 目标值同拍）。**单行形**（`id`）——逐行落笔 =
+ *  `applyRowUpdate`（自开事务：半途抛 ⇒ 行零改）。 */
+export function ledgerUpdate({ cwd, id, patch, executorSessionId, boundary, agent }) {
   const db = openLedger(cwd, { create: true, boundary })
   try {
     const row = db.prepare("SELECT * FROM items WHERE id = ?").get(id)
     if (!row) throw new Error(`ledgerUpdate：行 ${id} 不存在`)
-    const { id: rowId } = applyRowUpdate(db, cwd, row, patch, executorSessionId, boundary)
+    const { id: rowId } = applyRowUpdate(db, cwd, row, patch, executorSessionId, boundary, { agent, base: baseOf(cwd, boundary) })
     return { id: rowId }
   } finally { db.close() }
 }
 
-/** 单行落笔·close（**单行形 ∥ 批量形共函数**——设计档 §3.3「逐行语义单源」）：源态判（核销仅三源——
- *  在途不可跳）→ 核销标记门（LIGHT-CHANNEL.md §2.5——`已核销` ∧ 标题携标记 ⇒ 拒；撤回不拦）→
- *  值计算（拒面① 旗独传判于此）→ 追认口 `evidence` 门 → 拒面② → UPDATE。
- *  撤回（任意态 → 已废弃——含在途直撤）同步 `executor = NULL`（LEDGER.md §3.1 ④）；核销两源（勾销 /
- *  追认）`executor` 零触碰（非在途出边）。 */
-function applyRowClose(db, row, status, evidence, evidenceReplace) {
-  if (status === "已核销" && !["待讨论", "待设计", "待核销"].includes(row.status)) throw new Error(`ledgerClose：核销仅限 待讨论 / 待设计 / 待核销（现态 ${row.status}）`)
-  // 核销标记门（LIGHT-CHANNEL.md §2.5）：勾销 ∥ 追认同判；撤回（→ 已废弃）不入本门
-  if (status === "已核销" && String(row.title ?? "").includes(ROUND_MARKER)) {
-    throw new Error(`ledgerClose：行标题仍携「${ROUND_MARKER}」——收尾链未跑完，不许核销（先跑收尾全链，再由父侧清标记）`)
-  }
-  const nextEvidence = evidenceValue("ledgerClose", row.evidence, evidence, evidenceReplace)
-  if (status === "已核销" && ["待讨论", "待设计"].includes(row.status) && (nextEvidence == null || String(nextEvidence).trim() === "")) throw new Error(`ledgerClose：追认核销须带 evidence（现态 ${row.status}）`)
-  assertEvidenceValue("ledgerClose", evidence) // 判序：拒面②（新值空白）落追认门之后 → UPDATE
-  const now = nowIso()
-  db.prepare("UPDATE items SET status = ?, closed_at = ?, updated_at = ?, executor = ?, evidence = ? WHERE id = ?").run(status, now, now, status === "已废弃" ? null : row.executor, nextEvidence, row.id)
-  return { id: Number(row.id), status }
-}
-
-/** 收口（写命令，仅主 agent）：核销两源（勾销：待核销 → 已核销；追认核销：待讨论 / 待设计 → 已核销，
- *  行 `evidence` 非空，缺 / 全空白 ⇒ 拒）/ 撤回（任意态 → 已废弃），事务包裹；归档 = 软删除。
+/** 收口（写命令，仅主 agent）：核销（**只有一条边**——`待核销 → 已核销`：其余现态一律拒，拒文点名现态 + 该现态
+ *  的出路句）/ 撤回（任意态 → 已废弃），事务包裹；归档 = 软删除。
  *  可选 `evidence` 参：传值 = 追加缺省（§13.9——旧空直写 / 旧非空拼 `旧｜新`）、`evidenceReplace: true`
- *  同传 = 整段替换；勾销 / 追认 / 撤回三径同携（写值落行，内容不判）；两拒面（旗独传 @值计算 ∥
- *  新值空白 @追认门后）见 `evidenceValue` / `assertEvidenceValue`。
- *  判序（同函数体同层，§13.9）：目标集判 → 行取 → 源态判 → 值计算 → 追认门（原样——判**结果值**缺 /
- *  全空白 ⇒ 拒，文案逐字不变）→ 拒面②（新值空白）→ UPDATE（LEDGER.md §3 收口两源）。**单行形**
- *  （`id`）——逐行落笔 = `applyRowClose`。 */
-export function ledgerClose({ cwd, id, status, evidence, evidenceReplace, boundary }) {
+ *  同传 = 整段替换；核销 / 撤回两径同携（写值落行，内容不判）；两拒面（旗独传 @值计算 ∥
+ *  新值空白 @值计算后）见 `evidenceValue` / `assertEvidenceValue`。
+ *  判序（同函数体同层，§13.9）：目标集判 → 行取 → 源态判 → **核销机检**（`已核销` 才触）→ 值计算 →
+ *  拒面②（新值空白）→ UPDATE（LEDGER.md §3 核销只有一条边）。**单行形**（`id`）——逐行落笔 = `applyRowClose`。 */
+export function ledgerClose({ cwd, id, status, evidence, evidenceReplace, boundary, agent }) {
   if (status !== "已核销" && status !== "已废弃") throw new Error(`ledgerClose：目标态 ${status} ∉ {已核销, 已废弃}`)
   const db = openLedger(cwd, { create: true, boundary })
   try {
@@ -294,7 +186,7 @@ export function ledgerClose({ cwd, id, status, evidence, evidenceReplace, bounda
     try {
       const row = db.prepare("SELECT * FROM items WHERE id = ?").get(id)
       if (!row) throw new Error(`ledgerClose：行 ${id} 不存在`)
-      const out = applyRowClose(db, row, status, evidence, evidenceReplace)
+      const out = applyRowClose(db, row, status, evidence, evidenceReplace, { agent, base: baseOf(cwd, boundary) })
       db.exec("COMMIT")
       return out
     } catch (e) { db.exec("ROLLBACK"); throw e }
@@ -303,43 +195,25 @@ export function ledgerClose({ cwd, id, status, evidence, evidenceReplace, bounda
 
 // ── 批级批量迁移与结算（设计档 §3.3 · P1 · AC-M2-26 ∥ AC-M2-27）────────────────
 
-/** `batch` 入参自身门（设计档 §3.3 · fail-closed）：值自身须**可解析**（含非空文件部分）∧ 解析后批档
- *  **在盘** ⇒ 否则拒（零写）。判的是**本笔指名**的那一笔——与 §6.1 臂② 同一律、不同字段（§6.2 归批
- *  门判结果行存在性 + 本笔新指名，本门判 `batch` 入参自身）。无匹配行 ⇒ 不拒（`applied = []`）。
- *  @returns {string} 批档绝对路径（解析基准 = `base`）
- */
-function assertBatchArg(fnName, base, batch) {
-  const part = filePartOf(batch)
-  const hit = part === "" ? { ok: false, abs: "" } : resolveDeclaredRef(base, part)
-  if (!hit.ok) throw new Error(`${fnName}：batch 不可解析或不在盘（${batch}）`)
-  return hit.abs
-}
-
-/** 批 → 行集（选行**单源** · 设计档 §3.3）：`task_book` 文件部分经 `resolveDeclaredRef` 解析为与批档
- *  **同一绝对路径**的行（任意状态、含归档态）。判据 = 解析同址而非串等值（同批档三种指针写法并存——
- *  无后缀 / `§2` / `§1.5（括注）`，串等值会漏行）。 */
-function resolveBatchRows(db, base, abs) {
-  return db.prepare("SELECT * FROM items ORDER BY id").all()
-    .filter((r) => { const part = filePartOf(r.task_book); return part !== "" && resolveDeclaredRef(base, part).abs === abs })
-}
-
 /** 批级批量迁移（设计档 §3.3）：`patch.status` 在场 ⇒ 逐行按既有迁移表重判；不在场 ⇒ **纯字段补丁**
  *  （`status` 零写、迁移表不判、`executor` 普通补丁语义——回执 `status` 键 = `null`）。
  *  **门拒 ≠ 事务失败**：逐行门（迁移表 / §6.1 写门 / evidence 门）抛错 ⇒ 本行捕获计入 `skipped`
  *  （`why` = 该门拒因文案原文），其余行照落；**事务级失败**（取写锁 / `COMMIT` 层）⇒ 整批 `ROLLBACK`
  *  并抛（零行改）——故「部分落地」只由逐行门拒产生，「中途失败」不留半批。
  *  `BEGIN IMMEDIATE`：写锁一次先把（逐行不升级锁 ⇒ 事务级失败在首行之前即失败）。
+ *  核销机检 ③ 自 2026-10-27 起读档面（不看 token 槽），本径不再预读归属并集——逐行照判、不缺不省。
  *  @returns {{batch: string, status: string|null, applied: number[], skipped: {id: number, from: string, why: string}[]}} */
-export function ledgerUpdateBatch({ cwd, batch, patch = {}, executorSessionId, boundary }) {
+export function ledgerUpdateBatch({ cwd, batch, patch = {}, executorSessionId, boundary, agent }) {
   const db = openLedger(cwd, { create: true, boundary })
   try {
     const base = baseOf(cwd, boundary)
     const abs = assertBatchArg("ledgerUpdate", base, batch)
+    const proof = { agent, base }
     db.exec("BEGIN IMMEDIATE")
     try {
       const applied = [], skipped = []
       for (const row of resolveBatchRows(db, base, abs)) {
-        try { applied.push(applyRowUpdate(db, cwd, row, patch, executorSessionId, boundary).id) }
+        try { applied.push(applyRowUpdate(db, cwd, row, patch, executorSessionId, boundary, proof, true).id) }
         catch (e) { skipped.push({ id: Number(row.id), from: row.status, why: String(e?.message ?? e) }) }
       }
       db.exec("COMMIT")
@@ -349,29 +223,30 @@ export function ledgerUpdateBatch({ cwd, batch, patch = {}, executorSessionId, b
 }
 
 /** 批级批量结算（设计档 §3.3）：**只销已到 `待核销` 的行**（勾销径）；`待讨论` / `待设计` ⇒ `skipped`
- *  逐行点名（**追认核销不入批量面**——追认须逐行结账依据，统一文本会造假账；转单行面），`在途` ⇒
+ *  逐行点名（**须先 `update` 到 `在途` 认领**——无核销边可走，统一文本会造假账），`在途` ⇒
  *  `skipped` 逐行点名（不可跳）。**归档态（`已核销` / `已废弃`）行 ⇒ 静默不计**（不入 `applied`、
  *  不入 `skipped`——归档行本非结算对象，点名会让每批重跑刷屏）。`evidence` 逐行追加同一文本
  *  （`evidenceValue` 同源）。回执 `status` 恒 `已核销`（批量形缺省 = 勾销单值；携则守卫已收窄为
  *  `{已核销}`——§3.2 `whenPresent`）。事务语义同 `ledgerUpdateBatch`。
  *  @returns {{batch: string, status: string, applied: number[], skipped: {id: number, from: string, why: string}[]}} */
-export function ledgerCloseBatch({ cwd, batch, evidence, evidenceReplace, boundary }) {
+export function ledgerCloseBatch({ cwd, batch, evidence, evidenceReplace, boundary, agent }) {
   const status = "已核销"
   const db = openLedger(cwd, { create: true, boundary })
   try {
     const base = baseOf(cwd, boundary)
     const abs = assertBatchArg("ledgerClose", base, batch)
+    const proof = { agent, base } // ③ 读档面（2026-10-27 起不再预读 token 槽归属）
     db.exec("BEGIN IMMEDIATE")
     try {
       const applied = [], skipped = []
       for (const row of resolveBatchRows(db, base, abs)) {
         if (row.status === "已核销" || row.status === "已废弃") continue // 归档态静默不计
         if (row.status !== "待核销") {
-          const why = row.status === "在途" ? "ledgerClose：在途不可跳（须先 待核销）" : "ledgerClose：追认核销不入批量面（转单行 close）"
+          const why = row.status === "在途" ? "ledgerClose：在途不可跳（须先 待核销）" : "ledgerClose：待认领不可核销（须先 update 到 在途）"
           skipped.push({ id: Number(row.id), from: row.status, why })
           continue
         }
-        try { applied.push(applyRowClose(db, row, status, evidence, evidenceReplace).id) }
+        try { applied.push(applyRowClose(db, row, status, evidence, evidenceReplace, proof).id) }
         catch (e) { skipped.push({ id: Number(row.id), from: row.status, why: String(e?.message ?? e) }) }
       }
       db.exec("COMMIT")
@@ -382,9 +257,6 @@ export function ledgerCloseBatch({ cwd, batch, evidence, evidenceReplace, bounda
 
 // ── 指针判据重锚面（设计档 §7.1 · B 读数 ∥ C 收口重锚 · 台账 #1550）────────────────
 
-/** 重锚取行集（设计档 §6.2——`待核销` 属已落只待结账，不取：对它写「须另起批次接手」失实，且核销零触指针）。 */
-const REANCHOR_STATUSES = ["待讨论", "待设计", "在途"]
-
 /** 本批行集（只读，任意状态——设计档 §7.1）：批身份单源 = `resolveBatchRows` 解析同址（零二写）；
  *  逐行携读数 `taskBookOnDisk`（不入库、不入 `DATA_COLUMNS`）。`batch` 不可解析 ∥ 无根 ⇒ 抛（同族
  *  `assertBatchArg` 形）；库不在 ⇒ 空集。`cwd` 口径 = 批档所属项目根（§6.2 `cwd` 基准——不用会话锚）；
@@ -401,14 +273,21 @@ export function ledgerBatchRows({ cwd, batch, boundary } = {}) {
   } finally { db.close() }
 }
 
-/** 收口重锚单源（写命令，主 agent 面——设计档 §6.2 · C · AC-M2-30）：取本批未落行（`REANCHOR_STATUSES`）→
- *  现值已 `条件` ⇒ 零写跳过（幂等）；`认账不排期` 零触（政策判断归行主人）→ 逐行改 `trigger = 条件` + 复启句
- *  （`原批 <批名> 已收口，须另起批次接手`）落 `resume_when`；该列现值非空（行主条件句在册）⇒ **不覆盖**、
- *  复句追加 `evidence`。单事务：任一步失败 ⇒ 整集 `ROLLBACK`（零行改）。**不抛**——失败经返回形 `failed`
- *  报出（`null` 常态）；`cwd` 无根 ⇒ 不取行、不重锚（**不落兜底基准**——落了就是静默零命中）。
- *  `updated_at` 零触（机器重锚不是人工推进的痕迹——行龄读数照旧）。
- *  `boundary` = 上溯上界（会话锚——与工具面 / `ledgerBatchRows` 同一枚界；缺省 = 进程 cwd）。
- *  @returns {{batch:string, reanchored:{id:number,status:string,title:string,sentenceTo:"resume_when"|"evidence"}[], alreadyAnchored:{id:number,status:string,title:string}[], failed:string|null}} */
+/**
+ * 收口重锚单源（写命令，主 agent 面——设计档 §6.2 · C · AC-M2-30；2026-10-27 按行状态分流 · §2.7）：
+ * 取本批行集 → **先行排除** `trigger = 认账不排期`（零触、不点名——政策判断归行主人）→ 按**行状态**分流：
+ *   · `在途`（本批的工作行，父侧没在收口前处置）⇒ `待核销`（做完待结账）+ `executor = NULL`（出边的自动
+ *     语义——同 §3.1），回执点名；
+ *   · `待讨论` / `待设计`（本批没动的行）⇒ `条件` + 复启句（`原批 <批名> 已收口，须另起批次接手`）落
+ *     `resume_when`；该列现值非空（行主条件句在册）⇒ **不覆盖**、复句追加 `evidence`；回执点名；
+ *   · `条件`（已在锚位）⇒ 零写跳过（幂等）；`待核销` / 归档态 ⇒ 不动、不点名（`alreadyAnchored` 承载
+ *     幂等跳过面，回执不噪）。
+ * 单事务：任一步失败 ⇒ 整集 `ROLLBACK`（零行改）。**不抛**——失败经返回形 `failed` 报出（`null` 常态）；
+ * `cwd` 无根 ⇒ 不取行、不重锚（**不落兜底基准**——落了就是静默零命中）。
+ * `updated_at` 零触（机器重锚不是人工推进的痕迹——行龄读数照旧）。
+ * `boundary` = 上溯上界（会话锚——与工具面 / `ledgerBatchRows` 同一枚界；缺省 = 进程 cwd）。
+ * @returns {{batch:string, reanchored:{id:number,status:string,title:string,to:"待核销"|"条件",sentenceTo?:"resume_when"|"evidence"}[], alreadyAnchored:{id:number,status:string,title:string}[], failed:string|null}}
+ */
 export function ledgerReanchorBatch({ cwd, batch, boundary } = {}) {
   const failedResult = (why) => ({ batch, reanchored: [], alreadyAnchored: [], failed: why })
   const derived = cwd == null ? null : resolveLedgerRoot(cwd, boundary)
@@ -425,15 +304,21 @@ export function ledgerReanchorBatch({ cwd, batch, boundary } = {}) {
       db.exec("BEGIN IMMEDIATE")
       const reanchored = [], alreadyAnchored = []
       for (const row of resolveBatchRows(db, base, abs)) {
-        if (!REANCHOR_STATUSES.includes(row.status)) continue
-        if (row.trigger === "认账不排期") continue
+        if (row.trigger === "认账不排期") continue // 先行排除：零触、不点名（§2.7）
         const face = { id: Number(row.id), status: row.status, title: row.title }
-        if (row.trigger === "条件") { alreadyAnchored.push(face); continue }
+        if (row.status === "在途") {
+          // 本批的工作行：做完待结账（出边自动语义——executor 清零，行离工作位）
+          db.prepare("UPDATE items SET status = ?, executor = NULL WHERE id = ?").run("待核销", row.id)
+          reanchored.push({ ...face, to: "待核销" })
+          continue
+        }
+        if (row.status !== "待讨论" && row.status !== "待设计") continue // 待核销 / 归档态：不动、不点名
+        if (row.trigger === "条件") { alreadyAnchored.push(face); continue } // 幂等零写
         const kept = row.resume_when != null && String(row.resume_when).trim() !== ""
         const nextEvidence = kept ? evidenceValue("ledgerReanchorBatch", row.evidence, sentence, false) : row.evidence
         db.prepare("UPDATE items SET trigger = ?, resume_when = ?, evidence = ? WHERE id = ?")
           .run("条件", kept ? row.resume_when : sentence, nextEvidence, row.id)
-        reanchored.push({ ...face, sentenceTo: kept ? "evidence" : "resume_when" })
+        reanchored.push({ ...face, to: "条件", sentenceTo: kept ? "evidence" : "resume_when" })
       }
       db.exec("COMMIT")
       return { batch, reanchored, alreadyAnchored, failed: null }