@thincoder/core 0.10.6 → 0.10.8

package/config-watch.mjs

@@ -1,13 +1,13 @@
 /**
  * config-watch.mjs — config.json 外部写盘感知·**纯逻辑面**（R8 · 桌面功能对位批「上提」KD-T2——
- * 自 `thincoder-vscode/src/extension/config-watch.mjs:35-77` 逐字随迁：去抖 300ms ∕ stat 元组
+ * 自 `thincoder-vscode/src/extension/config-watch.mjs` 的 `startConfigWatch` 逐字随迁：去抖 300ms ∕ stat 元组
  * （`mtimeMs:size`）比对 ∕ 自写抑制；原批 = 第 21 批 B5 · `docs/design/SETTINGS.md` §2.6）。
  *
  * `~/.thincoder/config.json` 为多端共享单文件：CLI（`/advisor`、`settings set`）或手工编辑写盘后，
  * 常开面板原本零感知（只在打开面板/保存时拉快照）。机制（零语义改）：
  *   宿主 fs 事件 →（端落子）`onEvent` → 去抖 → 元组比对 → 变化才 `onChange`（事件驱动零空转）。
  * 自写抑制：本端自身写盘同样改元组 ⇒ 裸推送会在用户编辑中被快照重建；写盘成功后核 `config-io`
- * `saveRaw` 同步回调 `onConfigSelfWrite`（`config-io.mjs:107`）⇒ `noteSelfWrite()` 把基线刷到当前
+ * `saveRaw` 同步回调 `onConfigSelfWrite`（`config-io.mjs`）⇒ `noteSelfWrite()` 把基线刷到当前
  * 元组 ⇒ 事件到达时元组已等于基线 ⇒ 零推送；外部写无回调 ⇒ 元组异于基线 ⇒ 推送。
  *
  * 平台面两注入（核内零宿主绑定）：① `attach`（fs 事件源工厂——端落子：VSC = `createFileSystemWatcher`、

package/config.mjs

@@ -64,6 +64,13 @@ export const DEFAULTS = {
     // §6.30.3 门三件③（D-TW5）：timer 空闲自唤醒开关——默认开（工具描述面已承诺到点提醒）；
     // false ⇒ 端侧不武装闩（回既有回合边界投递——零调度器面）。键面随 DEFAULTS 派生进 settings 类型表。
     timerWake: true,
+    // 注入开关（PROMPT-SYSTEM.md §6.24 · 台账 #1420）：文档类 ∥ 记忆类自动注入——默认开；
+    // 判据 `!== false`（缺省 = 现行为零变）。消费点 = 核 `agent/setup.mjs` 判点（逐 run 现读）。
+    // 2026-10-15（§6.27 · 台账 #1465）：① 项目指令块独立成键——`injectDocs` 收窄为只管 ② 相关文档块；
+    // 两键完全正交（关任一方另一方照常）。`injectProjectRules` 判点 = 核 `agent/setup.mjs`（`prepareRun` 项目指令段）。
+    injectDocs: true,
+    injectProjectRules: true,
+    injectMemories: true,
   },
   memory: {
     dbPath: join(configDir, "memory.db"),

package/conventions.mjs

@@ -189,4 +189,4 @@ export function isStatePath(p, conv) {
 // 迁出面（2026-10-01 拆分批 · #755 ∥ #786）：声明装载面外提 `declaration.mjs`——本档经
 // 转口保名（消费面 / 单元测试档 import 面零改；`DEFAULT_DECLARATION` 另供本档分类裁判缺省取用）。
 // ─────────────────────────────────────────────────────────────────────────────
-export { loadProjectDeclaration, declarationForTarget, DEFAULT_DECLARATION, isExcludedRelPath, declaredPublicRoots, clearDeclarationCache } from "./declaration.mjs"
+export { loadProjectDeclaration, declarationForTarget, DEFAULT_DECLARATION, isExcludedRelPath, declaredIndexScope, isInDeclaredScope, declaredPublicRoots, clearDeclarationCache } from "./declaration.mjs"

package/declaration.mjs

@@ -5,9 +5,10 @@
  * name / shape / defaults = schema 面 `docs/core/design/MANIFEST.md` §2.2）。迁出块逐字；
  * 原档 `conventions.mjs` 经 `export { … } from` 转口保名（消费面 / 单元测试档 import 面零改）。
  */
-import { existsSync, statSync } from "node:fs"
+import { existsSync, readdirSync, statSync } from "node:fs"
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path"
-import { DEFAULT_MANIFEST, manifestFilePath, owningProject, readManifest } from "./manifest.mjs"
+import { DEFAULT_MANIFEST, MANIFEST_REL, docRootPaths, manifestFilePath, onManifestInit, owningProject, readManifest } from "./manifest.mjs"
+import { isSkippedRelPath } from "./memory/file-walk.mjs" // 面⑦ 子目录扫描的跳过段谓词单源（零环：file-walk 不引本档）
 import { logEvent } from "./log.mjs"
 
 /** Retired declaration carrier (project-root relative). Its EXISTENCE is checked, its
@@ -78,6 +79,7 @@ function buildDeclaration(m, root = null) {
   const docExtensions = normalizeExtensions(m?.index?.docExtensions)
   const excludePaths = normalizePathList(m?.index?.excludePaths)
   const publicRepos = normalizePathList(m?.index?.publicRepos)
+  const batchRecords = batchSegments(m?.docRoot?.batches) // §6.14 面⑥ 声明值投影（`declared` 旗不涉——docRoot 族现状零改）
   const docMap = normalizeString(m?.advisor?.docMap)
   const standardsDoc = normalizeString(m?.advisor?.standardsDoc)
   const defaults = normalizeCodePaths(DEFAULT_MANIFEST.codePaths) ?? []
@@ -86,6 +88,7 @@ function buildDeclaration(m, root = null) {
   return Object.freeze({
     declared,
     codePaths: Object.freeze(codePaths),
+    batchRecords: Object.freeze(batchRecords.map((s) => Object.freeze(s))),
     index: Object.freeze({
       codeExtensions: Object.freeze(codeExtensions),
       docExtensions: Object.freeze(docExtensions),
@@ -101,25 +104,158 @@ function buildDeclaration(m, root = null) {
  *  consumer gets; built from `DEFAULT_MANIFEST` so the default values stay single-source. */
 export const DEFAULT_DECLARATION = buildDeclaration(null)
 
