@thincoder/core 0.10.9 → 0.10.10

package/doc-check/index.mjs

@@ -1,109 +1,91 @@
 /**
- * doc-check/index.mjs — 文档纪律机检 · 引擎入口（域扫描 + 声明面读取 + 报面行）。
+ * doc-check/index.mjs — 文档纪律机检 · 引擎入口（两条判据 + 报面行）。
  *
  * 判据两条（起步 · 闭集——口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.20 条目 S）：
  *   ① 锚（档缺 / 节缺）——实现 = `./anchors.mjs`；② 行宽——口径 = §3.18 条目 Q，实现 = `./width.mjs`。
- * 判据参数由**被开发项目**的 `PROJECT-MANIFEST.json` `checkConfig` 声明（不硬编码任何本仓路径）。
+ * 判据参数 = **工具内置常量** `DOC_CHECK_BUILTINS`：不读任何项目的声明面，因而没有「缺参数 ⇒ 拒跑」这一层，
+ *   也没有常量校验面——改判据 = 改代码、走评审。
+ * 判定范围 = **调用方传入的文件清单**（判定范围 = 解析范围 = 传入的那几档；无目录遍历、无全域兜底）：
+ *   不给清单 ⇒ 明确报错要求显式清单——判了本轮没碰过的档，别轮的存量问题会记到本轮头上。
  * 两种问法（§3.20「工具形」——同一条判据）：
- *   `report`（缺省）= 全域报告态——**零门禁 / 零退出码 / 零阻断**，输出不得被读作拒执行的理由（用户令 > 机检）；
- *   `gate` = 交付时点的**范围化裁定**——只判本轮改过的档（整档入判），首行给机器可判 verdict；
- *   强制面住交付协议 + 批次档 §6 前置，工具本体仍不阻断任何动作。
+ *   `report`（缺省）= 报告态——**零门禁 / 零退出码 / 零阻断**，输出不得被读作拒执行的理由（用户令 > 机检）；
+ *   清单里不可判档（不在盘 ∥ 非 .md）⇒ 报错点名、整次零判定；
+ *   `gate` = 交付时点的裁定——首行给机器可判 verdict；不可判档给跳过行（可见，不静默丢掉）。
+ *   强制面住交付协议 + 批次档 §6 前置，工具本体不阻断任何动作。
  */
 import { statSync } from "node:fs"
 import { relative, resolve } from "node:path"
-import { MANIFEST_REL, readManifest } from "../manifest.mjs"
-import { anchorRootError } from "../manifest-schema.mjs"
-import { scanDomain, checkDocWidths } from "./width.mjs"
+import { checkDocWidths } from "./width.mjs"
 import { checkAnchors } from "./anchors.mjs"
 
+/** 判据参数（内置常量 · 冻结）：阈值 300 字符；两项空列表 = 区带类 / 豁免类默认值且恒空
+ *  ——豁免谓词（表行 / 围栏 / 可执行行 / 引文）住代码，没有「登记后放过」的写入口（空列表 ≠ 可登记豁免）。 */
+export const DOC_CHECK_BUILTINS = Object.freeze({
+  lineWidth: 300,
+  widthExemptZones: Object.freeze([]),
+  exemptions: Object.freeze([]),
+})
+
 /** 相对路径显示形（正斜杠——跨平台同形）。 */
 const rel = (root, p) => relative(root, p).replace(/\\/g, "/")
 
-/** 平台路径键（Windows 大小写不敏感——只用于域集比对，非判据面）。 */
+/** 平台路径键（Windows 大小写不敏感——只用于清单去重，非判据面）。 */
 const pathKey = (p) => (process.platform === "win32" ? p.toLowerCase() : p)
 
