@thincoder/core 0.10.12 → 0.11.1

package/doc-check/anchors.mjs

@@ -5,19 +5,42 @@
  * · 文档指针 = 档 token（含 `.md`，可带目录段）± 节指示（紧随 `§` + 编号 N / N.M / N.M.K）；
  *   **行号坐标（`:N`）不作节指示**——行号不作引用；
  * · 档不在盘 ⇒ `档缺`；带节指示 ∧ 节不在盘 ⇒ `节缺`。
+ * · 依据行（`依据 <档路径>「<逐字引文>」`——口径单源 = 同档 §3.25 条目 Y）：路径面走**同一解析序**，
+ *   引文面要求「目标档全文里的一段连续子串」——不是 ⇒ `引缺`。不构成标记的行不判；不新增判据条数、
+ *   不新增 verdict 词（三个命中类同计「锚 N 条」）。
  *
  * 抽取面：逐行扫；fenced 块整块跳过；可执行行（`isExecutableLine`）整行跳过（命令保字面）；
  *   提示词面另剥 CANON 操作数（面判据 = `./paragraph.mjs` 的 `isPromptFace`——七名整串删除后再抽，见 `CANON_OPERANDS`）。
- * 解析序**两级**：① 仓根相对全路径 → ② 引用方档所在目录相对。零命中 ⇒ `档缺`。
- *   **裸名不跨目录解析**：跨目录解析须先建全域目录索引——为认出一个裸名而重建索引，等于把全仓扫描请回来；
- *   写全路径后解析零索引，逐档判就是全部（与 D4 实现坐标口径一致）。
+ * 解析序**两级**（算法单源 = `../path-resolve.mjs` 的统一解析层，本档只声明本面参数）：
+ *   ① 仓根相对全路径 → ② 引用方档所在目录相对。零命中 ⇒ `档缺`，并**列同名候选**（「你是不是指这个」——
+ *   候选只作提示，**不产命中档**：裸名仍不跨目录解析，全域索引不建）。
+ *   跨仓形（`仓名/相对路径`）⇒ **零命中**，回执记一行（声明源引用 / 须先声明——只判引用写对没有，不查存在性）。
  * 节在盘：**只读解析命中的那一档**（点查，不遍历）——目标档内存在标题行，其标题编号
  *   （标题文本去 `^#{1,6}\s` 后的首个 `\d+(?:\.\d+)*`）= 指针节号。
- * 残余登记（fail-open 方向——归评审核验面）：未闭合围栏 ⇒ 至档尾免；指针行的坐标尾不入判、同行的档 token 照判。
+ * 残余登记（fail-open 方向——归评审核验面）：未闭合围栏 ⇒ 至档尾免；指针行的坐标尾不入判、同行的档 token 照判；
+ *  **引文含 `」` 时只抽到第一个 `」`**（抽取段是 `[^」]`）——逐字引用一段内含「…」的句子时被验的只是前缀，
+ *  错的后半段静默放行（方向是不误拦，不是不误放；这一半的最终裁定归评审核验面，同设计 §3.25「评审面」）。
+ * 档名豁免（类名 ∥ 占位词干）的**判定只此一处** = 本档导出的 `docNameExemption`（判据单源 = §3.24 条目 X）：
+ *   两张表保持私有、不上导出面；另两处消费面（兄弟脚本 ∥ 行号坐标清单）只拿判定、拿不到名单。
  */
-import { readFileSync, statSync } from "node:fs"
-import { basename, dirname, resolve } from "node:path"
-import { fenceMark, isExecutableLine, isPromptFace } from "./paragraph.mjs"
+import { readFileSync } from "node:fs"
+import { basename, resolve } from "node:path"
+import { docRootPaths, readManifest } from "../manifest.mjs"
+import { resolvePathTarget } from "../path-resolve.mjs"
+import { fenceMark, isFenceClose, isExecutableLine, isPromptFace } from "./paragraph.mjs"
+
+/** `docRoot` 各键 → 绝对根集（**只作同名候选的扫描根**，不作受理边界——受理面仍是「档在盘 / 节在盘」）。
+ *  读声明面单源 = `docRootPaths`（本档零自持根判定）；无 manifest / 非法 ⇒ 空集。 */
+function docRootBaseKeys(root) {
+  let man = { ok: false }
+  try { man = readManifest(root) } catch { return [] }
+  if (!man.ok) return []
+  const docRoot = man.manifest?.docRoot
+  if (!docRoot || typeof docRoot !== "object") return []
+  const out = []
+  for (const key of Object.keys(docRoot)) for (const abs of docRootPaths(docRoot[key], root)) if (!out.includes(abs)) out.push(abs)
+  return out
+}
 
 /** 文档指针 token：`(目录段/)*名.md` + 可选行号坐标尾 + 可选节指示（`§` + 编号）。
  *  左界守卫排除更长 token 的尾段；右界排除后续字母数字（`.md` 之后紧邻 `[\w]` ⇒ 非完整 token）。 */
@@ -35,6 +58,52 @@ const PLACEHOLDER_STEMS = new Set([
   "x", "a", "b", "file", "out", "foo", "bar", "example", "sample", "name", "path",
 ])
 