-/** 排除前缀谓词（单源——§6.14 面①）：`rel`（**`base` 相对**——缺省视为根相对）命中声明前缀（恰等
- *  ∨ 后随 `/`——`openclaw` 不吞 `openclaw-fork`）⇒ true；缺省 `[]` ⇒ 恒 false（零行为变化）。
+/** 段序列归一（面⑥ 目标集）：值（串 ∥ 串数组——元素层归一同 `normalizePathList`）⇒ 实义段序列
+ *  （空 ∥ `.` ∥ `..` 段剔除——空序列另剔，防恒真；去重保序）。 */
+function batchSegments(v) {
+  const out = []
+  for (const e of normalizePathList(Array.isArray(v) ? v : v == null ? [] : [v])) {
+    const segs = e.split("/").filter((s) => s && s !== "." && s !== "..")
+    if (segs.length && !out.some((q) => q.length === segs.length && q.every((s, i) => s === segs[i]))) out.push(segs)
+  }
+  return out
+}
+
+/** 约定段（面⑥——`DEFAULT_MANIFEST.docRoot.batches` 单源派生；默认值改名/迁移两处同动）。 */
+const DEFAULT_BATCH_SEGMENTS = batchSegments(DEFAULT_MANIFEST.docRoot.batches)
+
+/** 排除谓词（单源——§6.14 面① 前缀 ∥ 面⑥ 批次档段序列；两族同一谓词全判，非第二判定面）：
+ *  面⑥（2026-10-13 · 台账 #1366 · **无条件**——不看 `index.excludePaths` 是否配置）：`rel` 命中
+ *  约定段 ∪ 声明值段序列（`decl.batchRecords`——`docRoot.batches` 投影）于**路径任意深度**
+ *  （段边界 = 整段一致——`docs/batchesx` ∥ `doc/batches` 判假）⇒ true；`docRoot.batches: null`
+ *  ⇒ 约定段恒在（无逃生口）；`decl` 缺 ⇒ 约定段照判。
+ *  面①（前缀语义）：`rel`（**`base` 相对**——缺省视为根相对）命中声明前缀（恰等 ∨ 后随 `/`——
+ *  `openclaw` 不吞 `openclaw-fork`）⇒ true；缺省 `[]` ⇒ 恒 false（零行为变化）。
  *  `base`（调用面 cwd/origin·#700）= `rel` 的相对基：`resolve` + `relative` 换算至 `decl.root` 根面
- *  再比前缀（cwd = 项目根时与既有行为逐字等义）；换算越出根面（`..` 头 ∥ 根外绝对形）⇒ **不命中**
- *  （保守不排除——沉默洞方向收窄，与 D17 aux 面「indeterminate ⇒ 不匹配」同向）；`decl.root` 缺
- *  ⇒ `rel` 原样（根起步调用面等义）。 */
+ *  再判（cwd = 项目根时与既有行为逐字等义）；换算越出根面（`..` 头 ∥ 根外绝对形）⇒ 面① **不命中**
+ *  （保守不排除——沉默洞方向收窄，与 D17 aux 面「indeterminate ⇒ 不匹配」同向）∥ 面⑥ 按入参
+ *  **原样 `rel`** 判（段序列面不回退——面① 不命中口径逐字零改）；`decl.root` 缺 ⇒ `rel` 原样
+ *  （根起步调用面等义）。 */
 export function isExcludedRelPath(rel, decl, base = null) {
-  const list = decl?.index?.excludePaths
-  if (!Array.isArray(list) || list.length === 0) return false
   let s = String(rel ?? "").replace(/\\/g, "/")
   const root = decl?.root
+  let inRoot = true
   if (base != null && root) {
     const converted = relative(root, resolve(base, s)).replace(/\\/g, "/")
-    if (converted === ".." || converted.startsWith("../") || isAbsolute(converted)) return false
-    s = converted
+    if (converted === ".." || converted.startsWith("../") || isAbsolute(converted)) inRoot = false
+    else s = converted
   }
+  // 面⑥ 段序列（约定段 ∪ 声明值——任意深度连续命中）；越根（`inRoot=false`）⇒ `s` 即原样 rel
+  const segs = s.split("/").filter(Boolean)
+  if ([...DEFAULT_BATCH_SEGMENTS, ...(decl?.batchRecords ?? [])].some((seq) => segs.some((_, i) => seq.every((q, j) => segs[i + j] === q)))) return true
+  // 面① 前缀（既有口径逐字零改：缺省 `[]` ∥ 越根 ⇒ 不命中）
+  const list = decl?.index?.excludePaths
+  if (!Array.isArray(list) || list.length === 0 || !inRoot) return false
   return list.some((p) => p && (s === p || s.startsWith(`${p}/`)))
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// §6.14 面⑦ 索引范围声明化（结构门——2026-10-13 · 台账 #1367）：范围 = 锚的**管辖 manifest**
+// 声明目录 ∪ **一级子目录**（带档者）声明目录——「未声明 ⇒ 不进」；条目集空 ⇒ 零索引
+// （不回落全树）。键面 = `docRoot.*`（五子键合并）∪ `codePaths`——两键各按自身既有语义
+// （本规 = 新增消费点，键值语义零改）。写面（收录）∥ 读面（存量行准入）共用本谓词族。
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** 文档面前缀集合（条目根相对——`docRoot.*` 五子键合并展开；解析单源 = `docRootPaths`，F7）：
+ *  值 = 根相对字面前缀（恰等 ∨ 后随 `/`——路径及子树；文件值如 `docs/RELEASE.md` ⇒ 恰该文件）；
+ *  `"."` = 该条目根自身（整根面）；越根值（`../` 形）剔除——条目子树内的文件永不可命中它。
+ *  去重保序。 */
+function entryDocPaths(docRoot, root) {
+  const out = []
+  if (docRoot === null || typeof docRoot !== "object" || Array.isArray(docRoot)) return out
+  for (const key of Object.keys(DEFAULT_MANIFEST.docRoot)) {
+    for (const abs of docRootPaths(docRoot[key], root)) {
+      const rel = relative(root, abs).replace(/\\/g, "/")
+      if (rel === "" || rel === ".") { if (!out.includes(".")) out.push("."); continue }
+      if (rel === ".." || rel.startsWith("../") || isAbsolute(rel)) continue
+      if (!out.includes(rel)) out.push(rel)
+    }
+  }
+  return out
+}
+
+/** 段序列任意深度连续命中（面⑦ 代码面——大小写不敏感 = 既有键语义口径，同 `conventions.mjs`
+ *  `hasSequenceIn`）；`face` = 已小写化的根相对段表。 */
+function hasSegmentRun(face, seq) {
+  const want = String(seq).replace(/\\/g, "/").split("/").filter(Boolean).map((s) => s.toLowerCase())
+  if (want.length === 0) return false
+  for (let i = 0; i + want.length <= face.length; i++) {
+    if (want.every((w, j) => face[i + j] === w)) return true
+  }
+  return false
+}
+
+/** 面⑦ 一条目（`root` = 仓根绝对路径；档在场 = 调用面已判）：`docPaths` = 根相对字面前缀 ∥
+ *  `codePaths` = 段名数组（既有归一单源 = `loadProjectDeclaration`——`[]` = 无段面）。档**非法**
+ *  （坏 JSON ∥ 形态错）⇒ 两族按默认值参与 + 既有可见告警（声明链 KD-M1-32——`loadProjectDeclaration`
+ *  的降级告警单源，本档零第二实现）——不静默成零。 */
+function scopeEntryOf(root) {
+  const decl = loadProjectDeclaration(root)
+  const r = readManifest(root)
+  const docRoot = r.ok ? r.manifest.docRoot : DEFAULT_MANIFEST.docRoot // 档在场才补默认（无档 = 无条目，不走本函数）
+  return Object.freeze({
+    root,
+    docPaths: Object.freeze(entryDocPaths(docRoot, root)),
+    codePaths: Object.freeze([...decl.codePaths]),
+  })
+}
+
+/**
+ * §6.14 面⑦ 范围求并（结构门——单源）：① `dir` 的**管辖 manifest**（`manifestFilePath(dir)` 同一根
+ * 解析——最近祖先带档 ∥ 发现兜底；**可高于 `dir`** ⇒ 深 cwd 等义）在场 ⇒ 锚条目（`root` = 档所在
+ * 目录）；② `dir` 的**直接子目录**（非跳过段——点段 ∥ 内建名单，防 `.thincoder/tmp` 类伪档）根下带档
+ *  者 ⇒ 各一条目（`root` = 该子目录）。**一层、纯向下、绝不向上**（发现纪律在案）。
+ *  冻结条目数组（按根去重保序）；条目集空 ⇒ 范围空 ⇒ **零索引**（不回落全树）。
+ *  缓存按 `dir` 归一绝对路径（`clearDeclarationCache()` 同清——测试缝单点）。
+ * @param {string} [dir] 会话锚 ∕ 同步根（项目内子目录 ⇒ 管辖 manifest 生效）
+ * @returns {ReadonlyArray<{root: string, docPaths: readonly string[], codePaths: readonly string[]}>}
+ */
+export function declaredIndexScope(dir) {
+  const key = resolve(dir ?? ".")
+  const hit = _scopeCache.get(key)
+  if (hit) return hit
+  const roots = []
+  const anchorFile = manifestFilePath(key) // 数据档路径单源（KD-M1-18）
+  if (existsSync(anchorFile)) roots.push(dirname(anchorFile))
+  let names = []
+  try { names = readdirSync(key, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort() } catch { /* 不可读 ⇒ 零子条目（不抛——同发现梯内核） */ }
+  for (const name of names) {
+    if (isSkippedRelPath(name)) continue
+    const child = join(key, name)
+    if (!existsSync(join(child, MANIFEST_REL)) || roots.includes(child)) continue // 发现兜底命中的子目录 = 锚条目同根 ⇒ 去重
+    roots.push(child)
+  }
+  const scope = Object.freeze(roots.map(scopeEntryOf))
+  _scopeCache.set(key, scope)
+  return scope
+}
+
+/**
+ * §6.14 面⑦ 范围谓词（纯谓词——单一实现，写面 ∥ 读面共用）：`rel`（`base` 相对；缺省按进程 cwd
+ * 解析）经 `resolve` 绝对化 ⇒ 逐条目判归属（`abs` ∈ `root` 子树；无归属条目 = **未声明**）⇒ 两面试
+ * 任一命中即入范围（两层锚条目间 = 并集）：
+ *   · **文档面** = 条目根相对面**字面前缀**（恰等 ∨ 后随 `/`；`"."` = 整根）；
+ *   · **代码面** = 段序列**任意深度**命中（大小写不敏感）。
+ * 不在任何条目子树内（越根）⇒ 不命中。`scope` 空 ∥ 缺 ⇒ false（零索引面——未声明 ⇒ 不进）。
+ * @param {string} rel 路径（`base` 相对）
+ * @param {ReadonlyArray<object>} scope `declaredIndexScope()` 回执
+ * @param {string|null} [base] `rel` 的相对基（目录绝对路径；缺省 = 进程 cwd）
+ * @returns {boolean}
+ */
+export function isInDeclaredScope(rel, scope, base = null) {
+  if (!Array.isArray(scope) || scope.length === 0) return false
+  const abs = resolve(base ?? ".", String(rel ?? "").replace(/\\/g, "/"))
+  for (const entry of scope) {
+    const relFromRoot = relative(entry.root, abs).replace(/\\/g, "/")
+    if (relFromRoot === "" || relFromRoot === ".." || relFromRoot.startsWith("../") || isAbsolute(relFromRoot)) continue
+    if (entry.docPaths.some((p) => p === "." || relFromRoot === p || relFromRoot.startsWith(`${p}/`))) return true
+    if (entry.codePaths.length > 0) {
+      const face = relFromRoot.split("/").filter(Boolean).map((s) => s.toLowerCase())
+      if (entry.codePaths.some((seq) => hasSegmentRun(face, seq))) return true
+    }
+  }
+  return false
+}
+
 /**
  * 声明公共仓**绝对根集**（§6.15 解析层——检索同步 ∥ 读面 origin 集 ∥ 引用解析三消费面共用的单一定义，
  * 不得二写）：值形层逐项 `resolve(decl.root, p)` ⇒ 绝对根集（去重保序）；存在性判归消费面（本层不判）。
@@ -165,12 +301,20 @@ export function resolveDeclaredRef(base, part) {
 const isFile = (p) => { try { return statSync(p).isFile() } catch { return false } }
 
 const _cache = new Map()
+/** 面⑦ 范围缓存（按 `dir` 归一绝对路径——子目录档 ∥ 声明变更后经本缝同清）。 */
+const _scopeCache = new Map()
 
-/** Drop the per-data-file-path cache (test seam — declarations are read once per path). */
+/** Drop the per-data-file-path cache (test seam — declarations are read once per path).
+ *  #1367：面⑦ 范围缓存同清（「声明 ∥ 一级子目录档」变更后同一条测试缝）。 */
 export function clearDeclarationCache() {
   _cache.clear()
+  _scopeCache.clear()
 }
 
+// #1376：eng 建档路（`manifest.mjs` `resolveEngineeringManifest` init 支）成功 ⇒ 同清两缓存——
+// 反向注册（本档已向依赖 manifest.mjs，其侧零出边保持——KD-M1-33）；失败路径不广播、文件面零变。
+onManifestInit(clearDeclarationCache)
+
 /** Retired-carrier warning (existence check only — zero content parsing, zero fallback). */
 function warnRetiredCarrier(root) {
   console.warn(`[declaration] ${RETIRED_REL_PATH} is retired and no longer read — move codePaths / index.*Extensions / advisor.{docMap,standardsDoc} into PROJECT-MANIFEST.json`)
@@ -188,7 +332,7 @@ function warnRetiredCarrier(root) {
  * A retired `.thincoder/conventions.json` at the manifest's project root → one warning
  * per cache miss (content zero-parsed, zero effect on the readings — KD-M1-34).
  * @param {string} cwd — project dir / anchor (root resolved by manifest.mjs)
- * @returns {Readonly<{declared: boolean, codePaths: readonly string[],
+ * @returns {Readonly<{declared: boolean, codePaths: readonly string[], batchRecords: readonly (readonly string[])[],
  *   index: {codeExtensions: string[], docExtensions: string[], excludePaths: string[], publicRepos: string[]},
  *   advisor: {docMap: string, standardsDoc: string}, root: string|null}>}
  */

package/doc-check/anchors.mjs

@@ -0,0 +1,100 @@
+/**
+ * doc-check/anchors.mjs — 文档纪律机检 · 起步判据 ①（锚）：指针抽取 + 解析序 + 节在盘判定。
+ *
+ * 判据句单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.20 判据 ①（本节只实现，不重述口径）：
+ * · 文档指针 = 档 token（含 `.md`，可带目录段）± 节指示（紧随 `§` + 编号 N / N.M / N.M.K）；
+ *   **行号坐标（`:N`）不作节指示**——行号不作引用；
+ * · 档不在盘 ⇒ `档缺`；带节指示 ∧ 节不在盘 ⇒ `节缺`。
+ *
+ * 抽取面：逐行扫；fenced 块整块跳过；可执行行（`isExecutableLine`）整行跳过（命令保字面）。
+ * 解析序：① 仓根相对 → ② 域根相对（`scanDirs` 逐根）→ ③ 引用方档所在目录相对 →
+ *   ④ 域内唯一 basename 索引；同名 ≥2 ⇒ **不判**（列报告面）。
+ * 节在盘：目标档内存在标题行，其标题编号（标题文本去 `^#{1,6}\s` 后的首个 `\d+(?:\.\d+)*`）= 指针节号。
+ * 残余登记（fail-open 方向——归评审核验面）：裸档名在域内多义 ⇒ 不判；未闭合围栏 ⇒ 至档尾免；
+ *   指针行的坐标尾不入判、同行的档 token 照判。
+ */
+import { readFileSync, statSync } from "node:fs"
+import { basename, dirname, resolve } from "node:path"
+import { fenceMark, isExecutableLine } from "./width.mjs"
+
+/** 文档指针 token：`(目录段/)*名.md` + 可选行号坐标尾 + 可选节指示（`§` + 编号）。
+ *  左界守卫排除更长 token 的尾段；右界排除后续字母数字（`.md` 之后紧邻 `[\w]` ⇒ 非完整 token）。 */
+const ANCHOR_RE = /(?<![A-Za-z0-9_.\-\\/@])((?:[A-Za-z0-9_.\-]+\/)*[A-Za-z0-9_.\-]+\.md)(?::\d+(?:-\d+)?)?(?:\s*§\s*(\d+(?:\.\d+)*))?(?![\w])/g
+
+/** 文件存在性（目录 / 读错 ⇒ false）。 */
+function isFile(p) { try { return statSync(p).isFile() } catch { return false } }
+
+/** 标题编号（标题文本去 `^#{1,6}\s` 后的首个 `\d+(?:\.\d+)*`）；非标题行 ⇒ null。 */
+function headingNumber(line) {
+  const m = /^#{1,6}\s+/.exec(line)
+  if (!m) return null
+  const n = /\d+(?:\.\d+)*/.exec(line.slice(m[0].length))
+  return n ? n[0] : null
+}
+
+/** 节在盘：目标档内任一标题行的编号 = 指针节号（字符串逐字等值——两处同归一形）。 */
+function sectionOnDisk(path, num) {
+  let text = ""
+  try { text = readFileSync(path, "utf8") } catch { return false }
+  for (const l of text.split("\n")) if (headingNumber(l) === num) return true
+  return false
+}
+
+/** 档解析（判据 ① 的解析序 ①–④）：命中 ⇒ `{ ok, path }`；同名 ≥2 ⇒ `{ ambiguous, candidates }`；零命中 ⇒ `{ ok:false }`。
+ *  行号坐标尾（`:N`）不参与档解析——token 只取 `.md` 段（抽取面已剥离坐标尾与节指示）。 */
+function resolveDoc(token, refFile, base, scanDirs, index) {
+  const p1 = resolve(base, token)
+  if (isFile(p1)) return { ok: true, path: p1 } // ① 仓根相对
+  for (const d of scanDirs) { const p = resolve(base, d, token); if (isFile(p)) return { ok: true, path: p } } // ② 域根相对
+  const p3 = resolve(dirname(refFile), token)
+  if (isFile(p3)) return { ok: true, path: p3 } // ③ 引用方档所在目录相对
+  const cands = index.get(basename(token)) ?? [] // ④ 域内唯一 basename 索引
+  if (cands.length === 1) return { ok: true, path: cands[0] }
+  if (cands.length > 1) return { ambiguous: true, candidates: cands }
+  return { ok: false }
+}
+
+/**
+ * 锚判据主行程：域内逐档逐行抽取 + 解析 + 节在盘判定。
+ * @param {string} root 项目根（判据参数已由调用方自 `checkConfig` 读出）
+ * @param {{scanDirs?:string[], files?:string[]}} o `files` = 域内 `.md` 全集（单源 = `scanDomain`）
+ * @returns {{hits:Array, reports:Array}} hits = 命中（`档缺` / `节缺`）；reports = 报告面（多义——不作判）
+ */
+export function checkAnchors(root, { scanDirs = [], files = [] } = {}) {
+  const base = resolve(root)
+  const dirs = Array.isArray(scanDirs) ? scanDirs : []
+  const index = new Map()
+  for (const f of files) {
+    const k = basename(f)
+    if (!index.has(k)) index.set(k, [])
+    index.get(k).push(f)
+  }
+  const hits = []
+  const reports = []
+  for (const f of files) {
+    let text = ""
+    try { text = readFileSync(f, "utf8") } catch { continue }
+    const re = new RegExp(ANCHOR_RE.source, "g") // 每档一份实例（零共享 lastIndex 状态）
+    let fence = null // 围栏标记（` ∥ ~）；null = 不在块内
+    text.split("\n").forEach((l, i) => {
+      const mark = fenceMark(l)
+      if (mark !== null) { // 围栏块整块跳过：起于围栏行、止于同形围栏行（未闭合 ⇒ 至档尾免）
+        if (fence === null) fence = mark
+        else if (mark === fence) fence = null
+        return
+      }
+      if (fence !== null) return
+      if (isExecutableLine(l)) return // 可执行行整行跳过
+      let m
+      while ((m = re.exec(l)) !== null) {
+        const token = m[1]
+        const num = m[2] ?? null
+        const r = resolveDoc(token, f, base, dirs, index)
+        if (r.ambiguous) { reports.push({ file: f, line: i + 1, token, candidates: r.candidates }); continue }
+        if (!r.ok) { hits.push({ file: f, line: i + 1, token, clazz: "档缺" }); continue }
+        if (num !== null && !sectionOnDisk(r.path, num)) hits.push({ file: f, line: i + 1, token, clazz: "节缺", section: num, target: r.path })
+      }
+    })
+  }
+  return { hits, reports }
+}

package/doc-check/index.mjs

@@ -0,0 +1,61 @@
+/**
+ * doc-check/index.mjs — 文档纪律机检 · 引擎入口（域扫描 + 声明面读取 + 报面行）。
+ *
+ * 判据两条（起步 · 闭集——口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.20 条目 S）：
+ *   ① 锚（档缺 / 节缺）——实现 = `./anchors.mjs`；② 行宽——口径 = §3.18 条目 Q，实现 = `./width.mjs`。
+ * 判据参数由**被开发项目**的 `PROJECT-MANIFEST.json` `checkConfig` 声明（不硬编码任何本仓路径）。
+ * 纯函数：**零门禁 / 零退出码 / 零阻断**——报告态由工具面 `agent-tools/doc-check.mjs` 呈现；
+ * 输出不得被读作拒执行的理由（用户令 > 机检）。
+ */
+import { relative, resolve } from "node:path"
+import { MANIFEST_REL, readManifest } from "../manifest.mjs"
+import { scanDomain, checkDocWidths } from "./width.mjs"
+import { checkAnchors } from "./anchors.mjs"
+
+/** 相对路径显示形（正斜杠——跨平台同形）。 */
+const rel = (root, p) => relative(root, p).replace(/\\/g, "/")
+
+/**
+ * 跑一次文档纪律机检（报告态）。
+ * @param {string} root 项目根（判据参数取该根的 `PROJECT-MANIFEST.json` `checkConfig`）
+ * @returns {{report:string, hits:{total:number, anchors:number, width:number}, anchorHits:Array,
+ *   widthHits:Array, anchorReports:Array, files:string[], scanDirs:string[], lineWidth:number,
+ *   zones:string[], exclude:string[]}}
+ */
+export function runDocCheck(root) {
+  const base = resolve(root)
+  const read = readManifest(base)
+  if (!read.ok) {
+    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("；")})`)
+  }
+  const cfg = read.manifest.checkConfig ?? {}
+  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 lineWidth = cfg.lineWidth
+  const zones = (Array.isArray(cfg.widthExemptZones) ? cfg.widthExemptZones : []).filter((z) => typeof z === "string" && z !== "")
+
+  const files = scanDomain(base, { scanDirs, exclude })
+  const anchors = checkAnchors(base, { scanDirs, files })
+  const widths = checkDocWidths(base, { lineWidth, scanDirs, exclude, exemptZones: zones, files })
+
+  const total = anchors.hits.length + widths.length
+  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}）`,
+  ]
+  // 报告面（不作判）：域内同名 ≥2 ⇒ 多义不判（残余登记——fail-open 方向，归评审核验面）
+  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 条命中（锚 ∥ 行宽 均清）")
+
+  return { report: out.join("\n"), hits: { total, anchors: anchors.hits.length, width: widths.length }, anchorHits: anchors.hits, widthHits: widths, anchorReports: anchors.reports, files, scanDirs, lineWidth, zones, exclude }
+}

package/doc-check/width.mjs

@@ -0,0 +1,131 @@
+/**
+ * doc-check/width.mjs — 文档纪律机检的产品档位（行宽谓词族 + 域扫描 + 行宽判据——实现单源）。
+ *
+ * 口径单源 = `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`——零硬编码本仓路径，换项目开箱可用。
+ * 豁免五类 = 表格行 ∥ 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()
+}
+
+/** 表格行谓词（markdown 表格行结构性不可折行——行宽豁免，与锚检查同源）。 */
+export const isTableRow = (l) => /^\s*\|.*\|\s*$/.test(String(l))
+
+/** 围栏标记（行首可选空白 + 三反引号 ∥ 三波浪号 ⇒ 标记字符；非围栏行 ⇒ null）——**单源**：
+ *  `isFenceLine` 与两处块扫描（本节行宽 ∥ `./anchors.mjs` 锚抽取）同取此式，使「同形围栏行止」只此一解
+ *  （同一模块内同符两义 = 单源可漂的结构口子）。 */
+export function fenceMark(l) {
+  const m = /^\s*(`{3,}|~{3,})/.exec(String(l))
+  return m ? m[1][0] : null
+}
+
+/** 围栏行谓词（单源 = `fenceMark`）——围栏行自身与块内整行均豁免。 */
+export const isFenceLine = (l) => fenceMark(l) !== null
+
+/** 引文块行谓词（行首可选空白 + `>`）——连续 `>` 行整块豁免（引证须逐字连续、不可折，同表行理据）。 */
+export const isQuoteLine = (l) => /^\s*>/.test(String(l))
+
+/** 区带头谓词（§3.15 谓词面）：标题文本去首部编号（`^\d+(?:\.\d+)*[.、]?\s*`）后——等于区带名 ∨ 以
+ *  「区带名 + （∕(」起（容括注后缀，如 `变更记录（续）`）；闭集外一律不纳（fail-closed）。 */
+export function isZoneHead(headingText, zones = []) {
+  const text = String(headingText).replace(/^\d+(?:\.\d+)*[.、]?\s*/, "")
+  return zones.some((z) => typeof z === "string" && z !== "" && (text === z || text.startsWith(z + "（") || text.startsWith(z + "(")))
+}
+
+/** 行内可执行坐标（命令 / 搜索模式串码段）——整行豁免（证据与命令保字面，与锚判据同源）。 */
+export function isExecutableLine(line) {
+  const l = String(line)
+  if (/`[^`\n]*&&[^`\n]*`/.test(l)) return true // 命令链（cd … && …）
+  if (/`[^`\n]*\b(?:cd|node|npm|npx|grep|rg|git)\s[^`\n]*`/.test(l)) return true // 码段内命令词
+  if (/`[^`\n]*(?:\[\^|\\\.|\(\?<|\(\?:|\{\d)/.test(l)) return true // 码段内搜索模式串片段
+  return false
+}
+
+/** 行内位置是否在反引号码段内（引述面不判）。 */
+export function inCodeSpan(line, idx) {
+  return (String(line).slice(0, idx).match(/`/g) ?? []).length % 2 === 1
+}
+
+/** 行宽判据（单判据 = `checkConfig.lineWidth`）：`[...line].length` > 阈值 ∧ 非表格行 ∧ 非 fenced 块内
+ *  ∧ 非可执行行 ∧ 非连续引文 ∧ 非区带内 ⇔ 命中（口径逐字 = §3.18 条目 Q）。
+ *  单遍扫描携标题栈（`^(#{1,6})\s` 行入栈——同级 ∥ 更高级出栈）：行所属标题链任一为区带头 ⇒ 豁免。
+ *  围栏未闭合 ⇒ 至档尾整块免（fail-open 方向——§3.18 残余登记 ①）；`exemptZones` 缺省 ∥ 空集 ⇒ 零豁免。 */
+export function checkDocWidths(base, { lineWidth, scanDirs, exclude, exemptZones = [], files } = {}) {
+  const zones = (Array.isArray(exemptZones) ? exemptZones : []).filter((z) => typeof z === "string" && z !== "")
+  const hits = []
+  // `files` 给定时直接用（调用方已扫同一域 ⇒ 域只走一遍、文件集由值保证同一）；缺省自扫（既有调用面不变）。
+  for (const f of files ?? scanDomain(base, { scanDirs, exclude })) {
+    let text = ""
+    try { text = readFileSync(f, "utf8") } catch { continue }
+    const stack = [] // 标题栈 —— { level, exempt }；exempt = 自身 ∥ 祖先命中区带
+    let fence = null // 围栏标记（` ∥ ~）；null = 不在块内
+    text.split("\n").forEach((l, i) => {
+      const mark = fenceMark(l)
+      if (mark !== null) {
+        if (fence === null) fence = mark
+        else if (mark === fence) fence = null
+        return // 围栏行自身免
+      }
+      if (fence !== null) return // 块内整块免（未闭合 ⇒ 至档尾免）
+      const hm = /^(#{1,6})\s+(.*)$/.exec(l)
+      if (hm) {
+        while (stack.length && stack[stack.length - 1].level >= hm[1].length) stack.pop()
+        const self = isZoneHead(hm[2].trim(), zones)
+        stack.push({ level: hm[1].length, exempt: self || (stack[stack.length - 1]?.exempt ?? false) })
+        return
+      }
+      const inZone = stack[stack.length - 1]?.exempt === true
+      const len = [...l].length
+      if (len > lineWidth && !isTableRow(l) && !isExecutableLine(l) && !isQuoteLine(l) && !inZone) hits.push({ file: f, line: i + 1, len })
+    })
+  }
+  return hits
+}

package/file-refs.mjs

@@ -3,12 +3,12 @@
  * 上提源 = VSC `thincoder-vscode/src/extension/file-refs.mjs` 自持档（逐字搬——regex ∕ 4000 截断 ∕
  * `[File: …]` 围栏 ∕ 摘要块格式零语义改良）；本档 = **单源**；两端各持薄壳（端侧 `node:fs` 探针注入）：
  * VSC `thincoder-vscode/src/extension/file-refs.mjs` ∥ 桌面 `thincoder-desktop/src/main/file-refs.mjs`。
- * 消费面：VSC 注入 `panel-chat.mjs:187` ∕ 恢复剥离 `panel-session.mjs:185` ∕ 标题剥离
- * `panel-session-write.mjs:139`；桌面注入缝 = `turn-driver.mjs`（起跑前单点，`turn-face.mjs`）∥
- * 恢复剥离 = `session-slots.mjs` `pageHistory` ∥ 标题剥离 = 核 `generate-title.mjs:132`（读源处）。
- * 文本形逐字冻结（`docs/vsc/design/WEBVIEW.md:154`「落线文本逐字不变」契约）：上提不携任何行为面改动。
+ * 消费面：VSC 注入 `panel-chat.mjs` 的 `injectAtRefs` ∕ 恢复剥离 `panel-session.mjs` 的 `stripAtRefs` ∕ 标题剥离
+ * `panel-session-write.mjs` 的 `generateTitle`；桌面注入缝 = `turn-driver.mjs`（起跑前单点，`turn-face.mjs`）∥
+ * 恢复剥离 = `session-slots.mjs` `pageHistory` ∥ 标题剥离 = 核 `generate-title.mjs` 的 `ensureSessionTitle`（读源处）。
+ * 文本形逐字冻结（`docs/vsc/design/WEBVIEW.md` §4.4「落线文本逐字不变」契约）：上提不携任何行为面改动。
  * 判据 = **盘面探针注入缝**（`probe = { readFileSync, existsSync, statSync }` —— `node:fs` 同名面；
- * 缺 ∕ 形违 ⇒ 抛 —— fail-loud：盘面闸未接线不得静默扮成「零引用」，沿 `file-links.mjs:29-31` 先例）。
+ * 缺 ∕ 形违 ⇒ 抛 —— fail-loud：盘面闸未接线不得静默扮成「零引用」，沿 `file-links.mjs` 的 `extractFileLinks` 先例）。
  * `stripAtRefs` = 注入语法的逆变换：fail-closed 判据逐字依赖注入输出格式 —— 语法与其逆变换同住一处，
  * 零第二实现（本档为唯一产者）。
  */
@@ -26,7 +26,7 @@ function probeOf(probe) {
 }
 
 /** Scan text for @path references and replace with inline file content.
- *  零文本（非串 ∥ 空串）先于探针校验早退（零判据——探针不检，同序沿核 `file-links.mjs:28`）。 */
+ *  零文本（非串 ∥ 空串）先于探针校验早退（零判据——探针不检，同序沿核 `file-links.mjs` 的 `extractFileLinks`）。 */
 export function injectAtRefs(text, cwd, probe) {
   if (typeof text !== "string" || text === "") return text
   const io = probeOf(probe)

package/generate-title.mjs

@@ -14,7 +14,7 @@ import { resolveProviderSecrets } from "./env-ref.mjs"
 // （`isRealUserMsg`——纯函数零依赖，无环）。
 import { isRealUserMsg } from "./history-window.mjs"
 // #632（缺面族批补 · @ 文件引用对齐 · 2026-09-29）：标题源剥离单源——注入形不得进标题请求（核件
-// `file-refs.mjs`；CLI 无注入 ⇒ 零动作；VSC 同位转口 = `panel-session-write.mjs:139`）。
+// `file-refs.mjs`；CLI 无注入 ⇒ 零动作；VSC 同位转口 = `panel-session-write.mjs` 的 `generateTitle`）。
 import { stripAtRefs } from "./file-refs.mjs"
 // #363③（off 形族单源——MODEL-SPECS.md §16.2 / §16.4）：禁思考形与「是否可禁」一律引核
 // （`thinkOffShape` / `thinkOffPath`——本档零副本）；spec 查表同单源（`specForModel`）。

package/hooks.mjs

@@ -98,7 +98,7 @@ async function runOneHook(event, hook, ctx) {
     // Timeout guard（#135-④：`timeout` ms 到点杀掉子进程 + 放行——原由 spawn 的 `timeout`
     // 选项承担，见上）。句柄捕获 + `unref()`：进程存活期间守卫照常触发（真 CLI 运行事件循环
     // 另有 handle），但不再单独维持事件循环存活 ⇒ 子进程钩子用例的测试进程零尾挂；
-    // 任一出口经 `done` 收尾 clearTimeout（house 先例 = mcp/transport-stdio.mjs:20）。
+    // 任一出口经 `done` 收尾 clearTimeout（house 先例 = `mcp/transport-stdio.mjs` 的 `killTree`）。
     guard = setTimeout(() => {
       try { proc.kill() } catch { /* already gone */ }
       done(0)

package/i18n.mjs

@@ -7,7 +7,7 @@
  *  - `projectDictionary(locale)` = **VSC 字典投影**：核常量 → VSC `locales/*.json` 的扁平
  *    字典形态（VSC 的 `i18n.mjs` `t()` 壳在 S2 接线时并入本投影，壳内零文案）。
  *
- * 契约（CORE-UNIFICATION §2.12.2 第 12 行 · 输出文案类）：**机器消费面冻结**——本表键值
+ * 契约（CORE-UNIFICATION §2.12.2「输出文案类」）：**机器消费面冻结**——本表键值
  * 与现 VSC `locales/{en,zh}.json` 逐字一致（已锁定串不得改）；人读文案后续变更须登记 +
  * CHANGELOG（S2 落地物）。`${name}` = 插值占位（两端同约定）。
  *
@@ -76,6 +76,16 @@ export const CORE_MESSAGES = Object.freeze({
   "tool.done": { en: "done", zh: "完成" },
   // ── 台账（ledger）· F-LX3 变体键库首跑提示（批 2026-10-05-ledger-variant-db-notice · 台账 #935 · LEDGER.md §12.2 逐字；消费面 = CLI TUI 启动行）
   "ledger.variantDbNotice": { en: "Legacy variant-key ledger DB found for this project (pre-upgrade; rows may be outside the current ledger): thincoder ledger audit to inspect; thincoder ledger migrate to reconcile", zh: "检测到本项目的存量变体键台账库（升级遗留，数据可能未并入当前库）：thincoder ledger audit 查看；thincoder ledger migrate 收正" },
+  // ── SSH 会话（批 ssh-session · 台账 #1436 · TOOLS.md §6.22 ⑧——凭据窗词面单源；三端经本字典投影）──
+  "ssh.credentialTitle": { en: "SSH credential", zh: "SSH 凭据" },
+  "ssh.credentialPrompt": { en: "Enter the login credential for ${host}", zh: "输入 ${host} 的登录凭据" },
+  "ssh.secretTitle": { en: "SSH secret", zh: "SSH 密文" },
+  "ssh.secretPrompt": { en: "Enter the secret for ${host}", zh: "输入 ${host} 的密文" },
+  "ssh.field.user": { en: "Username", zh: "用户名" },
+  "ssh.field.password": { en: "Password", zh: "密码" },
+  "ssh.field.secret": { en: "Secret", zh: "密文" },
+  // 无 UI 失败句（E6；三端投影单源）：en 侧 = CLI 端 `SECRET_NO_UI_TEXT` 逐字（端常量收正为核键）。
+  "ssh.no_ui": { en: "ssh credential input requires an interactive UI (none in this context) - use key-based auth or ssh-agent", zh: "ssh 凭据输入需要交互界面（当前场合没有）——请改用密钥认证或 ssh-agent" },
 })
 // 深度冻结（机器消费面冻结——嵌套 { en, zh } 也冻结；浅冻结下值可被静默改写）。
 for (const entry of Object.values(CORE_MESSAGES)) Object.freeze(entry)