@thincoder/core 0.10.7 → 0.10.9

package/agent-tools/batch-gate.mjs

@@ -0,0 +1,198 @@
+/**
+ * agent-tools/batch-gate.mjs — 文档机检门（`batch` 工具两机械点的**单源门**）。
+ *
+ * 权威规格 = `docs/core/design/DOC-DISCIPLINE.md` §3.20「结构兜底」（判据 / 范围 / 范围分域 / 适用面 /
+ * ERROR 消费分野 / 门自身异常 / 不检面）——本档只实现，**不重述口径**（D2）。需求 = `DOC-CHECK.md` F9 / AC-7。
+ *
+ * 调用面两处、各一取值（`scope` 语义 = 规范「调用面开关，无第三值」）：
+ *   ① `batch.mjs` append 写 §2 / §5（`!depth0 && !review`）⇒ `scope: "writer"`——范围 = 写者触达记账
+ *      （与工具面 gate 同源 `docsSource="session"`）；`REFUSED` ⇒ 调用面 throw；`ERROR` / 门自身异常 ⇒ 放行 +
+ *      回执明示（子代理无法重启会话，卡死写账 = 无账之笔；② 会拒收口 ⇒ 轮次不会被当成已通过）。
+ *   ② `batch-lifecycle.mjs` close ∥ status 值余核「已收口」⇒ `scope: "close"`——范围 = 本批笔域集（触达账；
+ *      `git diff --name-only <批起 sha> HEAD` 的基 sha 只有父侧掌握 ⇒ 取不到基时只认触达账 + 回执明示）
+ *      ∪ git 面（`git diff --name-only HEAD` ∪ `git ls-files --others --exclude-standard`，域求交归引擎）；
+ *      `REFUSED`（K ≥ 1）∥ `ERROR` ⇒ 调用面 throw（fail-closed）；命中 ⊆ 他批在途集 ⇒ 不阻收口 + 固定行逐档列出。
+ *
+ * 判据零变：本档不新增判据——只决定「判谁」与「何时强制」；判据与裁定串由产品引擎
+ * `doc-check/index.mjs` 产出（判据源唯一）。引擎版本前置同源 = `doc-check/version.mjs`。
+ *
+ * 两条边界（设计与实测同口径）：① **批档自身不入范围**（载体不是判据对象；声明域已排除 `batches`，
+ * 传入只产「跳过域外」行 = 假检查）；② **本轮提交面不在工具面**——`<批起 sha>` 只有父侧掌握，
+ * ② 的写入集只认触达账 + 回执明示「基 sha 未定」，提交面由父侧协议清单兜（不静默）。
+ */
+import { execFileSync } from "node:child_process"
+import { relative, resolve } from "node:path"
+
+import { owningProject, readManifest } from "../manifest.mjs"
+import { runDocCheck } from "../doc-check/index.mjs"
+import { firstVerdictLine, gateEngineError, staleEngineFiles } from "../doc-check/version.mjs"
+import { batchProjectRoot } from "./batch-paths.mjs"
+
+/** 平台路径键（win32 大小写不敏感——只作集比对，非判据面）。 */
+const pathKey = (p) => (process.platform === "win32" ? p.toLowerCase() : p)
+
+/** 文档档谓词 + 绝对化（触达账 / git 面同形；非 `.md` 不进范围）。 */
+const isDocPath = (p) => typeof p === "string" && p.trim() !== "" && p.toLowerCase().endsWith(".md")
+function docPaths(list, base) {
+  const out = []
+  for (const p of Array.isArray(list) ? list : []) if (isDocPath(p)) out.push(resolve(base, p))
+  return out
+}
+
+/**
+ * git 面（他批在途集候选——只取清单，域求交归引擎）：`git diff --name-only HEAD` ∪ 未跟踪档。
+ * 路径以**仓根**（`rev-parse --show-toplevel`）为基还原——项目根住大仓子目录时条目不丢（清单相对仓根）。
+ * 不可得（非仓 / 无 git）⇒ `ok: false` + 空集（调用面回执明示「git 面不可得」，不静默）。
+ */
+function gitSurface(root) {
+  const run = (cwd, argv) => execFileSync("git", ["-C", cwd, ...argv], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 8000 })
+  try {
+    const top = run(root, ["rev-parse", "--show-toplevel"]).trim()
+    const base = top || root
+    const changed = run(base, ["diff", "--name-only", "HEAD"]).split(/\r?\n/)
+    const untracked = run(base, ["ls-files", "--others", "--exclude-standard"]).split(/\r?\n/)
+    return { ok: true, base, files: [...changed, ...untracked].filter(Boolean) }
+  } catch {
+    return { ok: false, base: root, files: [] }
+  }
+}
+
+/** 命中 → `{ aligned, entries }`：`file` = 判定用（引擎给绝对路径）；显示行取引擎已产出的 `✗` 行
+ *   （报面单源不重写）；行数与命中数不等（引擎报面行序变动）⇒ `aligned: false` + 自造行，由调用面回执明示。 */
+function hitEntries(res, root) {
+  const lines = res.report.split("\n").filter((l) => l.startsWith("✗ "))
+  const hits = [...res.anchorHits, ...res.widthHits]
+  const aligned = lines.length === hits.length
+  const entries = hits.map((h, i) => ({
+    file: h.file,
+    line: aligned ? lines[i] : `✗ ${relative(root, h.file).replace(/\\/g, "/")}:${h.line}`,
+  }))
+  return { aligned, entries }
+}
+
+/** 固定行里的定位片（`档:行`——取自命中行；取不到则退回相对路径）。 */
+function locationOf(entry, root) {
+  return /(\S+?\.md:\d+)/.exec(entry.line)?.[1] ?? relative(root, entry.file).replace(/\\/g, "/")
+}
+
+/** 报面组装：只换首行 + 插入本条附加行（其余行 = 引擎原样，不重写格式）；`dropDisposal` ⇒ 剔除引擎的
+ *  「处置：同轮修正后复跑…」行（close 面 PASS 且命中全属他批在途时——该行会把读者引去改别人的档）。 */
+function composeReport(res, first, notes, dropDisposal) {
+  const lines = String(res.report).split("\n").filter((l) => !(dropDisposal && l.startsWith("处置：")))
+  lines[0] = first
+  if (notes.length) {
+    const at = lines.findIndex((l) => l.startsWith("处置："))
+    if (at >= 0) lines.splice(at, 0, ...notes)
+    else lines.push(...notes)
+  }
+  return lines.join("\n")
+}
+
+/** 空范围返回形（`range` 恒在场——回执要读 `范围 N 档`）。 */
+const emptyRange = (basis) => ({ count: 0, k: 0, foreign: 0, basis })
+const errorState = (first, range = emptyRange("none")) => ({ state: "error", first, report: first, hitLines: [], noteLines: [], range })
+
+/**
+ * 跑一次门（**非抛错**：三因之外的门自身异常收为 `error` 态，由调用面按 `scope` 消费）。
+ * @param {{abs:string, cwd?:string, agent?:object, scope?:'writer'|'close', clock?:object}} o
+ *   `abs` = 目标批次档绝对路径（根解析用）；`agent._touchedFiles` = 触达记账；`clock` = 版本判定的测试注入缝。
+ * @returns {{state:'pass'|'refused'|'error'|'not-applicable', first:string|null, report:string,
+ *   hitLines:string[], noteLines:string[], range:{count:number, k:number, foreign:number, basis:string}}}
+ *   `first` = 唯一机判串（首行 `DOC-CHECK GATE:`）；`not-applicable` ⇒ `first = null` + 固定回执行。
+ */
+export function runBatchGate({ abs, cwd, agent = {}, scope = "writer", clock } = {}) {
+  // `scope` 两取值、无第三值（设计「`scope` 语义」）——未知值不静默降级（降级即 ② 变 fail-open）
+  if (scope !== "writer" && scope !== "close") {
+    return errorState(`DOC-CHECK GATE: ERROR（未知 scope：${JSON.stringify(scope)}——取值只有 "writer" ∥ "close"）`)
+  }
+  try {
+    return evaluate({ abs, cwd, agent, scope, clock })
+  } catch (e) {
+    const first = `DOC-CHECK GATE: ERROR（门自身异常：${e?.message ?? String(e)}）`
+    return errorState(first)
+  }
+}
+
+/** 门体（正常路径——异常由上抛给 `runBatchGate` 收口）。 */
+function evaluate({ abs, cwd, agent, scope, clock }) {
+  const base = resolve(cwd ?? process.cwd())
+  const root = owningProject(resolve(abs)) ?? batchProjectRoot(base)
+  const close = scope === "close"
+
+  let read
+  try { read = readManifest(root) } catch (e) {
+    return errorState(`DOC-CHECK GATE: ERROR（manifest 不可读 —— ${e?.message ?? String(e)}）`)
+  }
+  // 适用面（声明面驱动）：无 manifest ⇒ 不适用 + 回执明示；**不是豁免清单**——判据参数来自 checkConfig。
+  if (!read.ok && read.reason === "missing") {
+    return { state: "not-applicable", first: null, report: "[doc-check gate] 未跑（本项目无声明面）", hitLines: [], noteLines: [], range: emptyRange("none") }
+  }
+  // 引擎版本前置（fail-closed）：stale ⇒ 直接 ERROR 串，不进引擎（不产 PASS）。
+  const version = staleEngineFiles(clock ?? {})
+  if (version.stale.length) {
+    const report = gateEngineError(version)
+    return { state: "error", first: firstVerdictLine(report), report, hitLines: [], noteLines: [], range: emptyRange("none") }
+  }
+
+  // 范围（判谁）：writer = 写者触达账；close = 本批笔域集（触达账）∪ git 面。
+  // 批档自身不入范围（载体不是判据对象；声明域已排除 batches ⇒ 传入只产「跳过域外」行 = 假检查）。
+  const selfKey = pathKey(resolve(abs))
+  const touched = docPaths(agent?._touchedFiles, base).filter((p) => pathKey(p) !== selfKey)
+  const git = close ? gitSurface(root) : { ok: false, base: root, files: [] }
+  const gitDocs = docPaths(git.ok ? git.files : [], git.base).filter((p) => pathKey(p) !== selfKey)
+  const docs = close ? [...new Set([...touched, ...gitDocs])] : touched
+  const basis = close ? (git.ok ? "touched+git" : "touched（git 面不可得）") : "touched"
+  const res = runDocCheck(root, { mode: "gate", docs, docsSource: close ? "explicit" : "session" })
+  if (res.error) return { state: "error", first: firstVerdictLine(res.report), report: res.report, hitLines: [], noteLines: [], range: { count: res.checkFiles.length, k: 0, foreign: 0, basis } }
+
+  const { aligned, entries } = hitEntries(res, root)
+  const ownKeys = new Set(touched.map(pathKey))
+  const own = close ? entries.filter((e) => ownKeys.has(pathKey(e.file))) : entries
+  const foreign = close ? entries.filter((e) => !ownKeys.has(pathKey(e.file))) : []
+  const k = own.length
+  const first = k >= 1
+    ? `DOC-CHECK GATE: REFUSED（命中 ${k} 条）`
+    : (res.checkFiles.length ? "DOC-CHECK GATE: PASS" : "DOC-CHECK GATE: PASS（0 档）")
+
+  // 附加行（只挂 close 面）：他批在途（逐档列出、不计入 K）+ 两条取基明示（不静默）。
+  const notes = []
+  if (!aligned) notes.push("命中行不可对齐（引擎报面 ✗ 行数与命中数不等）——显示行按自造形，判定按命中对象")
+  if (close) {
+    if (foreign.length) notes.push(`他批在途 ${foreign.length} 档（非本批笔域 · 未计入 K · 请其作者在其批修复）：${foreign.map((e) => locationOf(e, root)).join(" ∥ ")}`)
+    if (!git.ok) notes.push("git 面不可得——他批在途集只按触达账判（不静默）")
+    notes.push("基 sha 未定——本批笔域集只认触达账（git 提交面由父侧协议清单兜）")
+  }
+
+  return {
+    state: k >= 1 ? "refused" : "pass",
+    first,
+    report: composeReport(res, first, notes, k === 0 && foreign.length > 0),
+    hitLines: entries.map((e) => e.line),
+    noteLines: notes,
+    range: { count: res.checkFiles.length, k, foreign: foreign.length, basis },
+  }
+}
+
+/** 成功回执行（append / close / status 三面同形；`null` 门 ⇒ 零改——非挂门路径回执逐字旧形）。
+ *  附注行（他批在途逐档列出 ∥ 取基 / git 面明示）紧随其后**逐字**列出——不静默吞掉可见性。 */
+export function gateReceiptLine(gate) {
+  if (!gate) return ""
+  if (gate.state === "not-applicable") return "\n[doc-check gate] 未跑（本项目无声明面）"
+  const head = `\n[doc-check gate] ${gate.first} · 范围 ${gate.range?.count ?? 0} 档`
+  return [head, ...(gate.noteLines ?? []).map((l) => `\n${l}`)].join("")
+}
+
+/**
+ * 拒绝串（throw 载荷；两机械点同源措辞）：`batch:` 前缀 + verdict 首行 + 逐条 `✗` 行 + 处置句；
+ * ① 追加同路既有句「失败 ⇒ 勿 close」（字面同 append 既有拒因，不新造措辞）。
+ */
+export function gateRefusalMessage(gate, action = "append") {
+  const lead = action === "append"
+    ? "batch: 文档机检门拒写（doc-check gate · 结构兜底 ①）—— 本次段写入未落盘，档字节不变。"
+    : `batch: 文档机检门拒收口（doc-check gate · 结构兜底 ②）—— ${action === "close" ? "close" : "status → 已收口"} 被拒绝，§1 状态行字节不变。`
+  const detail = gate.state === "error" ? String(gate.report ?? "").split("\n").slice(1) : gate.hitLines
+  const tail = action === "append"
+    ? "处置：同轮修正后复跑（改文档 ∥ 修引擎）；不转台账；拿不准 ⇒ 上抛主 agent 裁决（主 agent 拿不准 ⇒ 转呈用户）。Nothing was written. Do NOT close the record after a refused append — nothing landed, and closing freezes the missing section for good (失败 ⇒ 勿 close)."
+    : "处置：同轮修正后复跑（改文档 ∥ 修引擎）；不转台账；命中他批笔域 ⇒ 报告父侧转派作者；拿不准 ⇒ 上抛主 agent 裁决（主 agent 拿不准 ⇒ 转呈用户）。Nothing was written."
+  return [lead, gate.first, ...(detail ?? []), ...(gate.noteLines ?? []), tail].join("\n")
+}

