@thincoder/core 0.10.9 → 0.10.11

package/doc-check/paragraph.mjs

@@ -0,0 +1,119 @@
+/**
+ * doc-check/paragraph.mjs — 文档纪律机检的产品档位（段判据谓词族 + 段判据——实现单源）。
+ *
+ * 口径单源 = `docs/core/design/DOC-DISCIPLINE.md` §3.18 条目 Q（单位是段 / 面谓词 / 阈值 / 不分域）；
+ * 产品内建裁定 = 同档 §3.20 条目 S——谓词单源随迁：本仓 `scripts/doc-check-paragraph.mjs` 改述为
+ * **再出口缝**（薄档 · 零逻辑 · 逐名再出口），盘上不留第二份谓词实现。
+ * 两面切块：文档面量段（相邻非空正文行合并成一段，量段长）· 提示词面（`isPromptFace`）量行
+ * （逐行裸判，无结构豁免）。度量 = `[...line].length`（CJK 计 1——不引显示宽度 / 字体）；
+ * 阈值 = 调用方的内置常量（`DOC_CHECK_BUILTINS.paragraphMax` / `lineMax`）——不读声明面，也不扫目录：
+ * **判定集 = 调用方传入的文件清单**。
+ * 不计入段的行类（同时把段断开）= 空行 ∥ 表格行 ∥ 标题 ∥ 列表项 ∥ 引用行 ∥ 围栏（标记行与块内整行）
+ * ∥ 区带内：只认结构谓词，无行级白名单（按行号 / 注释声明的豁免不入判）；可执行行在段判据里**不豁免**
+ * （段 = 读者所见，码段渲染后仍在段内——§3.18 关键决策 ①）。
+ * 边界：本档零门禁 / 零退出码 / 零阻断——报告态由 `agent-tools/doc-check.mjs` 呈现。
+ */
+import { readFileSync } from "node:fs"
+
+/** 表格行谓词（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))
+
+/** 列表项谓词（无序 `-` ∥ `*` ∥ `+` · 有序 `数字 + . ∥ ） ∥ 、` + 空白）——列表项不计入段且断段。 */
+export const isListItem = (l) => /^\s*(?:[-*+]|\d+[.)、])\s/.test(String(l))
+
+/** 提示词面谓词（`thincoder-core/prompts/**`——形态对齐 `./anchors.mjs` 的 `OPERAND_FACE`，单源住本档）：
+ *  模型读原始文本，一行就是一个块（FR46 同源理由）⇒ 该面逐行裸判，无结构豁免。 */
+export const isPromptFace = (abs) => /(?:^|\/)thincoder-core\/prompts\//i.test(String(abs).replace(/\\/g, "/"))
+
+/** 区带头谓词（§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
+}
+
+/** 段判据（阈值 = 调用方内置常量 `paragraphMax` ∥ `lineMax`；口径逐字 = §3.18 条目 Q）：
+ *  · 文档面：相邻非空正文行合并成一段，段长 = 组成行 `[...line].length` 之和 > `paragraphMax` ⇔ 命中
+ *    （`clazz: "段太长"`，定位 = 段首行号）。正文行 = 非空 ∧ 非表格行 ∧ 非标题 ∧ 非列表项 ∧ 非引用行
+ *    ∧ 非围栏（标记行与块内整行）∧ 非区带内；其余行类不计入、且把段断开。
+ *  · 提示词面（`isPromptFace`）：逐行裸判——`[...line].length` > `lineMax` ⇔ 命中（`clazz: "行太长"`，
+ *    无结构豁免）。
+ *  单遍扫描携标题栈（`^(#{1,6})\s` 行入栈——同级 ∥ 更高级出栈）：行所属标题链任一为区带头 ⇒ 区带内
+ *  （不计入段且断段）。围栏未闭合 ⇒ 至档尾整块免（fail-open 方向——§3.18 残余登记 ①）；
+ *  `exemptZones` 缺省 ∥ 空集 ⇒ 零豁免。`files`（必填）= **判定集**（调用方传入的档清单——本档不遍历
+ *  任何目录；空集 ⇒ 零命中）。 */
+export function checkParagraphs({ paragraphMax, lineMax, exemptZones = [], files = [] } = {}) {
+  const zones = (Array.isArray(exemptZones) ? exemptZones : []).filter((z) => typeof z === "string" && z !== "")
+  const hits = []
+  for (const f of files) {
+    let text = ""
+    try { text = readFileSync(f, "utf8") } catch { continue }
+    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: "行太长" })
+      })
+      continue
+    }
+    const stack = [] // 标题栈 —— { level, exempt }；exempt = 自身 ∥ 祖先命中区带
+    let fence = null // 围栏标记（` ∥ ~）；null = 不在块内
+    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: "段太长" })
+      para = null
+    }
+    lines.forEach((l, i) => {
+      const mark = fenceMark(l)
+      if (mark !== null) {
+        if (fence === null) fence = mark
+        else if (mark === fence) fence = null
+        flush()
+        return // 围栏标记行自身断段
+      }
+      if (fence !== null) { flush(); 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) })
+        flush()
+        return // 标题断段
+      }
+      const inZone = stack[stack.length - 1]?.exempt === true
+      if (inZone || l.trim() === "" || isTableRow(l) || isListItem(l) || isQuoteLine(l)) { flush(); return }
+      if (para === null) para = { start: i + 1, len: 0 }
+      para.len += [...l].length
+    })
+    flush()
+  }
+  return hits
+}