+/** 扩展名闭集（档名后缀族——与 `thincoder-core/doc-check/line-refs.mjs` 的抽取式同一组枚举）：
+ *  谓词按这一组剥后缀取词干。**两处必须同改**——两档互 import 会成环（`line-refs.mjs` 已 import 本档谓词），
+ *  所以这里留一份，改扩展名族时两处一起改。 */
+const DOC_EXTS = ["md", "mjs", "cjs", "js", "json", "css", "html", "svg", "yml", "yaml", "sh", "ps1"]
+
+/** 依据行标记（口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.25 条目 Y「写法」表）：
+ *  `依据` + 可选分隔符（`:` ∥ `：` ∥ `=`）+ 档路径（可带反引号）+ `「引文」`。
+ *  「相邻」行 = 路径 token 与 `「` 之间**只允许分隔符与反引号**——夹进别的字符（散文词 ∥ 标点 ∥ 空白）
+ *  就**不构成标记**，不判：讲写法的档里本就有「`依据` = 判据契约（…）＋用户裁定「…」」这类散文句，
+ *  松判会把它们读成标记形，而批档恒在收口判域，一次假命中就拦一次合法收口。
+ *  （`依据` 与路径之间、以及那个分隔符是否带空白不限——那一段不是判据要防的那一处。）
+ *  扩展名族 = `DOC_EXTS`（与行号坐标族同组，单源）。
+ *  **导出面说明**：源串导出只作**量法扫串的单一源**（改面单测档的「存量读数」用它，不再自建第二份字面）——
+ *  生产行为不变，别处不去拼它。 */
+export const CITE_RE_SRC = `依据\\s*[:：=]?\\s*\`?((?:[A-Za-z0-9_.\\-]+/)*[A-Za-z0-9_.\\-]+\\.(?:${DOC_EXTS.join("|")}))\`?[:：=]?「([^」]*)」`
+
+/** 引文面的目标档读法（**同档一次读、同轮缓存**；CRLF→LF 归一——比较基准的形态单源）。 */
+function citedTextReader() {
+  const cache = new Map()
+  return (abs) => {
+    if (!cache.has(abs)) {
+      let text = ""
+      try { text = readFileSync(abs, "utf8") } catch { text = "" }
+      cache.set(abs, text.replace(/\r\n/g, "\n"))
+    }
+    return cache.get(abs)
+  }
+}
+
+/**
+ * 档名豁免判定（**唯一一处** · 判据单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.24 条目 X）：
+ * 三处消费同一个谓词——锚判（本档）∥ `scripts/prompt-refs-check.mjs`（J1 ∥ J3 命中过滤）∥ 行号坐标清单（`./line-refs.mjs`）。
+ * @param {string} name 档名 = **末段名、不带目录段**，大小写不敏感
+ * @returns {null|"filename-class"|"placeholder"} `"filename-class"` = 约定的类名（整名判，不剥后缀）；
+ *   `"placeholder"` = 占位词干（按闭集剥后缀后取词干，词干 ≤ 1 字符或命中占位表）；`null` = 不是豁免名
+ */
+export function docNameExemption(name) {
+  const bn = String(name ?? "").toLowerCase()
+  if (FILENAME_CLASSES.has(bn)) return "filename-class"
+  const dot = bn.lastIndexOf(".")
+  const ext = dot > 0 ? bn.slice(dot + 1) : ""
+  const stem = DOC_EXTS.includes(ext) ? bn.slice(0, dot) : bn
+  if (stem.length <= 1 || PLACEHOLDER_STEMS.has(stem)) return "placeholder"
+  return null
+}
+
 /** CANON 操作数族（**规范豁免串** · 判据单源 = `docs/core/design/PROMPT-SYSTEM.md` §6.6「判保留面」）：
  *  七个名字在模型面是**模型要写出来 / 读写的文件名**（行为操作数 · 路径操作数），不是「去读这个档」的指针——
  *  换个目录解析必然 `档缺`。**只对提示词面剥**（面判据 = `isPromptFace`，单源住 `./paragraph.mjs`）：`docs/` 面不会因本条多放行一个名——
@@ -61,9 +130,6 @@ export function stripCanonOperands(line) {
 // 提示词面判据单源 = `./paragraph.mjs` 的 `isPromptFace`（§3.18 ②——形态与旧 `OPERAND_FACE` 逐字同）。
 const isOperandFace = isPromptFace
 
-/** 文件存在性（目录 / 读错 ⇒ 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)
@@ -80,15 +146,14 @@ function sectionOnDisk(path, num) {
   return false
 }
 
-/** 档解析（判据 ① 的解析序两级）：命中 ⇒ `{ ok, path }`；零命中 ⇒ `{ ok:false }`。
+/** 档解析（判据 ① 的解析序两级——**算法单源 = 统一解析层** `../path-resolve.mjs`：本面只声明
+ *  `kind:"file"` / `order:"root-first"`（与既有两级序逐字同序）/ `crossRepo:"visible"`（文档锚面是
+ *  唯一开跨仓读数的面），`bases` = 无、`scanBases` = `docRoot` 各键（只喂同名候选提示）。
  *  行号坐标尾（`:N`）不参与档解析——token 只取 `.md` 段（抽取面已剥离坐标尾与节指示）。
- *  `num` = 指针节号（`§` 后编号；无节指示 ⇒ null）——仅用于判定节在盘，不参与档解析。 */
-function resolveDoc(token, refFile, base) {
-  const p1 = resolve(base, token)
-  if (isFile(p1)) return { ok: true, path: p1 } // ① 仓根相对全路径
-  const p2 = resolve(dirname(refFile), token)
-  if (isFile(p2)) return { ok: true, path: p2 } // ② 引用方档所在目录相对
-  return { ok: false }
+ *  `num` = 指针节号（`§` 后编号；无节指示 ⇒ null）——仅用于判定节在盘，不参与档解析。
+ *  @returns {{state:string, ...}} 层的四态结果 */
+function resolveDoc(token, refFile, base, scanBases) {
+  return resolvePathTarget(base, token, { kind: "file", order: "root-first", referrer: refFile, crossRepo: "visible", scanBases })
 }
 
 /**
@@ -96,40 +161,75 @@ function resolveDoc(token, refFile, base) {
  * @param {string} root 项目根（解析序 ① 的基准）
  * @param {{files?:string[]}} o `files` = **判定集兼解析集**（调用方传入的档清单——判定范围 = 解析范围，
  *   无目录遍历、无全域索引：清单外的档既不判也不参与解析）
- * @returns {{hits:Array}} hits = 命中（`档缺` / `节缺`）
+ * @returns {{hits:Array, crossRepo:Array}} hits = 命中（`档缺` / `节缺` / `引缺`——`档缺` 携 `sameName` 同名候选，
+ *   `引缺` 携 `quote` 引文原文与 `target` 命中的档）；
+ *   `crossRepo` = 跨仓引用读数（零命中、只入回执——§2.6 一行）
  */
 export function checkAnchors(root, { files = [] } = {}) {
   const base = resolve(root)
+  const scanBases = docRootBaseKeys(base)
   const hits = []
+  const crossRepo = []
+  const citedTextOf = citedTextReader() // 引文面：目标档全文（同档一次读、同轮缓存）
   for (const f of files) {
     let text = ""
     try { text = readFileSync(f, "utf8") } catch { continue }
     const re = new RegExp(ANCHOR_RE.source, "g") // 每档一份实例（零共享 lastIndex 状态）
+    const citeRe = new RegExp(CITE_RE_SRC, "g") // 同上（引文标记面）
     const stripOperands = isOperandFace(f) // 只有提示词面剥（面判据 = `isPromptFace`）
     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
+        else if (isFenceClose(mark, fence)) fence = null
         return
       }
       if (fence !== null) return
       if (isExecutableLine(l)) return // 可执行行整行跳过
       const scan = stripOperands ? stripCanonOperands(l) : l // 提示词面：操作数先剥再抽；文档面 = 原行
+      // ── 依据行（§3.25 条目 Y）：一行多处各自判；路径 token 的区间要记下来——锚抽取得跳过它，
+      //    否则一个解析不到的 `.md` 路径会被两条判法各报一次（同一处缺陷两条命中）。
+      //    **标记先成立才占区间**：空引文 ∥ 豁免名两条不构成「引文判的标记」——它们的 token
+      //    仍归锚面照常判（既有类零改）：空引文那行里的悬空 `.md` 照旧 `档缺`，不会凭空消失。
+      const cited = []
+      if (scan.includes("依据")) {
+        let c
+        while ((c = citeRe.exec(scan)) !== null) {
+          const token = c[1]
+          const quote = c[2].trim()
+          if (quote === "") continue // `「」` 空引文不构成标记（§3.25 边界：没有第二分支）
+          // 豁免名（类名 ∥ 占位）在锚面不抽 ⇒ 引文面同判：同一 token 不得两套口径（§3.24 条目 X / F12 单源）
+          if (docNameExemption(basename(token)) !== null) continue
+          const start = c.index + c[0].indexOf(token)
+          cited.push({ start, end: start + token.length })
+          const r = resolveDoc(token, f, base, scanBases)
+          if (r.state === "crossRepo") { crossRepo.push({ file: f, line: i + 1, token, ...r }); continue } // 跨仓：零命中，回执一行（同锚面）
+          if (r.state !== "resolved") { // 路径先判存在性——两因不混（路径错 ⇒ `档缺`，引文错 ⇒ `引缺`）
+            hits.push({ file: f, line: i + 1, token, clazz: "档缺", missing: r.state === "dangling" ? r.missing : "", sameName: r.state === "dangling" ? r.sameName : [] })
+            continue
+          }
+          // 引文面：只判「是不是该档里的一段连续子串」——不折叠空白、不换全半角、不换算大小写（§3.25 边界）
+          if (!citedTextOf(r.abs).includes(quote)) hits.push({ file: f, line: i + 1, token, clazz: "引缺", quote, target: r.abs })
+        }
+      }
       let m
       while ((m = re.exec(scan)) !== null) {
         const token = m[1]
+        if (cited.some((c) => m.index >= c.start && m.index < c.end)) continue // 该 token 归引文判（上面已判，不重报）
         const num = m[2] ?? null
-        const bn = basename(token).toLowerCase()
-        const stem = bn.replace(/\.md$/, "")
-        // 类名 ∥ 占位符两免：抽取面不把它们当指针（判据 = DOC-DISCIPLINE §3.20 ① 的「档 token」定义面）
-        if (FILENAME_CLASSES.has(bn) || stem.length <= 1 || PLACEHOLDER_STEMS.has(stem)) continue
-        const r = resolveDoc(token, f, base)
-        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 })
+        // 类名 ∥ 占位符两免：抽取面不把它们当指针（判据 = DOC-DISCIPLINE §3.24 条目 X——
+        // 判定只此一处，兄弟脚本与行号坐标清单消费同一谓词）
+        if (docNameExemption(basename(token)) !== null) continue
+        const r = resolveDoc(token, f, base, scanBases)
+        if (r.state === "crossRepo") { crossRepo.push({ file: f, line: i + 1, token, ...r }); continue } // 跨仓：零命中，回执一行
+        if (r.state !== "resolved") {
+          hits.push({ file: f, line: i + 1, token, clazz: "档缺", missing: r.state === "dangling" ? r.missing : "", sameName: r.state === "dangling" ? r.sameName : [] })
+          continue
+        }
+        if (num !== null && !sectionOnDisk(r.abs, num)) hits.push({ file: f, line: i + 1, token, clazz: "节缺", section: num, target: r.abs })
       }
     })
   }
