@thincoder/core 0.10.10 → 0.10.12

package/doc-check/index.mjs

@@ -2,7 +2,7 @@
  * doc-check/index.mjs — 文档纪律机检 · 引擎入口（两条判据 + 报面行）。
  *
  * 判据两条（起步 · 闭集——口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.20 条目 S）：
- *   ① 锚（档缺 / 节缺）——实现 = `./anchors.mjs`；② 行宽——口径 = §3.18 条目 Q，实现 = `./width.mjs`。
+ *   ① 锚（档缺 / 节缺）——实现 = `./anchors.mjs`；② 段判据（段太长 ∥ 行太长）——口径 = §3.18 条目 Q，实现 = `./paragraph.mjs`。
  * 判据参数 = **工具内置常量** `DOC_CHECK_BUILTINS`：不读任何项目的声明面，因而没有「缺参数 ⇒ 拒跑」这一层，
  *   也没有常量校验面——改判据 = 改代码、走评审。
  * 判定范围 = **调用方传入的文件清单**（判定范围 = 解析范围 = 传入的那几档；无目录遍历、无全域兜底）：
@@ -15,14 +15,15 @@
  */
 import { statSync } from "node:fs"
 import { relative, resolve } from "node:path"
-import { checkDocWidths } from "./width.mjs"
+import { checkParagraphs } from "./paragraph.mjs"
 import { checkAnchors } from "./anchors.mjs"
 
-/** 判据参数（内置常量 · 冻结）：阈值 300 字符；两项空列表 = 区带类 / 豁免类默认值且恒空
- *  ——豁免谓词（表行 / 围栏 / 可执行行 / 引文）住代码，没有「登记后放过」的写入口（空列表 ≠ 可登记豁免）。 */
+/** 判据参数（内置常量 · 冻结）：阈值 300 字符（一段 ∥ 一行同值——§3.18 ④）；两项空列表 = 区带类 / 豁免类默认值且恒空
+ *  ——豁免谓词（表行 / 围栏 / 列表项 / 引文）住代码，没有「登记后放过」的写入口（空列表 ≠ 可登记豁免）。 */
 export const DOC_CHECK_BUILTINS = Object.freeze({
-  lineWidth: 300,
-  widthExemptZones: Object.freeze([]),
+  paragraphMax: 300,
+  lineMax: 300,
+  paragraphExemptZones: Object.freeze([]),
   exemptions: Object.freeze([]),
 })
 
@@ -61,17 +62,20 @@ function resolveRange(base, docs) {
   return { check: check.sort(), undecidable, missing, notMarkdown, invalid }
 }
 
+/** 段判据命中行（报面单源——两类命中同形，按 `clazz` 分词）。 */
+const paragraphHitLine = (base, h) => `✗ ${h.clazz} ${rel(base, h.file)}:${h.line}（${h.len} 字符）`
+
 /** gate 报面（固定句形——§3.20「报面（固定句形 · 交付门 gate）」）：首行 verdict = 唯一机判串。 */