package/fts-text.mjs

@@ -30,7 +30,10 @@ export function segmentCJK(text) {
  * 无 token ⇒ 返回空串（消费侧据此退化——SESSION.md §6.19 边界情形表）。
  */
 export function buildFtsQuery(query) {
-  const terms = query
+  // 模型偶尔把 query 传成数组 / 对象（schema 声明是 string）：先按文本归一。
+  // 不归一的话 query.split 直接抛 TypeError，整个回合崩掉（GitHub #30）。
+  const text = Array.isArray(query) ? query.join(" ") : query == null ? "" : String(query)
+  const terms = text
     .split(/[\s,，。、;；!！?？()（）"`]+/)
     .map((t) => t.trim())
     .filter(Boolean)

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/ledger-cmd.mjs

@@ -12,6 +12,9 @@
  * 「档此刻在不在盘」降为读数——读面导出 `ledgerBatchRows`、收口重锚单源 `ledgerReanchorBatch`。
  * 批量面（§3.3 P1）：选行单源 `resolveBatchRows` + 逐行落笔 `applyRowUpdate` / `applyRowClose`
  * （与单行形共函数——迁移表判 / 写门 / evidence 门逐行照判）。
+ * 核销标记门（LIGHT-CHANNEL.md §2.5 · 台账 #1780）：写入 `已核销` 的三径（close 单行 ∥ close 批量 ∥
+ *  update 迁移——均经两逐行共函数）判**结果行标题**携 `ROUND_MARKER` ⇒ 拒；判据只认标题标记
+ * （不查批档 ∥ 不查评审实跑），撤回（→ 已废弃）不拦。
  *
  * 接线（设计档 §2.2 命令面接线）：族出口 = `ledger.mjs`（re-export 两源——KD-M2-3）；查询命令 ←
  * tools/index.mjs（assembleBuiltinTools 全角色面）；写命令 ← agent/family-tools.mjs（assembleFamilyTools
@@ -19,7 +22,7 @@
  * 消费侧静态 import 会破 W8 契约②）。
  */
 import { resolve } from "node:path"
-import { AGING_DAYS, ALLOWED_MIGRATIONS, EVIDENCE_SOFT_LIMIT, nowIso, openLedger, PENDING_STATUSES, resolveLedgerRoot } from "./ledger-db.mjs"
+import { AGING_DAYS, ALLOWED_MIGRATIONS, EVIDENCE_SOFT_LIMIT, nowIso, openLedger, PENDING_STATUSES, resolveLedgerRoot, ROUND_MARKER } from "./ledger-db.mjs"
 import { resolveDeclaredRef } from "./declaration.mjs"
 
 /** 逐行老化判真（LEDGER.md §13.4 · 2026-10-07 批 ledger-tool）：未决四态（`PENDING_STATUSES`）∧
@@ -210,8 +213,9 @@ function assertEvidenceValue(fnName, evidence) {
   if (evidence != null && String(evidence).trim() === "") throw new Error(`${fnName}：evidence 为空（非空字符串）`)
 }
 
-/** 单行落笔·update（**单行形 ∥ 批量形共函数**——设计档 §3.3「逐行语义单源」）：迁移表判 → executor /
- *  evidence 值计算（含两拒面）→ 写门 → UPDATE（判序 = §13.9 逐字未变）。`to` = `patch.status ?? 行现态`
+/** 单行落笔·update（**单行形 ∥ 批量形共函数**——设计档 §3.3「逐行语义单源」）：迁移表判 → 核销标记门
+ *  （目标 = `已核销` ∧ 结果标题携标记 ⇒ 拒——判序 = LIGHT-CHANNEL.md §2.5）→ executor / evidence 值计算
+ *  （含两拒面）→ 写门 → UPDATE（判序 = §13.9 逐字未变）。`to` = `patch.status ?? 行现态`
  *  ——批量形纯字段补丁（不携 `status`）时 `to === row.status` ⇒ 迁移表不判、`status` 零写（§3.3）。
  *  `resume_when` = 普通可空字段补丁（`patch.resume_when ?? 行值`——§3.4）。 */
 function applyRowUpdate(db, cwd, row, patch, executorSessionId) {
@@ -219,6 +223,10 @@ function applyRowUpdate(db, cwd, row, patch, executorSessionId) {
   if (to !== row.status && !(ALLOWED_MIGRATIONS[row.status] ?? []).includes(to)) {
     throw new Error(`ledgerUpdate：迁移 ${row.status} → ${to} 不在允许迁移表`)
   }
+  // 核销标记门（LIGHT-CHANNEL.md §2.5）：判**结果标题**——一笔同携清标记 title + status=已核销 ⇒ 放行
+  if (to === "已核销" && String(patch.title ?? row.title ?? "").includes(ROUND_MARKER)) {
+    throw new Error(`ledgerUpdate：行标题仍携「${ROUND_MARKER}」——收尾链未跑完，不许核销（先跑收尾全链，再由父侧清标记）`)
+  }
   const nextExecutor = resolveExecutorTarget(row, to, patch, executorSessionId)
   const nextEvidence = evidenceValue("ledgerUpdate", row.evidence, patch.evidence, patch.evidenceReplace)
   assertEvidenceValue("ledgerUpdate", patch.evidence)
@@ -252,11 +260,16 @@ export function ledgerUpdate({ cwd, id, patch, executorSessionId }) {
 }
 
 /** 单行落笔·close（**单行形 ∥ 批量形共函数**——设计档 §3.3「逐行语义单源」）：源态判（核销仅三源——
- *  在途不可跳）→ 值计算（拒面① 旗独传判于此）→ 追认口 `evidence` 门 → 拒面② → UPDATE。
+ *  在途不可跳）→ 核销标记门（LIGHT-CHANNEL.md §2.5——`已核销` ∧ 标题携标记 ⇒ 拒；撤回不拦）→
+ *  值计算（拒面① 旗独传判于此）→ 追认口 `evidence` 门 → 拒面② → UPDATE。
  *  撤回（任意态 → 已废弃——含在途直撤）同步 `executor = NULL`（LEDGER.md §3.1 ④）；核销两源（勾销 /
  *  追认）`executor` 零触碰（非在途出边）。 */
 function applyRowClose(db, row, status, evidence, evidenceReplace) {
   if (status === "已核销" && !["待讨论", "待设计", "待核销"].includes(row.status)) throw new Error(`ledgerClose：核销仅限 待讨论 / 待设计 / 待核销（现态 ${row.status}）`)
+  // 核销标记门（LIGHT-CHANNEL.md §2.5）：勾销 ∥ 追认同判；撤回（→ 已废弃）不入本门
+  if (status === "已核销" && String(row.title ?? "").includes(ROUND_MARKER)) {
+    throw new Error(`ledgerClose：行标题仍携「${ROUND_MARKER}」——收尾链未跑完，不许核销（先跑收尾全链，再由父侧清标记）`)
+  }
   const nextEvidence = evidenceValue("ledgerClose", row.evidence, evidence, evidenceReplace)
   if (status === "已核销" && ["待讨论", "待设计"].includes(row.status) && (nextEvidence == null || String(nextEvidence).trim() === "")) throw new Error(`ledgerClose：追认核销须带 evidence（现态 ${row.status}）`)
   assertEvidenceValue("ledgerClose", evidence) // 判序：拒面②（新值空白）落追认门之后 → UPDATE

package/ledger-db.mjs

@@ -87,23 +87,24 @@ export function ledgerChildren(dir) {
 }
 
 /** 项目根推导**单源**（设计档 §2.1「根解析面」/ §3.8——读写同一判据、同一实现）：
- *  自 `target`（「动作目标路径」；缺省 = `.`）起沿**祖先链**向上（含自身）取**最近一个「已注册」目录**
- *  ⇒ `{ root, basis: 'ancestor' }`（自明——回执逐字零改）。
- *  祖先链无命中 ∧ `descend: true` ⇒ **向下收敛**锚的直接子目录（`ledgerChildren` 同款惰性枚举 +
+ *  自 `target` 沿**祖先链**上溯取最近「已注册」目录——**以会话锚（`process.cwd()`）为界，越界即停**：
+ *  界内上溯 = 子目录归到自己的项目根（应该）；越过锚 = 挂到无关外层项目上（禁止）。
+ *  命中 ⇒ `{ root, basis: 'self' | 'ancestor' }`（自身 vs 界内祖先）；
+ *  界内无命中 ∧ `descend: true` ⇒ **向下收敛**锚的直接子目录（`ledgerChildren` 同款惰性枚举 +
  *  上限、名序升序）：恰一 ⇒ 取之；≥2 ⇒ ① 先取**有键控库**者（账已在盘 = 事实）② 该集名序首者 ⇒
  *  `{ root, basis: 'descendant' }`（向下发现——**须报明**）；零已注册子目录 ⇒ `null`（无根）。
- *  `descend: false` ⇒ 只问祖先支（族发现 ∥ 标记面——容器 ∥ 工作区锚 ⇒ `null` ⇒ 族求和）。
+ *  `descend: false` ⇒ 只问界内上溯支（族发现 ∥ 标记面——容器 ∥ 工作区锚 ⇒ `null` ⇒ 族求和）。
  *  **无自指**：内部「库在盘」判据只用 `ledgerKey` + `keyedDbFile`（不经 `ledgerDbPath`）。
  *  @param {string} [target] 动作目标路径（目录）
  *  @param {{descend?: boolean}} [opts] `descend` 缺省 `true`（动作面——`openLedger` / `ledgerDbPath` / 单范围读）
- *  @returns {{root: string, basis: 'ancestor'|'descendant'}|null} 项目根 + 判据来源 / 无根（`null`） */
+ *  @returns {{root: string, basis: 'self'|'ancestor'|'descendant'}|null} 项目根 + 判据来源 / 无根（`null`） */
 export function resolveLedgerRoot(target, { descend = true } = {}) {
   const start = resolve(target ?? ".")
   let dir = start
   for (;;) {
-    if (isRegistered(dir)) return { root: dir, basis: "ancestor" }
+    if (isRegistered(dir)) return { root: dir, basis: dir === start ? "self" : "ancestor" }
     const parent = dirname(dir)
-    if (parent === dir) break // 盘根 → 祖先链无已注册者
+    if (parent === dir) break
     dir = parent
   }
   if (!descend) return null
@@ -116,7 +117,7 @@ export function resolveLedgerRoot(target, { descend = true } = {}) {
 
 /** 无根文案（单源——设计档 §3.8「无根契约」逐字；`openLedger` 写面 ∥ `ledgerDbPath` 共用同一句）。 */
 const noRootMessage = (start) =>
-  `台账：自 ${start} 未能推导项目根——祖先链与本级子目录均无已注册项目（带 PROJECT-MANIFEST.json 或已有键控台账库）`
+  `台账：自 ${start} 未能推导项目根——该目录与本级子目录均无已注册项目（带 PROJECT-MANIFEST.json 或已有键控台账库）`
 
 /** 项目根 → 库路径（稳定键 = `ledgerKey` 前 16 位——路径唯一标识，不含分隔符）。
  *  **归单源**（2026-10-16 批 ledger-root-derivation）：根 = `resolveLedgerRoot(cwd)`——与读面 / 写面
@@ -133,6 +134,11 @@ export function ledgerDbPath(cwd) {
 /** 未决四态（「活条目」口径 = 计数单源 WHERE 集；已核销 / 已废弃 = 归档态）。 */
 export const PENDING_STATUSES = ["待讨论", "待设计", "在途", "待核销"]
 
+/** 轻通道轮次行标记（单源——LIGHT-CHANNEL.md §2.3 开轮挂账 ∥ §2.8 闸凭据 ∥ §2.5 核销标记门
+ *  判据三面同一字面；消费面 = `agent/light-round.mjs`（经 `ledger.mjs` re-export 动态解构——
+ *  W8 契约②零新静态边）∥ `ledger-cmd.mjs` 核销标记门）。 */
+export const ROUND_MARKER = "收尾链待跑"
+
 /** 老化阈值（天——口径 = 需求档；消费面 = `buildScan`（展示，`days` 可覆盖）+ `ledgerQuery` 逐行
  *  `aged`（查询面，`now` 可注入））。2026-10-07 批 ledger-tool：自 `ledger.mjs` 迁入（枚举常量档单源
  *  ——`ledgerQuery` 计算面直引本档，消 `ledger-cmd ↔ ledger.mjs` 新环；`ledger.mjs` 同名 re-export

package/ledger.mjs

@@ -151,7 +151,7 @@ export function detailScans(scans, current) {
 // ── re-export（拆分件接口——命令面接线 = 动态 import 本档，KD-M2-3；`AGING_DAYS` 常量单源 = `ledger-db.mjs`
 //    ——2026-10-07 批 ledger-tool 自本档迁入，公共面零变；`ledgerChildren` / `MAX_SIBLING_SCAN` / `resolveLedgerRoot`
 //    ——2026-10-16 批 ledger-root-derivation 随迁 / 新增，公共面形零改） ──
-export { AGING_DAYS, ALLOWED_MIGRATIONS, EVIDENCE_SOFT_LIMIT, MAX_SIBLING_SCAN, ledgerChildren, ledgerDbPath, ledgerKey, ledgerDirPath, openLedger, PENDING_STATUSES, resolveLedgerRoot, _setLedgerDirForTest, _resetLedgerDirForTest, ensureColumn, ensureExecutorColumn } from "./ledger-db.mjs"
+export { AGING_DAYS, ALLOWED_MIGRATIONS, EVIDENCE_SOFT_LIMIT, MAX_SIBLING_SCAN, ledgerChildren, ledgerDbPath, ledgerKey, ledgerDirPath, openLedger, PENDING_STATUSES, resolveLedgerRoot, ROUND_MARKER, _setLedgerDirForTest, _resetLedgerDirForTest, ensureColumn, ensureExecutorColumn } from "./ledger-db.mjs"
 export { ledgerAdd, ledgerBatchRows, ledgerClose, ledgerCloseBatch, ledgerCount, ledgerEvidenceOversize, ledgerQuery, ledgerReanchorBatch, ledgerUpdate, ledgerUpdateBatch, overdueOf } from "./ledger-cmd.mjs"
 export { ledgerTool, ledgerReadTool, ledgerAddTool, ledgerCloseTool, ledgerCountTool, ledgerQueryTool, ledgerUpdateTool } from "./ledger-tools.mjs"
 export { runLedgerAudit, runLedgerMigrate } from "./ledger-migrate.mjs"

package/manifest-discovery.mjs

@@ -9,7 +9,7 @@
  * （`MANIFEST_REL` ∥ `discoverProjects` ∥ `owningProject` ∥ `resolveProjectRoot`）随 import。
  * 零环：本档不引宿主（方向单行）；档外依赖 = `node:fs` ∥ `node:path`；机制详述 = `docs/core/design/MANIFEST.md` §2.2 / §2.9。
  */
-import { existsSync, readdirSync } from "node:fs"
+import { existsSync, readdirSync, statSync } from "node:fs"
 import { dirname, join, resolve } from "node:path"
 
 /** 数据档文件名（**每个项目一份**——项目根 = 带档目录；**git 非前提**。2026-09-17 / 2026-09-21 用户裁定）。 */
@@ -88,27 +88,36 @@ export function discoverRepos(cwd) {
 }
 
 /**
- * **归属形单点**（KD-M1-30 / 设计 §2.9 A——2026-09-21 用户裁定「最近者优先」）：自 `target`
- * （目录含自身；文件路径自其父目录起）沿**祖先链**逐级上溯至盘根，取**最近**带 `MANIFEST_REL`
- * 的目录；无 ⇒ `null`（⇒ 调用方走发现兜底）。**嵌套合法**：子内归子、根其余归根。
- * **纯 fs**（只判存在性——不解析档内容 / 不问模式）· **不跨兄弟** · **无全局优先级**。
- * **覆盖位**（`_setProjectRootForTest` 在场）⇒ **头部短路**：直接返回覆盖值（不查档存在性——
- * 保「覆盖即覆盖值」语义，回归守卫 = 本批单元测试档基座用例（`docs/batches/2026-10-02-manifest-resolution-fix.test.mjs`——
- * 基座三态 + 覆盖位 + 薄委托等价逐格）+ `docs/batches/2026-09-29-structure-split-2.test.mjs` 导出枚举探针（`Object.keys` 名面核））。
+ * **归属形单点**（KD-M1-30 · 2026-10-23 用户裁定）：自 `target`（目录 = 自身；文件 = 其所在目录）
+ * 沿**祖先链**上溯，取最近带 `MANIFEST_REL` 的目录 ⇒ 该目录；无 ⇒ `null`（交发现兜底）。
+ * 会话落在项目内层子目录时，这一路上溯正是它归到自己项目根的通路（用户 2026-10-23 23:24
+ * 「本来就该爬到项目根啊」）；**发现梯（`discoverProjects`）仍纯向下**——从工作区容器只找直接
+ * 子目录，不把容器挂到外层项目上。**纯 fs** · **不跨兄弟** · **无全局优先级**。
+ * **覆盖位**（`_setProjectRootForTest` 在场）⇒ **头部短路**：直接返回覆盖值（不查档存在性）。
  * @param {string} [target] 目标路径（目录 / 文件）
- * @returns {string|null} 最近带档祖先目录绝对路径 / null
+ * @returns {string|null} 带档目录绝对路径 / null
  */
 export function owningProject(target) {
   if (_projectRootOverride) return resolve(_projectRootOverride)
   let dir = resolve(target ?? ".")
+  const st = statSync(dir, { throwIfNoEntry: false })
+  if (st && !st.isDirectory()) dir = dirname(dir)
   for (;;) {
     if (existsSync(join(dir, MANIFEST_REL))) return dir
     const parent = dirname(dir)
-    if (parent === dir) return null // 盘根 → 祖先链无档
+    if (parent === dir) return null
     dir = parent
   }
 }
 
+/** `dir` 是否等于 `bound` 或在其子树内（分隔符归一比较）。 */
+function isInsideOrEqual(dir, bound) {
+  const norm = (p) => p.replaceAll("\\", "/").replace(/\/+$/, "")
+  const d = norm(dir)
+  const b = norm(bound)
+  return d === b || d.startsWith(b + "/")
+}
+
 /** **项目根解析的直读形**（判定单点——设计 `MANIFEST.md` §2.2 `projectRootView` 契约行 / §2.5
  *  「单项目解析律与四处会话级缺省收口」条）：`ok`（唯一解析：归属命中 ∥ 发现 `self` / `unique`）/
  *  `workspace`（锚自身无档 ∧ 下辖 **≥2** 项目 ⇒ `root` null + 下辖项目全列**按名排序**——工作区

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"
@@ -135,13 +135,13 @@ export function manifestFilePath(cwd) {
 /** #802（KD-M1-36）未知键告警去重 memo：档路径 → 上次观测键集（进程内）；读到零未知键即清该条。 */
 const unknownKeysSeen = new Map()
 
-/** 读面一行可见告警（#802）：含键名；同档同键集恰一次——console.warn + logEvent('manifest:unknown-keys')。 */
+/** 未知键诊断（#802 · 2026-10-23 改）：**不上界面**——只写 logEvent('manifest:unknown-keys')；同档同键集恰一次。 */
 function warnUnknownKeys(file, unknownKeys) {
   if (unknownKeys.length === 0) { unknownKeysSeen.delete(file); return }
   const sig = JSON.stringify([...unknownKeys].sort())
   if (unknownKeysSeen.get(file) === sig) return
   unknownKeysSeen.set(file, sig)
-  console.warn(`[manifest] ${MANIFEST_REL} unknown key(s) ignored: ${unknownKeys.join(", ")} — not an error; check spelling / version mismatch (KD-M1-36)`)
+  // 不上界面（2026-10-23 用户裁定：换别的项目也不能弹，不许骚扰用户）；只写诊断日志，`manifest read` 时才出现在结果里
   logEvent("manifest:unknown-keys", { path: file, keys: unknownKeys.join(",") })
 }
 
@@ -264,20 +264,32 @@ function workspaceProjectMessage(cwd, candidates) {
  * 不替被开发项目创建目录（§1.4 边界）——cwd 不存在时写失败自然上抛。
  * @returns {object} 传入的 manifest（校验通过后原样落盘）
  */
+/** 已退役的顶层键（FR42 八键 → 五键）：写入时静默丢弃——它们不是用户拼错，是产品自己退场的键，
+ *  留着只会让读面反复报「未知键」骚扰用户（2026-10-23 用户裁定「死键你删掉啊」）。 */
+const RETIRED_KEYS = ["promptsLanding", "checkConfig", "advisor"]
+
+/** 返回去掉退役键的新对象（不改入参）。 */
+function stripRetiredKeys(obj) {
+  const out = { ...obj }
+  for (const k of RETIRED_KEYS) delete out[k]
+  return out
+}
+
 export function writeManifest(cwd, manifest, { writer = "subagent" } = {}) {
   if (writer !== "main") {
     throw new Error("writeManifest 拒绝：非主 agent 无写权（writer 须为 \"main\"，fail-closed 缺省拒）")
   }
-  const validated = validateManifest(manifest)
+  const cleaned = stripRetiredKeys(manifest)
+  const validated = validateManifest(cleaned)
   if (!validated.ok) {
     throw new Error(`writeManifest 拒绝：manifest 校验不过——${validated.errors.join("；")}`)
   }
-  writeFileSync(manifestFilePath(cwd), JSON.stringify(manifest, null, 2) + "\n")
-  return manifest
+  writeFileSync(manifestFilePath(cwd), JSON.stringify(cleaned, null, 2) + "\n")
+  return cleaned
 }
 
 /**
- * 初始化 = 写默认八键档（模块设计 §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(`

package/memory/read-gate.mjs

@@ -0,0 +1,26 @@
+/**
+ * memory/read-gate.mjs — 读面准入闸（§6.14 面①∪面⑥∪面⑦；2026-10-19 批 K · 台账 #1372 抽件）。
+ *
+ * 判据单源：`memory/docs.mjs` ∥ `memory/code-search.mjs` 原先各持一份**逐字相同**的 `rowHidden`
+ * （排除谓词 ∪ 声明范围门）——两份判据迟早会不一致，而它们判的是同一件事：这行要不要藏。
+ *
+ * 判据序 = `isExcludedRelPath(path, decl, origin)` ∪ `!isInDeclaredScope(path, scope, origin)`。
+ * 两缓存（项目声明 ∥ 声明索引范围）为工厂闭包私有 Map，逐 origin 预载一次；
+ * 实例粒度 = 每次检索调用建一次 ⇒ 与抽出前的函数作用域缓存同寿命，行为零变。
+ */
+import { loadProjectDeclaration, isExcludedRelPath, declaredIndexScope, isInDeclaredScope } from "../conventions.mjs"
+
+/** 建一个读面准入闸：返回 `{ rowHidden(origin, path) → boolean }`（true = 该行不进结果集）。 */
+export function createReadGate() {
+  const declCache = new Map() // origin → 项目声明（`loadProjectDeclaration` 回执）
+  const scopeCache = new Map() // origin → 声明索引范围（`declaredIndexScope` 回执）
+  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)
+  }
+  return { rowHidden }
+}