-  return { hits }
+  return { hits, crossRepo }
 }

package/doc-check/index.mjs

@@ -2,7 +2,7 @@
  * doc-check/index.mjs — 文档纪律机检 · 引擎入口（两条判据 + 报面行）。
  *
  * 判据两条（起步 · 闭集——口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.20 条目 S）：
- *   ① 锚（档缺 / 节缺）——实现 = `./anchors.mjs`；② 段判据（段太长 ∥ 行太长）——口径 = §3.18 条目 Q，实现 = `./paragraph.mjs`。
+ *   ① 锚（档缺 / 节缺 / 引缺）——实现 = `./anchors.mjs`；② 段判据（文字太长，难于阅读 ∥ 行太长）——口径 = §3.18 条目 Q，实现 = `./paragraph.mjs`。
  * 判据参数 = **工具内置常量** `DOC_CHECK_BUILTINS`：不读任何项目的声明面，因而没有「缺参数 ⇒ 拒跑」这一层，
  *   也没有常量校验面——改判据 = 改代码、走评审。
  * 判定范围 = **调用方传入的文件清单**（判定范围 = 解析范围 = 传入的那几档；无目录遍历、无全域兜底）：
@@ -12,11 +12,16 @@
  *   清单里不可判档（不在盘 ∥ 非 .md）⇒ 报错点名、整次零判定；
  *   `gate` = 交付时点的裁定——首行给机器可判 verdict；不可判档给跳过行（可见，不静默丢掉）。
  *   强制面住交付协议 + 批次档 §6 前置，工具本体不阻断任何动作。