package/agent-tools/batch-lifecycle.mjs

@@ -15,15 +15,30 @@
  * （eng-designer → §2 · 评审 → §3 · eng-coder → §5 · coder → §5【普通模式分支增表】· 主 agent →
  * 工程 §1 ∥ 普通 §1/§2/§5【取段——§4.16】——§4/§6 状态面走普通文档写）；depth-0 的 status/path 面
  * 按 D-BR21（可选 path，缺省 = 在飞批唯一时取）。
+ *
+ * 文档机检门（§3.20「结构兜底」②）：`close` 与 `status` 值余核「已收口」两路写盘前跑
+ * `runBatchGate({ scope: "close" })`——`REFUSED`（K ≥ 1）∥ `ERROR` ⇒ throw（§1 状态行字节不变）；
+ * `PASS` / 未跑（无声明面）⇒ 落盘 + 回执明示。门单源住 `batch-gate.mjs`（判据零改）。
+ *
+ * 链完整性门（§4.18-A）：`close` ∥ `status` 写「已收口」两路在写盘前同过 `assertCloseoutChainComplete`
+ * ——§2/§3/§4/§6 各段有内容 ∥ §1 声明不适用（仅 §2/§3/§4 可声明；§6 不可声明 · §5 段号豁免）；
+ * 缺段 ⇒ 点名拒（门位 = 冻结拒写之后、文档机检门之前）。重开径（§4.18-B）：已收口档
+ * `status` §1 → 进行中 + `note` 非空 ⇒ 状态行改写 + §1 段尾追记行（只追加，其余行字节不变）。
+ *
+ * 收口重锚（§6.2 · C · AC-M2-30）：收口有两条通路——`close` ∥ `status` 写 §1「已收口」——两路都冻结档、
+ * 都让批「收口了」，故**两路同调**单源 `reanchorOnClose`（本档下方），调点均在状态行写盘之后。
+ * 一次收口只出一份 `[ledger reanchor]` 回执段（判据 = 前态未冻结：已冻结档在两路都被冻结门早拒）。
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
-import { dirname, resolve } from "node:path"
+import { dirname, relative, resolve } from "node:path"
 
 import {
   SEGMENT_BY_ROLE, SEGMENT_BY_ROLE_NORMAL, DEPTH0_SEGMENTS, STATUS_WORDS, STATUS_LINE_RE, readBatchStatusLine, sectionHasStatusLine, sectionHeaderRe, batchSkeleton,
   TEMPLATE_PLACEHOLDERS, findPlaceholderResidue, placeholderResidueError,
+  sectionContentState, malformedInapplicableLine, inapplicableDeclarationError,
 } from "./batch-skeleton.mjs"
 import { resolveBatchCreatePath } from "./batch-paths.mjs"
