@thincoder/core 0.10.11 → 0.10.12

package/agent-tools/design-token.mjs

@@ -13,6 +13,10 @@
 
 import { randomUUID } from "node:crypto"
 import { tokenExpiryMs } from "../token-ttl.mjs"
+// 批归属派生（DESIGN-TOKEN-SETTLEMENT §10）——判据与清点面同源（同一个 `lastIndexOf("batches")`）。
+// 本档 ⇄ `design-slots.mjs` 为**静态环**（对方取 `effectiveTokenTtlMs`）：两侧绑定只在函数体内
+// 运行时使用，求值期零顶层调用 ⇒ 环安全（与 token-ttl ⇄ session 同构）。
+import { batchAbsPath } from "./design-slots.mjs"
 
 /**
  * F2c/F2e (§29.1 2026-09-07): the engine-generated Approved suffix — ONE builder
@@ -120,8 +124,10 @@ const VERDICT_GATE_MARK = (reason) => `裁定非通过——token 未签发 (rev
  * IS the verdict — the advisor echoes it only on approval. On echo (full string
  * OR truncated — uuid present; §5.1①): slot the token under designId (always the
  * FULL token; + eng-coder gate flag; single-value mirror retired per
- * DESIGN-TOKEN-SETTLEMENT D3) and return the clean output with the Approved
- * suffix (truncated echo: the M2 marker sits before the suffix); the review
+ * DESIGN-TOKEN-SETTLEMENT D3), record its batch attribution (`_engDesignTokenBatches`
+ * — the reviewed doc-set's `batches/` file, §10 E1; no batch in the set ⇒ no
+ * attribution) and return the clean output with the
+ * Approved suffix (truncated echo: the M2 marker sits before the suffix); the review
  * instance CLOSES (a later review of the same doc-set starts a fresh full
  * review). On non-echo: strip every echo form (single source §5.1③) and return
  * the findings text + the constant M1 marker — slots stay untouched
@@ -164,6 +170,16 @@ export function settleDesignReview(agent, run, designToken, rawResult, opts = {}
   // Echoed the token → review passed. Issue it to the parent for eng-coder.
   agent._engDesignTokens ??= new Map()
   agent._engDesignTokens.set(run.designId, designToken)
+  // §10 E1（DESIGN-TOKEN-SETTLEMENT）：批归属旁列同拍写——派生 = 本评审文档集 `docSetKey` 中
+  // `batches/` 段档的绝对路径（零新输入）。文档集不含批档 ⇒ 归属 = 无（不猜）：**删**该 designId
+  // 的旧行——否则一次改了范围的复评会让新槽继承上一轮的归属，收口时消费掉本不该消费的授权。
+  const batchAbs = batchAbsPath(run.docSetKey)
+  if (batchAbs) {
+    agent._engDesignTokenBatches ??= new Map()
+    agent._engDesignTokenBatches.set(run.designId, batchAbs)
+  } else if (agent._engDesignTokenBatches instanceof Map) {
+    agent._engDesignTokenBatches.delete(run.designId)
+  }
   // DESIGN-TOKEN-SETTLEMENT D3（2026-09-08）：单值镜像 `_engDesignToken` 退役——
   // 只写多槽 Map（AC3 零镜像写）；settle 落盘由调用方（settleAdvisorRun）当场做。
   // Unlock the dispatch design gate for eng-coder SELF-review (defense-in-depth —

package/agent-tools/manifest.mjs

@@ -19,7 +19,7 @@
  *
  * 目标面（KD-M1-39——判据复用零新解析器）：`read` = `projectView`；`init` / `write` =
  * `projectRootView`（工作区 ⇒ 拒 + 下辖项目全列 + 显式 `target` 指引）；`resolveProjectRoot` 对
- * 工作区塌缩 `null` 再回落 cwd ⇒ 写 / 建两动作**不得**直用。
+ * 工作区塌缩 `null`（**回落发生在调用方 `writeRoot`，非本函数**）⇒ 写 / 建两动作**不得**直用。
  *
  * 写路径复用（零新写路径）：落盘恒经 `writeManifest` / `initManifest`——`writer` 恒显式 `'main'`
  * （缺省 `'subagent'` = 写门 fail-closed 缺省，KD-M1-3 / AC-M1-5 零改）。

package/agent-tools/review-facts.mjs

@@ -87,7 +87,7 @@ export function resolveReviewDocPaths(documents, cwd) {
     if (!abs && view.state !== "ok") { invalid.push({ doc, resolved: null, reason: "no-project-root" }); continue }
     const p = abs ? doc : resolve(view.root, doc)
     if (!abs && !isInside(p, view.root)) { invalid.push({ doc, resolved: p, reason: "outside-project" }); continue }
-    if (abs && !owningProject(p)) { invalid.push({ doc, resolved: p, reason: "outside-project" }); continue }
+    if (abs && !owningProject(p, cwd)) { invalid.push({ doc, resolved: p, reason: "outside-project" }); continue }
     if (!isDocFile(p)) { invalid.push({ doc, resolved: p, reason: "not-doc-file" }); continue }
     resolved.set(doc, p)
   }

package/ledger-cmd.mjs

@@ -40,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）。 */
@@ -92,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 = []
@@ -103,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() }
 }