+ * **`report` 面另有一份只读清点：行号坐标清单**（`./line-refs.mjs` · 口径 = `docs/core/design/DOC-DISCIPLINE.md` §3.23 条目 W）——
+ *   **只报不拦**：不进 `gate`、不计入 `hits`、不阻断写入。判据面仍是上面两条，一字不改。
  */
 import { statSync } from "node:fs"
 import { relative, resolve } from "node:path"
-import { checkParagraphs } from "./paragraph.mjs"
+import { checkParagraphs, DOC_CLASS } from "./paragraph.mjs"
 import { checkAnchors } from "./anchors.mjs"
+import { collectLineRefs, lineRefsBlock } from "./line-refs.mjs"
+// 跨仓引用一行读数的文案骨架（单源 = 统一解析层；本档只把它摆进报面）。
+import { crossRepoNote } from "../path-resolve.mjs"
 
 /** 判据参数（内置常量 · 冻结）：阈值 300 字符（一段 ∥ 一行同值——§3.18 ④）；两项空列表 = 区带类 / 豁免类默认值且恒空
  *  ——豁免谓词（表行 / 围栏 / 列表项 / 引文）住代码，没有「登记后放过」的写入口（空列表 ≠ 可登记豁免）。 */
@@ -27,6 +32,26 @@ export const DOC_CHECK_BUILTINS = Object.freeze({
   exemptions: Object.freeze([]),
 })
 
+/** 命中类名单源再出口（`./paragraph.mjs` 的 `DOC_CLASS`）：`agent-tools/batch-gate.mjs` 要判「处置块何时出」，
+ *  而它按判据链纪律只 import 本档（引擎 import 只指向 `../doc-check/index.mjs`）⇒ 类名由本档再出口，
+ *  消费面不抄字面类名——抄一次就是「改报面忘改过滤」那类字面漂移（`paragraph.mjs` 头注记着 2026-10-26 实发过一次）。 */
+export { DOC_CLASS }
+
+/** 段命中的处置块（五行 · 逐字单源）：口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.20「报面（固定句形 · 交付门 gate）」尾行。
+ *  三处消费面（本档 `gateReport` ∥ `agent-tools/batch-gate.mjs` 的报面组装与拒串 ∥ `scripts/doc-check.mjs` 的段报告段）
+ *  只 import 本数组、零字面复制——同一句话抄三遍，改一处漏两处是必然。
+ *  **为什么住本档**：报面尾行本来就住这里，`batch-gate.mjs` 已 import 本档 ⇒ 字面随报面同源，不新增第三个 import 面。
+ *  **为什么是五行而不是一句命令口吻的单条出路**：被拒的人当场只读得到这一面——旧句只说「你该怎么改」且只给一条出路；
+ *  规则面本有三条，且「过机检」与「是处置」是两件事（切段 ∥ 缩短能过计数，读者拿到的还是同一堵墙）。
+ *  **何时出**：只跟「文字太长，难于阅读」类命中走；仅锚 ∥ 仅行命中 ⇒ 零处置块（叫人对段落动手而问题不在此 = 指错方向）。 */
+export const PARA_DISPOSE = Object.freeze([
+  "处置：上面这些段落，读者一口气读不完——不是字符数超了，是这一段装的事太多。",
+  "出路三条：① 重组结构——无标记的续行逐条添标记、逐条起名，拆成带名的列表项（逐字不改）∥ ② 重写文字——把长句拆成几句短的（意思不变，句子变少）∥ ③ 改写成表格行——内容本是逐条读数 / 映射 / 清单时成立。",
+  "① ∥ ③ 只对能逐条起名的并列断言成立——一条因果链拆成带名条目还是同一条因果链，读者拿到的只有断点；讲因果的长段走 ②。",
+  "折行连机检都过不了——句子中间插换行，读者拿到的还是同一堵墙；切段 ∥ 缩短能过机检，但不是处置——机检绿了不等于读者读得动。",
+  "同轮修正后复跑；不转台账。",
+])
+
 /** 相对路径显示形（正斜杠——跨平台同形）。 */
 const rel = (root, p) => relative(root, p).replace(/\\/g, "/")
 
@@ -62,23 +87,62 @@ function resolveRange(base, docs) {
   return { check: check.sort(), undecidable, missing, notMarkdown, invalid }
 }
 
-/** 段判据命中行（报面单源——两类命中同形，按 `clazz` 分词）。 */
-const paragraphHitLine = (base, h) => `✗ ${h.clazz} ${rel(base, h.file)}:${h.line}（${h.len} 字符）`
+/** 段判据命中行（报面单源——两类命中同形，按 `clazz` 分词）。**不报字符数**：用户 2026-10-26 11:16「不能表述成超长多少个字符，要表述成为文字太长难于阅读」。 */
+const paragraphHitLine = (base, h) => `✗ ${h.clazz} ${rel(base, h.file)}:${h.line}`
+
+/** 跨仓引用读数行（零命中、只入回执——文案骨架单源 = `path-resolve.mjs` 的 `crossRepoNote`）。 */
+const crossRepoLine = (h) => `跨仓引用：${crossRepoNote(h.token, h)}`
+
+/** `档缺` 命中行的追加提示（§2.6：缺的那一段 + 盘上同名——候选只提示，不改判态）。 */
+const missingHint = (base, h) => {
+  const seg = typeof h.missing === "string" && h.missing !== "" ? `缺「${h.missing}」` : ""
+  const same = Array.isArray(h.sameName) && h.sameName.length > 0 ? `盘上同名：${h.sameName.map((p) => rel(base, p)).join(" ∥ ")}` : ""
+  const parts = [seg, same].filter(Boolean)
+  return parts.length > 0 ? `（${parts.join("；")}）` : ""
+}
+
+/** 锚命中的类名词（报面标签——类名由引擎定，本档只配显示形；三属同一条判据、同计「锚 N 条」）。 */
+const ANCHOR_LABELS = { 档缺: "锚·档缺", 节缺: "锚·节缺", 引缺: "锚·引缺" }
+
+/** 锚命中行（报面单源——三命中类同形，按 `clazz` 分词）：`档缺` 追加缺哪一段与盘上同名，
+ *  `节缺` 点名目标档，`引缺` 点名引文前 40 字（读者不必回目标档自己找哪一段不对）。
+ *  两处消费（`gate` 报面 ∥ 报告态报面）只调本函数——各写一份三元式改一处必漏一处。 */
+const anchorHitLine = (base, h) => {
+  const head = `✗ ${ANCHOR_LABELS[h.clazz] ?? `锚·${h.clazz}`} ${rel(base, h.file)}:${h.line} \`${h.token}\``
+  if (h.clazz === "引缺") return `${head}（引文不在该档内：「${String(h.quote ?? "").slice(0, 40)}…」）`
+  if (h.clazz === "节缺") return `${head}（目标 ${rel(base, h.target)} 无 §${h.section}）`
+  return head + missingHint(base, h)
+}
 
 /** gate 报面（固定句形——§3.20「报面（固定句形 · 交付门 gate）」）：首行 verdict = 唯一机判串。 */