+import { gateReceiptLine, gateRefusalMessage, runBatchGate } from "./batch-gate.mjs"
 
 /** 可读文件判据（存在且为文件——目录/缺失同判不可读；与主档同名 helper 同型——KD-4 单向
  *  依赖下各自持有，三行谓词不构成第二权威源）。 */
@@ -202,21 +217,10 @@ function updateSectionStatusLine(src, seg, value) {
   return src.slice(0, hdr.index) + parts.join("") + src.slice(endIdx)
 }
 
-/** §6 段体非空白内容判据（#422①——close 前闸：段头行余文（标题文本）不计入内容；
- *  §6 段头缺失同判空——create 是骨架唯一权威入口）。 */
-function sectionSixHasContent(src) {
-  const hdr = sectionHeaderRe(6).exec(src)
-  if (!hdr) return false
-  const nextRe = /^## §\d/gm
-  nextRe.lastIndex = hdr.index + hdr[0].length
-  const next = nextRe.exec(src)
-  const body = src.slice(hdr.index + hdr[0].length, next ? next.index : src.length)
-  const nl = body.indexOf("\n") // 跳过段头行余文（`## §6 …` 的标题部分）
-  return (nl >= 0 ? body.slice(nl + 1) : "").trim() !== ""
-}
-
-/** §6 空闸拒绝句（#422①——空 ⇒ 拒 + 提示先写 §6；防「append 被拒 ⇒ close 照常 ⇒ §6 永久为空」
- *  复发——2026-09-26 dispatch-sizing 批实证）。 */
+/** §6 空闸拒句（#422①——空 ⇒ 拒 + 提示先写 §6；防「append 被拒 ⇒ close 照常 ⇒ §6 永久为空」
+ *  复发——2026-09-26 dispatch-sizing 批实证）：**§6 为唯一缺段时**拒串取本函数（§4.18-A J2——
+ *  「非空门」文案逐字零回归）；判据本体 = 单源谓词 `sectionContentState(src, 6)`（`batch-skeleton.mjs`），
+ *  旧谓词函数已随判据单源退场（不留第二套）。 */
 function emptySectionSixError() {
   return "batch: §6 收口段为空（non-empty gate）— close refuses: the closeout section (§6) has no content, and closing would freeze the record with that section permanently empty. Write the section first (append §6: the closeout / verification summary), then call close again. Nothing was written."
 }