-/** 文件存在性（目录 / 读错 ⇒ false）。 */
-function isFile(p) { try { return statSync(p).isFile() } catch { return false } }
-
-/** gate 取参失败（manifest 不可读 ∥ checkConfig 不合法）——**不产 PASS**（消费面 fail-closed）。 */
-function gateParamError(base, read) {
-  const reason = read.reason === "missing"
-    ? `${MANIFEST_REL} 不在 ${base}`
-    : (read.errors?.length ? read.errors.join("；") : String(read.reason ?? "未知原因"))
-  return {
-    report: [
-      `DOC-CHECK GATE: ERROR（manifest 不可读 —— ${reason}）`,
-      "原因：取参失败——判据参数来自 `PROJECT-MANIFEST.json` `checkConfig`，无声明面即无判据",
-      "处置：修声明面（`checkConfig`）后复跑",
-    ].join("\n"),
-    hits: { total: 0, anchors: 0, width: 0 }, anchorHits: [], widthHits: [], anchorReports: [],
-    files: [], checkFiles: [], scanDirs: [], lineWidth: null, zones: [], exclude: [],
-    skipped: { outside: [], gone: [] }, error: "manifest",
-  }
-}
-
-/** 声明面形态判据（gate 专用——报告态行为逐字不变）：取参不合法 ⇒ 判据失效却出 PASS = fail-open，故 gate 先判后跑。
- *  分工：**整键缺** = 上方 `read.missingKeys` 判据（`fillDefaults` 会补内置默认值）；**子键形态** = 本函数
- *  （`validateManifest` 只拒 `docRoot` 值与三族键形态，`checkConfig` 子键不拒 ⇒ 不在这里判就没人判）。 */
-function configError(cfg) {
-  if (cfg === null || typeof cfg !== "object" || Array.isArray(cfg)) return "`checkConfig` 须为对象"
-  if (!Array.isArray(cfg.scanDirs) || cfg.scanDirs.length === 0 || !cfg.scanDirs.every((d) => typeof d === "string" && d.trim() !== "")) {
-    return "`checkConfig.scanDirs` 须为非空字符串数组（空域不得出 PASS——空域假绿比红更坏）"
-  }
-  if (typeof cfg.lineWidth !== "number" || !Number.isFinite(cfg.lineWidth) || cfg.lineWidth <= 0) return "`checkConfig.lineWidth` 须为正有限数值"
-  if (cfg.widthExemptZones !== undefined && !Array.isArray(cfg.widthExemptZones)) return "`checkConfig.widthExemptZones` 须为数组"
-  if (cfg.anchors !== undefined) {
-    if (cfg.anchors === null || typeof cfg.anchors !== "object" || Array.isArray(cfg.anchors)) return "`checkConfig.anchors` 须为对象"
-    if (cfg.anchors.exclude !== undefined && !Array.isArray(cfg.anchors.exclude)) return "`checkConfig.anchors.exclude` 须为数组"
-    if (cfg.anchors.roots !== undefined) {
-      if (!Array.isArray(cfg.anchors.roots)) return "`checkConfig.anchors.roots` 须为字符串数组（元素 = 相对项目根的目录）"
-      for (const r of cfg.anchors.roots) {
-        const why = anchorRootError(r)
-        if (why) return `\`checkConfig.anchors.roots\` ${why}：${JSON.stringify(r)}`
-      }
-    }
-  }
+/** 不可判档的两因（闭集 · 判序 = 存在性 → 类型）：不在盘 ∥ 非 markdown 档（目录归后因）。 */
+function undecidableReason(abs) {
+  let st
+  try { st = statSync(abs) } catch { return "not on disk" }
+  if (!st.isFile() || !abs.toLowerCase().endsWith(".md")) return "not a markdown document"
   return null
 }
 
-/**
- * gate 范围求交：候选（`docs`）= 显式清单 ∥ 本会话触达记账 ⇒ **声明域内 ∧ 盘上存在的 `.md`**。
- * 域外 / 已删**不是命中**但必须可见（跳过行）——静默丢掉会把「没跑」装成「跑了且清」。
- * 解析基线不缩：域内全集仍交锚判据建索引（只收窄被判档）。
- */
-function resolveRange(base, files, docs) {
-  const inDomain = new Map(files.map((f) => [pathKey(f), f]))
-  const check = new Set()
-  const outside = []
-  const gone = []
-  for (const d of Array.isArray(docs) ? docs : []) {
-    if (typeof d !== "string" || d.trim() === "") continue
+/** 清单 → 可判集（去重保序）+ 不可判档两类（`missing` ∥ `notMarkdown`）+ 非法条目下标（非字符串 / 空白）。 */
+function resolveRange(base, docs) {
+  const seen = new Set()
+  const check = []
+  const undecidable = []
+  const missing = []
+  const notMarkdown = []
+  const invalid = []
+  docs.forEach((d, i) => {
+    if (typeof d !== "string" || d.trim() === "") { invalid.push(i); return }
     const abs = resolve(base, d)
-    const hit = inDomain.get(pathKey(abs))
-    if (hit) check.add(hit)
-    else if (isFile(abs)) outside.push(abs)
-    else gone.push(abs)
-  }
-  return { check: [...check].sort(), outside, gone }
+    const key = pathKey(abs)
+    const reason = undecidableReason(abs)
+    if (reason === null) { if (!seen.has(key)) { seen.add(key); check.push(abs) } return }
+    undecidable.push({ abs, reason })
+    if (reason === "not on disk") missing.push(abs)
+    else notMarkdown.push(abs)
+  })
+  return { check: check.sort(), undecidable, missing, notMarkdown, invalid }
 }
 
 /** gate 报面（固定句形——§3.20「报面（固定句形 · 交付门 gate）」）：首行 verdict = 唯一机判串。 */
-function gateReport({ base, docsSource, checkFiles, domainCount, skipped, anchors, widths, lineWidth, exclude }) {
+function gateReport({ base, docsSource, checkFiles, skipped, anchors, widths, lineWidth }) {
   const total = anchors.hits.length + widths.length
   const src = docsSource === "session" ? "本会话写过的文档" : "显式 docs"
   const out = [
     total ? `DOC-CHECK GATE: REFUSED（命中 ${total} 条）` : (checkFiles.length ? "DOC-CHECK GATE: PASS" : "DOC-CHECK GATE: PASS（0 档）"),
     "文档纪律机检（交付门 · gate）",
-    `范围：${src} ${checkFiles.length} 档（声明域 ${domainCount} 档）· 阈值 ${lineWidth} 字符（运行时取 checkConfig.lineWidth）· 排除：${exclude.length ? exclude.join(" ∥ ") : "（无）"}`,
-    "判据：与报告态同源（`PROJECT-MANIFEST.json` `checkConfig`）——范围只收窄被判档，不收窄解析",
+    checkFiles.length
+      ? `范围：${src} ${checkFiles.length} 档 · 阈值 ${lineWidth} 字符（工具内置常量）`
+      : `范围：${src} —— **0 档受检**（空清单：本次没有判任何档，不得读作「已检」）· 阈值 ${lineWidth} 字符（工具内置常量）`,
+    "判据：工具内置常量（锚 ∥ 行宽）——判定范围 = 解析范围 = 传入档",
   ]
-  if (skipped.outside.length) out.push(`跳过 ${skipped.outside.length} 档（不在声明域内，未检）：${skipped.outside.map((p) => rel(base, p)).join(" ∥ ")}`)
-  if (skipped.gone.length) out.push(`跳过 ${skipped.gone.length} 档（已不在盘，未检）：${skipped.gone.map((p) => rel(base, p)).join(" ∥ ")}`)
+  if (skipped.missing.length) out.push(`跳过 ${skipped.missing.length} 档（已不在盘，未检）：${skipped.missing.map((p) => rel(base, p)).join(" ∥ ")}`)
+  if (skipped.notMarkdown.length) out.push(`跳过 ${skipped.notMarkdown.length} 档（非 markdown 档，未检）：${skipped.notMarkdown.map((p) => rel(base, p)).join(" ∥ ")}`)
   if (checkFiles.length === 0) {
-    // 空范围不静默当通过（K6）——照实说明 + 给出补充通道
+    // 空范围不静默当通过（K6）——照实说明 + 给出补充通道（两侧都不得读成「已检」）。
+    // 措辞按「有没有跳过行」分流：无跳过行时不得写「见上方跳过行」。
+    const hasSkips = skipped.missing.length > 0 || skipped.notMarkdown.length > 0
     out.push(docsSource === "session"
-      ? "范围为空：本会话没有写过声明域内的文档——若确认改过 ⇒ 显式传 docs"
-      : "范围为空：显式 docs 无一落在声明域内——见上方跳过行")
+      ? (hasSkips
+        ? "范围为空：本会话触达的档均不可判（见上方跳过行）——若确认改过 ⇒ 显式传 docs"
+        : "范围为空：本会话没有写过 .md 档——若确认改过 ⇒ 显式传 docs")
+      : (hasSkips
+        ? "范围为空：显式 docs 里没有可判档——见上方跳过行"
+        : "范围为空：显式 docs 是空清单——列出要判的档后复跑"))
   } else if (total === 0) {
     out.push(`结论：0 条命中（${checkFiles.length} 档全清）`)
   } else {
@@ -120,91 +102,71 @@ function gateReport({ base, docsSource, checkFiles, domainCount, skipped, anchor
 
 /**
  * 跑一次文档纪律机检。
- * @param {string} root 项目根（判据参数取该根的 `PROJECT-MANIFEST.json` `checkConfig`）
+ * @param {string} root 项目根（解析序 ① 的基准）
  * @param {{docs?:string[], mode?:'report'|'gate', docsSource?:'session'|'explicit'}} [o]
- *   `mode` 缺省 = `report`（全域报告态）；`docs` = **仅 gate** 的范围候选（相对 `root` 或绝对）；
- *   `docsSource` = 范围来源标签（`session` = 本会话触达记账 ∥ `explicit` = 显式 `docs`）——缺省按 `docs` 是否给定推定；只影响报面措辞。
+ *   `mode` 缺省 = `report`；`docs` = 被判档清单（相对 `root` 或绝对）——**必填**（两种问法同）：
+ *   缺省 ∥ 非数组 ⇒ 报错要求显式清单（零遍历、零全域兜底）；`report` 面**空数组也报错**，`gate` 面空数组 ⇒
+ *   `PASS（0 档）` + 空范围说明（「本轮一档没碰」是真实读数）；`report` 面不可判档 ⇒ 报错、整次零判定；
+ *   `gate` 面不可判档 ⇒ 跳过行；`docsSource` = 范围来源标签（`session` = 本会话触达记账 ∥ `explicit` = 显式
+ *   `docs`）——缺省 = `explicit`；只影响报面措辞。
  * @returns {{report:string, hits:{total:number, anchors:number, width:number}, anchorHits:Array,
- *   widthHits:Array, anchorReports:Array, anchorRootGaps:Array, files:string[], checkFiles:string[], scanDirs:string[],
- *   lineWidth:number|null, zones:string[], exclude:string[], skipped:{outside:string[], gone:string[]},
- *   error?:"manifest"}}
- *   `error` 在场 ⇒ 取参失败形（首行 = `DOC-CHECK GATE: ERROR（…）`、`lineWidth` = null、`hits` 恒 0）——
- *   消费面判「清」须读 `report` 首行，不得只看 `hits.total`（0 与「未跑成」不同义）。
+ *   widthHits:Array, files:string[], checkFiles:string[], lineWidth:number,
+ *   skipped:{missing:string[], notMarkdown:string[]}}}
+ *   消费面判「清」须读 `report` 首行（gate）∥ `hits.total`（report），不得只看其中一个。
  */
 export function runDocCheck(root, { docs, mode = "report", docsSource } = {}) {
   const base = resolve(root)
   const gate = mode === "gate"
-  // `docs` = gate 专属（report + docs ⇒ 拒，不静默忽略——与工具面同一判据）
-  if (!gate && docs !== undefined) throw new Error("doc_check: `docs` is gate-only — report mode always checks the whole declared domain")
-  const source = docsSource ?? (docs === undefined ? "session" : "explicit")
-  let read
-  try {
-    read = readManifest(base)
-  } catch (e) {
-    if (!gate) throw e // 报告态既有行为逐字不变（读错 fail-closed 上抛）
-    return gateParamError(base, { reason: "unreadable", errors: [e?.message ?? String(e)] })
+  if (docs !== undefined && !Array.isArray(docs)) {
+    throw new Error(`doc_check: \`docs\` must be an array of paths (got ${typeof docs}) — a bare string is refused rather than read as a whole-domain request; pass ["<path>"].`)
   }
-  if (!read.ok) {
-    if (gate) return gateParamError(base, read)
-    throw new Error(`doc_check: cannot read ${MANIFEST_REL} at ${base} — the check parameters come from that project's checkConfig (${read.reason ?? read.errors.join("；")})`)
+  if (!Array.isArray(docs)) {
+    throw new Error('doc_check: `docs` is required — pass the explicit list of documents to judge. There is no default range: nothing is scanned unless you name it.')
   }
-  // `checkConfig` 整键缺失：`readManifest` 会经 `fillDefaults` 灌入默认值（`missingKeys` 是唯一痕迹）——
-  // gate 不得拿内置默认值当声明面（设计「取参失败 ⇒ ERROR」的第一支）。
-  if (gate && (read.missingKeys ?? []).includes("checkConfig")) {
-    return gateParamError(base, { reason: "invalid-config", errors: ["`checkConfig` 缺——声明面未声明判据参数"] })
+  // 报告态空清单 = 报错（「没跑」不得装成「跑了且清」）；gate 面空清单照实出 `PASS（0 档）` + 空范围说明
+  // ——交付面「本轮一档没碰」是一种真实读数，不是省略。
+  if (!gate && (docs.length === 0 || docs.every((d) => typeof d !== "string" || d.trim() === ""))) {
+    throw new Error('doc_check: docs is empty — an empty list names no document, so nothing can be judged; list the documents you mean.')
   }
-  const cfg = read.manifest.checkConfig ?? {}
-  if (gate) {
-    const bad = configError(cfg)
-    if (bad) return gateParamError(base, { reason: "invalid-config", errors: [bad] })
+  const source = docsSource ?? "explicit"
+  const range = resolveRange(base, docs)
+  // 清单条目本身非法（非字符串 / 空白）——调用方错误，两种问法同拒：静默丢掉一条就是不静默地收窄范围。
+  if (range.invalid.length) {
+    throw new Error(`doc_check: \`docs\` entries ${range.invalid.map((i) => `[${i}]`).join(", ")} are not paths — every entry must be a non-empty string; no document was judged.`)
+  }
+  // 报告态 fail-closed：清单里有一个不可判档 ⇒ 报错点名、整次零判定——清单写错却报 0 命中就是「没跑」装成「跑了且清」。
+  if (!gate && range.undecidable.length) {
+    const named = range.undecidable.map((u) => `${rel(base, u.abs)}（${u.reason}）`).join(" ∥ ")
+    throw new Error(`doc_check: docs names ${range.undecidable.length} document(s) that cannot be judged — no document was checked: ${named}. Fix the list and re-run; nothing is silently skipped and the check never widens beyond the list.`)
   }
-  const scanDirs = (Array.isArray(cfg.scanDirs) ? cfg.scanDirs : []).filter((d) => typeof d === "string" && d !== "")
-  const exclude = Array.isArray(cfg.anchors?.exclude) ? cfg.anchors.exclude : []
-  const roots = cfg.anchors?.roots // 原值下传：值形 ∥ 根在盘的门归 anchors（报告态弃用、不炸）
-  const lineWidth = cfg.lineWidth
-  const zones = (Array.isArray(cfg.widthExemptZones) ? cfg.widthExemptZones : []).filter((z) => typeof z === "string" && z !== "")
-
-  const files = scanDomain(base, { scanDirs, exclude })
-  const range = gate ? resolveRange(base, files, docs) : { check: files, outside: [], gone: [] }
   const checkFiles = range.check
-  const anchors = checkAnchors(base, { scanDirs, files, checkFiles, roots })
-  const widths = checkDocWidths(base, { lineWidth, scanDirs, exclude, exemptZones: zones, files, checkFiles })
+  const { lineWidth, widthExemptZones } = DOC_CHECK_BUILTINS
+  const anchors = checkAnchors(base, { files: checkFiles })
+  const widths = checkDocWidths({ lineWidth, exemptZones: widthExemptZones, files: checkFiles })
 
   const hits = { total: anchors.hits.length + widths.length, anchors: anchors.hits.length, width: widths.length }
   const shared = {
-    hits, anchorHits: anchors.hits, widthHits: widths, anchorReports: anchors.reports, anchorRootGaps: anchors.rootGaps,
-    files, checkFiles, scanDirs, lineWidth, zones, exclude, skipped: { outside: range.outside, gone: range.gone },
+    hits, anchorHits: anchors.hits, widthHits: widths, files: checkFiles, checkFiles, lineWidth,
+    skipped: { missing: range.missing, notMarkdown: range.notMarkdown },
   }
   if (gate) {
-    return {
-      ...shared,
-      report: gateReport({ base, docsSource: source, checkFiles, domainCount: files.length, skipped: shared.skipped, anchors, widths, lineWidth, exclude }),
-    }
+    return { ...shared, report: gateReport({ base, docsSource: source, checkFiles, skipped: shared.skipped, anchors, widths, lineWidth }) }
   }
 
-  const total = hits.total
   const out = [
     "文档纪律机检（报告态 · 非门禁）",
-    `射程：${base} · ${scanDirs.join(" + ") || "（无）"}（${files.length} 档）· 阈值 ${lineWidth} 字符 · 区带豁免：${zones.length ? zones.join(" ∥ ") : "无"} · 排除：${exclude.length ? exclude.join(" ∥ ") : "（无）"}`,
-    "声明：判据参数依据 `PROJECT-MANIFEST.json` `checkConfig`",
-    `命中 ${total} 条（锚 ${anchors.hits.length} · 行宽 ${widths.length}）`,
+    `射程：${base} · 传入清单 ${checkFiles.length} 档 · 阈值 ${lineWidth} 字符（工具内置常量）· 区带豁免：${widthExemptZones.length ? widthExemptZones.join(" ∥ ") : "无"}`,
+    "声明：判据参数 = 工具内置常量；范围 = 传入文件（判定范围 = 解析范围）",
+    `范围：传入清单 ${checkFiles.length} 档（整档入判 · 判定范围 = 解析范围）`,
+    `命中 ${hits.total} 条（锚 ${anchors.hits.length} · 行宽 ${widths.length}）`,
   ]
-  // 报告面（不作判）：① 声明解析根弃用 ∥ 缺位（⑤ 的配置面）；② 域内同名 ≥2 ⇒ 多义不判（残余登记——fail-open 方向，归评审核验面）
-  for (const g of anchors.rootGaps) {
-    out.push(g.kind === "missing"
-      ? `报告 锚·声明解析根缺位 \`${g.root}\`（未核、不入判）`
-      : `报告 锚·解析根弃用 ${JSON.stringify(g.root)}（值形非法：${g.reason} · 本元素不入判）`)
-  }
-  for (const r of anchors.reports) {
-    out.push(`报告 锚·多义 ${rel(base, r.file)}:${r.line} \`${r.token}\`（同名 ${r.candidates.length}：${r.candidates.map((c) => rel(base, c)).join(" ∥ ")}——报告面，不作判）`)
-  }
   for (const h of anchors.hits) {
     out.push(h.clazz === "档缺"
       ? `✗ 锚·档缺 ${rel(base, h.file)}:${h.line} \`${h.token}\``
       : `✗ 锚·节缺 ${rel(base, h.file)}:${h.line} \`${h.token}\`（目标 ${rel(base, h.target)} 无 §${h.section}）`)
   }
   for (const w of widths) out.push(`✗ 行宽 ${rel(base, w.file)}:${w.line}（${w.len} 字符）`)
-  out.push(total ? `结论：${total} 条命中——报告态，不作拒执行的理由` : "结论：0 条命中（锚 ∥ 行宽 均清）")
+  out.push(hits.total ? `结论：${hits.total} 条命中——报告态，不作拒执行的理由` : "结论：0 条命中（锚 ∥ 行宽 均清）")
 
   return { ...shared, report: out.join("\n") }
 }

package/doc-check/width.mjs

@@ -1,60 +1,16 @@
 /**
- * doc-check/width.mjs — 文档纪律机检的产品档位（行宽谓词族 + 域扫描 + 行宽判据——实现单源）。
+ * doc-check/width.mjs — 文档纪律机检的产品档位（行宽谓词族 + 行宽判据——实现单源）。
  *
- * 口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.18 条目 Q（度量 / 域 / 豁免类 / 阈值）；
+ * 口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.18 条目 Q（度量 / 豁免类）；
  * 产品内建裁定 = 同档 §3.20 条目 S——谓词单源随迁：本仓 `scripts/doc-check-width.mjs` 改述为
  * **再出口缝**（薄档 · 零逻辑 · 逐名再出口），盘上不留第二份谓词实现。
- * 度量 = `[...line].length`（CJK 计 1——不引显示宽度 / 字体）；阈值 / 域 / 排除全部读
- * `PROJECT-MANIFEST.json` 的 `checkConfig`——零硬编码本仓路径，换项目开箱可用。
+ * 度量 = `[...line].length`（CJK 计 1——不引显示宽度 / 字体）；阈值 = 调用方的内置常量
+ * （`DOC_CHECK_BUILTINS.lineWidth`）——不读声明面，也不扫目录：**判定集 = 调用方传入的文件清单**。
  * 豁免五类 = 表格行 ∥ fenced 块 ∥ 可执行行 ∥ 连续引文 ∥ 区带：**只认结构谓词**，
  * 无行级白名单（按行号 / 注释声明的豁免不入判）。
  * 边界：本档零门禁 / 零退出码 / 零阻断——报告态由 `agent-tools/doc-check.mjs` 呈现。
  */
-import { readdirSync, readFileSync, statSync } from "node:fs"
-import { join, resolve } from "node:path"
-import { MANIFEST_REL } from "../manifest.mjs"
-
-/** 域发现跳过目录（不视作候选产品域；递归亦不进入）。 */
-const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage", ".turbo", ".thincoder"])
-
-/** 域发现（声明面）：cwd 根（持 manifest）+ 各持自身 manifest 的一级子目录——判据 = manifest 在场，无路径硬编码。 */
-export function discoverDomains(root) {
-  const rootAbs = resolve(root)
-  const hasManifest = (p) => { try { return statSync(join(p, MANIFEST_REL)).isFile() } catch { return false } }
-  const out = []
-  if (hasManifest(rootAbs)) out.push(rootAbs)
-  let names = []
-  try { names = readdirSync(rootAbs) } catch { /* 不可读：仅根域 */ }
-  for (const n of names) {
-    if (SKIP_DIRS.has(n) || n.startsWith("dist-")) continue
-    const p = join(rootAbs, n)
-    try { if (statSync(p).isDirectory() && hasManifest(p)) out.push(p) } catch { /* 跳过 */ }
-  }
-  return out
-}
-
-/** 递归列 .md（跳过 SKIP_DIRS ∧ 声明面 exclude 段——exclude 逐层生效）。 */
-function walkMd(dir, exclude, out) {
-  let names = []
-  try { names = readdirSync(dir) } catch { return out }
-  for (const n of names) {
-    if (SKIP_DIRS.has(n) || n.startsWith("dist-") || exclude.includes(n)) continue
-    const p = join(dir, n)
-    let st
-    try { st = statSync(p) } catch { continue }
-    if (st.isDirectory()) walkMd(p, exclude, out)
-    else if (n.endsWith(".md")) out.push(p)
-  }
-  return out
-}
-
-/** 源域（单源）：`scanDirs` × `exclude` 声明面下的全部 .md——锚检查与行宽检查同一文件集。 */
-export function scanDomain(base, { scanDirs = [], exclude = [] } = {}) {
-  const ex = Array.isArray(exclude) ? exclude : []
-  const out = []
-  for (const d of Array.isArray(scanDirs) ? scanDirs : []) walkMd(resolve(base, d), ex, out)
-  return [...new Set(out)].sort()
-}
+import { readFileSync } from "node:fs"
 
 /** 表格行谓词（markdown 表格行结构性不可折行——行宽豁免，与锚检查同源）。 */
 export const isTableRow = (l) => /^\s*\|.*\|\s*$/.test(String(l))
@@ -94,16 +50,15 @@ export function inCodeSpan(line, idx) {
   return (String(line).slice(0, idx).match(/`/g) ?? []).length % 2 === 1
 }
 
-/** 行宽判据（单判据 = `checkConfig.lineWidth`）：`[...line].length` > 阈值 ∧ 非表格行 ∧ 非 fenced 块内
+/** 行宽判据（阈值 = 调用方内置常量 `lineWidth`）：`[...line].length` > 阈值 ∧ 非表格行 ∧ 非 fenced 块内
  *  ∧ 非可执行行 ∧ 非连续引文 ∧ 非区带内 ⇔ 命中（口径逐字 = §3.18 条目 Q）。
  *  单遍扫描携标题栈（`^(#{1,6})\s` 行入栈——同级 ∥ 更高级出栈）：行所属标题链任一为区带头 ⇒ 豁免。
  *  围栏未闭合 ⇒ 至档尾整块免（fail-open 方向——§3.18 残余登记 ①）；`exemptZones` 缺省 ∥ 空集 ⇒ 零豁免。
- *  `checkFiles`（可选）= **被判集**（gate 的范围收窄面）；缺省 ⇒ `files`（全域，报告态遍历面零变）。 */
-export function checkDocWidths(base, { lineWidth, scanDirs, exclude, exemptZones = [], files, checkFiles } = {}) {
+ *  `files`（必填）= **判定集**（调用方传入的档清单——本档不遍历任何目录；空集 ⇒ 零命中）。 */
+export function checkDocWidths({ lineWidth, exemptZones = [], files = [] } = {}) {
   const zones = (Array.isArray(exemptZones) ? exemptZones : []).filter((z) => typeof z === "string" && z !== "")
   const hits = []
-  // 被判集优先（范围只收窄被判档）；`files` 给定时直接用（调用方已扫同一域 ⇒ 域只走一遍）；缺省自扫。
-  for (const f of checkFiles ?? files ?? scanDomain(base, { scanDirs, exclude })) {
+  for (const f of files) {
     let text = ""
     try { text = readFileSync(f, "utf8") } catch { continue }
     const stack = [] // 标题栈 —— { level, exempt }；exempt = 自身 ∥ 祖先命中区带

package/i18n.mjs

@@ -60,6 +60,11 @@ export const CORE_MESSAGES = Object.freeze({
   "sub.cancelled": { en: "cancelled", zh: "已取消" },
   "sub.awaitingDigest": { en: "done · awaiting digestion", zh: "已完成 · 等待消化" },
   "sub.queueSlot": { en: "queued · position ${n} (slot full)", zh: "排队中 · 位置 ${n}（槽满等位）" },
+  // #1507 补四键（核字典缺键——值形与宿主同形：desktop `renderer/i18n.mjs:197-200` ∥ VSC `locales/{en,zh}.json`）
+  "sub.async": { en: "async", zh: "异步" },
+  "sub.sync": { en: "sync", zh: "同步" },
+  "sub.waiting": { en: "waiting", zh: "等待中" },
+  "sub.awaitingApproval": { en: "Awaiting approval: ${tool}", zh: "等待审批: ${tool}" },
   // ── 会诊状态词 ──
   "consult.answered": { en: "answered", zh: "已回复" },
   "consult.terminated": { en: "terminated", zh: "已终止" },

package/manifest-schema.mjs

@@ -1,7 +1,7 @@
 /**
  * manifest-schema.mjs — **校验 ∕ 默认值族**出档（2026-09-29 structure-split-2 · 台账 #620）：自 `manifest.mjs`
  * 全量迁出——`isValidDocRootValue`（docRoot 子键值形态判据）·
- * `DEFAULT_MANIFEST`（默认八键）· `MANIFEST_SCHEMA`（判据单源）· 元素层谓词一件 · `validateManifest` ·
+ * `DEFAULT_MANIFEST`（默认五键）· `MANIFEST_SCHEMA`（判据单源）· 元素层谓词一件 · `validateManifest` ·
  * `fillDefaults`；**结构拆分零语义**（面不变 ∕ 判据不变，只换宿主档；切点 ∕ 缝单源 =
  * 批档 `docs/batches/2026-09-29-structure-split-2.md` §2.2-C）。
  *
@@ -25,21 +25,8 @@ export function isValidDocRootValue(value) {
   return value.every((p) => typeof p === "string" && p.trim() !== "")
 }
 
-/** `checkConfig.anchors.roots` **单元素值形判据**（判据单源——解析根 = 相对项目根的目录）：
- *  合法 ⇒ `null`；非法 ⇒ 理由句（非空字符串 ∥ 相对路径 ∥ 无 `..` 越界段）。
- *  消费面两处：产品引擎 `doc-check/anchors.mjs`（报告态逐元素弃用）∥ `doc-check/index.mjs`
- *  （gate 面 `configError` 拒，fail-closed）。
- * @param {unknown} value 解析根元素
- * @returns {string|null}
- */
-export function anchorRootError(value) {
-  if (typeof value !== "string" || value.trim() === "") return "元素须为非空字符串"
-  if (/^(?:[A-Za-z]:[\\/]|[\\/])/.test(value)) return "元素须为相对项目根的路径（不得为绝对路径）"
-  if (value.split(/[\\/]/).includes("..")) return "元素不得含 `..` 越界段"
-  return null
-}
-
-/** 默认八键（架构 §2.3 E1 五键 + 三族声明键——KD-M1-31）——整档初始化的写源与缺键 fallback 的补源。 */
+/** 默认五键——整档初始化的写源与缺键 fallback 的补源；每一键描述的都是这个用户项目自身
+ *  （阶段 / 文档层 / 代码段 / 索引），产品内部布局与工具参数不住这里。 */
 export const DEFAULT_MANIFEST = Object.freeze({
   version: 1,
   phase: "initial-dev",
@@ -50,18 +37,9 @@ export const DEFAULT_MANIFEST = Object.freeze({
     modules: "docs/design/modules",
     batches: "docs/batches",
   }),
-  promptsLanding: "thincoder-core/prompts",
-  checkConfig: Object.freeze({
-    scanDirs: Object.freeze(["docs"]),
-    lineWidth: 300,
-    widthExemptZones: Object.freeze([]),
-    anchors: Object.freeze({ domain: "docs", exclude: Object.freeze(["_archive", "batches"]), roots: Object.freeze([]) }),
-    exemptions: Object.freeze([]),
-  }),
   // 项目声明三族（2026-09-27 声明载体唯一化批并入——键名 / 形态逐字承前；来源档已退役）。
   codePaths: Object.freeze(["src"]),
   index: Object.freeze({ codeExtensions: Object.freeze([]), docExtensions: Object.freeze([]), excludePaths: Object.freeze([]), publicRepos: Object.freeze([]) }),
-  advisor: Object.freeze({ docMap: "", standardsDoc: "" }),
 })
 
 /** 校验判据（模块设计 §2.2）——枚举 / 键存在（fallback 用）；判据单源（KD-M1-4）。 */
@@ -73,9 +51,7 @@ export const MANIFEST_SCHEMA = Object.freeze({
   keys: Object.freeze(Object.keys(DEFAULT_MANIFEST)),
   nestedKeys: Object.freeze({
     docRoot: Object.freeze(Object.keys(DEFAULT_MANIFEST.docRoot)),
-    checkConfig: Object.freeze(Object.keys(DEFAULT_MANIFEST.checkConfig)),
     index: Object.freeze(Object.keys(DEFAULT_MANIFEST.index)),
-    advisor: Object.freeze(Object.keys(DEFAULT_MANIFEST.advisor)),
   }),
 })
 
@@ -89,7 +65,7 @@ function isNonEmptyStringArray(v) {
  * 形状校验（模块设计 §2.2）——枚举 / version 数值恒做；**纯函数、零 fs**（原 `{ cwd }`
  * 指针分支已随字段整链裁撤——KD-M1-5 墓志）；不落盘。键存在性入 missingKeys（非拒）：
  * 缺键 = 便利 fallback（补默认值），不是错（与整档缺失两分——KD-M1-2）。
- * 未知键（#802 / KD-M1-36）：顶层 + 四嵌套层产 `unknownKeys`（非拒——ok 定性零变；产线恰 =
+ * 未知键（#802 / KD-M1-36）：顶层 + 两嵌套层产 `unknownKeys`（非拒——ok 定性零变；产线恰 =
  * fillDefaults 丢弃面；嵌套键用点形路径——同 missingKeys 口径）。
  * @param {object} obj 待校验 manifest 对象
  * @returns {{ok:boolean, errors:string[], missingKeys:string[], unknownKeys:string[]}}
@@ -100,7 +76,7 @@ export function validateManifest(obj) {
   if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
     return { ok: false, errors: ["manifest 顶层必须是 JSON 对象"], missingKeys, unknownKeys: [] }
   }
-  // #802（KD-M1-36——未知键可见化）：顶层 + 四嵌套层逐键对照（非拒——ok 定性零变；嵌套键点形）。
+  // #802（KD-M1-36——未知键可见化）：顶层 + 两嵌套层逐键对照（非拒——ok 定性零变；嵌套键点形）。
   const unknownKeys = []
   for (const key of Object.keys(obj)) if (!MANIFEST_SCHEMA.keys.includes(key)) unknownKeys.push(key)
   for (const [nested, subkeys] of Object.entries(MANIFEST_SCHEMA.nestedKeys)) {
@@ -129,7 +105,6 @@ export function validateManifest(obj) {
   // `index.excludePaths`（§6.14 面①）：**数组层** fail-closed（非数组 ⇒ 拒）；元素层宽容——空 ∕ 非串
   // 元素由归一剔除（L-①-1 夹具 `["./openclaw/","refs",""]` ⇒ `["openclaw","refs"]`）；`index.publicRepos`（§6.15）同款。
   const strArrErr = (key, v) => { if (!isNonEmptyStringArray(v)) errors.push(`${key} 值形态非法：${JSON.stringify(v)}（须为非空字符串数组——KD-M1-32）`) }
-  const strErr = (key, v) => { if (typeof v !== "string") errors.push(`${key} 值形态非法：${JSON.stringify(v)}（须为字符串——KD-M1-32）`) }
   const objErr = (key, v) => (v === null || typeof v !== "object" || Array.isArray(v)
     ? `${key} 值形态非法：${JSON.stringify(v)}（须为对象——KD-M1-32）` : null)
   if (obj.codePaths !== undefined) strArrErr("codePaths", obj.codePaths)
@@ -144,9 +119,6 @@ export function validateManifest(obj) {
       errors.push(`index.publicRepos 值形态非法：${JSON.stringify(obj.index.publicRepos)}（须为数组——非数组 fail-closed；空 ∕ 非串元素由归一剔除）`)
     }
   }
-  const advBad = obj.advisor === undefined ? null : objErr("advisor", obj.advisor)
-  if (advBad) errors.push(advBad)
-  else if (obj.advisor !== undefined) for (const k of ["docMap", "standardsDoc"]) if (obj.advisor[k] !== undefined) strErr(`advisor.${k}`, obj.advisor[k])
   if (obj.phase !== undefined && !MANIFEST_SCHEMA.enum.phase.includes(obj.phase)) {
     errors.push(`phase 取值非法："${obj.phase}"（允许：${MANIFEST_SCHEMA.enum.phase.join(" | ")}）`)
   }
@@ -156,7 +128,7 @@ export function validateManifest(obj) {
   return { ok: errors.length === 0, errors, missingKeys, unknownKeys }
 }
 
-/** 缺键补默认值（module 设计 §2.2 管线）：顶层缺键补默认、嵌套键（docRoot/checkConfig/index/advisor）
+/** 缺键补默认值（module 设计 §2.2 管线）：顶层缺键补默认、嵌套键（docRoot/index）
  *  子键补默认（与整键缺同语义）；不覆写既有值。深拷贝默认源（structuredClone）——冻结常量永不外泄引用。
  *  三族键的非对象值**原样透传**（不洗白——再校验拒，KD-M1-32）。 */
 export function fillDefaults(obj) {
@@ -167,7 +139,7 @@ export function fillDefaults(obj) {
     if (def !== null && typeof def === "object" && !Array.isArray(def)) {
       const src = obj[key]
       if (src === null || typeof src !== "object" || Array.isArray(src)) {
-        if (key === "index" || key === "advisor") out[key] = src // 形态错 → 透传（再校验拒）；docRoot/checkConfig 保持默认
+        if (key === "index") out[key] = src // 形态错 → 透传（再校验拒）；docRoot 保持默认
         continue
       }
       for (const sub of Object.keys(def)) {

package/manifest.mjs

@@ -11,8 +11,8 @@
  *    同档同键集去重、读到零未知键清该档 memo）——非拒定性零变。
  *  - validateManifest(obj) → { ok, errors, missingKeys, unknownKeys }：枚举 / version 数值 /
  *    docRoot 子键值形态（串 | 数组 | null（本面无——KD-M1-37），F7）——**纯函数、零 fs**；不落盘。
- *  - 三族声明键（`codePaths` / `index.{codeExtensions,docExtensions,publicRepos}` / `advisor.{docMap,standardsDoc}`——
- *    KD-M1-31 / M1-32）：缺键补默认；形态错 = 档非法（fail-closed，与 docRoot 子键同款）；
+ *  - 两族声明键（`codePaths` / `index.{codeExtensions,docExtensions,publicRepos}`——KD-M1-31 / M1-32）：
+ *    缺键补默认；形态错 = 档非法（fail-closed，与 docRoot 子键同款）；
  *    读向 = `declaration.mjs`（2026-10-01 自 `conventions.mjs` 迁出——经其转口可达）经 `readManifest` /
  *    `manifestFilePath` 投影（单向——KD-M1-33）；`index.publicRepos` 绝对根集 = `declaredPublicRoots`（§6.15）。
  *  - isValidDocRootValue(value) / docRootPaths(value, cwd)（F7 判据单源 KD-M1-8）：值形态谓词
@@ -35,7 +35,7 @@
  *    落盘）；仅 writer === 'main' 落盘（fail-closed 缺省拒）。
  *
  * N1 零依赖：仅 node:fs / node:path + 标准库 JSON.parse——无第三方解析器、无 node:sqlite。
- * N3 可迁移：本模块不硬编码任何本仓路径（docRoot / checkConfig 由被开发项目声明）。
+ * N3 可迁移：本模块不硬编码任何本仓路径（docRoot 由被开发项目声明；机检参数不在 manifest 面——住引擎内置常量）。
  */
 import { readFileSync, writeFileSync } from "node:fs"
 import { join, resolve } from "node:path"
@@ -277,7 +277,7 @@ export function writeManifest(cwd, manifest, { writer = "subagent" } = {}) {
 }
 
 /**
- * 初始化 = 写默认八键档（模块设计 §2.2）：只提供机制，不包交互问答（问答归壳面）。
+ * 初始化 = 写默认五键档（模块设计 §2.2）：只提供机制，不包交互问答（问答归壳面）。
  * 落盘走同一写门（内部 writeManifest(cwd, DEFAULT_MANIFEST, { writer })）——与 AC-M1-5
  * 同一闸，无第二条写路径（KD-M1-4 / 评审 #12）。
  * @returns {object} 写入的默认 manifest

package/memory/code-search.mjs

@@ -8,7 +8,8 @@
 import { embed, embedTolerant, cosine, toBlob, fromBlob } from "../embedding.mjs"
 import { scanVectors, createTopK } from "./scan.mjs"
 import { normalizeOrigin } from "./origin.mjs"
-import { declaredPublicRoots, loadProjectDeclaration, isExcludedRelPath, declaredIndexScope, isInDeclaredScope } from "../conventions.mjs"
+import { declaredPublicRoots } from "../conventions.mjs"
+import { createReadGate } from "./read-gate.mjs" // 面⑥∪面⑦ 读面准入单源（#1372 抽件——两档原各持一份逐字相同的 rowHidden）
 import { buildFtsQuery, ensureEmbeddings, EMBED_TEXT_MAX_LEN } from "./core.mjs"
 import { safeSliceUTF16 } from "../text-budget.mjs"
 import { DESC } from "../tools/shared.mjs" // #15 描述外置：文本单点 = tool-docs/code_search.md
@@ -35,19 +36,9 @@ export async function codeSearch(memory, query, { limit = 5 } = {}) {
   const origins = searchOrigins(memory)
   const ftsOriginFilter = origins.length === 1 ? `AND c.origin = ?` : origins.length > 1 ? `AND c.origin IN (${origins.map(() => "?").join(", ")})` : ""
   const originParams = origins
-  // §6.14 读面准入过滤（FTS 列表建成后 ∥ 向量 top-K push 前；两判据并列互不吞）：排除谓词（面①∪面⑥，
-  // 行 origin 为 `base`）∪ 声明范围门（面⑦——`isInDeclaredScope(path, declaredIndexScope(origin), origin)`，
-  // 逐 origin 预载一次）⇒「批次档 ∥ 范围外路径从未入索引」等价检索；存量行不删（收尾保护位）；窗口欠额接受。
-  const declCache = new Map()
-  const scopeCache = new Map()
-  const rowHidden = (origin, path) => {
-    const d = declCache.get(origin) ?? loadProjectDeclaration(origin)
-    declCache.set(origin, d)
-    if (isExcludedRelPath(path, d, origin)) return true
-    let scope = scopeCache.get(origin)
-    if (scope === undefined) { scope = declaredIndexScope(origin); scopeCache.set(origin, scope) }
-    return !isInDeclaredScope(path, scope, origin)
-  }
+  // §6.14 读面准入过滤（FTS 列表建成后 ∥ 向量 top-K push 前）——判据与逐 origin 预载单源 = `./read-gate.mjs`；
+  // 存量行不删（收尾保护位）；窗口欠额接受。
+  const { rowHidden } = createReadGate()
   const ftsNeedOrigin = origins.length !== 1 // 单 origin 形 SQL 零改；多 origin ∥ 无过滤形补 `origin` 列（行 origin 随行可得）
 
   const ftsList = ftsQuery ? memory.db.prepare(`

package/memory/docs.mjs

@@ -12,7 +12,8 @@ import { _upsertDocFile, yieldTick } from "./code-index.mjs"
 import { markIndexedCommit, listProjectFiles, indexExtensions, declaredRootEntries } from "./code-sync.mjs"
 import { searchOrigins } from "./code-search.mjs"
 import { createRowBudget, rowCountOfPath, sweepStaleRows } from "./sync-tail.mjs"
-import { loadProjectDeclaration, isExcludedRelPath, declaredIndexScope, isInDeclaredScope } from "../conventions.mjs" // 面① 谓词经 `decl` 传 `sweepStaleRows`；面⑥∪面⑦ 读面准入本档直调
+import { loadProjectDeclaration, declaredIndexScope } from "../conventions.mjs" // 面① 谓词经 `decl` 传 `sweepStaleRows`
+import { createReadGate } from "./read-gate.mjs" // 面⑥∪面⑦ 读面准入单源（#1372 抽件——两档原各持一份逐字相同的 rowHidden）
 import { logEvent } from "../log.mjs"
 import { safeSliceUTF16 } from "../text-budget.mjs"
 import { DESC } from "../tools/shared.mjs" // #15 描述外置：文本单点 = tool-docs/*.md（DESC 单解析面，缺档抛错语义不变）
@@ -117,19 +118,9 @@ export async function docSearch(memory, query, { limit = 5, origins: originsOver
   const origins = originsOverride ?? searchOrigins(memory)
   const ftsOriginFilter = origins.length === 1 ? `AND d.origin = ?` : origins.length > 1 ? `AND d.origin IN (${origins.map(() => "?").join(", ")})` : ""
   const originParams = origins
-  // §6.14 读面准入过滤（FTS 列表建成后 ∥ 向量 top-K push 前；两判据并列互不吞）：排除谓词（面①∪面⑥，
-  // 行 origin 为 `base`）∪ 声明范围门（面⑦——`isInDeclaredScope(path, declaredIndexScope(origin), origin)`，
-  // 逐 origin 预载一次）⇒「批次档 ∥ 范围外路径从未入索引」等价检索；存量行不删（收尾保护位）；窗口欠额接受。
-  const declCache = new Map()
-  const scopeCache = new Map()
-  const rowHidden = (origin, path) => {
-    const d = declCache.get(origin) ?? loadProjectDeclaration(origin)
-    declCache.set(origin, d)
-    if (isExcludedRelPath(path, d, origin)) return true
-    let scope = scopeCache.get(origin)
-    if (scope === undefined) { scope = declaredIndexScope(origin); scopeCache.set(origin, scope) }
-    return !isInDeclaredScope(path, scope, origin)
-  }
+  // §6.14 读面准入过滤（FTS 列表建成后 ∥ 向量 top-K push 前）——判据与逐 origin 预载单源 = `./read-gate.mjs`；
+  // 存量行不删（收尾保护位）；窗口欠额接受。
+  const { rowHidden } = createReadGate()
   const ftsNeedOrigin = origins.length !== 1 // 单 origin 形 SQL 零改；多 origin ∥ 无过滤形补 `origin` 列（行 origin 随行可得）
 
   const ftsList = ftsQuery ? memory.db.prepare(`