@thincoder/core 0.10.13 → 0.11.1

package/agent-tools/design-token.mjs

@@ -12,11 +12,18 @@
  */
 
 import { randomUUID } from "node:crypto"
+import { readFileSync } from "node:fs"
 import { tokenExpiryMs } from "../token-ttl.mjs"
-// 批归属派生（DESIGN-TOKEN-SETTLEMENT §10）——判据与清点面同源（同一个 `lastIndexOf("batches")`）。
+// 段面读判据单源（骨架档）：轮次块计数 ∥ 段级状态行 ∥ §3 完成词——§3 落地门与写入面读同一形态。
+// 裁定行锚（`_V_PRE` / `_V_SUF` / `VERDICT_CHANGES_LINE`）同住骨架档锚块，组合序也只在那一档（`verdictGapOf`）：
+// 本档的裁定闸判据、写入面（`append §3` 的打回重置 `statusResetPlan`）与 `§5` 写入门读同一个函数——
+// 锚与序都只此一份，三处不各写一遍。
+import { countRoundBlocks, readSectionStatusWord, STATUS_WORDS, VERDICT_PASS_LINE, verdictGapOf } from "./batch-skeleton.mjs"
+// 批归属派生（DESIGN-TOKEN-SETTLEMENT §10）——两源定序 `batchAbsPathOfRun`：`run.batchDoc` 优先、
+// `docSetKey` 的批档兜底（判据与清点面同源）。
 // 本档 ⇄ `design-slots.mjs` 为**静态环**（对方取 `effectiveTokenTtlMs`）：两侧绑定只在函数体内
 // 运行时使用，求值期零顶层调用 ⇒ 环安全（与 token-ttl ⇄ session 同构）。
-import { batchAbsPath } from "./design-slots.mjs"
+import { batchAbsPathOfRun } from "./design-slots.mjs"
 
 /**
  * F2c/F2e (§29.1 2026-09-07): the engine-generated Approved suffix — ONE builder
@@ -104,29 +111,46 @@ const TRUNCATED_ECHO_MARK = "注：回显被截断（uuid 之后缺失或不符
 // 裁定行接受本地化等价形（GitHub #32 / #14）：评审席用中文回执很常见，
 // 只认英文会让 pass 落成 no-pass-line、凭证永不签发；判据仍只认整行逐字面，
 // 不做「句中含『通过』」这类模糊匹配——那样会把「未通过」也放过。
-const _V_PRE = "^[ \\t]*[*_`]*[ \\t]*"
-const _V_SUF = "[ \\t]*[*_`]*[ \\t]*$"
-const VERDICT_PASS_LINE = new RegExp(
-  _V_PRE + "(?:VERDICT:[ \\t]*(?:pass|通过|通过。)|结论[:：][ \\t]*(?:通过|pass))" + _V_SUF, "mi")
-const VERDICT_CHANGES_LINE = new RegExp(
-  _V_PRE + "(?:VERDICT:[ \\t]*(?:changes-required|不通过|需修改)|结论[:：][ \\t]*(?:不通过|需修改|changes-required))" + _V_SUF, "mi")
+// 四条锚与两条裁定正则全住骨架档锚块（`batch-skeleton.mjs`），裁定读数单源 = 同档 `verdictGapOf`：
+// 本档、`§5` 写入门与 `append §3` 的通过置位读同一个函数（判定单源，零复制）。
+// pass 锚经本档**原样再导出**——`batch-closeout.mjs` 的 import 面零改。
+export { VERDICT_PASS_LINE }
+/** 裁定闸的拒因（§5.2 #940）：对外只两个词，`changes-required` ∥ `no-pass-line`——本批改的是判据来源，
+ *  不是这两个词。四格映射（`verdictGapOf` 值域 → 拒因）：
+ *  - `null`（说了 pass）⇒ `null`（签发）；
+ *  - `「VERDICT: changes-required」` ∥ `「两者同携」` ⇒ `changes-required`——同携今天就走这一格
+ *    （改前打回锚先命中即判打回），组合序挪进函数后这张表照旧；
+ *  - `「无裁定行」` ⇒ `no-pass-line`。 */
 export function verdictGateFailure(rawResult) {
   if (typeof rawResult !== "string") return "no-pass-line"
-  if (VERDICT_CHANGES_LINE.test(rawResult)) return "changes-required"
-  return VERDICT_PASS_LINE.test(rawResult) ? null : "no-pass-line"
+  const gap = verdictGapOf(rawResult)
+  if (gap === null) return null
+  return gap === "无裁定行" ? "no-pass-line" : "changes-required"
 }
 
 /** §5.2 rejection mark (verbatim — machine-greppable; reason = no-pass-line | changes-required). */
 const VERDICT_GATE_MARK = (reason) => `裁定非通过——token 未签发 (review verdict is not pass — no design token was issued; reason: ${reason}; the echoed token was stripped)`
 