-function gateReport({ base, docsSource, checkFiles, skipped, anchors, paragraphs, paragraphMax }) {
+function gateReport({ base, docsSource, checkFiles, skipped, anchors, paragraphs }) {
   const total = anchors.hits.length + paragraphs.length
   const src = docsSource === "session" ? "本会话写过的文档" : "显式 docs"
+  // 首行：锚与段分列（用户 11:16：段的问题叫「文字太长，难于阅读」，不是「命中 N 条」也不是字符数）
+  const verdict = () => {
+    if (total === 0) return checkFiles.length ? "DOC-CHECK GATE: PASS" : "DOC-CHECK GATE: PASS（0 档）"
+    const parts = []
+    if (anchors.hits.length) parts.push(`锚 ${anchors.hits.length} 条`)
+    // 段与行分列——两类命中不得合并（提示词面一行 = 一个块，属「行太长」，不是「一段文字太长」）
+    const paraCount = paragraphs.filter((h) => h.clazz === DOC_CLASS.para).length
+    const lineCount = paragraphs.filter((h) => h.clazz === DOC_CLASS.line).length
+    if (paraCount) parts.push(`${paraCount} 段${DOC_CLASS.para}`)
+    if (lineCount) parts.push(`${lineCount} ${DOC_CLASS.line}`)
+    return `DOC-CHECK GATE: REFUSED（${parts.join(" · ")}）`
+  }
   const out = [
-    total ? `DOC-CHECK GATE: REFUSED（命中 ${total} 条）` : (checkFiles.length ? "DOC-CHECK GATE: PASS" : "DOC-CHECK GATE: PASS（0 档）"),
+    verdict(),
     "文档纪律机检（交付门 · gate）",
     checkFiles.length
-      ? `范围：${src} ${checkFiles.length} 档 · 阈值 ${paragraphMax} 字符（工具内置常量）`
-      : `范围：${src} —— **0 档受检**（空清单：本次没有判任何档，不得读作「已检」）· 阈值 ${paragraphMax} 字符（工具内置常量）`,
-    "判据：工具内置常量（锚 ∥ 段判据）——判定范围 = 解析范围 = 传入档",
+      ? `范围：${src} ${checkFiles.length} 档`
+      : `范围：${src} —— **0 档受检**（空清单：本次没有判任何档，不得读作「已检」）`,
+    "判据：逐段检查——" + DOC_CLASS.para,
   ]
   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(" ∥ ")}`)
+  // 跨仓引用读数（零命中类——不进 `total`、不改 verdict，只让作者看到「这一处没保证」）；
+  // 位置 = 命中区之前，末行仍留给结论 / 处置块。
+  for (const h of anchors.crossRepo ?? []) out.push(crossRepoLine(h))
   if (checkFiles.length === 0) {
     // 空范围不静默当通过（K6）——照实说明 + 给出补充通道（两侧都不得读成「已检」）。
     // 措辞按「有没有跳过行」分流：无跳过行时不得写「见上方跳过行」。
@@ -91,15 +155,12 @@ function gateReport({ base, docsSource, checkFiles, skipped, anchors, paragraphs
         ? "范围为空：显式 docs 里没有可判档——见上方跳过行"
         : "范围为空：显式 docs 是空清单——列出要判的档后复跑"))
   } else if (total === 0) {
-    out.push(`结论：0 条命中（${checkFiles.length} 档全清）`)
+    out.push(`结论：0 段有问题（${checkFiles.length} 档全清）`)
   } else {
-    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 h of anchors.hits) out.push(anchorHitLine(base, h))
     for (const w of paragraphs) out.push(paragraphHitLine(base, w))
-    out.push("处置：同轮修正后复跑（改文档 ∥ 修引擎）；不转台账；拿不准 ⇒ 上抛主 agent 裁决（主 agent 拿不准 ⇒ 转呈用户）")
+    // 处置块只跟「段」命中走：仅有行太长时不得叫人对段落重写；字面单源 = `PARA_DISPOSE`（三处消费面同一份）
+    if (paragraphs.some((h) => h.clazz === DOC_CLASS.para)) out.push(...PARA_DISPOSE)
   }
   return out.join("\n")
 }
@@ -115,7 +176,8 @@ function gateReport({ base, docsSource, checkFiles, skipped, anchors, paragraphs
  *   `docs`）——缺省 = `explicit`；只影响报面措辞。
  * @returns {{report:string, hits:{total:number, anchors:number, paragraph:number}, anchorHits:Array,
  *   paragraphHits:Array, files:string[], checkFiles:string[], paragraphMax:number,
- *   skipped:{missing:string[], notMarkdown:string[]}}}
+ *   skipped:{missing:string[], notMarkdown:string[]}, lineRefs?:{body:Array, fenced:Array, total:number}}}
+ *   `lineRefs`（行号坐标清单的采集结果）**只在 `report` 面返回**——`gate` 面构造上不产该字段。
  *   消费面判「清」须读 `report` 首行（gate）∥ `hits.total`（report），不得只看其中一个。
  */
 export function runDocCheck(root, { docs, mode = "report", docsSource } = {}) {
@@ -154,23 +216,27 @@ export function runDocCheck(root, { docs, mode = "report", docsSource } = {}) {
     skipped: { missing: range.missing, notMarkdown: range.notMarkdown },
   }
   if (gate) {
-    return { ...shared, report: gateReport({ base, docsSource: source, checkFiles, skipped: shared.skipped, anchors, paragraphs, paragraphMax }) }
+    return { ...shared, report: gateReport({ base, docsSource: source, checkFiles, skipped: shared.skipped, anchors, paragraphs }) }
   }
 
+  // 行号坐标清单的**唯一采集点**：放在 `if (gate)` 早返回之后——`gate` 分支上一行已返回，够不着这里。
+  // 「闸看不见清单」靠这个结构成立（不是「算出来再声明它不参与」——一份存在但被声明无用的数，读者迟早拿它当判据）。
+  const lineRefs = collectLineRefs({ files: checkFiles })
+
   const out = [
     "文档纪律机检（报告态 · 非门禁）",
-    `射程：${base} · 传入清单 ${checkFiles.length} 档 · 阈值 ${paragraphMax} 字符（工具内置常量）· 区带豁免：${paragraphExemptZones.length ? paragraphExemptZones.join(" ∥ ") : "无"}`,
+    `射程：${base} · 传入清单 ${checkFiles.length} 档 · 区带豁免：${paragraphExemptZones.length ? paragraphExemptZones.join(" ∥ ") : "无"}`,
     "声明：判据参数 = 工具内置常量；范围 = 传入文件（判定范围 = 解析范围）",
     `范围：传入清单 ${checkFiles.length} 档（整档入判 · 判定范围 = 解析范围）`,
-    `命中 ${hits.total} 条（锚 ${anchors.hits.length} · 段太长 ${paragraphs.filter((h) => h.clazz === "段太长").length} · 行太长 ${paragraphs.filter((h) => h.clazz === "行太长").length}）`,
+    `命中 ${hits.total} 条（锚 ${anchors.hits.length} · ${DOC_CLASS.para} ${paragraphs.filter((h) => h.clazz === DOC_CLASS.para).length} · ${DOC_CLASS.line} ${paragraphs.filter((h) => h.clazz === DOC_CLASS.line).length}）`,
   ]
-  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 h of anchors.hits) out.push(anchorHitLine(base, h))
   for (const w of paragraphs) out.push(paragraphHitLine(base, w))
-  out.push(hits.total ? `结论：${hits.total} 条命中——报告态，不作拒执行的理由` : "结论：0 条命中（锚 ∥ 段太长 ∥ 行太长 均清）")
+  // 跨仓引用读数（零命中类——只报不拦，位置 = 命中区之后、清单块之前）
+  for (const h of anchors.crossRepo ?? []) out.push(crossRepoLine(h))
+  // 清单块位置 = 命中区之后、末行 `结论：…` 之前（报面的末行恒是结论句，清单不抢它的位）。
+  out.push(...lineRefsBlock({ base, files: checkFiles, refs: lineRefs }))
+  out.push(hits.total ? `结论：${hits.total} 条命中——报告态，不作拒执行的理由` : `结论：0 条命中（锚 ∥ ${DOC_CLASS.para} ∥ ${DOC_CLASS.line} 均清）`)
 
-  return { ...shared, report: out.join("\n") }
+  return { ...shared, report: out.join("\n"), lineRefs }
 }

package/doc-check/line-refs.mjs

@@ -0,0 +1,112 @@
+/**
+ * doc-check/line-refs.mjs — `report` 面的行号坐标清单（只报不拦 · 三形归属窗）。
+ *
+ * 判据句单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.23 条目 W（本档只实现，不重述口径）：
+ * · 行号坐标 = **一个档名之后出现的 `:` 加数字**；归属窗三形闭集 = 紧贴 ∥ 承名 ∥ 段落承名
+ *   （三形是**读数分类**，不是判据分级——同一命中按处计，不按形加权）；
+ * · 它是**清点，不是判据**：不产 verdict、不计入 `hits`、不阻断任何写入。
+ *   调用点只在 `./index.mjs` 的 `if (gate) { return … }` 早返回之后的报面构造段——`gate` 分支够不着本档，
+ *   所以「闸看不见清单」是构造上的事实，不是「算出来但声明不参与」。
+ * · 档名豁免 = 与锚判同一谓词 `docNameExemption`（单源 = `./anchors.mjs` ∥ §3.24 条目 X）——
+ *   本档零自建名集：占位形（`x.md`）∥ 类名（`todo.md`）不算档名，也就不构成任何归属窗。
+ *
+ * 量法（清单块**首行**自承）：抽取式 = 本档两条正则；扫描域 = 调用方传入的档清单
+ *   （与两条判据同一集、同一档数；不另取范围、不做全仓扫描）。
+ * 两个面并列：**正文面** = 围栏块整块跳过 ∧ 可执行行跳过；**围栏内** = 不跳围栏时独有的处；**合计** = 两数之和。
+ *   为什么围栏面要留：围栏块里躺着成片的存量坐标（改前 / 改后对照块的左半），清账要看见的正是它们；
+ *   反方向也要防——围栏同时是举例的家，只报全文面会把举例混进读数，读数就没法跟下一份比。
+ */
+import { readFileSync } from "node:fs"
+import { basename, relative } from "node:path"
+import { docNameExemption } from "./anchors.mjs"
+import { fenceMark, isFenceClose, isExecutableLine } from "./paragraph.mjs"
+
+/** 档名 token（抽取式 · 逐字 = 判据句）：目录段可选，扩展名闭集。左界排除更长 token 的尾段、右界排除后续字母数字。 */
+export const NAME_RE = /(?<![A-Za-z0-9_.\-\\/@])((?:[A-Za-z0-9_.\-]+\/)*[A-Za-z0-9_.\-]+\.(?:md|mjs|cjs|js|json|css|html|svg|yml|yaml|sh|ps1))(?![\w])/
+
+/** 行号坐标（抽取式 · 逐字 = 判据句）：`:` 后接数字（可带 `-` 区间）；左界只排数字 / 冒号前导（挡时刻 `12:30`）。 */
+export const COORD_RE = /(?<![0-9:]):(\d+)(?:-(\d+))?(?![\w])/
+
+/** 相对路径显示形（正斜杠——跨平台同形）。 */
+const rel = (base, p) => relative(base, p).replace(/\\/g, "/")
+
+/** 原文片段 ≤ 40 字（CJK 按字计——`[...]` 逐码点切，不按 UTF-16 单元）。 */
+const snippet = (line) => [...line.trim()].slice(0, 40).join("")
+
+/** 一行内的档名位置（已过豁免谓词——豁免名不算档名，也就不构成任何归属窗）。 */
+function nameSpans(line) {
+  const out = []
+  const re = new RegExp(NAME_RE.source, "g")
+  let m
+  while ((m = re.exec(line)) !== null) {
+    if (docNameExemption(basename(m[1])) !== null) continue
+    out.push({ start: m.index, end: m.index + m[0].length })
+  }
+  return out
+}
+
+/**
+ * 采集：逐档逐行找行号坐标，定归属窗，分两面。
+ * @param {{files?:string[]}} o `files` = 扫描域（调用方传入的档清单——本档不遍历目录、不做全仓扫描）
+ * @returns {{body:Array, fenced:Array, total:number}}
+ *   `body` = 正文面的处（围栏块外 ∧ 非可执行行）；`fenced` = 围栏内独有的处；每处 = `{file, line, form, fenced, snippet}`
+ */
+export function collectLineRefs({ files = [] } = {}) {
+  const body = []
+  const fenced = []
+  for (const f of files) {
+    let text = ""
+    try { text = readFileSync(f, "utf8") } catch { continue }
+    let fence = null // 围栏标记（` ∥ ~）；null = 不在块内
+    let prevNames = [] // 上一行的档名位置（③ 段落承名取其中最后一个）
+    text.split("\n").forEach((l, i) => {
+      const mark = fenceMark(l)
+      const inFence = fence !== null
+      if (mark !== null) {
+        if (fence === null) fence = mark
+        else if (isFenceClose(mark, fence)) fence = null
+        prevNames = [] // 围栏标记行不承载档名（③ 因此不跨过围栏边界）
+        return
+      }
+      if (isExecutableLine(l)) { prevNames = []; return } // 可执行行整行不判（命令保字面——两面同跳）
+      const names = nameSpans(l)
+      const re = new RegExp(COORD_RE.source, "g")
+      let m
+      while ((m = re.exec(l)) !== null) {
+        const at = m.index
+        const before = names.filter((n) => n.end <= at)
+        let form
+        if (before.length && before[before.length - 1].end === at) form = "①" // 紧贴：档名与 `:` 之间零字符
+        else if (before.length) form = "②" // 承名：本行前文有档名（反引号收尾的坐标归此形）
+        else if (prevNames.length) form = "③" // 段落承名：本行无前文档名，取上一行最后一个档名
+        else continue // 无主——判据句自然排除，不列例外表
+        const hit = { file: f, line: i + 1, form, fenced: inFence, snippet: snippet(l) }
+        ;(inFence ? fenced : body).push(hit)
+      }
+      prevNames = names
+    })
+  }
+  return { body, fenced, total: body.length + fenced.length }
+}
+
+/**
+ * 清单块（四件 · 定名 = §3.23「清单块的形态与位置」）：**量法行**（首行：抽取式 + 扫描域）·
+ * **合计行** · **逐处行**（`源档:行` + 原文片段 ≤ 40 字，围栏内那处带 `围栏内` 标）· **空态行**（无命中时：`行号坐标 0 处`）。
+ * 块内不留空行——空行读起来像「没跑」。
+ * @param {{base:string, files?:string[], refs?:{body:Array, fenced:Array, total:number}}} o
+ *   `refs` 缺省 ⇒ 本函数现采一次；调用方要给返回值时传进来，别采两遍
+ * @returns {string[]} 块内各行（按序）
+ */
+export function lineRefsBlock({ base, files = [], refs = collectLineRefs({ files }) }) {
+  const out = [
+    `量法（行号坐标清单）：档名 = ${NAME_RE} · 坐标 = ${COORD_RE} · 扫描域 = 传入清单 ${files.length} 档（${base}）`,
+  ]
+  if (refs.total === 0) {
+    out.push("行号坐标 0 处")
+    return out
+  }
+  out.push(`正文面 ${refs.body.length} 处 · 围栏内 ${refs.fenced.length} 处 · 合计 ${refs.total} 处`)
+  for (const h of refs.body) out.push(`  · ${h.form} ${rel(base, h.file)}:${h.line}  ${h.snippet}`)
+  for (const h of refs.fenced) out.push(`  · ${h.form} ${rel(base, h.file)}:${h.line} 围栏内  ${h.snippet}`)
+  return out
+}

