@thincoder/core 0.10.7 → 0.10.8

package/ledger-migrate.mjs

@@ -12,7 +12,7 @@ import { basename, dirname, join, resolve } from "node:path"
 import { DatabaseSync } from "node:sqlite"
 
 import { resolveDeclaredRef } from "./declaration.mjs"
-import { ledgerDirPath, ledgerKey, openLedger } from "./ledger-db.mjs"
+import { ledgerDirPath, ledgerKey, openLedger, resolveLedgerRoot } from "./ledger-db.mjs"
 import { resolveProjectRoot } from "./manifest.mjs"
 
 /** 12 数据列（**等值比对列集**——不含 id：id 重发，§2.2 语义保全 / AC-M2-12）。 */
@@ -92,9 +92,9 @@ function fromKeyRefusal(fromKeys, dir) {
   return null
 }
 
-/** 迁移计划（dry-run / confirm 共用）。cwd 口径 = 写门口径 2 同一子表达式（`resolveProjectRoot` ∨ 兜底）。 */
+/** 迁移计划（dry-run / confirm 共用）。cwd 口径 = 写门口径 2 同一子表达式（根推导单源 `resolveLedgerRoot(cwd)?.root` ∨ 兜底）——与实开库（`openLedger`）同源。 */
 export function planLedgerMigration(cwd, { fromKeys = [] } = {}) {
-  const projectRoot = resolveProjectRoot(cwd) ?? resolve(cwd ?? ".")
+  const projectRoot = resolveLedgerRoot(cwd)?.root ?? resolve(cwd ?? ".")
   const dir = ledgerDirPath()
   const targetKey = ledgerKey(projectRoot)
   const targetPath = join(dir, `${targetKey}.db`)

package/ledger-read.mjs

@@ -10,19 +10,18 @@
  * （列集单源 = `DATA_COLUMNS`——D-10 直引，不另立副本；`evidence` 仅 full 入行）；缺列（旧库）按
  * null 归一；`schemaVersion` = 库 `PRAGMA user_version` 如实回读（旧库未标 = 0）；库不在 / 非台账库
  * ⇒ 项目不出项（空集）。
- * 范围（§2.4）：单范围 = 解析后项目根一项（`resolveProjectRoot(cwd) ?? resolve(cwd ?? ".")`——与库键
- * 同源）；`--family` = `discoverFamily` 发现序逐项（不可读跳过——既有语义）。
+ * 范围（§2.4）：单范围 = 推导所得项目根一项（`resolveLedgerRoot(cwd)`——与库键同源；无根 ⇒ 空集）；
+ * `--family` = `discoverFamily` 发现序逐项（不可读跳过——既有语义）。
  *
  * W8 契约②：本档静态入 `ledger-db.mjs`（node:sqlite）⇒ 消费侧一律**动态 import** 本档。
  * D-11：`ledger.mjs` 零编辑——族发现只 import `discoverFamily`。
  */
-import { basename, resolve } from "node:path"
+import { basename } from "node:path"
 
 import { ledgerQuery } from "./ledger-cmd.mjs"
 import { discoverFamily } from "./ledger.mjs"
 import { DATA_COLUMNS } from "./ledger-migrate.mjs"
-import { resolveProjectRoot } from "./manifest.mjs"
-import { openLedger } from "./ledger-db.mjs"
+import { openLedger, resolveLedgerRoot } from "./ledger-db.mjs"
 
 /** 行出形（§3.2）：`id` + 数据列序（`evidence` 仅 full）；缺列按 null 归一。 */
 function exportRow(r, full) {
@@ -50,8 +49,8 @@ function readProject(root, full) {
 export function ledgerExport({ cwd, family = false, full = false } = {}) {
   const anchor = cwd ?? process.cwd()
   if (!family) {
-    const root = resolveProjectRoot(anchor) ?? resolve(anchor)
-    const item = readProject(root, full)
+    const derived = resolveLedgerRoot(anchor)
+    const item = derived ? readProject(derived.root, full) : null
     return { projects: item ? [item] : [] }
   }
   const projects = []

package/ledger-tools.mjs

@@ -11,11 +11,20 @@
  * 消费侧一律动态 import（`ledger-db.mjs` 静态 import node:sqlite ⇒ W8 契约②）。
  */
 import { ledgerAdd, ledgerClose, ledgerCount, ledgerQuery, ledgerUpdate } from "./ledger-cmd.mjs"
+import { resolveLedgerRoot } from "./ledger-db.mjs"
 import { DESC } from "./tools/shared.mjs" // #15 描述外置：文本单点 = tool-docs/ledger.md（DESC 单解析面）
 
-/** 工具 cwd 供值面（缺省 → 当前项目根）。 */
+/** 工具 cwd 供值面（缺省 → 当前会话锚——「动作目标路径」；项目根由核 `resolveLedgerRoot` 推导）。 */
 const cwdOf = (ctx) => ctx?.agent?.cwd ?? ctx?.cwd ?? process.cwd()
 
+/** 根推导**报明面**（设计档 §3.8「报明形态」）：向下发现（`basis === 'descendant'`——容器锚收敛序）⇒
+ *  对象形回执增 `root` 键；祖先支（自明路径）⇒ `null`（展开零键——回执逐字零改）。供值面 = 核同一
+ *  单源 `resolveLedgerRoot`（工具层零自算根；单实现、多调用点）。 */
+const reportedRoot = (cwd) => {
+  const derived = resolveLedgerRoot(cwd)
+  return derived && derived.basis === "descendant" ? { root: derived.root } : null
+}
+
 // ── 工具层参数守卫（设计档 §3.2 · 2026-09-27 快车道修复 · Gitee #IKIQGK / 台账 #472） ──
 
 /** 值预览（P1–P5 文案的 `<预览>`——设计档 §3.2）：`JSON.stringify`，超 80 字符截断加 `…`
@@ -80,7 +89,7 @@ const FULL_ACTIONS = ["add", "update", "close", "query", "count"]
 const READ_ACTIONS = ["query", "count"]
 
 /** cwd 参数描述（五前身声明同文——文本单点）。 */
-const CWD_DESC = "项目根目录——台账按项目根关联存储于用户数据目录（工作树外、不进 git）。相对路径按当前工作目录解析；查/写别的项目请给绝对路径。缺省 = 当前会话项目根"
+const CWD_DESC = "本次动作的目标路径——项目根由它推导：沿祖先链最近的项目目录（带 PROJECT-MANIFEST.json 或已有台账库）；容器目录下收敛到子项目。台账按项目根关联存储于用户数据目录（工作树外、不进 git）。相对路径按当前工作目录解析；查/写别的项目请给绝对路径。缺省 = 当前会话锚"
 
 /** 各 action 声明条目（= 前身旧工具 `parameters` 逐字；伪工具对象守卫 + 弃用壳共用单源）。 */
 const ACTION_SPECS = {
@@ -207,25 +216,31 @@ function makeLedgerTool(actions, { readonly = false, writeFace = false } = {}) {
       switch (action) {
         case "add": {
           const { cwd, ...row } = rest
-          const id = ledgerAdd({ cwd: cwd ?? cwdOf(ctx), row })
-          return JSON.stringify({ id, status: "待讨论" })
+          const target = cwd ?? cwdOf(ctx)
+          const id = ledgerAdd({ cwd: target, row })
+          return JSON.stringify({ id, status: "待讨论", ...reportedRoot(target) })
         }
         case "update": {
           const { cwd, id, ...patch } = rest
+          const target = cwd ?? cwdOf(ctx)
           let executorSessionId
           if (patch.executor == null) {
             // 显式 `null` ≡ 略去（§3.1 `null` 口径 · #474——与缺省同分支）；动态 import——零新静态边（K-LX1）
             const { getSessionId } = await import("./session-slots.mjs")
             executorSessionId = getSessionId()
           }
-          return JSON.stringify(ledgerUpdate({ cwd: cwd ?? cwdOf(ctx), id, patch, executorSessionId }))
+          return JSON.stringify({ ...ledgerUpdate({ cwd: target, id, patch, executorSessionId }), ...reportedRoot(target) })
+        }
+        case "close": {
+          const target = rest.cwd ?? cwdOf(ctx)
+          return JSON.stringify({ ...ledgerClose({ cwd: target, id: rest.id, status: rest.status, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace }), ...reportedRoot(target) })
         }
-        case "close":
-          return JSON.stringify(ledgerClose({ cwd: rest.cwd ?? cwdOf(ctx), id: rest.id, status: rest.status, evidence: rest.evidence, evidenceReplace: rest.evidenceReplace }))
         case "query":
           return JSON.stringify(ledgerQuery({ cwd: rest.cwd ?? cwdOf(ctx), status: rest.status, kind: rest.kind, board: rest.board, trigger: rest.trigger }), null, 2)
-        case "count":
-          return JSON.stringify({ count: ledgerCount({ cwd: rest.cwd ?? cwdOf(ctx) }) })
+        case "count": {
+          const target = rest.cwd ?? cwdOf(ctx)
+          return JSON.stringify({ count: ledgerCount({ cwd: target }), ...reportedRoot(target) })
+        }
         default:
           // 不可达（② 枚举守门已先拒）——fail-loud 兜底（防未来变体增量 drift）
           throw new Error(`ledger：action 非法：${argPreview(action)}（取值 ∈ ${enumText(actions)}）`)

package/ledger.mjs

@@ -15,10 +15,8 @@
  *
  * W8 契约②：ledger-db.mjs 静态 import node:sqlite ⇒ 消费侧一律**动态 import** 本档（禁止静态 import）。
  */
-import { opendirSync, statSync } from "node:fs"
-import { basename, dirname, join, resolve } from "node:path"
-import { projectRootView } from "./manifest.mjs"
-import { ledgerDbPath, PENDING_STATUSES, AGING_DAYS } from "./ledger-db.mjs"
+import { basename, dirname, resolve } from "node:path"
+import { AGING_DAYS, PENDING_STATUSES, ledgerChildren, ledgerDbPath, resolveLedgerRoot } from "./ledger-db.mjs"
 import { ledgerQuery } from "./ledger-cmd.mjs"
 import { executorTail } from "./ledger-executors.mjs"
 
@@ -45,55 +43,20 @@ export function entryTitle(text) {
   return norm.length > 20 ? norm.slice(0, 20) + "…" : norm
 }
 
-const isFile = (p) => { try { return statSync(p).isFile() } catch { return false } }
-
-/** 向上（含自身）最近的已注册台账项目根 → {root, ledger} / null（F4——CLI 锚 = cwd；
- *  标记 = 用户数据目录里以该项目路径为键的台账库——项目目录内不落任何标记文件）。 */
+/** 向上（含自身）最近的**已注册**项目根 → {root, ledger} / null（F4——CLI 锚 = cwd）。
+ *  薄委托 `resolveLedgerRoot(anchor, { descend: false })`（设计档 §3.8——**取祖先支**）：`root` = 推导所
+ *  得项目根（非锚）；容器 ∥ 工作区锚 ⇒ `null` ⇒ 族发现按容器形（族求和——§7.2 / AC-M2-18 / AC-M2-19）。 */
 export function findProject(anchor) {
-  let dir = resolve(anchor)
-  for (;;) {
-    const ledger = ledgerDbPath(dir)
-    if (isFile(ledger)) return { root: dir, ledger }
-    const parent = dirname(dir)
-    if (parent === dir) return null
-    dir = parent
-  }
-}
-
-/** 同级枚举上限（N2 成本有界：父目录超此规模 = 缓存 / 临时等非仓族形态 → 退化空集，只显当前项目）。 */
-export const MAX_SIBLING_SCAN = 100
-
-/** 目录下已注册台账的直接子目录（目录名升序；不可读 → []；**惰性枚举 + 上限**——大目录零全量扫描）。
- *  导出面 = 族发现（本档）∥ 轻通道闸候选枚举（`agent/light-round.mjs`——同级判据单源）。 */
-export function ledgerChildren(dir) {
-  const out = []
-  let handle
-  try { handle = opendirSync(dir) } catch { return out }
-  try {
-    let n = 0
-    for (;;) {
-      const ent = handle.readSync()
-      if (!ent) break
-      if (++n > MAX_SIBLING_SCAN) return []
-      if (!ent.isDirectory()) continue
-      const root = join(dir, ent.name)
-      const ledger = ledgerDbPath(root)
-      if (isFile(ledger)) out.push({ root, ledger })
-    }
-  } catch { /* 读中断 → 已得子集（尽力而为） */ }
-  finally { try { handle.closeSync() } catch { /* 已关 */ } }
-  return out.sort((a, b) => (a.root < b.root ? -1 : a.root > b.root ? 1 : 0))
+  const derived = resolveLedgerRoot(anchor, { descend: false })
+  return derived ? { root: derived.root, ledger: ledgerDbPath(derived.root) } : null
 }
 
-/** 项目族发现：{current, projects}——projects = current + 其同级含台账库目录（**发现序：current 在前**，
- *  其余按目录名升序）；current 缺（容器目录，K6）→ 锚本地：取锚自身含台账库的直接子目录（不沿祖先链上找）。
- *  **歧义根不充当项目**（轻通道轮 · 2026-10-04）：命中锚若项目解析 `ambiguous`（≥2 候选——`projectRootView`）
- *  ⇒ 该锚不可扫描（`openLedger` 歧义拒）——其键控库（先于 #828 写门的存量空壳 / 幽灵）不得遮蔽族发现；
- *  按容器形落子目录族（需求：打开容器根 ⇒ 族内合计——标记范围批 §1 原话）。 */
+/** 项目族发现：{current, projects}——current = `findProject`（**祖先支**：容器 ∥ 工作区锚 ⇒ `null` ⇒ 按
+ *  容器形落子目录族）；projects = current + 其**同级已注册**目录（**发现序：current 在前**，其余按目录
+ *  名升序）；current 缺（容器目录，K6）→ **锚本地**：取锚自身**已注册**的直接子目录（不沿祖先链上找）。
+ *  「工作区根不充当项目」的判据单源 = `resolveLedgerRoot` 的库臂排除（§2.1）——本函数零自持判据。 */
 export function discoverFamily(anchor) {
-  const hit = findProject(anchor)
-  // 歧义根跳过（键控库存在 ≠ 可作项目——扫描面 `buildScan` 对歧义锚必拒；遮蔽则标记静默缺席）。
-  const current = hit && projectRootView(hit.root).state === "ambiguous" ? null : hit
+  const current = findProject(anchor)
   if (current) {
     const siblings = ledgerChildren(dirname(current.root)).filter((p) => p.root !== current.root)
     return { current, projects: [current, ...siblings] }
@@ -105,10 +68,16 @@ export function discoverFamily(anchor) {
  *  agedKeys/agedTitles/thresholdReached/boards/actionable/root/name/ledger。行龄 = 时间戳
  *  （updated_at ?? created_at 距今 > days；未知不计——零假阳降级，同 v1 行龄未知口径）。
  *  `now`/`days` = 注入面（确定性用例——替代 v1 ageOf git 注入面）。
+ *  **根推导**（设计档 §3.8）：`root` / `name` / `ledger` = `resolveLedgerRoot(anchor)` 推导所得项目根（非锚
+ *  ——容器 ∥ 工作区锚取收敛序之根）——与行集读取同一单源；无根 ⇒ `ledger` = `null`（不落兜底根——
+ *  该态下 `root` / `name` 回落锚、行集为空，且该 scan 不进族枚举（`discoverFamily` 容器支只列已注册子目录））。
  *  `inflightExecutors`（F-LX1 · sync 零变——K-LX2）：在途且 executor 非空行集原样携带
  *  {executor, updated_at, created_at}——判活解析由 `resolveExecutorStates` async 单源负责，本函数零探测。 */
 export function buildScan({ cwd, days = AGING_DAYS, now = Date.now() } = {}) {
-  const rows = ledgerQuery({ cwd })
+  const anchor = resolve(cwd)
+  const derived = resolveLedgerRoot(anchor)
+  const root = derived ? derived.root : anchor
+  const rows = ledgerQuery({ cwd: anchor })
   const pending = rows.filter((r) => PENDING_STATUSES.includes(r.status))
   const poolEntries = pending.filter((r) => r.kind === "requirement")
   const techEntries = pending.filter((r) => r.kind === "tech_todo")
@@ -123,12 +92,11 @@ export function buildScan({ cwd, days = AGING_DAYS, now = Date.now() } = {}) {
     if (key) boards.set(key, (boards.get(key) ?? 0) + 1)
   }
   const thresholdReached = poolEntries.length >= THRESHOLD_POOL || [...boards.values()].some((n) => n >= THRESHOLD_BOARD)
-  const root = resolve(cwd)
   const inflightExecutors = pending
     .filter((r) => r.status === "在途" && r.executor)
     .map((r) => ({ executor: r.executor, updated_at: r.updated_at ?? null, created_at: r.created_at ?? null }))
   return {
-    name: basename(root), root, ledger: ledgerDbPath(root),
+    name: basename(root), root, ledger: derived ? ledgerDbPath(root) : null,
     pool: poolEntries.length, tech: techEntries.length, aged: aged.length,
     agedKeys: aged.map((r) => normalizeEntry(r.title)), agedTitles: aged.map((r) => entryTitle(r.title)),
     thresholdReached, boards, actionable: aged.length > 0 || thresholdReached,
@@ -178,8 +146,9 @@ export function detailScans(scans, current) {
 }
 
 // ── re-export（拆分件接口——命令面接线 = 动态 import 本档，KD-M2-3；`AGING_DAYS` 常量单源 = `ledger-db.mjs`
-//    ——2026-10-07 批 ledger-tool 自本档迁入，公共面零变） ──
-export { AGING_DAYS, ALLOWED_MIGRATIONS, ledgerDbPath, ledgerKey, ledgerDirPath, openLedger, PENDING_STATUSES, _setLedgerDirForTest, _resetLedgerDirForTest, ensureExecutorColumn } from "./ledger-db.mjs"
+//    ——2026-10-07 批 ledger-tool 自本档迁入，公共面零变；`ledgerChildren` / `MAX_SIBLING_SCAN` / `resolveLedgerRoot`
+//    ——2026-10-16 批 ledger-root-derivation 随迁 / 新增，公共面形零改） ──
+export { AGING_DAYS, ALLOWED_MIGRATIONS, MAX_SIBLING_SCAN, ledgerChildren, ledgerDbPath, ledgerKey, ledgerDirPath, openLedger, PENDING_STATUSES, resolveLedgerRoot, _setLedgerDirForTest, _resetLedgerDirForTest, ensureExecutorColumn } from "./ledger-db.mjs"
 export { ledgerAdd, ledgerClose, ledgerCount, ledgerQuery, ledgerUpdate } from "./ledger-cmd.mjs"
 export { ledgerTool, ledgerReadTool, ledgerAddTool, ledgerCloseTool, ledgerCountTool, ledgerQueryTool, ledgerUpdateTool } from "./ledger-tools.mjs"
 export { runLedgerAudit, runLedgerMigrate } from "./ledger-migrate.mjs"

package/log.mjs

@@ -16,8 +16,10 @@
  *   ① 字段名精确匹配黑名单（apiKey/designToken/password/secret/token，大小写不敏感；
  *      另加防御性名称 authorization/proxy/proxyUri——防凭据型 URL/头字段泄漏——§2.5）
  *      → 整个字段丢弃；
- *   ② 内容只扫密钥形态（sk-xxx / Bearer xxx / key=… 等）→ 截断到形态之前
+ *   ② 内容只扫密钥形态（sk-xxx / Bearer xxx / key=… / token 值形等）→ 截断到形态之前
  *      ——宁可丢信息不漏密钥。
+ *      token 值形（`uuid:epoch`——2026-10-14 design-token-recovery 批并入）：design-slots
+ *      reveal 结果经 `tool:done` head 落盘时不落值（与 batch.mjs 凭据第三形同判据）。
  *   工具事件不记 args；URL 不入事件（llm/tool 事件从不携带 URL；err 文本经形态扫描）。
  * - 摘要截断（B 方案，2026-09-03 用户裁定）：截断处带 "…" 标记（截后仍 ≤上限）。
  * - 测试隔离：node --test 进程（NODE_TEST_CONTEXT）默认不写盘——防测试事件污染真实
@@ -37,8 +39,8 @@ import { join } from "node:path"
 export const MAX_LINE = 512
 /** 字段名精确黑名单（NF-L3/§2.4——2026-09-03 评审 refinement #7：与 §2.4 词表一致含 token） */
 const BLACKLIST_FIELDS = new Set(["apikey", "designtoken", "password", "secret", "token", "authorization", "proxyuri", "proxy"])
-/** 内容密钥形态扫描（大小写不敏感）——命中即截断到形态前 */
-const SECRET_FORM = /(\bsk-[A-Za-z0-9_-]{6,}|\bBearer\s+[A-Za-z0-9._~+/=-]{6,}|\b(?:api[_-]?key|key|token|secret|password|pwd|passwd)\s*[=:]\s*['"]?[A-Za-z0-9._~+/=-]{6,})/i
+/** 内容密钥形态扫描（大小写不敏感）——命中即截断到形态前（含 token 值形 `uuid:epoch`——同 batch.mjs 凭据第三形判据） */
+const SECRET_FORM = /(\bsk-[A-Za-z0-9_-]{6,}|\bBearer\s+[A-Za-z0-9._~+/=-]{6,}|\b(?:api[_-]?key|key|token|secret|password|pwd|passwd)\s*[=:]\s*['"]?[A-Za-z0-9._~+/=-]{6,}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:\d{10,16})/i
 /** 字符串字段长度兜底：head ≤300 / err ≤200 / 其余 ≤120 */
 const FIELD_CAPS = { head: 300, err: 200 }
 
@@ -154,6 +156,18 @@ export function redactSecret(fieldKey, value) {
   return hit ? s.slice(0, hit.index) + "[redacted]" : s
 }
 
+/** 结构面遮蔽（#1432——tool-errors args 落痕前过同一链）：键级 ∥ 内容级复用 `redactSecret`；嵌套对象 ∥ 数组递归；
+ *  非串值仅在键名命中黑名单时整键遮蔽（否则原样 ∥ 递归）——「宁可丢信息不漏密钥」同判据。 */
+export function redactArgs(value) {
+  if (Array.isArray(value)) return value.map(redactArgs)
+  if (value && typeof value === "object") {
+    const out = {}
+    for (const [k, v] of Object.entries(value)) out[k] = typeof v === "string" || BLACKLIST_FIELDS.has(String(k).toLowerCase()) ? redactSecret(k, v) : redactArgs(v)
+    return out
+  }
+  return typeof value === "string" ? redactSecret("", value) : value
+}
+
 /** 内容级净化：密钥形态截断到形态前（②）；超长截断 + "…" 标记。 */
 export function sanitizeString(key, value) {
   let s = String(value)

package/manifest-discovery.mjs

@@ -1,6 +1,6 @@
 /**
  * manifest-discovery.mjs — **发现 ∕ 归属族**出档（2026-09-29 structure-split-2 · 台账 #620）：自 `manifest.mjs`
- * 全量迁出〔原 `:39-143`〕——`MANIFEST_REL` · 测试注入位（`_setProjectRootForTest` / `_resetProjectRootForTest`）·
+ * 全量迁出——`MANIFEST_REL` · 测试注入位（`_setProjectRootForTest` / `_resetProjectRootForTest`）·
  * `scanChildren`（两条梯表共用 walk 内核）· `discoverProjects`（项目梯）· `discoverRepos`（仓梯）·
  * `owningProject`（归属形）· `resolveProjectRoot`（归属 ∨ 发现）；**结构拆分零语义**（面不变 ∕ 判据不变，
  * 只换宿主档；切点 ∕ 缝单源 = 批档 `docs/batches/2026-09-29-structure-split-2.md` §2.2-C）。
@@ -41,13 +41,14 @@ function scanChildren(anchor, isHit) {
 /**
  * **项目发现**（项目梯五级——KD-M1-23 / 设计 `docs/core/design/MANIFEST.md` §2.2；**git 非前提**，
  * 2026-09-21 用户裁定）：① 锚自身带 `MANIFEST_REL` ⇒ 锚；② 锚含 `.git` ⇒ 锚（缺档 = 建档机会）；
- * ③ 直接子目录中**带档**者优先（非空即只看此级：恰一 ⇒ `unique` / ≥2 ⇒ `ambiguous`）；
- * ④ 零带档才看含 `.git` 的**裸仓**（同判）；⑤ 均无 ⇒ `none`（⇒ 建档流，落点 = 会话锚）。
+ * ③ 直接子目录中**带档**者优先（非空即只看此级：恰一 ⇒ `unique` / ≥2 ⇒ `workspace`——下辖多项目
+ * = 工作区常态，非错误态）；④ 零带档才看含 `.git` 的**裸仓**（同判）；⑤ 均无 ⇒ `none`（⇒ 建档流，
+ * 落点 = 会话锚）。
  * `candidates` 一律**按名排序**（`self` / `none` ⇒ `[]`）；`matched` ∈ `manifest` / `git` / `null`
- * 记命中（或歧义）出自哪一级。**纯 fs**（只判存在性——不解析档内容）· **不抛** · **不向上** · **不递归**。
+ * 记命中（或工作区）出自哪一级。**纯 fs**（只判存在性——不解析档内容）· **不抛** · **不向上** · **不递归**。
  * **覆盖位**（`_setProjectRootForTest` 在场）⇒ **头部短路**（测试注入面——先于真判据，同 `discoverRepos`）。
  * @param {string} [cwd] 会话锚（缺省 → 进程 cwd）
- * @returns {{kind:'self'|'unique'|'none'|'ambiguous', root:string|null, candidates:string[], matched:'manifest'|'git'|null}}
+ * @returns {{kind:'self'|'unique'|'none'|'workspace', root:string|null, candidates:string[], matched:'manifest'|'git'|null}}
  */
 export function discoverProjects(cwd) {
   if (_projectRootOverride) return { kind: "self", root: resolve(_projectRootOverride), candidates: [], matched: null }
@@ -55,10 +56,10 @@ export function discoverProjects(cwd) {
   if (existsSync(join(anchor, MANIFEST_REL))) return { kind: "self", root: anchor, candidates: [], matched: "manifest" }
   if (existsSync(join(anchor, ".git"))) return { kind: "self", root: anchor, candidates: [], matched: "git" }
   const withManifest = scanChildren(anchor, (d) => existsSync(join(d, MANIFEST_REL)))
-  if (withManifest.length > 1) return { kind: "ambiguous", root: null, candidates: withManifest, matched: "manifest" }
+  if (withManifest.length > 1) return { kind: "workspace", root: null, candidates: withManifest, matched: "manifest" }
   if (withManifest.length === 1) return { kind: "unique", root: withManifest[0], candidates: [...withManifest], matched: "manifest" }
   const bareRepos = scanChildren(anchor, (d) => existsSync(join(d, ".git")))
-  if (bareRepos.length > 1) return { kind: "ambiguous", root: null, candidates: bareRepos, matched: "git" }
+  if (bareRepos.length > 1) return { kind: "workspace", root: null, candidates: bareRepos, matched: "git" }
   if (bareRepos.length === 1) return { kind: "unique", root: bareRepos[0], candidates: [...bareRepos], matched: "git" }
   return { kind: "none", root: null, candidates: [], matched: null }
 }
@@ -66,21 +67,22 @@ export function discoverProjects(cwd) {
 /**
  * **仓发现**（仓梯——KD-M1-23 / `docs/core/design/TOOLS.md` §6.13；**单源** KD-M1-22——`git` 工具
  * 经此符号接线，禁第二份实现）：① 锚含 `.git` ⇒ 锚；② 直接子目录中 `.git` **∧** 带档者恰一 ⇒ 命中
- * （≥2 ⇒ 歧义）；③ **零个此类时才看**含 `.git` 的裸仓（恰一 ⇒ 命中 / ≥2 ⇒ 歧义）；④ 均无 ⇒ `none`。
+ * （≥2 ⇒ `workspace`——下辖多仓 = 常态）；③ **零个此类时才看**含 `.git` 的裸仓（恰一 ⇒ 命中 /
+ * ≥2 ⇒ `workspace`）；④ 均无 ⇒ `none`。
  * 与 `discoverProjects` = **同一 walk 内核**（`scanChildren`）的两种梯表——差异只在谓词与级序。
  * `candidates` 按名排序；`matched` 记档位；纯 fs / 不抛 / 不递归 / 不向上；覆盖位 ⇒ 头部短路。
  * @param {string} [cwd] 会话锚（缺省 → 进程 cwd）
- * @returns {{kind:'self'|'unique'|'none'|'ambiguous', root:string|null, candidates:string[], matched:'manifest'|'git'|null}}
+ * @returns {{kind:'self'|'unique'|'none'|'workspace', root:string|null, candidates:string[], matched:'manifest'|'git'|null}}
  */
 export function discoverRepos(cwd) {
   if (_projectRootOverride) return { kind: "self", root: resolve(_projectRootOverride), candidates: [], matched: null }
   const anchor = resolve(cwd ?? ".")
   if (existsSync(join(anchor, ".git"))) return { kind: "self", root: anchor, candidates: [], matched: "git" }
   const scoped = scanChildren(anchor, (d) => existsSync(join(d, ".git")) && existsSync(join(d, MANIFEST_REL)))
-  if (scoped.length > 1) return { kind: "ambiguous", root: null, candidates: scoped, matched: "manifest" }
+  if (scoped.length > 1) return { kind: "workspace", root: null, candidates: scoped, matched: "manifest" }
   if (scoped.length === 1) return { kind: "unique", root: scoped[0], candidates: [...scoped], matched: "manifest" }
   const bare = scanChildren(anchor, (d) => existsSync(join(d, ".git")))
-  if (bare.length > 1) return { kind: "ambiguous", root: null, candidates: bare, matched: "git" }
+  if (bare.length > 1) return { kind: "workspace", root: null, candidates: bare, matched: "git" }
   if (bare.length === 1) return { kind: "unique", root: bare[0], candidates: [...bare], matched: "git" }
   return { kind: "none", root: null, candidates: [], matched: null }
 }
@@ -107,23 +109,24 @@ export function owningProject(target) {
   }
 }
 
-/** **项目根解析的歧义直读形**（判定单点——设计 `MANIFEST.md` §2.2 `projectRootView` 契约行 / §2.5
- *  「多档解析消费面收口」条）：`ok`（唯一解析：归属命中 ∥ 发现 `self` / `unique`）/ `ambiguous`
- *  （≥2 候选 ⇒ `root` null + 候选全列**按名排序**）/ `none`（无项目 ⇒ 双空）；覆盖位在场 ⇒
- *  头部短路（`ok` + 覆盖值）。**非抛错 / 零写**；`resolveProjectRoot` 薄委托本函数（行为逐字零变）。
- *  @returns {{state:'ok'|'ambiguous'|'none', root:string|null, candidates:string[]}} */
+/** **项目根解析的直读形**（判定单点——设计 `MANIFEST.md` §2.2 `projectRootView` 契约行 / §2.5
+ *  「单项目解析律与四处会话级缺省收口」条）：`ok`（唯一解析：归属命中 ∥ 发现 `self` / `unique`）/
+ *  `workspace`（锚自身无档 ∧ 下辖 **≥2** 项目 ⇒ `root` null + 下辖项目全列**按名排序**——工作区
+ *  常态，非错误态）/ `none`（无项目 ⇒ 双空）；覆盖位在场 ⇒ 头部短路（`ok` + 覆盖值）。
+ *  **非抛错 / 零写**；`resolveProjectRoot` 薄委托本函数（行为逐字零变）。
+ *  @returns {{state:'ok'|'workspace'|'none', root:string|null, candidates:string[]}} */
 export function projectRootView(cwd) {
   const owning = owningProject(cwd)
   if (owning) return { state: "ok", root: owning, candidates: [] }
   const d = discoverProjects(cwd)
   if (d.root) return { state: "ok", root: d.root, candidates: [] }
-  if (d.kind === "ambiguous") return { state: "ambiguous", root: null, candidates: d.candidates }
+  if (d.kind === "workspace") return { state: "workspace", root: null, candidates: d.candidates }
   return { state: "none", root: null, candidates: [] }
 }
 
 /** 项目根解析（**归属 ∨ 发现**——KD-M1-30 / M1-24）：**薄委托** `projectRootView(cwd).root`（判定
  *  单点见上——#828）。带档路径与批前**逐字同**；变更面两条（设计 §2.2 同条）：① 项目树内路径
- *  （祖先带档）⇒ 该项目根；② 裸仓恰一 ⇒ 该仓根（零档降级 = 建档机会）。`none` / `ambiguous` ⇒
+ *  （祖先带档）⇒ 该项目根；② 裸仓恰一 ⇒ 该仓根（零档降级 = 建档机会）。`none` / `workspace` ⇒
  *  `null`。调用方零改（行为随语义变更——设计 §2.5 键面条 / 错层条）。
  *  @returns {string|null} 项目根绝对路径 / null */
 export function resolveProjectRoot(cwd) {

package/manifest-schema.mjs

@@ -1,7 +1,7 @@
 /**
  * manifest-schema.mjs — **校验 ∕ 默认值族**出档（2026-09-29 structure-split-2 · 台账 #620）：自 `manifest.mjs`
- * 全量迁出〔原 `:194-205` + `:240-369` 两段非连续〕——`isValidDocRootValue`（docRoot 子键值形态判据）·
- * `DEFAULT_MANIFEST`（默认八键）· `MANIFEST_SCHEMA`（判据单源）· 元素层谓词两件 · `validateManifest` ·
+ * 全量迁出——`isValidDocRootValue`（docRoot 子键值形态判据）·
+ * `DEFAULT_MANIFEST`（默认八键）· `MANIFEST_SCHEMA`（判据单源）· 元素层谓词一件 · `validateManifest` ·
  * `fillDefaults`；**结构拆分零语义**（面不变 ∕ 判据不变，只换宿主档；切点 ∕ 缝单源 =
  * 批档 `docs/batches/2026-09-29-structure-split-2.md` §2.2-C）。
  *
@@ -43,7 +43,6 @@ export const DEFAULT_MANIFEST = Object.freeze({
     widthExemptZones: Object.freeze([]),
     anchors: Object.freeze({ domain: "docs", exclude: Object.freeze(["_archive", "batches"]) }),
     exemptions: Object.freeze([]),
-    lineCounts: Object.freeze([]), // 行数面机检声明（#546）：[] = 未载惰性（doc-check 行数族）
   }),
   // 项目声明三族（2026-09-27 声明载体唯一化批并入——键名 / 形态逐字承前；来源档已退役）。
   codePaths: Object.freeze(["src"]),
@@ -72,12 +71,6 @@ function isNonEmptyStringArray(v) {
   return Array.isArray(v) && v.every((e) => typeof e === "string" && e.trim() !== "")
 }
 
-/** `checkConfig.lineCounts` 元素层判据（#546）：数组且各元素为非数组对象、`doc` / `section` 皆非空串（`trim` 后非空）；`[]` = 未载惰性。 */
-function isLineCountsValue(v) {
-  return Array.isArray(v) && v.every((e) => e !== null && typeof e === "object" && !Array.isArray(e)
-    && typeof e.doc === "string" && e.doc.trim() !== "" && typeof e.section === "string" && e.section.trim() !== "")
-}
-
 /**
  * 形状校验（模块设计 §2.2）——枚举 / version 数值恒做；**纯函数、零 fs**（原 `{ cwd }`
  * 指针分支已随字段整链裁撤——KD-M1-5 墓志）；不落盘。键存在性入 missingKeys（非拒）：
@@ -116,10 +109,6 @@ export function validateManifest(obj) {
       if (nested === "docRoot" && !isValidDocRootValue(value[sub])) {
         errors.push(`docRoot.${sub} 值形态非法：${JSON.stringify(value[sub])}（须为非空字符串 / 非空字符串数组 / null（本面无）——KD-M1-6 / KD-M1-7 / KD-M1-37）`)
       }
-      // checkConfig.lineCounts 元素层形态（#546）：数组，元素 = { doc, section } 非空串；非法 → 拒（不静默跳过）。
-      if (nested === "checkConfig" && sub === "lineCounts" && !isLineCountsValue(value[sub])) {
-        errors.push(`checkConfig.lineCounts 值形态非法：${JSON.stringify(value[sub])}（须为数组，元素 = { doc: 非空串, section: 非空串 }——#546）`)
-      }
     }
   }
   // 三族声明键形态（KD-M1-32——fail-closed：非法即 errors，不静默跳过；缺键仍在 missingKeys）。

package/manifest.mjs

@@ -10,7 +10,7 @@
  *    未知键（#802 / KD-M1-36）→ 产 unknownKeys + 一行可见告警（console.warn + logEvent；
  *    同档同键集去重、读到零未知键清该档 memo）——非拒定性零变。
  *  - validateManifest(obj) → { ok, errors, missingKeys, unknownKeys }：枚举 / version 数值 /
- *    docRoot 子键值形态（串 | 数组 | null（本面无——KD-M1-37），F7）+ checkConfig.lineCounts 元素层形态——**纯函数、零 fs**；不落盘。
+ *    docRoot 子键值形态（串 | 数组 | null（本面无——KD-M1-37），F7）——**纯函数、零 fs**；不落盘。
  *  - 三族声明键（`codePaths` / `index.{codeExtensions,docExtensions,publicRepos}` / `advisor.{docMap,standardsDoc}`——
  *    KD-M1-31 / M1-32）：缺键补默认；形态错 = 档非法（fail-closed，与 docRoot 子键同款）；
  *    读向 = `declaration.mjs`（2026-10-01 自 `conventions.mjs` 迁出——经其转口可达）经 `readManifest` /
@@ -25,10 +25,10 @@
  *  - projectView(target) → { state, root, path, manifest?, candidates?, errors?, matched }：**按用点解析**
  *    的读侧单点（归属 ∨ 发现兜底 / 五态 / 非抛错 / **零写**——KD-M1-24）。
  *  - resolveProjectRoot(cwd)：项目根（归属 ∨ 发现——KD-M1-30）= `projectRootView(cwd).root`（薄委托）；
- *    projectRootView(cwd) → { state: ok|ambiguous|none, root, candidates }：歧义直读形（判定单点——§2.2）。
+ *    projectRootView(cwd) → { state: ok|workspace|none, root, candidates }：项目根直读形（判定单点——§2.2）。
  *  - resolveEngineeringManifest(cwd, { writer, init }) → 入口决策树（**非抛错**——KD-M1-20）：
  *    两端入口钩子与翻转面（拒翻）共用同一张树（判据单源；§2.8 F1）——失败码五枚
- *    `missing` / `invalid` / `no-project` / `ambiguous` / `init-failed`（KD-M1-28）。名中 `Engineering` = 历史命名（沿用不改名）；消费面 = 两端入口钩子 + 翻转面——**非**「模式拥有本模块」。
+ *    `missing` / `invalid` / `no-project` / `workspace` / `init-failed`（KD-M1-28）。名中 `Engineering` = 历史命名（沿用不改名）；消费面 = 两端入口钩子 + 翻转面——**非**「模式拥有本模块」。
  *  - manifestFilePath(cwd) → 数据档绝对路径（档路径单源 KD-M1-18——读 / 写 / mtime 门控三处同源）。
  *  - initManifest(cwd, { writer = 'subagent' } = {}) → 经写门写 DEFAULT_MANIFEST，缺省拒。
  *  - writeManifest(cwd, manifest, { writer = 'subagent' } = {}) → 落盘前先校验（ok:false 拒
@@ -53,14 +53,14 @@ export { DEFAULT_MANIFEST, MANIFEST_SCHEMA, isValidDocRootValue, validateManifes
  * · **归属（第一段——§⑥ 归属形）**：`owningProject(target)` 沿祖先链取最近带档目录
  *   （子优于根 / 不跨兄弟 / 无全局优先级）⇒ 读该档 ⇒ `ok` / `invalid`。
  * · **发现兜底（第二段——§⑥ 发现规则，纯向下）**：祖先链无档 ⇒ `discoverProjects(target)` ⇒ 命中
- *   （`self` / `unique`）⇒ 读其档（带档 ⇒ `ok` / `invalid`；缺档 ⇒ `missing`）；`ambiguous` ⇒
- *   `ambiguous`（+ `candidates`）；`none` ⇒ `no-project`。
+ *   （`self` / `unique`）⇒ 读其档（带档 ⇒ `ok` / `invalid`；缺档 ⇒ `missing`）；`workspace` ⇒
+ *   `workspace`（+ `candidates`）；`none` ⇒ `no-project`。
  * 写侧（建档）**不在**此函数（归入口决策树——KD-M1-25 / M1-29）⇒ 注入器 / 只读消费面不会变写点。
  * `matched` 契约：归属段命中 ⇒ `'manifest'`；发现段 ⇒ `discoverProjects.matched` 逐字；
- * `no-project`（/ 覆盖位短路）⇒ `null`——报明行歧义变体按它分野（§2.6 条 1b）。
+ * `no-project`（/ 覆盖位短路）⇒ `null`——报明行工作区变体按它分野（§2.6 条 1b）。
  * 读错（非 ENOENT——权限 / 目录等）收为 `invalid`（非抛错契约；`readManifest` 语义零改）。
  * @param {string} [target] 目标路径（目录 / 文件——动作作用于哪个项目的路径）
- * @returns {{state:'ok'|'missing'|'no-project'|'ambiguous'|'invalid', root:string|null, path:string|null,
+ * @returns {{state:'ok'|'missing'|'no-project'|'workspace'|'invalid', root:string|null, path:string|null,
  *   manifest?:object, candidates?:string[], errors?:string[], matched:'manifest'|'git'|null}}
  */
 export function projectView(target) {
@@ -68,7 +68,7 @@ export function projectView(target) {
   const owning = owningProject(anchor)
   if (owning) return viewAtRoot(owning, "manifest")
   const d = discoverProjects(anchor)
-  if (d.kind === "ambiguous") return { state: "ambiguous", root: null, path: null, candidates: d.candidates, matched: d.matched }
+  if (d.kind === "workspace") return { state: "workspace", root: null, path: null, candidates: d.candidates, matched: d.matched }
   if (d.kind === "none") return { state: "no-project", root: null, path: null, matched: null }
   return viewAtRoot(d.root, d.matched)
 }
@@ -187,6 +187,16 @@ export function requireManifest(cwd) {
   return readManifest(cwd)
 }
 
+/** 建档（init 支）成功后的同步通知位（#1376——**反向注册**：`declaration.mjs` 已向依赖本模块，
+ *  订阅方由对侧注册 ⇒ 本模块保持零出边（MANIFEST.md KD-M1-33）；形同 `config-io.mjs` `onConfigSelfWrite`
+ *  ——返回退订函数；订阅方失败不影响建档）。 */
+const manifestInitFns = new Set()
+export function onManifestInit(fn) {
+  if (typeof fn !== "function") return () => {}
+  manifestInitFns.add(fn)
+  return () => { manifestInitFns.delete(fn) }
+}
+
 /**
  * 入口决策树（**非抛错**形态——KD-M1-20；docs/core/design/MANIFEST.md §2.8 F1）：三面共用——
  * ① CLI 装配 / 重估薄包装 ② VSC `hydrateRun` 钩子块 ③ 翻转面（`eng` 工具 / `/eng` /
@@ -196,22 +206,22 @@ export function requireManifest(cwd) {
  * 分支（两分支六出口——§2.8 F1 树）：
  *   档合法         → { ok:true, manifest, created:false }（manifest = 补默认值后的档内容）
  *   缺档 + init    → 梯②④⑤（锚 = 裸仓 / 裸仓命中 / 无项目）⇒ `initManifest(cwd, { writer })`
- *                    （抛错 → `init-failed`）；歧义（≥2 候选）⇒ `{ ok:false, code:'ambiguous',
- *                    message, candidates }`（**不建 / 不猜**）
+ *                    （抛错 → `init-failed`）；工作区（锚自身无档 ∧ 下辖 ≥2 项目）⇒
+ *                    `{ ok:false, code:'workspace', message, candidates }`（**不建 / 不猜**）
  *   缺档 + !init   → 梯⑤（无项目）⇒ `{ ok:false, code:'no-project' }`（KD-M1-28；`init:false` 面）；
- *                    梯②④（裸仓可解析、档缺）⇒ `{ ok:false, code:'missing' }`；歧义 ⇒ 同上
+ *                    梯②④（裸仓可解析、档缺）⇒ `{ ok:false, code:'missing' }`；工作区 ⇒ 同上
  *   档非法         → { ok:false, code:'invalid', message, errors }
  *
  * `writer` 由调用点**显式**传（生产调用点全传 `'main'`）：缺省 `'subagent'` 是写门 fail-closed
  * 缺省（KD-M1-3），误用缺省 ⇒「缺档 + 梯②④⑤」退化为 `init-failed`（拒翻——与 §2.8 F2 /
  * AC-20② 语义相反；T38 反证格）。
- * 失败码两态文案不同（KD-M1-28）：无项目 ⇒ 可在锚处落地 / 歧义 ⇒ 列候选不猜；文案族 =
- * 「项目不可解析」（稳定锚句 `/项目不可解析/`——拒翻面与报明面共用）。
+ * 失败码文案分野（KD-M1-28）：无项目 ⇒ 可在锚处落地 / 工作区 ⇒ 报明事实 + 点名项目根；文案族 =
+ * 「项目不可解析」（稳定锚句 `/项目不可解析/`）——**仅「档非法」格**（§2.8 F2 拒翻面唯一拒格）。
  * 边界：`readManifest` 的非 ENOENT 读错（权限 / 目录等）由 `projectView` 收为 `invalid`（非抛错
  * 契约——`readManifest` 返回语义零改）；本树只承诺上列六出口。
  * @param {string} [cwd] 会话锚（缺省 → 进程 cwd）
  * @returns {{ok:true, manifest:object, created:boolean}
- *   | {ok:false, code:'missing'|'invalid'|'no-project'|'ambiguous'|'init-failed',
+ *   | {ok:false, code:'missing'|'invalid'|'no-project'|'workspace'|'init-failed',
  *      message?:string, errors?:string[], candidates?:string[]}}
  */
 export function resolveEngineeringManifest(cwd, { writer = "subagent", init = true } = {}) {
@@ -223,24 +233,29 @@ export function resolveEngineeringManifest(cwd, { writer = "subagent", init = tr
       message: `项目不可解析：${MANIFEST_REL} 非法（fail-closed）：${(view.errors ?? []).join("；")}`,
     }
   }
-  if (view.state === "ambiguous") {
-    return { ok: false, code: "ambiguous", candidates: view.candidates, message: ambiguousProjectMessage(cwd, view.candidates) }
+  if (view.state === "workspace") {
+    return { ok: false, code: "workspace", candidates: view.candidates, message: workspaceProjectMessage(cwd, view.candidates) }
   }
   // 缺档（梯②④⑤）：init ⇒ 就地建档（内容 = DEFAULT_MANIFEST，经写门 writer:'main'）；!init ⇒ 归码。
   if (!init) return { ok: false, code: view.state === "no-project" ? "no-project" : "missing" }
   try {
-    return { ok: true, manifest: initManifest(cwd, { writer }), created: true }
+    const manifest = initManifest(cwd, { writer })
+    // #1376：建档支成功 ⇒ 同步广播（进程内声明 ∥ 范围缓存即刻随动——如 eng 翻转面结束后
+    // 同进程的声明复读；订阅方失败不阻断建档；失败路径不广播）。
+    for (const fn of manifestInitFns) { try { fn() } catch (e) { console.warn(`[manifest] init subscriber failed: ${e?.message ?? e}`) } }
+    return { ok: true, manifest, created: true }
   } catch (e) {
     return { ok: false, code: "init-failed", message: e?.message ?? String(e) }
   }
 }
 
-/** 歧义消息（文案族「项目不可解析」——KD-M1-28）：候选**全列**（绝对路径、按名排序）+ 指引
- *  显式指定目标——**不猜**（与报明行同族；拒翻面经 F3 明示面逐字转发）。 */
-function ambiguousProjectMessage(cwd, candidates) {
+/** 工作区消息（**事实行**——§2.5「单项目解析律」条 / §2.8 F2 工作区行）：念明下辖项目**全列**
+ *  （绝对路径、按名排序）+ 可执行下一步（点名项目根 / 目标路径）——报明事实，非错误框定
+ *  （不书「项目不可解析」/ 候选二义）。 */
+function workspaceProjectMessage(cwd, candidates) {
   const list = (candidates ?? []).map((c) => `- ${c}`).join("\n")
-  return `项目不可解析：会话锚 ${cwd} 下候选项目不是恰好一个（下列 ${(candidates ?? []).length} 个）——` +
-    `每个项目一份 ${MANIFEST_REL}；请显式指定目标项目（机制不猜）：\n${list}`
+  return `工作区：会话锚 ${cwd} 自身无 ${MANIFEST_REL}，下辖 ${(candidates ?? []).length} 个项目（下列全部）——` +
+    `每个项目一份 ${MANIFEST_REL}；请显式给出目标项目根或目标路径（动作按用点路径解析）：\n${list}`
 }
 
 /**

package/mcp/transport-stdio.mjs

@@ -5,7 +5,7 @@ import { spawn, spawnSync } from "node:child_process"
 import { rpcId, CALL_TIMEOUT_MS, withTimeout, quoteArg } from "./helpers.mjs"
 
 /** 退出相位标志（D-MC19）：模块加载期注册的 exit 钩子置位——退出相位无事件循环，
- *  只同步操作可落地（注册序恒早于宿主 cleanup——`thincoder-cli/src/tui/index.mjs:125`）。 */
+ *  只同步操作可落地（注册序恒早于宿主 cleanup——`thincoder-cli/src/tui/index.mjs` 的 `createExitCleanup`）。 */
 let exiting = false
 process.on("exit", () => { exiting = true })
 

package/mcp.mjs

@@ -93,14 +93,14 @@ async function createConnectedTransport(rawConfig, serverName) {
  *  零副作用：不进 _sessions、不动 agent.tools、无 onDead 挂钩；finally close
  *  （closed=true 使 onDead 重连不会触发）。initialize 与 tools/list 同受
  *  INIT_TIMEOUT_MS 约束（见 doInitialize）。不复用 connectMcpServer（避免污染
- *  session 幂等表）。 */
+ *  session 幂等表）。读数 = `{ ok, toolCount, tools, latencyMs }`（`tools` = 工具名数组——控制台具名读数，2026-10-14 走查轮增补）。 */
 export async function probeMcpServer(config) {
   const start = Date.now()
   let transport
   let mcpTools
   try {
     ;({ transport, mcpTools } = await createConnectedTransport(config, config.name ?? config.command ?? config.url ?? config.wsUrl))
-    return { ok: true, toolCount: mcpTools.length, latencyMs: Date.now() - start }
+     return { ok: true, toolCount: mcpTools.length, tools: mcpTools.map((t) => (typeof t?.name === "string" ? t.name : "")).filter((n) => n !== ""), latencyMs: Date.now() - start }
   } catch (error) {
     return { ok: false, error: error?.message ?? String(error) }
   } finally {

package/memory/core.mjs

@@ -132,7 +132,7 @@ export function fetchEntry(memory, uid) {
   const lastColon = uid.lastIndexOf(":")
   const origin = lastColon > layer.length ? uid.slice(layer.length + 1, lastColon) : ""
   const path = lastColon > layer.length ? uid.slice(lastColon + 1) : uid.slice(layer.length + 1)
-  const projectOrigin = normalizeOrigin(memory.projectOrigin) // §6.11 读缝归一（uid 解析面零改——`:131` 余量兜底仍在）
+  const projectOrigin = normalizeOrigin(memory.projectOrigin) // §6.11 读缝归一（uid 解析面零改——`fetchEntry` 余量兜底仍在）
   if (layer === "project" && projectOrigin) {
     const r = memory.db.prepare(`SELECT type, title, content, tags, author FROM files WHERE layer = ? AND origin = ? AND path = ?`).get(layer, origin || projectOrigin, path)
     if (r) return { ...r, layer, id: uid }