-function gateReport({ base, docsSource, checkFiles, skipped, anchors, widths, lineWidth }) {
-  const total = anchors.hits.length + widths.length
+function gateReport({ base, docsSource, checkFiles, skipped, anchors, paragraphs, paragraphMax }) {
+  const total = anchors.hits.length + paragraphs.length
   const src = docsSource === "session" ? "本会话写过的文档" : "显式 docs"
   const out = [
     total ? `DOC-CHECK GATE: REFUSED（命中 ${total} 条）` : (checkFiles.length ? "DOC-CHECK GATE: PASS" : "DOC-CHECK GATE: PASS（0 档）"),
     "文档纪律机检（交付门 · gate）",
     checkFiles.length
-      ? `范围：${src} ${checkFiles.length} 档 · 阈值 ${lineWidth} 字符（工具内置常量）`
-      : `范围：${src} —— **0 档受检**（空清单：本次没有判任何档，不得读作「已检」）· 阈值 ${lineWidth} 字符（工具内置常量）`,
-    "判据：工具内置常量（锚 ∥ 行宽）——判定范围 = 解析范围 = 传入档",
+      ? `范围：${src} ${checkFiles.length} 档 · 阈值 ${paragraphMax} 字符（工具内置常量）`
+      : `范围：${src} —— **0 档受检**（空清单：本次没有判任何档，不得读作「已检」）· 阈值 ${paragraphMax} 字符（工具内置常量）`,
+    "判据：工具内置常量（锚 ∥ 段判据）——判定范围 = 解析范围 = 传入档",
   ]
   if (skipped.missing.length) out.push(`跳过 ${skipped.missing.length} 档（已不在盘，未检）：${skipped.missing.map((p) => rel(base, p)).join(" ∥ ")}`)
   if (skipped.notMarkdown.length) out.push(`跳过 ${skipped.notMarkdown.length} 档（非 markdown 档，未检）：${skipped.notMarkdown.map((p) => rel(base, p)).join(" ∥ ")}`)
@@ -94,7 +98,7 @@ function gateReport({ base, docsSource, checkFiles, skipped, anchors, widths, li
         ? `✗ 锚·档缺 ${rel(base, h.file)}:${h.line} \`${h.token}\``
         : `✗ 锚·节缺 ${rel(base, h.file)}:${h.line} \`${h.token}\`（目标 ${rel(base, h.target)} 无 §${h.section}）`)
     }
-    for (const w of widths) out.push(`✗ 行宽 ${rel(base, w.file)}:${w.line}（${w.len} 字符）`)
+    for (const w of paragraphs) out.push(paragraphHitLine(base, w))
     out.push("处置：同轮修正后复跑（改文档 ∥ 修引擎）；不转台账；拿不准 ⇒ 上抛主 agent 裁决（主 agent 拿不准 ⇒ 转呈用户）")
   }
   return out.join("\n")
@@ -109,8 +113,8 @@ function gateReport({ base, docsSource, checkFiles, skipped, anchors, widths, li
  *   `PASS（0 档）` + 空范围说明（「本轮一档没碰」是真实读数）；`report` 面不可判档 ⇒ 报错、整次零判定；
  *   `gate` 面不可判档 ⇒ 跳过行；`docsSource` = 范围来源标签（`session` = 本会话触达记账 ∥ `explicit` = 显式
  *   `docs`）——缺省 = `explicit`；只影响报面措辞。
- * @returns {{report:string, hits:{total:number, anchors:number, width:number}, anchorHits:Array,
- *   widthHits:Array, files:string[], checkFiles:string[], lineWidth:number,
+ * @returns {{report:string, hits:{total:number, anchors:number, paragraph:number}, anchorHits:Array,
+ *   paragraphHits:Array, files:string[], checkFiles:string[], paragraphMax:number,
  *   skipped:{missing:string[], notMarkdown:string[]}}}
  *   消费面判「清」须读 `report` 首行（gate）∥ `hits.total`（report），不得只看其中一个。
  */
@@ -140,33 +144,33 @@ export function runDocCheck(root, { docs, mode = "report", docsSource } = {}) {
     throw new Error(`doc_check: docs names ${range.undecidable.length} document(s) that cannot be judged — no document was checked: ${named}. Fix the list and re-run; nothing is silently skipped and the check never widens beyond the list.`)
   }
   const checkFiles = range.check
-  const { lineWidth, widthExemptZones } = DOC_CHECK_BUILTINS
+  const { paragraphMax, lineMax, paragraphExemptZones } = DOC_CHECK_BUILTINS
   const anchors = checkAnchors(base, { files: checkFiles })
-  const widths = checkDocWidths({ lineWidth, exemptZones: widthExemptZones, files: checkFiles })
+  const paragraphs = checkParagraphs({ paragraphMax, lineMax, exemptZones: paragraphExemptZones, files: checkFiles })
 
-  const hits = { total: anchors.hits.length + widths.length, anchors: anchors.hits.length, width: widths.length }
+  const hits = { total: anchors.hits.length + paragraphs.length, anchors: anchors.hits.length, paragraph: paragraphs.length }
   const shared = {
-    hits, anchorHits: anchors.hits, widthHits: widths, files: checkFiles, checkFiles, lineWidth,
+    hits, anchorHits: anchors.hits, paragraphHits: paragraphs, files: checkFiles, checkFiles, paragraphMax,
     skipped: { missing: range.missing, notMarkdown: range.notMarkdown },
   }
   if (gate) {
-    return { ...shared, report: gateReport({ base, docsSource: source, checkFiles, skipped: shared.skipped, anchors, widths, lineWidth }) }
+    return { ...shared, report: gateReport({ base, docsSource: source, checkFiles, skipped: shared.skipped, anchors, paragraphs, paragraphMax }) }
   }
 
   const out = [
     "文档纪律机检（报告态 · 非门禁）",
-    `射程：${base} · 传入清单 ${checkFiles.length} 档 · 阈值 ${lineWidth} 字符（工具内置常量）· 区带豁免：${widthExemptZones.length ? widthExemptZones.join(" ∥ ") : "无"}`,
+    `射程：${base} · 传入清单 ${checkFiles.length} 档 · 阈值 ${paragraphMax} 字符（工具内置常量）· 区带豁免：${paragraphExemptZones.length ? paragraphExemptZones.join(" ∥ ") : "无"}`,
     "声明：判据参数 = 工具内置常量；范围 = 传入文件（判定范围 = 解析范围）",
     `范围：传入清单 ${checkFiles.length} 档（整档入判 · 判定范围 = 解析范围）`,
-    `命中 ${hits.total} 条（锚 ${anchors.hits.length} · 行宽 ${widths.length}）`,
+    `命中 ${hits.total} 条（锚 ${anchors.hits.length} · 段太长 ${paragraphs.filter((h) => h.clazz === "段太长").length} · 行太长 ${paragraphs.filter((h) => h.clazz === "行太长").length}）`,
   ]
   for (const h of anchors.hits) {
     out.push(h.clazz === "档缺"
       ? `✗ 锚·档缺 ${rel(base, h.file)}:${h.line} \`${h.token}\``
       : `✗ 锚·节缺 ${rel(base, h.file)}:${h.line} \`${h.token}\`（目标 ${rel(base, h.target)} 无 §${h.section}）`)
   }
-  for (const w of widths) out.push(`✗ 行宽 ${rel(base, w.file)}:${w.line}（${w.len} 字符）`)
-  out.push(hits.total ? `结论：${hits.total} 条命中——报告态，不作拒执行的理由` : "结论：0 条命中（锚 ∥ 行宽 均清）")
+  for (const w of paragraphs) out.push(paragraphHitLine(base, w))
+  out.push(hits.total ? `结论：${hits.total} 条命中——报告态，不作拒执行的理由` : "结论：0 条命中（锚 ∥ 段太长 ∥ 行太长 均清）")
 
   return { ...shared, report: out.join("\n") }
 }

package/doc-check/paragraph.mjs

@@ -0,0 +1,119 @@
+/**
+ * doc-check/paragraph.mjs — 文档纪律机检的产品档位（段判据谓词族 + 段判据——实现单源）。
+ *
+ * 口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.18 条目 Q（单位是段 / 面谓词 / 阈值 / 不分域）；
+ * 产品内建裁定 = 同档 §3.20 条目 S——谓词单源随迁：本仓 `scripts/doc-check-paragraph.mjs` 改述为
+ * **再出口缝**（薄档 · 零逻辑 · 逐名再出口），盘上不留第二份谓词实现。
+ * 两面切块：文档面量段（相邻非空正文行合并成一段，量段长）· 提示词面（`isPromptFace`）量行
+ * （逐行裸判，无结构豁免）。度量 = `[...line].length`（CJK 计 1——不引显示宽度 / 字体）；
+ * 阈值 = 调用方的内置常量（`DOC_CHECK_BUILTINS.paragraphMax` / `lineMax`）——不读声明面，也不扫目录：
+ * **判定集 = 调用方传入的文件清单**。
+ * 不计入段的行类（同时把段断开）= 空行 ∥ 表格行 ∥ 标题 ∥ 列表项 ∥ 引用行 ∥ 围栏（标记行与块内整行）
+ * ∥ 区带内：只认结构谓词，无行级白名单（按行号 / 注释声明的豁免不入判）；可执行行在段判据里**不豁免**
+ * （段 = 读者所见，码段渲染后仍在段内——§3.18 关键决策 ①）。
+ * 边界：本档零门禁 / 零退出码 / 零阻断——报告态由 `agent-tools/doc-check.mjs` 呈现。
+ */
+import { readFileSync } from "node:fs"
+
+/** 表格行谓词（markdown 表格行结构性不可折行——不计入段，与锚检查同源）。 */
+export const isTableRow = (l) => /^\s*\|.*\|\s*$/.test(String(l))
+
+/** 围栏标记（行首可选空白 + 三反引号 ∥ 三波浪号 ⇒ 标记字符；非围栏行 ⇒ null）——**单源**：
+ *  `isFenceLine` 与两处块扫描（本节段判据 ∥ `./anchors.mjs` 锚抽取）同取此式，使「同形围栏行止」只此一解
+ *  （同一模块内同符两义 = 单源可漂的结构口子）。 */
+export function fenceMark(l) {
+  const m = /^\s*(`{3,}|~{3,})/.exec(String(l))
+  return m ? m[1][0] : null
+}
+
+/** 围栏行谓词（单源 = `fenceMark`）——围栏行自身与块内整行均不计入段。 */
+export const isFenceLine = (l) => fenceMark(l) !== null
+
+/** 引文块行谓词（行首可选空白 + `>`）——连续 `>` 行整块不计入段（引证须逐字连续、不可折，同表行理据）。 */
+export const isQuoteLine = (l) => /^\s*>/.test(String(l))
+
+/** 列表项谓词（无序 `-` ∥ `*` ∥ `+` · 有序 `数字 + . ∥ ） ∥ 、` + 空白）——列表项不计入段且断段。 */
+export const isListItem = (l) => /^\s*(?:[-*+]|\d+[.)、])\s/.test(String(l))
+
+/** 提示词面谓词（`thincoder-core/prompts/**`——形态对齐 `./anchors.mjs` 的 `OPERAND_FACE`，单源住本档）：
+ *  模型读原始文本，一行就是一个块（FR46 同源理由）⇒ 该面逐行裸判，无结构豁免。 */
+export const isPromptFace = (abs) => /(?:^|\/)thincoder-core\/prompts\//i.test(String(abs).replace(/\\/g, "/"))
+
+/** 区带头谓词（§3.15 谓词面）：标题文本去首部编号（`^\d+(?:\.\d+)*[.、]?\s*`）后——等于区带名 ∨ 以
+ *  「区带名 + （∕(」起（容括注后缀，如 `变更记录（续）`）；闭集外一律不纳（fail-closed）。 */
+export function isZoneHead(headingText, zones = []) {
+  const text = String(headingText).replace(/^\d+(?:\.\d+)*[.、]?\s*/, "")
+  return zones.some((z) => typeof z === "string" && z !== "" && (text === z || text.startsWith(z + "（") || text.startsWith(z + "(")))
+}
+
+/** 行内可执行坐标（命令 / 搜索模式串码段）——锚判据整行跳过用（证据与命令保字面）；段判据不豁免（段 = 读者所见）。 */
+export function isExecutableLine(line) {
+  const l = String(line)
+  if (/`[^`\n]*&&[^`\n]*`/.test(l)) return true // 命令链（cd … && …）
+  if (/`[^`\n]*\b(?:cd|node|npm|npx|grep|rg|git)\s[^`\n]*`/.test(l)) return true // 码段内命令词
+  if (/`[^`\n]*(?:\[\^|\\\.|\(\?<|\(\?:|\{\d)/.test(l)) return true // 码段内搜索模式串片段
+  return false
+}
+
+/** 行内位置是否在反引号码段内（引述面不判）。 */
+export function inCodeSpan(line, idx) {
+  return (String(line).slice(0, idx).match(/`/g) ?? []).length % 2 === 1
+}
+
+/** 段判据（阈值 = 调用方内置常量 `paragraphMax` ∥ `lineMax`；口径逐字 = §3.18 条目 Q）：
+ *  · 文档面：相邻非空正文行合并成一段，段长 = 组成行 `[...line].length` 之和 > `paragraphMax` ⇔ 命中
+ *    （`clazz: "段太长"`，定位 = 段首行号）。正文行 = 非空 ∧ 非表格行 ∧ 非标题 ∧ 非列表项 ∧ 非引用行
+ *    ∧ 非围栏（标记行与块内整行）∧ 非区带内；其余行类不计入、且把段断开。
+ *  · 提示词面（`isPromptFace`）：逐行裸判——`[...line].length` > `lineMax` ⇔ 命中（`clazz: "行太长"`，
+ *    无结构豁免）。
+ *  单遍扫描携标题栈（`^(#{1,6})\s` 行入栈——同级 ∥ 更高级出栈）：行所属标题链任一为区带头 ⇒ 区带内
+ *  （不计入段且断段）。围栏未闭合 ⇒ 至档尾整块免（fail-open 方向——§3.18 残余登记 ①）；
+ *  `exemptZones` 缺省 ∥ 空集 ⇒ 零豁免。`files`（必填）= **判定集**（调用方传入的档清单——本档不遍历
+ *  任何目录；空集 ⇒ 零命中）。 */
+export function checkParagraphs({ paragraphMax, lineMax, exemptZones = [], files = [] } = {}) {
+  const zones = (Array.isArray(exemptZones) ? exemptZones : []).filter((z) => typeof z === "string" && z !== "")
+  const hits = []
+  for (const f of files) {
+    let text = ""
+    try { text = readFileSync(f, "utf8") } catch { continue }
+    if (isPromptFace(f)) {
+      text.split("\n").forEach((l, i) => {
+        const len = [...l].length
+        if (len > lineMax) hits.push({ file: f, line: i + 1, len, clazz: "行太长" })
+      })
+      continue
+    }
+    const stack = [] // 标题栈 —— { level, exempt }；exempt = 自身 ∥ 祖先命中区带
+    let fence = null // 围栏标记（` ∥ ~）；null = 不在块内
+    let para = null // 在写的段 —— { start, len }；非正文行 ⇒ 断开
+    const lines = text.split("\n")
+    const flush = () => {
+      if (para !== null && para.len > paragraphMax) hits.push({ file: f, line: para.start, len: para.len, clazz: "段太长" })
+      para = null
+    }
+    lines.forEach((l, i) => {
+      const mark = fenceMark(l)
+      if (mark !== null) {
+        if (fence === null) fence = mark
+        else if (mark === fence) fence = null
+        flush()
+        return // 围栏标记行自身断段
+      }
+      if (fence !== null) { flush(); return } // 块内整行断段（未闭合 ⇒ 至档尾免）
+      const hm = /^(#{1,6})\s+(.*)$/.exec(l)
+      if (hm) {
+        while (stack.length && stack[stack.length - 1].level >= hm[1].length) stack.pop()
+        const self = isZoneHead(hm[2].trim(), zones)
+        stack.push({ level: hm[1].length, exempt: self || (stack[stack.length - 1]?.exempt ?? false) })
+        flush()
+        return // 标题断段
+      }
+      const inZone = stack[stack.length - 1]?.exempt === true
+      if (inZone || l.trim() === "" || isTableRow(l) || isListItem(l) || isQuoteLine(l)) { flush(); return }
+      if (para === null) para = { start: i + 1, len: 0 }
+      para.len += [...l].length
+    })
+    flush()
+  }
+  return hits
+}

package/fts-text.mjs

@@ -30,7 +30,10 @@ export function segmentCJK(text) {
  * 无 token ⇒ 返回空串（消费侧据此退化——SESSION.md §6.19 边界情形表）。
  */
 export function buildFtsQuery(query) {
-  const terms = query
+  // 模型偶尔把 query 传成数组 / 对象（schema 声明是 string）：先按文本归一。
+  // 不归一的话 query.split 直接抛 TypeError，整个回合崩掉（GitHub #30）。
+  const text = Array.isArray(query) ? query.join(" ") : query == null ? "" : String(query)
+  const terms = text
     .split(/[\s,，。、;；!！?？()（）"`]+/)
     .map((t) => t.trim())
     .filter(Boolean)

package/ledger-cmd.mjs

@@ -12,6 +12,9 @@
  * 「档此刻在不在盘」降为读数——读面导出 `ledgerBatchRows`、收口重锚单源 `ledgerReanchorBatch`。
  * 批量面（§3.3 P1）：选行单源 `resolveBatchRows` + 逐行落笔 `applyRowUpdate` / `applyRowClose`
  * （与单行形共函数——迁移表判 / 写门 / evidence 门逐行照判）。
+ * 核销标记门（LIGHT-CHANNEL.md §2.5 · 台账 #1780）：写入 `已核销` 的三径（close 单行 ∥ close 批量 ∥
+ *  update 迁移——均经两逐行共函数）判**结果行标题**携 `ROUND_MARKER` ⇒ 拒；判据只认标题标记
+ * （不查批档 ∥ 不查评审实跑），撤回（→ 已废弃）不拦。
  *
  * 接线（设计档 §2.2 命令面接线）：族出口 = `ledger.mjs`（re-export 两源——KD-M2-3）；查询命令 ←
  * tools/index.mjs（assembleBuiltinTools 全角色面）；写命令 ← agent/family-tools.mjs（assembleFamilyTools
@@ -19,7 +22,7 @@
  * 消费侧静态 import 会破 W8 契约②）。
  */
 import { resolve } from "node:path"
-import { AGING_DAYS, ALLOWED_MIGRATIONS, EVIDENCE_SOFT_LIMIT, nowIso, openLedger, PENDING_STATUSES, resolveLedgerRoot } from "./ledger-db.mjs"
+import { AGING_DAYS, ALLOWED_MIGRATIONS, EVIDENCE_SOFT_LIMIT, nowIso, openLedger, PENDING_STATUSES, resolveLedgerRoot, ROUND_MARKER } from "./ledger-db.mjs"
 import { resolveDeclaredRef } from "./declaration.mjs"
 
 /** 逐行老化判真（LEDGER.md §13.4 · 2026-10-07 批 ledger-tool）：未决四态（`PENDING_STATUSES`）∧
@@ -37,9 +40,9 @@ function isRowAged(row, now) {
  *  `batch` 同形同口径）。 */
 const filePartOf = (v) => (v == null ? "" : String(v).split("§")[0].trim())
 
-/** 解析基准（设计档 §6.1 口径 2 同一子表达式——与台账库键同源）：`resolveLedgerRoot(cwd)?.root
- *  ?? resolve(cwd ?? ".")`。 */
-const baseOf = (cwd) => resolveLedgerRoot(cwd)?.root ?? resolve(cwd ?? ".")
+/** 解析基准（设计档 §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）。 */
@@ -89,8 +92,8 @@ export function overdueOf(row, { now = Date.now(), base = process.cwd() } = {})
  *  （§3.7 出口态字串 ∥ null——机判单源 `overdueOf`）；`task_book` = 第 5 枚等值过滤（**原值等值**——列串直比，与 §3.3 选行的
  *  「文件部分解析同址」两径口径不同、各自单源）；`trigger` 过滤仅三枚举等值（`NULL` 不过滤）；
  *  `now` = 注入缝（确定性用例）。 */
-export function ledgerQuery({ cwd, status = null, kind = null, board = null, trigger = null, task_book = null, now = Date.now() } = {}) {
-  const db = openLedger(cwd, { readOnly: true })
+export function ledgerQuery({ cwd, boundary, status = null, kind = null, board = null, trigger = null, task_book = null, now = Date.now() } = {}) {
+  const db = openLedger(cwd, { readOnly: true, boundary })
   if (!db) return []
   try {
     const where = [], args = []
@@ -100,7 +103,7 @@ export function ledgerQuery({ cwd, status = null, kind = null, board = null, tri
     if (trigger) { where.push("trigger = ?"); args.push(trigger) }
     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)
+    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 }) }))
   } finally { db.close() }
 }
@@ -110,14 +113,14 @@ export function ledgerQuery({ cwd, status = null, kind = null, board = null, tri
  *  机判单源）；`evidenceOversize` = 其中 `evidence` 超限行数（§5）。**一次 SELECT + 逐行判**——
  *  `evidenceOversize` 与 `overdue` 同一次遍历（零额外 IO；成本模型 = §7.2）；不设缓存（读数须反映
  *  即时盘面）。库不在 = 三零。 */
-export function ledgerCount({ cwd, task_book = null } = {}) {
-  const db = openLedger(cwd, { readOnly: true })
+export function ledgerCount({ cwd, boundary, task_book = null } = {}) {
+  const db = openLedger(cwd, { readOnly: true, boundary })
   if (!db) return { count: 0, overdue: 0, evidenceOversize: 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)
+    const now = Date.now(), base = baseOf(cwd, boundary)
     let overdue = 0, oversize = 0
     for (const r of rows) {
       if (overdueOf(r, { now, base }) !== null) overdue++
@@ -129,8 +132,8 @@ export function ledgerCount({ cwd, task_book = null } = {}) {
 
 /** `evidence` 超限行数（设计档 §7.1 导出面——`count` 回报读数**同一单源**：本函数为其薄委托，
  *  不另立第二判定面）。 */
-export function ledgerEvidenceOversize({ cwd, task_book = null } = {}) {
-  return ledgerCount({ cwd, task_book }).evidenceOversize
+export function ledgerEvidenceOversize({ cwd, boundary, task_book = null } = {}) {
+  return ledgerCount({ cwd, boundary, task_book }).evidenceOversize
 }
 
 /** 本笔指名谓词（设计档 §6.1 口径 3）：显式空值（`null` / 空串 / 全空白） ≡ **未指名**——臂② 不触。 */
@@ -146,7 +149,7 @@ const namesPointer = (v) => v != null && String(v).trim() !== ""
  *  判位 = 与迁移表判同层（落盘前）；文案前缀 = 调用函数名；基准 = §6.1 口径 2（根推导单源同子表达式）。
  *  @param {{status:string, trigger:string|null, taskBook:string|null, wroteTaskBook:boolean, wroteBatchTrigger:boolean}} face 本笔写入面
  */
-function assertTaskBookGate(cwd, fnName, 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 必填（在途 / 待核销 / 归批 须携任务书指针）`)
@@ -154,14 +157,14 @@ function assertTaskBookGate(cwd, fnName, face) {
   if (!wroteTaskBook && !wroteBatchTrigger) return // 臂② 之外零判：旧指针所指档已清不阻任何此类写入
   const part = filePartOf(taskBook)
   if (!part) throw new Error(`${fnName}：task_book 不可解析（缺文件部分）：${taskBook}`)
-  const base = baseOf(cwd) // §6.1 口径 2 同一子表达式（单源 = 本档 `baseOf`）
+  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}）`)
 }
 
 /** 新增（写命令，仅主 agent）：INSERT——入待讨论（六态状态机入口）。`row.resume_when` 可空（§3.4）。 */
-export function ledgerAdd({ cwd, row }) {
-  const db = openLedger(cwd, { create: true })
+export function ledgerAdd({ cwd, row, boundary }) {
+  const db = openLedger(cwd, { create: true, boundary })
   try {
     // 结果行状态 = INSERT 硬编码「待讨论」⇒ 臂① 的 `status` 半幅当下不触；`trigger=归批` 半幅与臂② 照判
     assertTaskBookGate(cwd, "ledgerAdd", {
@@ -170,7 +173,7 @@ export function ledgerAdd({ cwd, row }) {
       taskBook: row.task_book ?? null,
       wroteTaskBook: namesPointer(row.task_book),
       wroteBatchTrigger: row.trigger === "归批",
-    })
+    }, boundary)
     const now = nowIso()
     const r = db.prepare(`INSERT INTO items (kind, status, title, board, req_doc, task_book, evidence, trigger, resume_when, created_at, updated_at) VALUES (?, '待讨论', ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
       .run(row.kind, row.title, row.board ?? null, row.req_doc ?? null, row.task_book ?? null, row.evidence ?? null, row.trigger ?? null, row.resume_when ?? null, now, now)
@@ -210,15 +213,20 @@ function assertEvidenceValue(fnName, evidence) {
   if (evidence != null && String(evidence).trim() === "") throw new Error(`${fnName}：evidence 为空（非空字符串）`)
 }
 
-/** 单行落笔·update（**单行形 ∥ 批量形共函数**——设计档 §3.3「逐行语义单源」）：迁移表判 → executor /
- *  evidence 值计算（含两拒面）→ 写门 → UPDATE（判序 = §13.9 逐字未变）。`to` = `patch.status ?? 行现态`
+/** 单行落笔·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) {
+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)
@@ -229,7 +237,7 @@ function applyRowUpdate(db, cwd, row, patch, executorSessionId) {
     taskBook: nextTaskBook,
     wroteTaskBook: namesPointer(patch.task_book),
     wroteBatchTrigger: patch.trigger === "归批",
-  }) // → 写门 → UPDATE
+  }, 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)
@@ -241,22 +249,27 @@ function applyRowUpdate(db, cwd, row, patch, executorSessionId) {
  *  纯函数可测；工具层动态 import getSessionId() 供值，零新静态边）。
  *  `evidence` 传值 = 追加缺省、`patch.evidenceReplace` = 布尔覆盖旗（§13.9——值计算 / 两拒面 = `evidenceValue`
  *  / `assertEvidenceValue`；判位 = 本语义段，随 executor 目标值同拍）。**单行形**（`id`）——逐行落笔 = `applyRowUpdate`。 */
-export function ledgerUpdate({ cwd, id, patch, executorSessionId }) {
-  const db = openLedger(cwd, { create: true })
+export function ledgerUpdate({ cwd, id, patch, executorSessionId, boundary }) {
+  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)
+    const { id: rowId } = applyRowUpdate(db, cwd, row, patch, executorSessionId, boundary)
     return { id: rowId }
   } finally { db.close() }
 }
 
 /** 单行落笔·close（**单行形 ∥ 批量形共函数**——设计档 §3.3「逐行语义单源」）：源态判（核销仅三源——
- *  在途不可跳）→ 值计算（拒面① 旗独传判于此）→ 追认口 `evidence` 门 → 拒面② → UPDATE。
+ *  在途不可跳）→ 核销标记门（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
@@ -273,9 +286,9 @@ function applyRowClose(db, row, status, evidence, evidenceReplace) {
  *  判序（同函数体同层，§13.9）：目标集判 → 行取 → 源态判 → 值计算 → 追认门（原样——判**结果值**缺 /
  *  全空白 ⇒ 拒，文案逐字不变）→ 拒面②（新值空白）→ UPDATE（LEDGER.md §3 收口两源）。**单行形**
  *  （`id`）——逐行落笔 = `applyRowClose`。 */
-export function ledgerClose({ cwd, id, status, evidence, evidenceReplace }) {
+export function ledgerClose({ cwd, id, status, evidence, evidenceReplace, boundary }) {
   if (status !== "已核销" && status !== "已废弃") throw new Error(`ledgerClose：目标态 ${status} ∉ {已核销, 已废弃}`)
-  const db = openLedger(cwd, { create: true })
+  const db = openLedger(cwd, { create: true, boundary })
   try {
     db.exec("BEGIN")
     try {
@@ -317,16 +330,16 @@ function resolveBatchRows(db, base, abs) {
  *  并抛（零行改）——故「部分落地」只由逐行门拒产生，「中途失败」不留半批。
  *  `BEGIN IMMEDIATE`：写锁一次先把（逐行不升级锁 ⇒ 事务级失败在首行之前即失败）。
  *  @returns {{batch: string, status: string|null, applied: number[], skipped: {id: number, from: string, why: string}[]}} */
-export function ledgerUpdateBatch({ cwd, batch, patch = {}, executorSessionId }) {
-  const db = openLedger(cwd, { create: true })
+export function ledgerUpdateBatch({ cwd, batch, patch = {}, executorSessionId, boundary }) {
+  const db = openLedger(cwd, { create: true, boundary })
   try {
-    const base = baseOf(cwd)
+    const base = baseOf(cwd, boundary)
     const abs = assertBatchArg("ledgerUpdate", base, batch)
     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).id) }
+        try { applied.push(applyRowUpdate(db, cwd, row, patch, executorSessionId, boundary).id) }
         catch (e) { skipped.push({ id: Number(row.id), from: row.status, why: String(e?.message ?? e) }) }
       }
       db.exec("COMMIT")
@@ -342,11 +355,11 @@ export function ledgerUpdateBatch({ cwd, batch, patch = {}, executorSessionId })
  *  （`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 }) {
+export function ledgerCloseBatch({ cwd, batch, evidence, evidenceReplace, boundary }) {
   const status = "已核销"
-  const db = openLedger(cwd, { create: true })
+  const db = openLedger(cwd, { create: true, boundary })
   try {
-    const base = baseOf(cwd)
+    const base = baseOf(cwd, boundary)
     const abs = assertBatchArg("ledgerClose", base, batch)
     db.exec("BEGIN IMMEDIATE")
     try {
@@ -374,13 +387,14 @@ const REANCHOR_STATUSES = ["待讨论", "待设计", "在途"]
 
 /** 本批行集（只读，任意状态——设计档 §7.1）：批身份单源 = `resolveBatchRows` 解析同址（零二写）；
  *  逐行携读数 `taskBookOnDisk`（不入库、不入 `DATA_COLUMNS`）。`batch` 不可解析 ∥ 无根 ⇒ 抛（同族
- *  `assertBatchArg` 形）；库不在 ⇒ 空集。`cwd` 口径 = 批档所属项目根（§6.2 `cwd` 基准——不用会话锚）。 */
-export function ledgerBatchRows({ cwd, batch } = {}) {
-  const derived = cwd == null ? null : resolveLedgerRoot(cwd)
+ *  `assertBatchArg` 形）；库不在 ⇒ 空集。`cwd` 口径 = 批档所属项目根（§6.2 `cwd` 基准——不用会话锚）；
+ *  `boundary` = 上溯上界（会话锚——与工具面同一枚界；缺省 = 进程 cwd）。 */
+export function ledgerBatchRows({ cwd, batch, boundary } = {}) {
+  const derived = cwd == null ? null : resolveLedgerRoot(cwd, boundary)
   if (!derived) throw new Error(`ledgerBatchRows：批档所属项目根不可推导（${cwd ?? "（缺 cwd）"}）`)
   const base = derived.root
   const abs = assertBatchArg("ledgerBatchRows", base, batch) // 失败语义先于「库不在 ⇒ 空集」（不可解析就是不可解析）
-  const db = openLedger(base, { readOnly: true })
+  const db = openLedger(base, { readOnly: true, boundary })
   if (!db) return []
   try {
     return resolveBatchRows(db, base, abs).map((r) => ({ ...r, taskBookOnDisk: pointerOnDisk(r, base) }))
@@ -393,14 +407,15 @@ export function ledgerBatchRows({ cwd, batch } = {}) {
  *  复句追加 `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}} */
-export function ledgerReanchorBatch({ cwd, batch } = {}) {
+export function ledgerReanchorBatch({ cwd, batch, boundary } = {}) {
   const failedResult = (why) => ({ batch, reanchored: [], alreadyAnchored: [], failed: why })
-  const derived = cwd == null ? null : resolveLedgerRoot(cwd)
+  const derived = cwd == null ? null : resolveLedgerRoot(cwd, boundary)
   if (!derived) return failedResult("批档所属项目根不可推导")
   const base = derived.root
   let db
-  try { db = openLedger(base) } catch (e) { return failedResult(String(e?.message ?? e)) } // 库不可开 ⇒ 零写报因
+  try { db = openLedger(base, { boundary }) } catch (e) { return failedResult(String(e?.message ?? e)) } // 库不可开 ⇒ 零写报因
   if (!db) return { batch, reanchored: [], alreadyAnchored: [], failed: null } // 库不在 ⇒ 零行可锚
   try {
     let abs