package/doc-check/paragraph.mjs

@@ -5,7 +5,7 @@
  * 产品内建裁定 = 同档 §3.20 条目 S——谓词单源随迁：本仓 `scripts/doc-check-paragraph.mjs` 改述为
  * **再出口缝**（薄档 · 零逻辑 · 逐名再出口），盘上不留第二份谓词实现。
  * 两面切块：文档面量段（相邻非空正文行合并成一段，量段长）· 提示词面（`isPromptFace`）量行
- * （逐行裸判，无结构豁免）。度量 = `[...line].length`（CJK 计 1——不引显示宽度 / 字体）；
+ * （逐行裸判，无结构豁免）——判据不分适用面，工具描述面同样按段判（口径 = §3.18 条 7）。度量 = `[...line].length`（CJK 计 1——不引显示宽度 / 字体）；
  * 阈值 = 调用方的内置常量（`DOC_CHECK_BUILTINS.paragraphMax` / `lineMax`）——不读声明面，也不扫目录：
  * **判定集 = 调用方传入的文件清单**。
  * 不计入段的行类（同时把段断开）= 空行 ∥ 表格行 ∥ 标题 ∥ 列表项 ∥ 引用行 ∥ 围栏（标记行与块内整行）
@@ -15,17 +15,25 @@
  */
 import { readFileSync } from "node:fs"
 