@@ -233,6 +237,99 @@ function assertGateOpen(src) {
   }
 }
 
+// ─── 链完整性门（§4.18-A——close ∥ status 写「已收口」两路收口前置；D-BR30）──────────
+
+/** 链判段集（§2/§3/§4/§6——§5 段号豁免恒不判；§1 主 agent 自述段不设前置）。 */
+const CHAIN_SEGMENTS = [2, 3, 4, 6]
+
+/** 链门拒绝句（§4.18-A J1——缺段非仅 §6 时；逐字文本 = `TOOLS.md` §6.24 J1。`missing` = 点名串，
+ *  形如 `§2 / §3 / §4`——按段号升序列出）。 */
+function closeoutChainError(missing) {
+  return "batch: 收口链未跑完（closeout chain gate）— close refuses: the record's closeout chain has not run, and closing would freeze it that way. " +
+    `Missing: ${missing}. Each named section must carry content (append it) or be declared inapplicable in §1 as ` +
+    "`> 不适用：§N —— <reason>` (§2 / §3 / §4 only). §6 must carry its verification (never declarable) and §5 is exempt (a light-channel round has no implementation section). " +
+    "Nothing was written."
+}
+
+/**
+ * 链完整性门（§4.18-A——**收口前置**）：`close` ∥ `status` 写「已收口」两路在写盘前同过本门。
+ * 判据：§2 / §3 / §4 / §6 每段须 `sectionContentState(src, seg) !== "empty"`（有内容 ∥ 声明不适用）；
+ * 不满足 ⇒ throw 并点名缺段（拒串 = J1——点名串按段号升序 `§2 / §3 / §4` 形）。**§6 为唯一缺段时
+ * 拒串 = 旧串逐字**（`emptySectionSixError()`——J2，零回归）。门位 = 既有拒因之后、文档机检门之前
+ * （§4.9 门清单第 ③ 道）；门不判内容质量、不做自动修复、不判 §1 / §5。
+ * @param {string} src — 档全文（写盘前只读）
+ */
+function assertCloseoutChainComplete(src) {
+  // 声明形不合先行（J3——不静默当作无声明）：§1 内「不适用」打头而完整形不合 ⇒ 拒
+  const badDecl = malformedInapplicableLine(src)
+  if (badDecl !== null) throw new Error(inapplicableDeclarationError(badDecl))
+  const missing = CHAIN_SEGMENTS.filter((n) => sectionContentState(src, n) === "empty")
+  if (missing.length === 0) return
+  if (missing.length === 1 && missing[0] === 6) throw new Error(emptySectionSixError()) // J2——零回归
+  throw new Error(closeoutChainError(missing.map((n) => `§${n}`).join(" / "))) // J1
+}
+
+// ─── 重开路径（§4.18-B——已收口档带审计的逆向流转；D-BR31）─────────────────────────
+
+/** 重开缺理由拒绝句（§4.18-B J4——触发合取缺 note；逐字文本 = `TOOLS.md` §6.24 J4）。 */
+function reopenReasonError() {
+  return "batch: 重开需理由（reopen requires a reason）— reopening a frozen record reverses a recorded decision, so the reason must be stated: pass it as `note` (it lands verbatim in the §1 reopen record). Nothing was written."
+}
+
+/**
+ * 重开（§4.18-B——已收口档 status(进行中, note 非空)）：一次写盘、两处落笔——
+ * ① §1 状态行 → `进行中（重开 <YYYY-MM-DD>）`（updateSectionStatusLine 既有单行豁免）；
+ * ② §1 **段尾追加**追记行 `**重开记录**：<日期> · 原收口 <旧日期> · 理由 = <note> · 操作者 = 主 agent`
+ *    （appendLineToSection——只追加；原收口 = 改写前状态行的收口日期字面，无日期字面 ⇒ `未标日期`）。
+ * 只追加判据：行数 +1、仅状态行原位替换、余行逐字节不变。EOL = §1 段头行自身行尾（CRLF 档 ⇒ CRLF）。
+ * @param {string} src — 档全文（closed 态）
+ * @param {string} note — 重开理由（调用面已验非空单行）
+ * @returns {string} 写盘用新全文
+ */
+function rewriteAsReopen(src, note) {
+  // 原收口 = 改写前 §1 状态行的收口日期字面（先取后改——重开后该行不再携带它）
+  const prevLine = (readBatchStatusLineRaw(src) ?? "").trim()
+  const prevDate = /已收口\s*(\d{4}-\d{2}-\d{2})/.exec(prevLine)?.[1] ?? "未标日期"
+  const date = todayLocal()
+  const withStatus = updateSectionStatusLine(src, 1, `进行中（重开 ${date}）`)
+  return appendLineToSection(withStatus, 1, `**重开记录**：${date} · 原收口 ${prevDate} · 理由 = ${note} · 操作者 = 主 agent`)
+}
+
+/** §1 状态行值原文（改写前的读取面——readBatchStatusLine 只给三态，日期字面须自己读）。 */
+function readBatchStatusLineRaw(src) {
+  const s1 = /^## §1(?=\s|$)/m.exec(src)
+  if (!s1) return null
+  const nextRe = /^## §\d/gm
+  nextRe.lastIndex = s1.index + s1[0].length
+  const next = nextRe.exec(src)
+  const body = src.slice(s1.index + s1[0].length, next ? next.index : src.length)
+  return body.split(/\r?\n/).map((line) => STATUS_LINE_RE.exec(line)).find(Boolean)?.[1] ?? null
+}
+
+/**
+ * §N 段尾追加一行（§4.18-B——重开追记行载体；append-only：只追加，既有行字节零变）。
+ * 位置 = 段体尾部（下一 `## §` 段头之前 ∥ 文末）；追加行 EOL = §1 段头行自身行尾
+ * （`\r\n` ⇒ CRLF ∥ 其余 ⇒ `\n`——探测窗 = 段头行整体〔含行尾〕，`/^## §N[^\r\n]*\r?\n/` 一次取形）。
+ * 段标题缺失 ⇒ throw（create 是骨架唯一权威入口——同 append 面 fail-closed）。
+ */
+function appendLineToSection(src, seg, line) {
+  const hdr = sectionHeaderRe(seg).exec(src)
+  if (!hdr) {
+    throw new Error(`batch: the batch record has no "## §${seg}" section header — cannot append to its tail (create is the skeleton's only authoritative entry). Nothing was written.`)
+  }
+  const headerLine = /^## §\d[^\r\n]*\r?\n/m.exec(src.slice(hdr.index))
+  const eol = headerLine?.[0].endsWith("\r\n") ? "\r\n" : "\n"
+  const nextRe = /^## §\d/gm
+  nextRe.lastIndex = hdr.index + hdr[0].length
+  const next = nextRe.exec(src)
+  const endIdx = next ? next.index : src.length
+  let before = src.slice(0, endIdx)
+  const after = src.slice(endIdx)
+  // 只保证「行自成行」：段尾无换行 ⇒ 补一个段头行行尾；已有换行零补（不插空行——只追加判据 = 行数 +1）
+  if (!before.endsWith(eol)) before += eol
+  return before + line + eol + after
+}
+
 /** 全词表去重并集（各段项——value 命中判据与 note 零命判据共用同一口径）。 */
 function statusVocabulary() {
   return [...new Set(Object.values(STATUS_WORDS).flatMap((w) => Object.values(w)))]
@@ -268,13 +365,20 @@ function assertStatusValue(seg, value) {
   }
 }
 