+/** §3 落地门拒因（ADVISOR-GUARDS.md §1.1——三值：判据 1 无条件的两个拒形落裁定闸之前 ⇒
+ *  changes-required 轮也会拿到；判据 2 的拒形只在签发路径上）。 */
+const RECORD_NO_BLOCK = "no-section3-block"
+const RECORD_STATUS_NOT_PASSED = "status-not-passed"
+const RECORD_BATCH_UNREADABLE = "batch-unreadable"
+
+/** §3 落地门 rejection mark (verbatim — machine-greppable; reason = 上三值之一)。与裁定闸同形：
+ * 槽零写、实例不翻 open——标记即回执，不进 `settlementCriterion`（§7 不新增判据值）。
+ * **恒定位 = 上方两行逐字不动**；`evidence`（可执行证据 = 当前状态行 ∥ 轮次块数 ∥ 写面通道）
+ * 另起一行落在其后——指名当前值，但不把证据塞进那个机器可 grep 的括号里。 */
+const REVIEW_RECORD_MARK = (reason, evidence) => `评审记录不合格——token 未签发 (review record incomplete — no design token was issued; reason: ${reason})\n补写该批档 §3（发现 + VERDICT —— 状态行由工具随块落）后重跑设计评审；未补写不得按已核处理。${evidence ? `\n证据：${evidence}` : ""}`
+
 /**
  * Shared design-review settlement (sync wrapper + async settle): the token echo
  * 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), 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
+ * — `batchAbsPathOfRun(run)`: the instance's bound `batchDoc`, else the reviewed doc-set's
+ * `batches/` file, §10; neither ⇒ 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
@@ -136,6 +160,11 @@ const VERDICT_GATE_MARK = (reason) => `裁定非通过——token 未签发 (rev
  *   （单谓词 `advisorIncompleteMarker`——结算方透传）。非空 ⇒ **一律不签发**（无论评审文本
  *   是否回显 token）：剥除全部 token 回显 + 追加未签发提示（原因 + 恢复指引），不写槽、
  *   不关实例（可重评）。
+ * @remarks §3 落地门（ADVISOR-GUARDS.md §1.1——同族：未完成即不签发）：**前置 = 绑了批档**（`run.batchDoc`
+ *   非空）——设计评审必携 `batchDoc`（准入门，判据 = 同档 §2 第 6 条）⇒ 到结算面仍为空只是接线故障，
+ *   在 `boundBatch` 判定处断言并 throw（程序不变量，早于写槽；不设对外拒因值，不返回判决）；已过回显闸 ⇒ 两次判：① 轮次块数 > 点火基线
+ *   `run.section3BlocksAtStart`（**无条件**——changes-required 轮同判；嵌在裁定闸之前）② 段级状态行 = `评审通过`
+ *   （只在签发路径上判）。不满足 ⇒ `{passed:false}` + 恒定标记，槽零写、实例不翻 open（补写后同实例可重评）。
  * @returns {{passed: boolean, output: string}}
  */
 export function settleDesignReview(agent, run, designToken, rawResult, opts = {}) {
@@ -160,6 +189,47 @@ export function settleDesignReview(agent, run, designToken, rawResult, opts = {}
     const stripped = stripDesignTokenEcho(rawResult, designToken).trim()
     return { passed: false, output: [stripped, NO_VALID_ECHO_MARK].filter(Boolean).join("\n\n") }
   }
+  // §3 落地门判据 1（**无条件**——pass 与 changes-required 都判）—— 嵌在回显闸之后、裁定闸之前。
+  // 设计单源 = `docs/core/design/ADVISOR-GUARDS.md` §1.1；**一次读档、两次判**（判据 2 复用同一 src）。
+  // 未回显 ⇒ 已走上面的 M1，记录面零判（连凭据都没有，报「记录不合格」会把真因盖掉）。
+  //
+  // 前置 = 绑了批档，**程序不变量、不是拒发分支**：设计评审必携 `batchDoc`（准入门，判据 = 同档 §2 第 6 条）
+  // ⇒ 到结算面仍为空只能是「绑定没传到实例」的接线故障 ⇒ 断言并 throw（串点名设计评审实例 + designId），
+  // 零槽写、不返回判决、不设对外拒因值。给没发生过的情形配文案就是没有场景的分支；接线 bug 该炸得响，
+  // 不该伪装成一条给用户看的拒因（本批 🔴1 裁定）。
+  // 位置 = 写槽（`agent._engDesignTokens.set(...)`）之前：落在其后 = 没拦，token 已在槽里、授权照发。
+  // 调用点不得补 catch 后继续——控制流会落回 `set(...)` ⇒ token 照签、零报错、只留一条日志（同档 §1.1）。
+  const boundBatch = typeof run?.batchDoc === "string" && run.batchDoc.trim() ? run.batchDoc : null
+  if (!boundBatch) {
+    throw new Error(`design review settled with no batch-record binding (designId: ${run?.designId ?? "(none)"}) — a design review is launched with \`batchDoc\` required, so settling without it is a wiring fault, not an input to report.`)
+  }
+  let batchSrc = null
+  let reason = null
+  let detail = ""
+  try {
+    batchSrc = readFileSync(boundBatch, "utf8")
+  } catch (e) {
+    reason = RECORD_BATCH_UNREADABLE
+    detail = `批档读不到: ${e?.code ?? e?.message ?? "unknown"}`
+  }
+  if (reason === null && !Number.isInteger(run.section3BlocksAtStart)) {
+    // 点火基线 = 评审实例绑定批档时读该档记下的块数（`advisor.mjs`）；null / 缺失 = 点火时读不到。
+    // 判据方向 =「绑了批档却验不了记录」不得当「没有记录要验」。
+    reason = RECORD_BATCH_UNREADABLE
+    detail = "点火基线缺失（批档在点火时不可读）"
+  }
+  if (reason === null) {
+    const blocks = countRoundBlocks(batchSrc, 3)
+    if (blocks <= run.section3BlocksAtStart) {
+      reason = RECORD_NO_BLOCK
+      detail = `§3 轮次块 ${blocks} 块、点火基线 ${run.section3BlocksAtStart} 块——本轮未写进 §3`
+    }
+  }
+  if (reason !== null) {
+    // 槽零写、`run.open` 不翻 ⇒ 补写 §3 后同一实例可重评（与裁定闸同形）。
+    const stripped = stripDesignTokenEcho(rawResult, designToken).trim()
+    return { passed: false, output: [stripped, REVIEW_RECORD_MARK(reason, detail)].filter(Boolean).join("\n\n") }
+  }
   // §5.2 裁定闸（#940）：签发 = 回显 ∧ 裁定行——缺 `VERDICT: pass` 行或含 `VERDICT: changes-required` 行
   // ⇒ 拒签（与 M1 径同形：剥净回显 + 恒定标记；槽零写 ∥ 实例保持——修后重评）。
   const gateFailure = verdictGateFailure(rawResult)
@@ -167,13 +237,24 @@ export function settleDesignReview(agent, run, designToken, rawResult, opts = {}
     const stripped = stripDesignTokenEcho(rawResult, designToken).trim()
     return { passed: false, output: [stripped, VERDICT_GATE_MARK(gateFailure)].filter(Boolean).join("\n\n") }
   }
+  // 判据 2（**只在签发路径上判**）——裁定行已判 pass、批档已读到（读不到已在上述判据 1 退场）。
+  // 段级 = 唯一状态行写面（`batch-skeleton.mjs` `updateSectionStatusLine`）的同一处——写它的是工具：
+  // `append §3` 那一笔随裁定行置位 ∥ 重置（`statusPassPlan` ∥ `statusResetPlan`），`status` 是同面上的
+  // 可选手写口——也是下游 `§5` 写入门读的那一处；轮次块只由工具戳标题、块内无状态行落点 ⇒
+  // 读块内状态行是读一行没人写的字。旧字面 `评审完成` 由 `readSectionStatusWord` 读侧等义。
+  const word = readSectionStatusWord(batchSrc, 3)
+  if (word !== STATUS_WORDS[3].done) {
+    const stripped = stripDesignTokenEcho(rawResult, designToken).trim()
+    const detail = `§3 状态行 = ${word ?? "（缺）"}；须 = ${STATUS_WORDS[3].done}（块落盘时由工具置位）`
+    return { passed: false, output: [stripped, REVIEW_RECORD_MARK(RECORD_STATUS_NOT_PASSED, detail)].filter(Boolean).join("\n\n") }
+  }
   // 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
+  // §10 E1（DESIGN-TOKEN-SETTLEMENT）：批归属旁列同拍写——派生 = `batchAbsPathOfRun(run)`（两源定序：
+  // `run.batchDoc` 优先、文档集里的批档兜底；零新输入）。派生为无 ⇒ 归属 = 无（不猜）：**删**该 designId
   // 的旧行——否则一次改了范围的复评会让新槽继承上一轮的归属，收口时消费掉本不该消费的授权。
-  const batchAbs = batchAbsPath(run.docSetKey)
+  const batchAbs = batchAbsPathOfRun(run)
   if (batchAbs) {
     agent._engDesignTokenBatches ??= new Map()
     agent._engDesignTokenBatches.set(run.designId, batchAbs)

package/agent-tools/doc-check.mjs

@@ -15,6 +15,7 @@
  */
 import { resolve } from "node:path"
 import { projectRootView } from "../manifest.mjs"
+import { resolvePathTarget } from "../path-resolve.mjs"
 import { runDocCheck } from "../doc-check/index.mjs"
 import { DESC } from "../tools/shared.mjs"
 
@@ -31,10 +32,25 @@ export const docCheckTool = {
   },
   readonly: true,
   execute(args, ctx) {
-    const anchor = ctx?.agent?.cwd ?? ctx?.cwd ?? process.cwd()
-    const target = args?.target ? resolve(anchor, String(args.target)) : resolve(anchor)
+    const anchor = ctx?.agent?.cwd ?? ctx?.cwd
     const mode = args?.mode === undefined ? "report" : String(args.mode)
     if (mode !== "report" && mode !== "gate") return `doc_check: unknown mode "${mode}" — use "report" (a report over the documents you list) or "gate" (this round's documents).`
+    // `target` 的路径判定经统一解析层（`kind:"dir"` / `order:"root-first"`）：判不出唯一根 ⇒ 报明候选（KD-5
+    // 的形），解析出 ⇒ 用。`dangling` 不阻断本面——本面判据 = 内置常量、不读声明面，任可判目录都能跑
+    // （受判档由 `docs` 给定），故无项目根时按显式目标 ∥ 会话锚照跑（受理判据归本面）。
+    const picked = resolvePathTarget(anchor, args?.target, { kind: "dir", order: "root-first" })
+    if (picked.state === "ambiguous") {
+      if (mode === "gate") {
+        return [
+          "DOC-CHECK GATE: ERROR（多项目工作区：请指名 target）",
+          `候选：${picked.candidates.join(" ∥ ")}`,
+          "处置：指名项目根（`target`）后复跑",
+        ].join("\n")
+      }
+      return `doc_check: ${anchor} is a workspace holding ${picked.candidates.length} projects — pass the project root explicitly via target:\n` +
+        picked.candidates.map((c) => `- ${c}`).join("\n")
+    }
+    const target = picked.state === "resolved" ? picked.abs : resolve(anchor, args?.target ? String(args.target) : "")
     const explicit = Array.isArray(args?.docs) ? args.docs : null
     if (args?.docs !== undefined && !Array.isArray(args.docs)) {
       return `doc_check: \`docs\` must be an array of paths (got ${typeof args.docs}) — a bare string is refused rather than read as a whole-domain request; pass ["<path>"].`

package/agent-tools/eng.mjs

@@ -80,7 +80,7 @@ export const engTool = {
       // **零副作用**（不清 token / 不重置 _advisorRuns / 不入列 ENG_ON_REMINDER /
       // 不动 _lastEngState / 不触镜像缝）；准 ⇒ 缺档格就地建档（writer:'main'）+
       // agent.manifest ← 结果（翻转面唯一赋值点——相位行当回合起活，§2.8 F2 放行行）。
-      const r = resolveEngineeringManifest(ctx.agent.cwd ?? ctx.cwd ?? process.cwd(), { writer: "main" })
+      const r = resolveEngineeringManifest(ctx.agent.cwd ?? ctx.cwd, { writer: "main" })
       if (!r.ok && r.code !== "workspace") {
         return `Error: cannot enter engineering mode — ${r.message} (mode unchanged)`
       }

package/agent-tools/escalate-async.mjs

@@ -62,7 +62,7 @@ function overlapPaths(parent, launchSeq, childTouched) {
   const sinceKeys = new Set(since.map(key))
   const hits = childTouched.filter((p) => sinceKeys.has(key(p)))
   // relative display form (touchedFilesNote precedent)
-  const cwd = parent?.cwd ?? process.cwd()
+  const cwd = parent?.cwd
   return hits.map((p) => {
     const r = relative(cwd, p)
     return r && !r.startsWith("..") && !isAbsolute(r) ? r : p
@@ -74,7 +74,7 @@ function childTouchedDisplay(child, cwd) {
   const touched = child?._touchedFiles ?? []
   if (touched.length === 0) return "(none recorded)"
   const shown = touched.map((f) => {
-    const r = relative(cwd ?? process.cwd(), f)
+    const r = relative(cwd, f)
     return r && !r.startsWith("..") && !isAbsolute(r) ? r : f
   })
   return shown.join(", ")
@@ -85,7 +85,7 @@ function touchedFilesNote(child, cwd) {
   const touched = child?._touchedFiles ?? []
   if (touched.length === 0) return ""
   const shown = touched.map((f) => {
-    const r = relative(cwd ?? process.cwd(), f)
+    const r = relative(cwd, f)
     return r && !r.startsWith("..") && !isAbsolute(r) ? r : f
   })
   return `\nTouched files: ${shown.join(", ")}`

package/agent-tools/manifest.mjs

@@ -11,8 +11,8 @@
  *  - `write` ⇒ **点改**：读现档 → 设节点 → 落盘（`writeManifest` 内先 `validateManifest`——
  *              编辑结果非法 ⇒ 拒 + 盘零变）；**缺档 ⇒ 拒** + 引导 `init`（写不建档）。
  *
- * 写面白名单（判据单源 = `MANIFEST_SCHEMA`——钉死谓词）：**12 个可写节点** = `keys` 中**非** `nestedKeys`
- * 父键者（`version` / `phase` / `codePaths` 整键）+ `nestedKeys` 子键（`docRoot.*` 五子键 / `index.*` 四子键）；
+ * 写面白名单（判据单源 = `MANIFEST_SCHEMA`——钉死谓词）：**13 个可写节点** = `keys` 中**非** `nestedKeys`
+ * 父键者（`version` / `phase` / `codePaths` 整键）+ `nestedKeys` 子键（`docRoot.*` 六子键 / `index.*` 四子键）；
  * **两族整键写（传整个对象）⇒ 拒**；白名单外 ⇒ 拒（拼写保护——未知键写盘 = 静默死键，KD-M1-36 问题本体）。
  * `value` 解析 = 同款口径 `settings.mjs` 的 `parseValue`（先 `JSON.parse`，失败取字面串；`"null"` ⇒ `null`
  * ——`docRoot.*` 的「本面无」，KD-M1-37）。
@@ -39,7 +39,7 @@
 import { existsSync } from "node:fs"
 import { join, resolve } from "node:path"
 import { MANIFEST_REL, MANIFEST_SCHEMA, initManifest, projectRootView, projectView, readManifest, writeManifest } from "../manifest.mjs"
-import { DESC } from "../tools/shared.mjs"
+import { DESC, LEDGER_PARAM_DESC_MANIFEST, PROJECT_PARAM_DESC } from "../tools/shared.mjs"
 import { clearDeclarationCache } from "../conventions.mjs" // #1367 面⑦：写档成功 ⇒ 缓存失效（fix 轮接线）
 
 /** 拒面统一前缀（设计 §2.10：`manifest <action>: refused — …`）——盘零变类拒绝一律经此抛错。 */
@@ -48,9 +48,9 @@ function refuse(action, reason) {
 }
 
 /** `target` 解析（先例 `eng.mjs` 的 `resolveEngineeringManifest` 缺省会话锚 ∥ `git.mjs` 的 `resolveBaseDir` 相对形归一）：缺省 = 会话锚
- *  （`ctx.agent.cwd ?? ctx.cwd ?? process.cwd()`）；显式相对形按会话锚归一（绝对形原样）。 */
+ *  （`ctx.agent.cwd ?? ctx.cwd`）；显式相对形按会话锚归一（绝对形原样）。 */
 function resolveTarget(args, ctx) {
-  const base = ctx?.agent?.cwd ?? ctx?.cwd ?? process.cwd()
+  const base = ctx?.agent?.cwd ?? ctx?.cwd
   return args?.target ? resolve(base, String(args.target)) : resolve(base)
 }
 
@@ -134,6 +134,9 @@ export const manifestTool = {
       target: { type: "string", description: "Explicit target directory — defaults to the session anchor; relative paths resolve against it. A workspace target (several projects below it) is refused with the full project list — pass the project root you mean." },
       key: { type: "string", description: "(write) Dot path of the node to set — version / phase / codePaths, or a sub-key of docRoot / index (e.g. docRoot.design / index.publicRepos); whole-object writes of those two families are refused", },
       value: { type: "string", description: "(write) New value — parsed as JSON first (null / true / 5 / [\"a\"]), otherwise kept as a literal string; \"null\" is the explicit no-such-face for docRoot.<key>" },
+      ledger: { type: "string", description: LEDGER_PARAM_DESC_MANIFEST },
+      // 项目声明面（决策 40）：`target` 缺位时才被读（定位参数优先）；纯声明，不改查/建的目标目录。
+      project: { type: "string", description: PROJECT_PARAM_DESC },
     },
     required: ["action"],
   },

package/agent-tools/read-history.mjs

@@ -80,8 +80,8 @@ function messageText(m) {
 
 /** Truncate long content (~500 chars) with an explicit marker. The cut never splits a UTF-16
  *  surrogate pair (emoji etc.) — a lone high surrogate in tool output would be an eyesore at
- *  minimum; the send layer sanitizes it anyway, but clean output costs nothing (setup.mjs
- *  safeSliceUTF16 same rule). */
+ *  minimum; the send layer sanitizes it anyway, but clean output costs nothing
+ *  (thincoder-core/text-budget.mjs `safeSliceUTF16` same rule). */
 function truncateContent(text) {
   const t = String(text ?? "")
   if (t.length <= CONTENT_CAP) return t
@@ -190,7 +190,7 @@ function exceedsScanMax(file) {
 
 /** 跨会话深查（回落面）：单个槽文件，同 filter 面（§6.13 D-R19a——两道护栏逐字保留）。 */
 function querySessionFile(pathArg, { role, kwRe, tool, since, until, direction, limit }, baseCwd) {
-  const file = isAbsolute(pathArg) ? pathArg : resolve(baseCwd ?? process.cwd(), pathArg)
+  const file = isAbsolute(pathArg) ? pathArg : resolve(baseCwd, pathArg)
   if (!existsSync(file)) return `Error: session file not found: ${file}`
   if (exceedsScanMax(file)) return TOO_LARGE_ERROR
   let text
@@ -221,7 +221,7 @@ function querySessionFile(pathArg, { role, kwRe, tool, since, until, direction,
  *  ——评审 #2：摘要必须含寻址字段——模型第二步深查 = 复制行内文件路径重调 path=）。
  *  计数不可得 = `null` ⇒ `messages: —`（§6.25 判据句 4——禁显示数值 0：真 0 与未知可分）。 */
 function discoverCwd(raw, baseCwd) {
-  const dir = resolve(baseCwd ?? process.cwd(), raw)
+  const dir = resolve(baseCwd, raw)
   let st = null
   try {
     st = statSync(dir)
@@ -358,7 +358,7 @@ export const readHistoryTool = {
     // keyword stays a literal substring).
     const kwRe = keyword ? new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i") : null
     const tool = typeof a.tool === "string" && a.tool.length > 0 ? a.tool : null
-    const baseCwd = ctx.agent?.cwd ?? process.cwd()
+    const baseCwd = ctx.agent?.cwd
 
     const pathArg = typeof a.path === "string" && a.path.trim().length > 0 ? a.path.trim() : null
     if (pathArg !== null) {

package/agent-tools/review-facts.mjs

@@ -9,11 +9,15 @@
  *    既有 import 面）；`resolveReviewDocPaths` = 评审文档路径解析单源；
  *  - 2026-10-25（评审文档路径收正批）：该解析器收为**单规则**——相对形按会话项目根 / 绝对形
  *    照用 / 受理 = 项目内现存 `.md`；候选试探与歧义归一退场（判据正文 = `ADVISOR-GUARDS.md` §12）。
+ *  - 2026-11-02（path-resolution-unify 批）：路径判定改调统一解析层（`../path-resolve.mjs`）——
+ *    本面只留受理判据；拒因词 `no-project-root` 退役，拆成 `ambiguous-path`（判不出唯一基根）
+ *    ∥ `dangling-path`（无项目根）。
  */
 import { existsSync, statSync } from "node:fs"
-import { isAbsolute, join, relative, resolve, sep } from "node:path"
+import { isAbsolute, join, relative, sep } from "node:path"
 import { DEFAULT_MANIFEST, docRootPaths, readManifest } from "../manifest.mjs"
 import { owningProject, projectRootView } from "../manifest-discovery.mjs"
+import { resolvePathTarget } from "../path-resolve.mjs"
 
 /** ABS 归一（cwd 相对 → cwd 拼接）——陈旧判定 / 冻结拦截 / 评审范围键同源（ADVISOR-GUARDS.md §5 E-4）。 */
 export function normAbs(p, cwd) {
@@ -66,26 +70,40 @@ function isInside(p, root) {
 
 /**
  * **评审文档路径解析单规则**（判据正文 = `docs/core/design/ADVISOR-GUARDS.md` §12）——逐文档：
- *   ① 相对形：基面 = **会话项目根** `projectRootView(cwd).root`——`p = resolve(根, doc)`；越根 ⇒ `outside-project`；
- *   ② 相对形 ∧ 项目根解析不出（锚 = `workspace` / `none`）⇒ `no-project-root`；
- *   ③ 绝对形：照用（零根试探、零拼接）；不住在任何项目里（`owningProject` 空）⇒ `outside-project`；
- *   ④ 受理 = 现存普通文件 ∧ `.md`（大小写不敏感）；否则 `not-doc-file`。
- *   **零试探**：无候选项目根、无祖先链、无歧义归一——路径要求写对（用户 2026-10-25 11:41
- *   「为啥要试探？不能要求写对吗？」）。
+ *   ① 路径判定全部经统一解析层（`kind:"file"` / `order:"root-first"` / `bases` = 无 /
+ *      `scanBases` = `docRoot` 各键——只喂同名候选，不作受理基底；本面受理面零放宽）；
+ *   ② 判不出唯一基根（层判 `ambiguous`——工作区锚）⇒ `ambiguous-path` + 候选全列；
+ *      无项目根（层判 `dangling.level:"base"`）⇒ `dangling-path`；
+ *   ③ 相对形 ∧ 锚无项目根 ⇒ `dangling-path`（受理判据「必须在项目内」——档层无根时相对形无基可挂）；
+ *      相对形越根 ⇒ `outside-project`；
+ *   ④ 绝对形照用（零根试探、零拼接）；不住在任何项目里（`owningProject` 空）⇒ `outside-project`；
+ *   ⑤ 受理 = 现存普通文件 ∧ `.md`（大小写不敏感）；否则 `not-doc-file`。
+ *   **零试探**：层判不出唯一即停（用户 2026-10-25 11:41「为啥要试探？不能要求写对吗？」）。
  *   非字符串 / 空白串项**静默跳过**（同 docSetKey 既有过滤语义——不进 resolved / invalid）。
- * @returns {{ resolved: Map<string,string>, invalid: Array<{doc: string, resolved: string|null, reason: string}> }}
- *   `reason` ∈ `no-project-root` / `outside-project` / `not-doc-file`（标识行恒 `criterion=scope-not-doc`，
- *   三值只作 `reason=`）；`resolved` 项 = 解析后绝对路径（`no-project-root` 无基面 ⇒ `null`）。
+ * @returns {{ resolved: Map<string,string>, invalid: Array<{doc: string, resolved: string|null, reason: string,
+ *   candidates?: string[], sameName?: string[]}> }}
+ *   `reason` ∈ `ambiguous-path` / `dangling-path` / `outside-project` / `not-doc-file`（标识行恒
+ *   `criterion=scope-not-doc`，四值只作 `reason=`）；`resolved` 项 = 解析后绝对路径（无基面 ⇒ `null`）。
  */
 export function resolveReviewDocPaths(documents, cwd) {
-  const view = projectRootView(cwd ?? process.cwd())
+  const view = projectRootView(cwd)
+  const scanBases = resolveReviewRootsFor(cwd)
   const resolved = new Map()
   const invalid = []
   for (const doc of (documents ?? [])) {
     if (typeof doc !== "string" || !doc.trim()) continue
     const abs = /^[a-zA-Z]:[\\/]/.test(doc) || doc.startsWith("/") || doc.startsWith("\\\\")
-    if (!abs && view.state !== "ok") { invalid.push({ doc, resolved: null, reason: "no-project-root" }); continue }
-    const p = abs ? doc : resolve(view.root, doc)
+    const r = resolvePathTarget(cwd, doc, { kind: "file", order: "root-first", crossRepo: "dangling", scanBases })
+    if (r.state === "ambiguous") { invalid.push({ doc, resolved: null, reason: "ambiguous-path", candidates: r.candidates }); continue }
+    // 相对形 ∧ 锚无项目根 ⇒ 无基可挂（受理判据「必须在项目内」）——**与盘上有没有那档无关**：
+    // 同一锚态同一个词（KD-8），否则拒因词成了磁盘状态的函数。
+    if (!abs && view.state !== "ok") { invalid.push({ doc, resolved: null, reason: "dangling-path" }); continue }
+    if (r.state === "dangling") {
+      if (r.level === "base") { invalid.push({ doc, resolved: null, reason: "dangling-path" }); continue }
+      invalid.push({ doc, resolved: r.tried?.[0] ?? null, reason: "not-doc-file", sameName: r.sameName })
+      continue
+    }
+    const p = r.abs
     if (!abs && !isInside(p, view.root)) { 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 }

package/agent-tools/spawn-gates.mjs

@@ -4,7 +4,7 @@
  * 已实现：F2（round 枚举 + 任务书参数门/拼装）· F6（files 声明面拦截谓词）。
  * 2026-10-24（AGENT-LOOP-SUBAGENT.md §6.22）：任务书单通道 = 批次档 §2——工程角色
  *   （eng-coder / eng-designer）零任务书文本参数，八个自由文本键（键在场即拒）命中即点名拒收；
- *   非工程角色（explore / plan / coder）保持四项核心 + `scope`。
+ *   非工程角色（explore / plan / coder / tester）保持四项核心 + `scope`。
  * 裁撤（2026-09-17 主 agent 裁定——不落代码）：
  *   - F4 修复轮窄带：全量勘察散文 marker 不可机判（误拒风险不可接受）→ 由 F2 的 round 参数承载轮次语义；
  *   - F5 advisor 角色：advisor 不入 spawn 通道（评审走 advisor 工具）——enum 收正为
@@ -26,7 +26,7 @@ const TASK_BOOK_CORE_MIN = {
   reportFormat: "交付表 + 文件路径 + 验证命令与结果。",
 }
 
-/** 非工程角色样例（核心四项 + `scope`）——explore / plan / coder。 */
+/** 非工程角色样例（核心四项 + `scope`）——explore / plan / coder / tester。 */
 export const PLAIN_TASK_BOOK_MIN = { ...TASK_BOOK_CORE_MIN, scope: "只读：相关源 / 设计档；不写任何文件、不碰 bench/。" }
 
 /**
@@ -80,7 +80,7 @@ export function rejectEngFreeTextParams(args, role) {
   if (offending.length === 0) return
   const names = offending
     .map((name) => (name === "designPoints"
-      ? `${name} (designPoints is retired for every role — write §2, or scope for explore/plan/coder)`
+      ? `${name} (designPoints is retired for every role — write §2, or scope for explore/plan/coder/tester)`
       : name))
     .join(" / ")
   const required = ENG_REQUIRED_NAMES[role] ?? "role · batchDoc (readable) · round"
@@ -182,22 +182,18 @@ const PROCESS_BASENAMES = new Set(["changelog.md"])
 const MANIFEST_BASENAME = "project-manifest.json"
 
 /**
- * F6 files 声明面拦截谓词（ENGINEERING-MODE-V2-MODULE-DELEGATION §2.2）：
- * scripts/*（工程工具面不入域——**层级锚定：仅仓根与直接子层**——目录名在深层不携带
- * face 信息（2026-10-14 收正：#1449——`deployment/<x>/scripts/*` 类交付物放行）——内容
- * 产物 only）与过程档（父侧职责）→ 收集全部违规后抛合并错误（fail-closed——错误即工具
- * 结果 JSON——无排队残留）。目录声明不在本谓词（normalizeFileList 循环内先行拒——错误
- * 序不变）。调用点 = normalizeFileList（subagent-scheduler.mjs——本谓词在循环后跑——
- * 目录错误先于过程档错误）。
+ * F6 files 声明面拦截谓词（ENGINEERING-MODE-V2-MODULE-DELEGATION §2.2）：过程档（父侧职责）与项目状态档
+ * → 收集全部违规后抛合并错误（fail-closed——错误即工具结果 JSON——无排队残留）。目录声明不在本谓词
+ * （normalizeFileList 循环内先行拒——错误序不变）。调用点 = normalizeFileList（subagent-scheduler.mjs——
+ * 本谓词在循环后跑——目录错误先于过程档错误）。
+ * 产品面路径（含仓根 `scripts/**` · `test/**`）本就该进 `files` 声明面——工程工具面退役后不再有这一臂。
  */
-export function rejectEngineeringFilePaths(files) {
+export function rejectProcessDocPaths(files) {
   const violations = []
   for (const f of Array.isArray(files) ? files : []) {
     const segs = String(f).replace(/\\/g, "/").split("/").filter((s) => s)
     const base = (segs[segs.length - 1] ?? "").toLowerCase()
-    if (segs.slice(0, 2).some((s) => s.toLowerCase() === "scripts")) {
-      violations.push(`engineering-tools face path ${f} must not be listed in files — scripts/* at the repo root or a direct child package is the engineering-tools face, not a content product (applies to every session, not engineering-mode-scoped; files carries source/test/design-doc paths only)`)
-    } else if (PROCESS_BASENAMES.has(base)) {
+    if (PROCESS_BASENAMES.has(base)) {
       violations.push(`Parent-side maintained file ${f} must not be listed in files — reconciliation is the parent's duty; use the design-doc path if you need to edit a design doc`)
     } else if (base === MANIFEST_BASENAME) {
       violations.push(`Manifest file ${f} must not be listed in files — PROJECT-MANIFEST.json is the project state manifest and the main agent is its only writer (M1 write gate); this files-domain check is the second line of defense`)