+/** 段判据类名单源（报面与统计同取此名——改报面忘改过滤的字面漂移，2026-10-26 实发过一次）。 */
+export const DOC_CLASS = Object.freeze({ para: "文字太长，难于阅读", line: "行太长" })
+
 /** 表格行谓词（markdown 表格行结构性不可折行——不计入段，与锚检查同源）。 */
 export const isTableRow = (l) => /^\s*\|.*\|\s*$/.test(String(l))
 
-/** 围栏标记（行首可选空白 + 三反引号 ∥ 三波浪号 ⇒ 标记字符；非围栏行 ⇒ null）——**单源**：
+/** 围栏标记（行首可选空白 + 三反引号 ∥ 三波浪号 ⇒ `{ ch, len }`；非围栏行 ⇒ null）——**单源**：
  *  `isFenceLine` 与两处块扫描（本节段判据 ∥ `./anchors.mjs` 锚抽取）同取此式，使「同形围栏行止」只此一解
- *  （同一模块内同符两义 = 单源可漂的结构口子）。 */
+ *  （同一模块内同符两义 = 单源可漂的结构口子）。
+ *  **长度带出**：闭合 = 同字符 ∧ 长度 ≥ 开启长度（CommonMark 围栏语义）——只比字符会让
+ *  `` ```` `` 包 `` ``` `` 的嵌套围栏在外层开启行处提前闭合，内层代码行落入正文并被并成段。 */
 export function fenceMark(l) {
   const m = /^\s*(`{3,}|~{3,})/.exec(String(l))