+/** note 单行判据（两径共用——非重开径落状态行括注、重开径落 §1 追记行，两者都是一行；
+ *  重开径不取 `assertStatusNote` 的另两条判据〔词表零命中 / 死占位〕——理由允许携词表关键字，
+ *  而追记行不是状态行形态、不参与 gate 判读（§4.18-B 理由校验）。 */
+function assertSingleLineNote(note) {
+  if (/\r?\n/.test(note)) {
+    throw new Error("batch: status note must be a single line — a multi-line note would break the one-line status-line form. Nothing was written.")
+  }
+}
+
 /** status `note` 字段校验（F11-A——落盘形态 = 状态行行内括注）：单行 + **全词表零命中**
  *  （括注永不误触冻结门——§1 判定是子串包含；已收口优先误冻结防线的第二道）+ 死占位判据零命中
  *  （括注不得成为骨架占位的新驻留面）。 */
 function assertStatusNote(note) {
-  if (/\r?\n/.test(note)) {
-    throw new Error("batch: status note must be a single line — a multi-line note would break the one-line status-line form. Nothing was written.")
-  }
+  assertSingleLineNote(note)
   const hits = statusVocabulary().filter((w) => note.includes(w))
   if (hits.length) {
     throw new Error(`batch: status note must not contain any STATUS_WORDS keyword (${hits.join(" + ")}) — a parenthetical carrying a keyword would be read as gate truth (§1 substring predicate). Put the keyword in value, the prose in note. Nothing was written.`)
@@ -293,9 +397,11 @@ function assertStatusNote(note) {
  * path 参数 = 仅 depth-0（D-BR21）——子代理/评审传 path ⇒ 拒（目标 = spawn/实例注入，语法上
  * 写不到别处）。F11-C 挂点 = 写盘前（assertStatusValue 后）：档头结构行含骨架死占位 ⇒ 拒
  * （段体引用豁免；close 不拦——收口是主 agent 终态动作）。
- * @returns {string} 成功消息
+ * **收口第二通路**：值余核 = §1「已收口」时本 action 同样收口（链门 + 机检门 + 冻结与 close 同序）⇒
+ * 状态行写盘后同调 `reanchorOnClose`（单源——不复制 close 径逻辑），回执携同一 `[ledger reanchor]` 段。
+ * @returns {Promise<string>} 成功消息
  */
-export function statusBatchRecord({ args, ctx, review, pickTarget, onWritten }) {
+export async function statusBatchRecord({ args, ctx, review, pickTarget, onWritten }) {
   const depth0 = isDepthZero(ctx)
   // 模式位执行期实读（§4.16——同款先例 = task.mjs execute 门；翻转即时生效——D-BR26）。
   // 写域：评审 → §3 · 子代理 → 身份段（普通模式分支合并 coder 增表——工程模式分支不查）·
@@ -332,44 +438,118 @@ export function statusBatchRecord({ args, ctx, review, pickTarget, onWritten })
   if (/\r?\n/.test(value)) {
     throw new Error("batch: status value must be a single line — a multi-line value would break the one-line status-line form. Nothing was written.")
   }
-  // note（可选）：散文说明的承载面——落状态行行内括注（value 内散文不再容忍）。缺省 / 空串 = 无括注。
+  // note（可选）：散文说明的承载面——落状态行行内括注（value 内散文不再容忍）；缺省 / 空串 = 无括注。
+  // **重开径例外（§4.18-B）**：值关键词 = 进行中 ∧ §1 门态 = closed ⇒ note = 重开理由（J4 缺则拒），
+  // 不进状态行括注（落 §1 追记行）；`assertStatusNote` 不取——理由允许携词表关键字（常写「误标已收口」）。
   const note = typeof args?.note === "string" ? args.note.trim() : ""
   assertStatusValue(seg, value)
-  if (note) assertStatusNote(note)
-  const lineValue = note ? `${value}（${note}）` : value
   const abs = pickTarget(args?.path)
   const src = readFileSync(abs, "utf8")
-  assertGateOpen(src)
+  // 重开合取（§4.18-B）：段 = §1 · depth-0（非评审）· 值关键词 = 进行中 · 门态 = closed——
+  // 先于冻结拒写判定（门②的唯一例外）；note = 重开理由（J4 缺则拒）。
+  const reopen = seg === 1 && depth0 && !review && stripDecorations(value) === STATUS_WORDS[1].open && readBatchStatusLine(src) === "closed"
+  if (reopen && !note) throw new Error(reopenReasonError()) // J4——重开必须带理由
+  // 重开径理由校验（§4.18-B）：单行 + 非空（非空已由 J4 判）；**不取 `assertStatusNote`**——理由
+  // 允许携状态词表关键字（常写「误标已收口」：追记行不是状态行形态、不参与 gate 判读）。
+  if (reopen) assertSingleLineNote(note)
+  else if (note) assertStatusNote(note)
+  const lineValue = note && !reopen ? `${value}（${note}）` : value
+  if (!reopen) assertGateOpen(src) // 冻结拒写——重开合取是唯一越过点（§4.9 门②例外；其余逐字零变）
   // F11-C（写盘前）：档头结构行死占位残留 ⇒ 拒（段体引用豁免——判据可辨性收正，`TOOLS.md` §6.20）
   const residues = findPlaceholderResidue(src)
   if (residues.length) throw new Error(placeholderResidueError(residues))
+  if (reopen) {
+    // 重开（§4.18-B）：一次写盘、两处落笔（状态行改写 + §1 段尾追记行）——不跑链门 / 机检门
+    //（值非「已收口」；写后门态 = open，后续 append/status 恢复放行）。
+    writeFileSync(abs, rewriteAsReopen(src, note))
+    onWritten?.(ctx?.agent ?? {}, abs)
+    return `batch: §1 reopened — status line → 「进行中（重开 ${todayLocal()}）」 + reopen record appended to §1 (reason lands verbatim in the record line). Append/status are writable again (BR-64); the closeout chain gate still applies at the next close.`
+  }
+  // ③ 链完整性门（§4.18-A——门位 = 冻结拒写之后、文档机检门之前）：链未跑完先报结构缺口，不先跑机检
+  // 收口判据（本笔把 §1 写成「已收口」）单点——链门 ∥ 机检门 ∥ 重锚合取三处共消费，段号守卫只写这一次
+  // （`STATUS_WORDS[1].closed` 只属 §1 项，`assertStatusValue` 亦拒他段该值；显式 `seg === 1` 让不变量不靠巧合）。
+  const closingValue = seg === 1 && stripDecorations(value) === STATUS_WORDS[1].closed
+  if (closingValue) assertCloseoutChainComplete(src)
+  // ④ 文档机检门（§3.20「结构兜底」②——门位 = 链门之后、状态行改写之前）：值余核 =「已收口」时同门；
+  // REFUSED（K ≥ 1）∥ ERROR ⇒ throw（§1 状态行字节不变）；其余值零挂（回执逐字旧形）。
+  const gate = closingValue ? runBatchGate({ abs, cwd: ctx?.agent?.cwd ?? process.cwd(), agent: ctx?.agent ?? {}, scope: "close" }) : null
+  if (gate && (gate.state === "refused" || gate.state === "error")) throw new Error(gateRefusalMessage(gate, "status"))
   const written = updateSectionStatusLine(src, seg, lineValue)
   writeFileSync(abs, written)
   onWritten?.(ctx?.agent ?? {}, abs)
-  return `batch: §${seg} status line updated to ${JSON.stringify(lineValue)} — the freeze gate (§1) is a read-only domain for non-§1 writes (frozen truth stays = the §1 line).`
+  // 收口重锚（§6.2 · C · AC-M2-30）：值余核 = §1「已收口」⇒ 本 action 就是收口（上两道门与 close 同序、
+  // 同样冻结档）⇒ 同调单源 `reanchorOnClose`（不复制 close 径逻辑）；次序位 = 状态行写盘之后（与 close 径一致）
+  // ——本笔被任一拒因拒 ⇒ 上面各门早 throw，台账零写（被拒的收口没有收口）。
+  // **一次收口只出一份清单**：触发 = `closingValue` ∧ 前态未冻结；`batch` 一次调用只分派一个 action
+  // （close ∥ status 不会同拍）⇒ 同一拍至多一次重锚、至多一份 `[ledger reanchor]`。前一合取项 =
+  // **defensive-only**：前态 closed 已被冻结门（`assertGateOpen`，本函数上方）早拒，正常路径跑不到这里。
+  const reanchor = closingValue && readBatchStatusLine(src) !== "closed" ? await reanchorOnClose(abs) : null
+  return `batch: §${seg} status line updated to ${JSON.stringify(lineValue)} — the freeze gate (§1) is a read-only domain for non-§1 writes (frozen truth stays = the §1 line).${gateReceiptLine(gate)}${reanchorReceiptLine(reanchor)}`
 }
 
 /**
  * close——收口冻结（§4.13，仅 depth-0）。§1 状态行 →「已收口 <YYYY-MM-DD>」；此后该档
- * append/status 全拒（冻结判据唯一真值 = §1 行——§4.9 零语义变）。对已收口档再 close ⇒ 拒
- * （close 本身是对冻结档的写）。不代写 §6 内容、不替代台账核销事务。
- * 前提三规则（#422）：① §6 非空闸（空 ⇒ 拒 + 提示先写 §6）；② 拒句含「失败 ⇒ 勿 close」
- * （append/status 面——见 batch.mjs 与上方 assertGateOpen）；③ 无状态行档 ⇒ 自建机读位
- * （updateSectionStatusLine 缺失即插——同路收口；「有行但不可解析」仍 fail-closed）。
- * @returns {string} 成功消息
+ * append/status 全拒（冻结判据唯一真值 = §1 行——§4.9 零语义变；唯一例外 = 重开合取 §4.18-B）。
+ * 对已收口档再 close ⇒ 拒（close 本身是对冻结档的写）。不代写 §6 内容、不替代台账核销事务。
+ * 前提规则（#422 + 本批 A 链门 §4.18-A）：① 链完整性门（收口前置——§2/§3/§4/§6 各段有内容 ∥ 声明
+ * 不适用；§6 唯一缺段时拒串 = 旧 §6 串逐字零回归）；② 拒句含「失败 ⇒ 勿 close」（append/status 面
+ * ——见 batch.mjs 与上方 assertGateOpen）；③ 无状态行档 ⇒ 自建机读位（updateSectionStatusLine
+ * 缺失即插——同路收口；「有行但不可解析」仍 fail-closed）。
+ * @returns {Promise<string>} 成功消息
  */
-export function closeBatchRecord({ args, ctx, review, pickTarget, onWritten }) {
+export async function closeBatchRecord({ args, ctx, review, pickTarget, onWritten }) {
   assertMainAgentOnly(ctx, "close", review)
   const abs = pickTarget(args?.path)
   const src = readFileSync(abs, "utf8")
   // #422③：§1 无状态行档 ⇒ 自建机读位（下行走 updateSectionStatusLine 缺失即插——同路收口）；
   // 「有行但不可解析」维持 fail-closed（assertGateOpen 拒——防误冻结）。
   if (readBatchStatusLine(src) !== "open" && sectionHasStatusLine(src, 1)) assertGateOpen(src)
-  // #422①：§6 非空闸（空 ⇒ 拒 + 提示先写 §6）——防「append 被拒 ⇒ close 照常 ⇒ §6 永久为空」复发。
-  if (!sectionSixHasContent(src)) throw new Error(emptySectionSixError())
+  // 链完整性门（§4.18-A——门位 = 既有拒因之后、文档机检门之前）：§2/§3/§4/§6 各段有内容 ∥ 声明
+  // 不适用；缺段 ⇒ 拒并点名（§6 唯一缺段 = J2 旧串逐字）。含声明形不合判（J3——不静默当作无声明）。
+  assertCloseoutChainComplete(src)
+  // 文档机检门（§3.20「结构兜底」②——门位 = 链门之后、状态行改写之前）：REFUSED（K ≥ 1）∥ ERROR
+  // ⇒ throw（fail-closed，不落「已收口」）；PASS / 未跑（无声明面）⇒ 落盘 + 回执明示。
+  const gate = runBatchGate({ abs, cwd: ctx?.agent?.cwd ?? process.cwd(), agent: ctx?.agent ?? {}, scope: "close" })
+  if (gate.state === "refused" || gate.state === "error") throw new Error(gateRefusalMessage(gate, "close"))
   const date = todayLocal()
   const written = updateSectionStatusLine(src, 1, `已收口 ${date}`)
   writeFileSync(abs, written)
   onWritten?.(ctx?.agent ?? {}, abs)
-  return `batch: §1 status line → 「已收口 ${date}」 — the record is frozen: append/status are refused from now on (整档冻结；改 = 新批新档; §6 内容与台账核销仍走既有通道).`
+  // 收口重锚（§6.2 · C · AC-M2-30）：顺序位 = 全部拒因通过、§1 状态行写盘**之后**（上两行）——close 被拒
+  //（身份 ∥ 冻结 ∥ 链完整性门 ∥ 文档机检门）⇒ 台账零写（被拒的 close 没有收口，「原批已收口」那时是假事实）。
+  const reanchor = await reanchorOnClose(abs)
+  return `batch: §1 status line → 「已收口 ${date}」 — the record is frozen: append is refused from now on, and status is refused except the reopen conjunction (§1 → 进行中 with a note) (整档冻结；改 = 新批新档; §6 内容与台账核销仍走既有通道).${gateReceiptLine(gate)}${reanchorReceiptLine(reanchor)}`
+}
+
+/** 收口重锚（设计档 §6.2 · C）——收口两条通路（`close` ∥ `status` 写 §1「已收口」）共调本函数（同一单源，
+ *  不复制逻辑）；写入单源 = `ledgerReanchorBatch`（本档只供 `cwd` 基准与回执形；工具层零 SQL）。
+ *  `cwd` = **批档所属项目根** = `resolveLedgerRoot(dirname(<batchDoc>))?.root`（§6.1 口径 2 同一子表达式）——
+ *  **不用会话锚**：会话锚为工作区 ∥ 容器时可能收到别的项目根 ⇒ 选行零命中 ⇒ 唯一的机器写静默失效。
+ *  无根 ⇒ 传 `null`（核心不取行、不重锚，`failed` 点名——不落兜底基准）。
+ *  `batch` = 项目根相对路径（复启句的 `<批名>` 即其文件部分；绝对路径同样可解析，但句内会带整条绝对路径）。
+ *  失败**不抛**（台账忙 ∥ 无根均不否决收口——档面写与台账库分属两存储，不做分布式事务）。 */
+async function reanchorOnClose(abs) {
+  try {
+    const { ledgerReanchorBatch, resolveLedgerRoot } = await import("../ledger.mjs") // 动态 import：ledger-db 静态引 node:sqlite（W8 契约②）
+    const root = resolveLedgerRoot(dirname(abs))?.root ?? null
+    // 句内路径统一正斜杠（与 `task_book` 列值同形——`<批名>` 是给人读的事实句，不是平台路径）
+    return ledgerReanchorBatch({ cwd: root, batch: root ? relative(root, abs).replace(/\\/g, "/") : abs })
+  } catch (e) {
+    // 非预期异常（模块加载失败 ∥ 根推导内读声明抛）同样不得否决收口——降为同一返回形（台账零写）
+    return { batch: abs, reanchored: [], alreadyAnchored: [], failed: String(e?.message ?? e) }
+  }
+}
+
+/** 重锚回执段（回执单源 = `ledgerReanchorBatch` 返回形——本档不另调选行再拼一次）：无未落行 ⇒ 无该段；
+ *  失败 ⇒ 点名失败因（台账零写、冻结照常）；非空不覆盖形（复启句入 `evidence`）逐行点名。 */
+function reanchorReceiptLine(result) {
+  if (!result) return ""
+  if (result.failed) return `\n[ledger reanchor] 未重锚：${result.failed}——台账零写；记录冻结照常完成`
+  const line = (r) => `#${r.id} ${r.status} 「${r.title}」`
+  const anchored = result.reanchored.map((r) => `${line(r)}→ 条件${r.sentenceTo === "evidence" ? "（resume_when 现值非空——原值保留，复启句追加 evidence）" : ""}`)
+  const skipped = result.alreadyAnchored.map((r) => line(r))
+  return [
+    anchored.length ? `\n[ledger reanchor] 本批未落行 → 条件 ${anchored.length} 行：${anchored.join("；")}` : "",
+    skipped.length ? `\n[ledger reanchor] 已是 条件（幂等跳过，零写）${skipped.length} 行：${skipped.join("；")}` : "",
+  ].join("")
 }

package/agent-tools/batch-paths.mjs

@@ -7,7 +7,7 @@
  * 契约（§4.15 逐字）：**候选序** = cwd → 项目根 → 逐基底（基底 = `batchDocBases` 声明面单源）；
  * **判据分野** = 读面取首个**可读**文件 / create 取首个**落基底根内**者；**锚定防嵌套** = 串以任一基底的
  * 「项目根相对前缀」打头且前缀后为**路径段边界** ⇒ 只解析项目根形（不二次拼接；不落基底内 ⇒ fail-closed）；
- * **歧义锚**（条 5 · 2026-10-02 · #828）= create 按目标所属项目落基底 ∥ 无所属显式拒；读面候选分支追加；
+ * **工作区锚**（条 5 · 2026-10-02 · #828）= create 按目标所属项目落基底 ∥ 无所属显式拒；读面候选分支追加；
  * 在飞 ∥ 写门基底集 = 候选并集（`batchDocBases`）；**零变面** = 绝对路径照旧、三个错误文案逐字、
  * 「参数在 + 路径可读」判据句、`ok` / `none` 两态。
  * **基底自有项目根分支 + 基底相对单段收窄**（条 6 · 2026-10-05 · #942）= 逐基底 `owningProject` 恰一落点收 ∥ 多落点显式拒（`ambiguousLandingError`）；基底相对分支限单段（多段串不二次拼接）。
@@ -24,10 +24,10 @@ function readableFile(abs) {
   try { return existsSync(abs) && statSync(abs).isFile() } catch { return false }
 }
 
-/** 歧义锚候选（判定单点 = `projectRootView`——`ambiguous` 态 ⇒ 候选全列**按名排序**；余者 null）。 */
-function ambiguousCandidates(cwd) {
+/** 工作区锚候选（判定单点 = `projectRootView`——`workspace` 态 ⇒ 候选全列**按名排序**；余者 null）。 */
+function workspaceCandidates(cwd) {
   const view = projectRootView(cwd ?? process.cwd())
-  return view.state === "ambiguous" ? view.candidates : null
+  return view.state === "workspace" ? view.candidates : null
 }
 
 /** 路径同一性比较（win32 大小写不敏感——同越基底判据口径）。 */
@@ -51,14 +51,14 @@ function declaredBases(cwd) {
 
 /** 批次档基底根数组（**声明面单源**——create / 在飞扫描 / 锚定判据共用）：manifest `docRoot.batches`
  *  （串 | 多根数组）→ 声明基底；缺失 / 非法 ⇒ 回退默认基底 `"docs/batches"`（恒返回非空数组）。
- *  **歧义锚**（条 5）⇒ 候选项目基底**并集**（候选按名排序、并集保序）——在飞扫描 / 写门基底集同取此值。
+ *  **工作区锚**（条 5）⇒ 候选项目基底**并集**（候选按名排序、并集保序）——在飞扫描 / 写门基底集同取此值。
  *  @param {string} cwd
  *  @returns {string[]} */
 export function batchDocBases(cwd) {
-  const amb = ambiguousCandidates(cwd)
-  if (amb) {
+  const ws = workspaceCandidates(cwd)
+  if (ws) {
     const union = []
-    for (const c of amb) for (const b of batchDocBases(c)) if (!union.includes(b)) union.push(b)
+    for (const c of ws) for (const b of batchDocBases(c)) if (!union.includes(b)) union.push(b)
     return union
   }
   const roots = declaredBases(cwd)
@@ -97,17 +97,17 @@ function insideBases(abs, bases) {
 const outsideBasesError = (raw) => new Error(`batch: create path resolves outside the batch-record base roots — a batch record must live under the declared docRoot.batches base (fail-closed). Path: ${raw}`)
 /** create 锚定但落基底外（§4.15 新文案逐字——不二次拼接）。 */
 const anchoredEscapeError = (raw) => new Error(`batch: create path is anchored at a batch base root but does not resolve under the declared docRoot.batches root(s) — refusing to nest it (fail-closed). Path: ${raw}`)
-/** 歧义锚 create 拒面（**文案逐字** = `BATCH-RECORD.md` §4.15 条 5——机检锚 `ambiguous session anchor`）。 */
-const ambiguousCreateError = (raw, candidates) => new Error(`batch: ambiguous session anchor — create target "${raw}" belongs to no candidate project; pass an explicit project path (e.g. "${candidates[0]}/docs/batches/<file>.md"). Candidates: ${candidates.join(", ")}`)
+/** 工作区锚 create 拒面（**文案逐字** = `BATCH-RECORD.md` §4.15 条 5——机检锚 `belongs to no project`）。 */
+const workspaceCreateError = (raw, candidates) => new Error(`batch: create target "${raw}" belongs to no project — the session anchor is a workspace holding ${candidates.length} projects: ${candidates.join(", ")}. Pass an explicit path under a project (e.g. "${candidates[0]}/docs/batches/<file>.md").`)
 const ambiguousLandingError = (raw, landings) => new Error(`batch: create path resolves under more than one declared batch-record base — refusing to pick one (fail-closed); pass an explicit path (absolute preferred). Path: ${raw}. Candidates: ${landings.join(", ")}`)
 
-/** 歧义锚读面候选分支（条 5）：逐候选项目——项目根形（`resolve(candidate, p)`）∥ 声明基底形
+/** 工作区锚读面候选分支（条 5）：逐候选项目——项目根形（`resolve(candidate, p)`）∥ 声明基底形
  *  （候选按名排序、并集保序——「首个可读」在此即为确定判读）。 */
-function ambiguousReadLegs(cwd, p) {
-  const amb = ambiguousCandidates(cwd)
-  if (!amb) return []
+function workspaceReadLegs(cwd, p) {
+  const ws = workspaceCandidates(cwd)
+  if (!ws) return []
   const out = []
-  for (const c of amb) {
+  for (const c of ws) {
     out.push(resolve(c, p))
     for (const b of declaredBases(c)) out.push(resolve(b, p))
   }
@@ -130,7 +130,7 @@ export function resolveBatchReadPath(cwd, given) {
     const abs = resolve(batchProjectRoot(base), p)
     return readableFile(abs) ? abs : null
   }
-  const candidates = [resolve(base, p), resolve(batchProjectRoot(base), p), ...declaredBases(base).map((b) => resolve(b, p)), ...ambiguousReadLegs(base, p)]
+  const candidates = [resolve(base, p), resolve(batchProjectRoot(base), p), ...declaredBases(base).map((b) => resolve(b, p)), ...workspaceReadLegs(base, p)]
   for (const abs of candidates) if (readableFile(abs)) return abs
   return null
 }
@@ -153,7 +153,7 @@ export function resolveBatchDocPath(cwd, given) {
 /**
  * **create 面**解析（§4.15 条 2/3/6）：绝对路径照旧取用（仍过越基底判据）；相对路径 = 候选序中首个**落基底
  * 根内**者（新档不存在——可读性无判别力）；锚定串只解析项目根形，不落基底内 ⇒ fail-closed 新文案。
- *  **歧义锚**（条 5）：目标所属项目（`owningProject`）∈ 锚候选集 ⇒ 基底 = 该项目声明面（落其基底内；
+ *  **工作区锚**（条 5）：目标所属项目（`owningProject`）∈ 锚候选集 ⇒ 基底 = 该项目声明面（落其基底内；
  *  越出 ⇒ 既有 fail-closed）；无所属 ⇒ **显式拒**（列候选 + 显式路径指引——不静默落锚）。
  * @param {string} cwd 会话锚
  * @param {string} given create `path` 原值
@@ -165,10 +165,10 @@ export function resolveBatchCreatePath(cwd, given, bases) {
   const raw = String(given ?? "").trim()
   const p = raw.replace(/\\/g, "/")
   let roots = bases
-  const amb = ambiguousCandidates(base)
-  if (amb) {
+  const ws = workspaceCandidates(base)
+  if (ws) {
     const owner = owningProject(isAbsolute(raw) ? resolve(raw) : resolve(base, p))
-    if (!owner || !amb.some((c) => samePath(c, owner))) throw ambiguousCreateError(raw, amb)
+    if (!owner || !ws.some((c) => samePath(c, owner))) throw workspaceCreateError(raw, ws)
     roots = batchDocBases(owner)
   }
   if (isAbsolute(raw)) {