@@ -113,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++
@@ -132,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` / 空串 / 全空白） ≡ **未指名**——臂② 不触。 */
@@ -149,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 必填（在途 / 待核销 / 归批 须携任务书指针）`)
@@ -157,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", {
@@ -173,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)
@@ -218,7 +218,7 @@ function assertEvidenceValue(fnName, 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} 不在允许迁移表`)
@@ -237,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)
@@ -249,12 +249,12 @@ 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() }
 }
@@ -286,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 {
@@ -330,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")
@@ -355,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 {
@@ -387,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) }))
@@ -406,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

package/ledger-db.mjs

@@ -6,8 +6,9 @@
  * 靠 DDL（AC-M2-2），不靠应用层 if。归档 = 软删除（状态值，无物理 DELETE——KD-M2-4）。
  * 本档静态 import node:sqlite ⇒ 消费侧一律动态 import 本模块链（W8 契约②——KD-M2-3）。
  *
- * 项目根推导单源（`resolveLedgerRoot`）+ 同级枚举（`ledgerChildren`）居本档——键 / 库位 / 根同源
- * （设计档 `LEDGER.md` §2.1「根解析面」/ §3.8）：读写同一判据（档在盘 ∨ 以目录自身路径为键的库在盘）。
+ * 项目根推导单源（`resolveLedgerRoot` = 判据本体 `owningProject` 的 `basis` 形状包装）+ 同级枚举
+ * （`ledgerChildren`）居本档——键 / 库位 / 根同源（设计档 `LEDGER.md` §2.1「根解析面」/ §3.8）：
+ * 读写同一判据（档在盘——项目 = 带 manifest 的目录；库在盘不算项目，台账无第二定义）。
  *
  * 落点（2026-09-17 用户裁定收正）：台账库**不在项目目录**——住用户数据目录
  * `~/.thincoder/ledger/<sha1(normalizeCwd(项目根绝对路径))[:16]>.db`（工作树外、天然不进 git；
@@ -17,11 +18,11 @@
  */
 import { createHash } from "node:crypto"
 import { existsSync, mkdirSync, opendirSync } from "node:fs"
-import { dirname, join, resolve } from "node:path"
+import { join, resolve } from "node:path"
 import { DatabaseSync } from "node:sqlite"
 
 import { configDir } from "./config-io.mjs"
-import { MANIFEST_REL, projectRootView } from "./manifest.mjs"
+import { MANIFEST_REL, owningProject, projectRootView } from "./manifest.mjs"
 // 归一步单源（KD-LN1——直引，不抽新 util：先例 = peer-domains.mjs / traces/trace-store.mjs）。
 import { normalizeCwd } from "./session-slots.mjs"
 
@@ -45,27 +46,24 @@ export function ledgerKey(root) {
   return createHash("sha1").update(normalizeCwd(root)).digest("hex").slice(0, 16)
 }
 
-/** 键控库文件路径（根 → 库位）——**内部形**：根推导内部判「库在盘」时用它，**不得经 `ledgerDbPath`**
- *  （互指即环，设计档 §3.8「无自指」）。库目录 = `ledgerDir`（`_setLedgerDirForTest` 覆盖 ⇒ 夹具根外零写）。 */
+/** 键控库文件路径（根 → 库位）——**内部形**：族枚举 / 库路径解析内部构造库位时用它，**不得经
+ *  `ledgerDbPath`**（互指即环，设计档 §3.8「无自指」）。库目录 = `ledgerDir`（`_setLedgerDirForTest` 覆盖 ⇒ 夹具根外零写）。 */
 const keyedDbFile = (root) => join(ledgerDir, `${ledgerKey(root)}.db`)
 
-/** 「已注册」判据（设计档 §2.1——**唯一**事实，两臂取一即成立）：
- *  档臂 = 该目录带项目声明档 `PROJECT-MANIFEST.json`（档在盘）；
- *  库臂 = 以该目录自身路径为键的键控库在盘 ∧ 该目录**非工作区态**（键控库存在 ≠ 可作项目）；
- *  工作区判据只在库在盘时才查（`projectRootView` 含 fs 扫描——档臂已中即短路）。 */
+/** 「已注册」判据（**唯一**事实）：该目录带项目声明档 `PROJECT-MANIFEST.json`。
+ *  项目 = 带 manifest 的目录（`docs/core/requirements/ENGINEERING-MODE-V2-SPEC-MANIFEST.md:68`）——
+ *  台账没有自己的「项目」定义：台账根 = 项目根，一个判据。 */
 function isRegistered(dir) {
-  if (existsSync(join(dir, MANIFEST_REL))) return true
-  if (!existsSync(keyedDbFile(dir))) return false
-  return projectRootView(dir).state !== "workspace"
+  return existsSync(join(dir, MANIFEST_REL))
 }
 
 /** 同级枚举上限（成本有界：父目录超此规模 = 缓存 / 临时等非仓族形态 → 退化空集）。
- *  2026-10-16 批 ledger-root-derivation 自 `ledger.mjs` 随迁（根推导收敛序 ∥ 族发现同级枚举同源）。 */
+ *  2026-10-16 批 ledger-root-derivation 自 `ledger.mjs` 随迁（同级枚举：族发现 ∥ 轻通道闸候选枚举同源）。 */
 export const MAX_SIBLING_SCAN = 100
 
-/** 目录下**已注册**（档 ∨ 库——§2.1 单谓词）的直接子目录（目录名升序；不可读 ∥ 超限 ⇒ 空集；
- *  **惰性枚举 + 上限**——大目录零全量扫描）。消费面 = 根推导收敛序 ∥ 族发现 ∥ 轻通道闸候选枚举。
- *  `ledger` = 该子目录根的键控库路径（谓词含档臂 ⇒ 可能尚未在盘）。2026-10-16 批自 `ledger.mjs` 随迁。 */
+/** 目录下**已注册**（档在盘——§2.1 单谓词）的直接子目录（目录名升序；不可读 ∥ 超限 ⇒ 空集；
+ *  **惰性枚举 + 上限**——大目录零全量扫描）。消费面 = 族发现 ∥ 轻通道闸候选枚举。
+ *  `ledger` = 该子目录根的键控库路径（推算值 ⇒ 可能尚未在盘）。2026-10-16 批自 `ledger.mjs` 随迁。 */
 export function ledgerChildren(dir) {
   const out = []
   let handle
@@ -86,48 +84,49 @@ export function ledgerChildren(dir) {
   return out.sort((a, b) => (a.root < b.root ? -1 : a.root > b.root ? 1 : 0))
 }
 
-/** 项目根推导**单源**（设计档 §2.1「根解析面」/ §3.8——读写同一判据、同一实现）：
- *  自 `target` 沿**祖先链**上溯取最近「已注册」目录——**以会话锚（`process.cwd()`）为界，越界即停**：
- *  界内上溯 = 子目录归到自己的项目根（应该）；越过锚 = 挂到无关外层项目上（禁止）。
- *  命中 ⇒ `{ root, basis: 'self' | 'ancestor' }`（自身 vs 界内祖先）；
- *  界内无命中 ∧ `descend: true` ⇒ **向下收敛**锚的直接子目录（`ledgerChildren` 同款惰性枚举 +
- *  上限、名序升序）：恰一 ⇒ 取之；≥2 ⇒ ① 先取**有键控库**者（账已在盘 = 事实）② 该集名序首者 ⇒
- *  `{ root, basis: 'descendant' }`（向下发现——**须报明**）；零已注册子目录 ⇒ `null`（无根）。
- *  `descend: false` ⇒ 只问界内上溯支（族发现 ∥ 标记面——容器 ∥ 工作区锚 ⇒ `null` ⇒ 族求和）。
- *  **无自指**：内部「库在盘」判据只用 `ledgerKey` + `keyedDbFile`（不经 `ledgerDbPath`）。
- *  @param {string} [target] 动作目标路径（目录）
- *  @param {{descend?: boolean}} [opts] `descend` 缺省 `true`（动作面——`openLedger` / `ledgerDbPath` / 单范围读）
- *  @returns {{root: string, basis: 'self'|'ancestor'|'descendant'}|null} 项目根 + 判据来源 / 无根（`null`） */
-export function resolveLedgerRoot(target, { descend = true } = {}) {
+/** 项目根推导**单源**（设计档 §2.1「根解析面」/ §3.8——读写同一判据、同一实现）：**判据本体的形状包装**
+ *  = `owningProject(target, boundary)`（祖先链上溯的唯一实现——本档零自持上溯）+ `basis`。
+ *  起点 = `target`（动作目标路径：目录 = 自身，文件 = 其所在目录）；界 = **会话锚**（越界即停——
+ *  不越出工作目录去挂外层项目，也不向下找、不猜）；`basis` = `self`（目标自身即带档目录）∥
+ *  `ancestor`（最近带档祖先）。「项目根报明 / 建档」由用点决定。
+ *  **无自指**：本档不判库在盘（台账无第二定义——库在盘不算项目）。
+ *  @param {string} [target] 动作目标路径（目录 | 文件则取其所在目录）
+ *  @param {string} [boundary] 上溯上界（会话锚；缺省 = `process.cwd()`）
+ *  @returns {{root: string, basis: 'self'|'ancestor'}|null} 项目根 + 判据来源 / 无根（`null`） */
+export function resolveLedgerRoot(target, boundary) {
   const start = resolve(target ?? ".")
-  let dir = start
-  for (;;) {
-    if (isRegistered(dir)) return { root: dir, basis: dir === start ? "self" : "ancestor" }
-    const parent = dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-  if (!descend) return null
-  const children = ledgerChildren(start)
-  if (children.length === 0) return null
-  if (children.length === 1) return { root: children[0].root, basis: "descendant" }
-  const withDb = children.filter((c) => existsSync(c.ledger))
-  return { root: (withDb.length > 0 ? withDb : children)[0].root, basis: "descendant" }
+  const edge = resolve(boundary ?? process.cwd())
+  const root = owningProject(start, edge)
+  return root ? { root, basis: root === start ? "self" : "ancestor" } : null
 }
 
-/** 无根文案（单源——设计档 §3.8「无根契约」逐字；`openLedger` 写面 ∥ `ledgerDbPath` 共用同一句）。 */
-const noRootMessage = (start) =>
-  `台账：自 ${start} 未能推导项目根——该目录与本级子目录均无已注册项目（带 PROJECT-MANIFEST.json 或已有键控台账库）`
+/** 无根文案（单源——`openLedger` 写面 ∥ `ledgerDbPath` ∥ 工具面读面（`ledger-tools.mjs`）共用同一句）：
+ *  **只陈述事实**——起点 + 上溯上界（界内无项目根），不写「祖先链无已注册项目」这类越界断言：
+ *  归属根可能就在界**之上**（界外）——那一格该句为假，读它会教人误判层级。
+ *  锚态 = 工作区时追报下辖候选（报明面读数 = `projectRootView` 的 `workspace` 态——
+ *  **只供报明，不参与取根**：取根仍以会话锚为界）。
+ *  @param {string} start 起点（动作目标路径）
+ *  @param {string} [boundary] 上溯上界（会话锚；缺省 = `process.cwd()`）——与 `resolveLedgerRoot` 同一缺省 */
+export const noRootMessage = (start, boundary) => {
+  const view = projectRootView(start)
+  const edge = resolve(boundary ?? process.cwd())
+  const tail = view.state === "workspace" ? `；下辖候选项目：${view.candidates.join(" ∥ ")}` : ""
+  return `台账：自 ${start} 未找到项目根（向上找到 ${edge} 为止）${tail}`
+}
 
 /** 项目根 → 库路径（稳定键 = `ledgerKey` 前 16 位——路径唯一标识，不含分隔符）。
- *  **归单源**（2026-10-16 批 ledger-root-derivation）：根 = `resolveLedgerRoot(cwd)`——与读面 / 写面
+ *  **归单源**（2026-10-16 批 ledger-root-derivation）：根 = `resolveLedgerRoot(cwd, boundary)`——与读面 / 写面
  *  同一推导；无根 ⇒ 抛**同一**无根文案（键需根，不产第二答案）。
+ *  `boundary` = 上溯上界（**会话锚**——设计档 §3.8「界（单源）」）：调用方知道锚就传；
+ *  缺省 = `process.cwd()`（CLI / 进程锚 = 会话锚的调用面不必传）。
  *  v2 键归一（2026-09-25 批）：盘符本大写（CLI）⇒ 键恒等零变；小写盘符（VSC `uri.fsPath`）
- *  并入同键 ⇒ 同项目两端同库（收正前 = 同项目两键两库）。 */
-export function ledgerDbPath(cwd) {
+ *  并入同键 ⇒ 同项目两端同库（收正前 = 同项目两键两库）。
+ *  @param {string} [cwd] 动作目标路径
+ *  @param {string} [boundary] 上溯上界（会话锚；缺省 = `process.cwd()`） */
+export function ledgerDbPath(cwd, boundary) {
   const start = resolve(cwd ?? ".")
-  const derived = resolveLedgerRoot(start)
-  if (!derived) throw new Error(noRootMessage(start))
+  const derived = resolveLedgerRoot(start, boundary)
+  if (!derived) throw new Error(noRootMessage(start, boundary))
   return keyedDbFile(derived.root)
 }
 
@@ -230,24 +229,26 @@ function markSchemaVersion(db) {
   if (v < LEDGER_SCHEMA_VERSION) db.exec(`PRAGMA user_version = ${LEDGER_SCHEMA_VERSION}`)
 }
 
-/** 开库（cwd = 「动作目标路径」）→ DatabaseSync 句柄 + 幂等建表 + 老库幂等迁移（executor 列）。
- *  **根推导**（设计档 §2.1 / §3.8）：项目根 = `resolveLedgerRoot(cwd)`——读写同一判据；嵌套取近者、
- *  容器锚向下收敛。**无根（`null`）**：写面（`create:true`）抛（fail-loud、零落盘零建库）；读面空账
+/** 开库（cwd = 「动作目标路径」；`boundary` = 上溯上界 / 会话锚）→ DatabaseSync 句柄 + 幂等建表 + 老库幂等迁移（executor 列）。
+ *  **根推导**（设计档 §2.1 / §3.8）：项目根 = `resolveLedgerRoot(cwd, boundary)`——读写同一判据；嵌套取近者、
+ *  容器锚不向下取根（无根 ⇒ 报明）。**无根（`null`）**：写面（`create:true`）抛（fail-loud、零落盘零建库）；读面空账
  *  （`null`——与「库不在 = 空账」同形）。
  *  读面（create=false）：库文件不存在 → 返回 null（读面不建库、无副作用）。
  *  写面（create=true）：库文件不存在自动建（台账目录随之创建）。
  *  **只读态**（readOnly=true——读面专用）：只读句柄 + 零 DDL / ALTER + items 探针（见 openReadOnly）；
  *  如实副作用：旧库（缺 executor 列）**读**不再自动补列——补列归写面开库；读出行缺列按 null 归一。
- *  「目录不存在」的真错照抛（fail-loud——先于推导，文案逐字零改）。 */
-export function openLedger(cwd, { create = false, readOnly = false } = {}) {
+ *  「目录不存在」的真错照抛（fail-loud——先于推导，文案逐字零改）。
+ *  `boundary` = 上溯上界（**会话锚**——设计档 §3.8「界（单源）」）：工具面传 `ctx.agent.cwd`；
+ *  缺省 = `process.cwd()`（CLI / 进程锚 = 会话锚的调用面不必传）。 */
+export function openLedger(cwd, { create = false, readOnly = false, boundary } = {}) {
   const start = resolve(cwd ?? ".")
   if (!existsSync(start)) {
     throw new Error(`项目目录不存在：${start}——cwd 请给存在的项目根（相对路径按当前工作目录解析；缺省 = 会话项目根）`)
   }
-  const derived = resolveLedgerRoot(start)
+  const derived = resolveLedgerRoot(start, boundary)
   if (!derived) {
-    if (create) throw new Error(noRootMessage(start)) // 写面抛——零落盘零建库
-    return null // 读面空账（未注册目录下旧行为亦为空 ⇒ 零回归）
+    if (create) throw new Error(noRootMessage(start, boundary)) // 写面抛——零落盘零建库
+    return null // 读面空账（两类同形：未注册目录 ∥ 目标落在界外的已注册项目——后者见 §3.8「界」；读面不抛）
   }
   const file = keyedDbFile(derived.root)
   if (!existsSync(file) && !create) return null

package/ledger-tools.mjs

@@ -10,19 +10,50 @@
  * 接线：族出口 = `ledger.mjs`（re-export——消费面 agent/family-tools.mjs；旧读二装配面已清零）；
  * 消费侧一律动态 import（`ledger-db.mjs` 静态 import node:sqlite ⇒ W8 契约②）。
  */
+import { existsSync } from "node:fs"
+import { isAbsolute, dirname, join, resolve } from "node:path"
 import { ledgerAdd, ledgerClose, ledgerCloseBatch, ledgerCount, ledgerQuery, ledgerUpdate, ledgerUpdateBatch } from "./ledger-cmd.mjs"
-import { resolveLedgerRoot } from "./ledger-db.mjs"
+import { noRootMessage, resolveLedgerRoot } from "./ledger-db.mjs"
 import { DESC } from "./tools/shared.mjs" // #15 描述外置：文本单点 = tool-docs/ledger.md（DESC 单解析面）
 
-/** 工具 cwd 供值面（缺省 → 当前会话锚——「动作目标路径」；项目根由核 `resolveLedgerRoot` 推导）。 */
-const cwdOf = (ctx) => ctx?.agent?.cwd ?? ctx?.cwd ?? process.cwd()
+/** 指针值 → 文件路径（剥 `§N` 段号；空值跳过）。 */
+const ptrPath = (v) => {
+  if (typeof v !== "string") return null
+  const p = v.split("§")[0].trim()
+  return p || null
+}
+
+/** 会话锚供值面（**单源**——`cwdOf` 的缺省起点与上溯上界（`boundary`）同一表达式）：
+ *  `ctx.agent.cwd` > `ctx.cwd` > 进程 cwd。界 = 会话锚（设计档 §3.8「界（单源）· 两面两界」）——
+ *  工具面传给 `resolveLedgerRoot` / `openLedger` 的上界恒取本值，不取 `process.cwd()`（desktop / VSC
+ *  宿主下两者不同：会话锚才是「不能跑到工作目录以外去」的那道界）。 */
+const anchorOf = (ctx) => ctx?.agent?.cwd ?? ctx?.cwd ?? process.cwd()
 
-/** 根推导**报明面**（设计档 §3.8「报明形态」）：向下发现（`basis === 'descendant'`——容器锚收敛序）⇒
- *  对象形回执增 `root` 键；祖先支（自明路径）⇒ `null`（展开零键——回执逐字零改）。供值面 = 核同一
- *  单源 `resolveLedgerRoot`（工具层零自算根；单实现、多调用点）。 */
-const reportedRoot = (cwd) => {
-  const derived = resolveLedgerRoot(cwd)
-  return derived && derived.basis === "descendant" ? { root: derived.root } : null
+/** 工具 cwd 供值面：**起点 = 动作目标路径**（`docs/core/requirements/ENGINEERING-MODE-V2-SPEC-MANIFEST.md:72`
+ *  「参数按用点解析——动作作用于哪个项目的路径，就取那个项目的档」）。
+ *  指针（`task_book` ∥ `req_doc` ∥ `batch`）在场 ⇒ 取该文件所在目录为起点（文件 = 其所在目录）；
+ *  无指针的动作（`query` ∥ `count` ∥ 首次建行）才回退会话锚。项目根由核 `resolveLedgerRoot` 推导。 */
+const cwdOf = (ctx, ...ptrs) => {
+  for (const raw of ptrs) {
+    const p = ptrPath(raw)
+    if (!p) continue
+    return dirname(isAbsolute(p) ? p : join(anchorOf(ctx), p))
+  }
+  return anchorOf(ctx)
+}
+
+/** 起点归一（**单源**——显式 `cwd` 与指针同基底）：显式 `cwd` 在场 ⇒ 相对路径按**会话锚**解析、
+ *  绝对路径照用；不在场 ⇒ 按指针 / 会话锚推导（`cwdOf`）。两径同一基底，避免「界 = 会话锚、起点按进程 cwd」
+ *  的自相矛盾（锚 ≠ 进程目录的宿主下，相对 `cwd` 否则恒落界外 ⇒ 一律报无根）。 */
+const startOf = (ctx, anchor, explicit, ...ptrs) => (explicit != null ? resolve(anchor, explicit) : cwdOf(ctx, ...ptrs))
+
+/** 起点推导无根 ⇒ 抛（设计档 §3.8「无根契约」· **工具面**：空集与「记到别的项目」在回执上无法区分——
+ *  静默空集不成立）。判据 = 同一单源 `resolveLedgerRoot`（无第二套上溯）；目录不存在不在此判
+ *  （交 `openLedger` 的既有文案——两判据不混）。展示面（`buildScan` ∥ 族发现）不经本函数：
+ *  无根 ⇒ `ledger: null` + 零行，不抛。`boundary` = 会话锚（界与 `openLedger` 同一枚）。 */
+function assertLedgerStart(start, boundary) {
+  if (!existsSync(start)) return
+  if (!resolveLedgerRoot(start, boundary)) throw new Error(noRootMessage(start, boundary))
 }
 
 // ── 工具层参数守卫（设计档 §3.2 · 2026-09-27 快车道修复 · Gitee #IKIQGK / 台账 #472） ──
@@ -105,7 +136,7 @@ const FULL_ACTIONS = ["add", "update", "close", "query", "count"]
 const READ_ACTIONS = ["query", "count"]
 
 /** cwd 参数描述（五前身声明同文——文本单点）。 */
-const CWD_DESC = "本次动作的目标路径——项目根由它推导：沿祖先链最近的项目目录（带 PROJECT-MANIFEST.json 或已有台账库）；容器目录下收敛到子项目。台账按项目根关联存储于用户数据目录（工作树外、不进 git）。相对路径按当前工作目录解析；查/写别的项目请给绝对路径。缺省 = 当前会话锚"
+const CWD_DESC = "本次动作的目标路径——项目根由它推导：沿祖先链取最近的项目目录（带 PROJECT-MANIFEST.json 的那一层；库在盘不算项目）。多根工作区 / 无项目目录 ⇒ 报明并给候选，不向下取子项目当根。台账按项目根关联存储于用户数据目录（工作树外、不进 git）。相对路径按当前会话锚解析；项目根按上溯界取——界外不挂项目。缺省 = 当前会话锚"
 
 /** 各 action 声明条目（= 前身旧工具 `parameters` 逐字；伪工具对象守卫 + 弃用壳共用单源）。
  *  `parameters` 内的键 = 交模型 / provider 的那一份声明；**组判据两键（`oneOfRequired` / `whenPresent`）
@@ -255,16 +286,18 @@ function makeLedgerTool(actions, { readonly = false, writeFace = false } = {}) {
       const spec = ACTION_SPECS[action]
       const rest = assertToolArgs({ name: `ledger(${action})`, ...spec }, rest0)
       // ④ 路由既有核函数（包装细节携自原工具 execute 逐字保留：cwd 缺省 / JSON 缩进 / getSessionId 动态 import）
+      // 界 = 会话锚（`anchorOf` 单源）——逐 action 传 `boundary`：`openLedger` / `resolveLedgerRoot` 的上溯上界
+      const anchor = anchorOf(ctx)
       switch (action) {
         case "add": {
           const { cwd, ...row } = rest
-          const target = cwd ?? cwdOf(ctx)
-          const id = ledgerAdd({ cwd: target, row })
-          return JSON.stringify({ id, status: "待讨论", ...reportedRoot(target) })
+          const target = startOf(ctx, anchor, cwd, row.task_book, row.req_doc)
+          const id = ledgerAdd({ cwd: target, row, boundary: anchor })
+          return JSON.stringify({ id, status: "待讨论" })
         }
         case "update": {
           const { cwd, id, batch, ...patch } = rest
-          const target = cwd ?? cwdOf(ctx)
+          const target = startOf(ctx, anchor, cwd, batch, patch.task_book, patch.req_doc)
           let executorSessionId
           if (patch.executor == null) {
             // 显式 `null` ≡ 略去（§3.1 `null` 口径 · #474——与缺省同分支）；动态 import——零新静态边（K-LX1）
@@ -272,20 +305,24 @@ function makeLedgerTool(actions, { readonly = false, writeFace = false } = {}) {
             executorSessionId = getSessionId()
           }
           // 批级批量（§3.3）——`batch` 与 `id` 恰携其一（守卫 P7 已先裁）
-          if (batch != null) return JSON.stringify({ ...ledgerUpdateBatch({ cwd: target, batch, patch, executorSessionId }), ...reportedRoot(target) })
-          return JSON.stringify({ ...ledgerUpdate({ cwd: target, id, patch, executorSessionId }), ...reportedRoot(target) })
+          if (batch != null) return JSON.stringify({ ...ledgerUpdateBatch({ cwd: target, batch, patch, executorSessionId, boundary: anchor }) })
+          return JSON.stringify({ ...ledgerUpdate({ cwd: target, id, patch, executorSessionId, boundary: anchor }) })
         }
         case "close": {
-          const target = rest.cwd ?? cwdOf(ctx)
+          const target = startOf(ctx, anchor, rest.cwd, rest.batch, rest.task_book)
           // 批级批量结算（§3.3——勾销径）
-          if (rest.batch != null) return JSON.stringify({ ...ledgerCloseBatch({ cwd: target, batch: rest.batch, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace }), ...reportedRoot(target) })
-          return JSON.stringify({ ...ledgerClose({ cwd: target, id: rest.id, status: rest.status, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace }), ...reportedRoot(target) })
+          if (rest.batch != null) return JSON.stringify({ ...ledgerCloseBatch({ cwd: target, batch: rest.batch, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace, boundary: anchor }) })
+          return JSON.stringify({ ...ledgerClose({ cwd: target, id: rest.id, status: rest.status, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace, boundary: anchor }) })
+        }
+        case "query": {
+          const target = startOf(ctx, anchor, rest.cwd, rest.task_book)
+          assertLedgerStart(target, anchor)
+          return JSON.stringify(ledgerQuery({ cwd: target, boundary: anchor, status: rest.status, kind: rest.kind, board: rest.board, trigger: rest.trigger, task_book: rest.task_book }), null, 2)
         }
-        case "query":
-          return JSON.stringify(ledgerQuery({ cwd: rest.cwd ?? cwdOf(ctx), status: rest.status, kind: rest.kind, board: rest.board, trigger: rest.trigger, task_book: rest.task_book }), null, 2)
         case "count": {
-          const target = rest.cwd ?? cwdOf(ctx)
-          return JSON.stringify({ ...ledgerCount({ cwd: target, task_book: rest.task_book }), ...reportedRoot(target) })
+          const target = startOf(ctx, anchor, rest.cwd, rest.task_book)
+          assertLedgerStart(target, anchor)
+          return JSON.stringify({ ...ledgerCount({ cwd: target, boundary: anchor, task_book: rest.task_book }) })
         }
         default:
           // 不可达（② 枚举守门已先拒）——fail-loud 兜底（防未来变体增量 drift）