-  return m ? m[1][0] : null
+  return m ? { ch: m[1][0], len: m[1].length } : null
 }
 
+/** 围栏闭合谓词（单源 = 上面的长度语义）：两个 `{ ch, len }` 判闭合。 */
+export const isFenceClose = (mark, fence) => mark.ch === fence.ch && mark.len >= fence.len
+
 /** 围栏行谓词（单源 = `fenceMark`）——围栏行自身与块内整行均不计入段。 */
 export const isFenceLine = (l) => fenceMark(l) !== null
 
@@ -62,7 +70,7 @@ export function inCodeSpan(line, idx) {
 
 /** 段判据（阈值 = 调用方内置常量 `paragraphMax` ∥ `lineMax`；口径逐字 = §3.18 条目 Q）：
  *  · 文档面：相邻非空正文行合并成一段，段长 = 组成行 `[...line].length` 之和 > `paragraphMax` ⇔ 命中
- *    （`clazz: "段太长"`，定位 = 段首行号）。正文行 = 非空 ∧ 非表格行 ∧ 非标题 ∧ 非列表项 ∧ 非引用行
+ *    （`clazz: "文字太长，难于阅读"`，定位 = 段首行号）。正文行 = 非空 ∧ 非表格行 ∧ 非标题 ∧ 非列表项 ∧ 非引用行
  *    ∧ 非围栏（标记行与块内整行）∧ 非区带内；其余行类不计入、且把段断开。
  *  · 提示词面（`isPromptFace`）：逐行裸判——`[...line].length` > `lineMax` ⇔ 命中（`clazz: "行太长"`，
  *    无结构豁免）。
@@ -71,6 +79,14 @@ export function inCodeSpan(line, idx) {
  *  `exemptZones` 缺省 ∥ 空集 ⇒ 零豁免。`files`（必填）= **判定集**（调用方传入的档清单——本档不遍历
  *  任何目录；空集 ⇒ 零命中）。 */
 export function checkParagraphs({ paragraphMax, lineMax, exemptZones = [], files = [] } = {}) {
+  // 配置缺失 = 硬错，不是静默不命中。
+  // `para.len > undefined` 恒 false ⇒ **永不命中 = 假绿**；而误报会被人发现，假绿不会。
+  // 实测来源：围栏批（2026-10-27）调试时把配置当第二参数传，一度以为修复无效——
+  // 两个阈值都是 undefined，门一路绿灯。
+  if (!Number.isFinite(paragraphMax) || !Number.isFinite(lineMax)) {
+    throw new Error(`checkParagraphs: paragraphMax ∥ lineMax 必须是有限数字（收到 ${paragraphMax} / ${lineMax}）。` +
+      "配置全在第一个参数：{ paragraphMax, lineMax, exemptZones, files }。阈值缺失时永不命中，读起来就是「全部过关」。")
+  }
   const zones = (Array.isArray(exemptZones) ? exemptZones : []).filter((z) => typeof z === "string" && z !== "")
   const hits = []
   for (const f of files) {
@@ -79,7 +95,7 @@ export function checkParagraphs({ paragraphMax, lineMax, exemptZones = [], files
     if (isPromptFace(f)) {
       text.split("\n").forEach((l, i) => {
         const len = [...l].length
-        if (len > lineMax) hits.push({ file: f, line: i + 1, len, clazz: "行太长" })
+        if (len > lineMax) hits.push({ file: f, line: i + 1, len, clazz: DOC_CLASS.line })
       })
       continue
     }
@@ -88,14 +104,14 @@ export function checkParagraphs({ paragraphMax, lineMax, exemptZones = [], files
     let para = null // 在写的段 —— { start, len }；非正文行 ⇒ 断开
     const lines = text.split("\n")
     const flush = () => {
-      if (para !== null && para.len > paragraphMax) hits.push({ file: f, line: para.start, len: para.len, clazz: "段太长" })
+      if (para !== null && para.len > paragraphMax) hits.push({ file: f, line: para.start, len: para.len, clazz: DOC_CLASS.para })
       para = null
     }
     lines.forEach((l, i) => {
       const mark = fenceMark(l)
       if (mark !== null) {
         if (fence === null) fence = mark
-        else if (mark === fence) fence = null
+        else if (isFenceClose(mark, fence)) fence = null
         flush()
         return // 围栏标记行自身断段
       }