@thincoder/core 0.10.2 → 0.10.4

package/embedding.mjs

@@ -7,6 +7,8 @@
 
 import { RETRYABLE_STATUS } from "./provider/index.mjs"
 import { resolveEnvRefs } from "./env-ref.mjs"
+// #859（MEMORY.md §6.3 ∥ §7 D-MEM31）：嵌入路径发送前净化孤立 UTF-16 代理——sanitize 单源复用
+import { sanitizeLoneSurrogates } from "./escape.mjs"
 const MAX_RETRIES = 3
 const BATCH_SIZE = 32 // max texts per request (within SiliconFlow limits)
 
@@ -48,6 +50,33 @@ export async function embed(embedder, texts, { signal } = {}) {
   return vectors
 }
 
+/**
+ * 毒行隔离消费面（MEMORY.md §6.3 ∥ §7 D-MEM31 · 台账 #859）：补嵌批的容错版 `embed`。
+ * 整批失败且错误携 `httpStatus === 400`（发送前清洗后仍 400 的未知毒形）⇒ 逐条独试：
+ * 成功者照常返回、仍败者置 `null`（调用面跳过不写 + 一行可见回执）；其余错误（网络 ∕ 401 等）
+ * 照旧整抛——隔离只兜 400 类。query 面（搜索侧单条嵌入）不走本函数（语义零变）。
+ * @returns {Promise<{vectors: (Float32Array|null)[], skipped: string[]}>}
+ */
+export async function embedTolerant(embedder, texts, { signal } = {}) {
+  try {
+    return { vectors: await embed(embedder, texts, { signal }), skipped: [] }
+  } catch (err) {
+    if (err?.httpStatus !== 400) throw err
+    const vectors = []
+    const skipped = []
+    for (let i = 0; i < texts.length; i++) {
+      try {
+        const [vec] = await embed(embedder, [texts[i]], { signal })
+        vectors.push(vec)
+      } catch (e) {
+        vectors.push(null)
+        skipped.push(`input #${i}: ${e.message}`)
+      }
+    }
+    return { vectors, skipped }
+  }
+}
+
 /** Cosine similarity (inputs are normalized, dot product equals cosine) */
 export function cosine(a, b) {
   if (a.length !== b.length) return 0
@@ -85,7 +114,8 @@ async function requestWithRetry(embedder, input, signal) {
           "Content-Type": "application/json",
           Authorization: `Bearer ${embedder.apiKey}`,
         },
-        body: JSON.stringify({ model: embedder.model, input }),
+        // #859 主修：发送前逐条净化孤立代理（存量毒行 ⇒ 硅基流动 400/20015；清洗后根因消除）
+        body: JSON.stringify({ model: embedder.model, input: input.map((t) => sanitizeLoneSurrogates(t)) }),
         signal: signal
           ? AbortSignal.any([signal, AbortSignal.timeout(60_000)])
           : AbortSignal.timeout(60_000),
@@ -100,11 +130,13 @@ async function requestWithRetry(embedder, input, signal) {
 
     const text = await response.text().catch(() => "")
     const message = `Embedding API error ${response.status}: ${text}`
+    const err = new Error(message)
+    err.httpStatus = response.status // #859：隔离层判据（400 类 ⇒ embedTolerant 逐条独试）
     if (RETRYABLE_STATUS.has(response.status)) {
-      lastError = new Error(message)
+      lastError = err
       continue
     }
-    throw new Error(message)
+    throw err
   }
   throw lastError
 }

package/escape.mjs

@@ -52,7 +52,7 @@ export function escapeLiteralEscapes(text) {
   return out
 }
 
-/** 净化孤立 UTF-16 代理对（毒源②）：高代理无低代理跟随 / 低代理无高代理前置 → 替换为 。 */
+/** 净化孤立 UTF-16 代理对（毒源②）：高代理无低代理跟随 / 低代理无高代理前置 → 剥除（出串零该码元——码 :66/:68 实读为准）。 */
 export function sanitizeLoneSurrogates(text) {
   text = String(text ?? "")
   let out = ""

package/i18n.mjs

@@ -41,6 +41,9 @@ export const CORE_MESSAGES = Object.freeze({
   "digest.turnLabelAsk": { en: "[auto-turn: answering ${from}: ${msg}]", zh: "自动回合：答复 ${from}：${msg}" },
   "digest.capAuto": { en: "[auto-turn: continuing past turn cap…]", zh: "自动回合：越过轮次上限，继续推进…" },
   "digest.capStop": { en: "[auto-turn stopped at ${turns} turns — partial digest; finished reports stay in history]", zh: "自动回合在 ${turns} 轮处停止——部分消化；已完成的报告保留在历史中" },
+  // 消化账务批 · 2026-10-05 · 台账 #930（§6.31.6 端面残余行——判据 = `unsettledCount(carrier)`；
+  // 消费面 = CLI 痕行 ∥ 桌面 / VSC 行元素；三端共读本键）
+  "digest.residue": { en: "${n} background report(s) not accounted — they will be re-delivered", zh: "有 ${n} 份后台报告未销账——将自动重投" },
   // ── 限流 / 供应商状态行 ──
   "status.rateWait": { en: "TPM throttle wait ~${s}s", zh: "TPM 限流等待 ~${s}s" },
   "status.rateLimited": { en: "Rate-limited 429, retry in ${s}s", zh: "限流 429，${s}s 后重试" },
@@ -69,6 +72,8 @@ export const CORE_MESSAGES = Object.freeze({
   "status.turn": { en: "turn ${n}/${m}", zh: "轮次 ${n}/${m}" },
   "tool.running": { en: "running…", zh: "执行中…" },
   "tool.done": { en: "done", zh: "完成" },
+  // ── 台账（ledger）· F-LX3 变体键库首跑提示（批 2026-10-05-ledger-variant-db-notice · 台账 #935 · LEDGER.md §12.2 逐字；消费面 = CLI TUI 启动行）
+  "ledger.variantDbNotice": { en: "Legacy variant-key ledger DB found for this project (pre-upgrade; rows may be outside the current ledger): thincoder ledger audit to inspect; thincoder ledger migrate to reconcile", zh: "检测到本项目的存量变体键台账库（升级遗留，数据可能未并入当前库）：thincoder ledger audit 查看；thincoder ledger migrate 收正" },
 })
 // 深度冻结（机器消费面冻结——嵌套 { en, zh } 也冻结；浅冻结下值可被静默改写）。
 for (const entry of Object.values(CORE_MESSAGES)) Object.freeze(entry)

package/ledger-cmd.mjs

@@ -10,15 +10,15 @@
  * 的 depthOnly 分支）——一律**动态 import** 本模块链（ledger-db.mjs 静态 import node:sqlite ⇒
  * 消费侧静态 import 会破 W8 契约②）。
  */
-import { statSync } from "node:fs"
-import { basename, resolve } from "node:path"
+import { resolve } from "node:path"
 import { ALLOWED_MIGRATIONS, nowIso, openLedger, PENDING_STATUSES } from "./ledger-db.mjs"
 import { resolveProjectRoot } from "./manifest.mjs"
-import { declaredPublicRoots } from "./declaration.mjs"
+import { resolveDeclaredRef } from "./declaration.mjs"
 
-/** 查询（只读，全角色）：SELECT 行集（status/kind/board 过滤，缺省 = 全部行；id 升序）。库不在 = 空账。 */
+/** 查询（只读，全角色）：SELECT 行集（status/kind/board 过滤，缺省 = 全部行；id 升序）。库不在 = 空账。
+ *  只读开库（readOnly 句柄 + 零 DDL/ALTER——read-data-interface 批 FR2③）；库档非台账库 ⇒ 空账。 */
 export function ledgerQuery({ cwd, status = null, kind = null, board = null } = {}) {
-  const db = openLedger(cwd)
+  const db = openLedger(cwd, { readOnly: true })
   if (!db) return []
   try {
     const where = [], args = []
@@ -29,9 +29,10 @@ export function ledgerQuery({ cwd, status = null, kind = null, board = null } =
   } finally { db.close() }
 }
 
-/** 计数单源（只读，全角色）：COUNT(*) WHERE 未决四态——替代 v1 md 计数面（AC-M2-3）。库不在 = 0。 */
+/** 计数单源（只读，全角色）：COUNT(*) WHERE 未决四态——替代 v1 md 计数面（AC-M2-3）。库不在 = 0。
+ *  只读开库（同 ledgerQuery——零 DDL/ALTER）；库档非台账库 ⇒ 0。 */
 export function ledgerCount({ cwd } = {}) {
-  const db = openLedger(cwd)
+  const db = openLedger(cwd, { readOnly: true })
   if (!db) return 0
   try {
     const row = db.prepare(`SELECT COUNT(*) AS n FROM items WHERE status IN (${PENDING_STATUSES.map(() => "?").join(",")})`).get(...PENDING_STATUSES)
@@ -39,9 +40,6 @@ export function ledgerCount({ cwd } = {}) {
   } finally { db.close() }
 }
 
-/** 路径 = 存在的**档**？（目录 / 缺失 → false——写门存在性判据用）。 */
-const isFile = (p) => { try { return statSync(p).isFile() } catch { return false } }
-
 /** 写门·指针存在性（设计档 §6.1 · 台账 #38 · AC-M2-10）：写命令落盘前判**结果行**——`status ∈
  *  {在途, 待核销}` ⇒ 判 `task_book`：`null`（缺指针）⇒ 拒（「必填」文案）；非 `null` ⇒ 文件部分
  *  （首个 `§` 前子串，trim）须经基准 `resolve(base, …)` 指向存在的档；缺文件部分（`§2` / 空串 /
@@ -50,23 +48,17 @@ const isFile = (p) => { try { return statSync(p).isFile() } catch { return false
  *  基准 `base` = **与台账库关联键同源**（2026-09-18 fix 轮 · O1 收正）：`resolveProjectRoot(cwd) ??
  *  resolve(cwd ?? ".")`——同表达式见 `ledger-db.mjs` `ledgerDbPath`；容器根会话（锚 cwd 下唯一注册
  *  子仓 P）与子仓会话 ⇒ 库键与指针基准同取 P（同库同基准；原实现 `resolve(cwd, …)` = 原始 cwd 会误拒）。
- *  #832：声明源前缀形同判（§6.15——首段 = 声明公共仓目录名 ⇒ 于该声明根解析；可核 ⇒ 通过；缺位拒）。 */
+ *  #832 ∥ #834：声明源前缀形同判——判定单源 = `declaration.mjs` `resolveDeclaredRef`（① 仓根解析 →
+ *  ② 声明源前缀解析序；同名多仓 ⇒ 声明序首者）——**与迁移旗（`ledger-migrate.mjs` `writeGateFlag`）
+ *  同消费**；未声明 ∥ 声明根缺位 ∥ 目标档缺 ⇒ 照旧拒（既有拒绝面零改——判据本体 = §6.1 口径 1–4 逐字）。 */
 function assertTaskBookGate(cwd, fnName, status, taskBook) {
   if (status !== "在途" && status !== "待核销") return
   if (taskBook == null) throw new Error(`${fnName}：task_book 必填（在途 / 待核销 须携任务书指针）`)
   const part = String(taskBook).split("§")[0].trim()
   if (!part) throw new Error(`${fnName}：task_book 不可解析（缺文件部分）：${taskBook}`)
   const base = resolveProjectRoot(cwd) ?? resolve(cwd ?? ".")
-  const abs = resolve(base, part)
-  // §6.15 声明源候选（#832 · LEDGER.md §6.1-4）：首段 = 声明公共仓目录名 ⇒ 该声明根解析余段（同名多仓 ⇒ 声明序首者）；未声明 ∥ 缺位 ⇒ 照旧拒。
-  if (isFile(abs)) return
-  const segs = part.replace(/\\/g, "/").split("/").filter(Boolean)
-  for (const root of declaredPublicRoots(base)) {
-    if (segs[0] !== basename(root)) continue
-    if (segs.length > 1 && isFile(resolve(root, segs.slice(1).join("/")))) return
-    break
-  }
-  throw new Error(`${fnName}：task_book 指向的档不存在：${taskBook}（解析 = ${abs}）`)
+  const { ok, abs } = resolveDeclaredRef(base, part)
+  if (!ok) throw new Error(`${fnName}：task_book 指向的档不存在：${taskBook}（解析 = ${abs}）`)
 }
 
 /** 新增（写命令，仅主 agent）：INSERT——入待讨论（六态状态机入口）。 */

package/ledger-db.mjs

@@ -55,6 +55,10 @@ export function ledgerDbPath(cwd) {
 /** 未决四态（「活条目」口径 = 计数单源 WHERE 集；已核销 / 已废弃 = 归档态）。 */
 export const PENDING_STATUSES = ["待讨论", "待设计", "在途", "待核销"]
 
+/** 台账库结构版本（N2 标记**单源**——`PRAGMA user_version` 落标：写面开库 `v < 本值 ⇒ 置`；
+ *  读面如实回读（旧库未标 = 0）；结构变更（新列 / 新表）同步升号——2026-10-03 read-data-interface 批）。 */
+export const LEDGER_SCHEMA_VERSION = 1
+
 /** 六态允许迁移表（ledgerUpdate 迁移前判，不在表内 → 拒——规格 ②.2；设计档 §2.1）。 */
 export const ALLOWED_MIGRATIONS = {
   "待讨论": ["待设计", "已废弃"],
@@ -100,12 +104,39 @@ export function ensureExecutorColumn(db, { exists } = {}) {
   }
 }
 
+/** 只读态开库（read-data-interface 批 FR2③——readOnly 句柄 + **零 DDL / 零 ALTER**；先例 = 本包
+ *  `ledger-migrate.mjs` 的 `openRead`）：文件必已在盘；items 表缺失探针 ⇒ 视同空账返回 null
+ *  （非台账库的 SQLite 档 / 空档——观测面保持「空集」，文件零触）。不可开（坏档 / 非 SQLite）⇒
+ *  抛（调用方按面处置：单范围 = 读错；族范围 = 不可读跳过）。 */
+function openReadOnly(file) {
+  let db
+  try {
+    db = new DatabaseSync(file, { readOnly: true })
+    if (db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'items'").get() === undefined) {
+      db.close()
+      return null // 无 items 表 ⇒ 非台账库 ⇒ 空账（探针零写）
+    }
+    return db
+  } catch (e) {
+    try { db?.close() } catch { /* 已关 / 未开 */ }
+    throw new Error(`台账库打开失败：${file}（${e.message}）`)
+  }
+}
+
+/** 写面落标（N2）：`user_version` < 常量 ⇒ 置；≥ 常量不动（未来版本零回退）。只在写面开库调用。 */
+function markSchemaVersion(db) {
+  const v = Number(db.prepare("PRAGMA user_version").get().user_version ?? 0)
+  if (v < LEDGER_SCHEMA_VERSION) db.exec(`PRAGMA user_version = ${LEDGER_SCHEMA_VERSION}`)
+}
+
 /** 开库（cwd = 项目根——仅作关联键）→ DatabaseSync 句柄 + 幂等建表 + 老库幂等迁移（executor 列）。
  *  读面（create=false）：库文件不存在 → 返回 null（空账——读面不建库、无副作用）。
  *  写面（create=true）：库文件不存在自动建（台账目录随之创建）；项目根目录不存在 → 抛友好错误。
+ *  **只读态**（readOnly=true——读面专用）：只读句柄 + 零 DDL / ALTER + items 探针（见 openReadOnly）；
+ *  如实副作用：旧库（缺 executor 列）**读**不再自动补列——补列归写面开库；读出行缺列按 null 归一。
  *  **歧义锚**（≥2 候选——`projectRootView` `ambiguous` 态）⇒ **显式拒**（列候选 + 显式项目根指引；
  *  零写——不静默回退锚；族锚「项目不可解析」，AC-M2-17）；兜底 `resolve(cwd ?? ".")` 只属 none 态。 */
-export function openLedger(cwd, { create = false } = {}) {
+export function openLedger(cwd, { create = false, readOnly = false } = {}) {
   const dir = resolve(cwd ?? ".")
   // 歧义锚 ⇒ 显式拒（零写——消「缺省空读 / 错写落锚」双面症；读 / 写五工具同经本门）。
   const view = projectRootView(dir)
@@ -118,11 +149,13 @@ export function openLedger(cwd, { create = false } = {}) {
     throw new Error(`项目目录不存在：${dir}——cwd 请给存在的项目根（相对路径按当前工作目录解析；缺省 = 会话项目根）`)
   }
   if (!existsSync(file) && !create) return null
+  if (readOnly) return openReadOnly(file)
   try { mkdirSync(ledgerDir, { recursive: true }) } catch { /* 已存在 / 并发建目录竞争——忽略 */ }
   const db = new DatabaseSync(file)
   try {
     db.exec(DDL)
     ensureExecutorColumn(db)
+    markSchemaVersion(db)
   } catch (e) {
     db.close()
     throw new Error(`台账库打开失败：${file}（${e.message}）`)

package/ledger-migrate.mjs

@@ -11,6 +11,7 @@ import { copyFileSync, mkdirSync, readdirSync, renameSync, statSync, writeFileSy
 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 { resolveProjectRoot } from "./manifest.mjs"
 
@@ -71,14 +72,14 @@ function readRowsOf(file, missing = []) {
   const db = openRead(file)
   try { return readRows(db, missing) } finally { db.close() }
 }
-/** 写门风险旗（§2.2 表）：迁入行属 `在途 / 待核销` 且 `task_book` 不可解析 / 指向档不存在 ⇒ 该行后续更新将拒于 §6.1 写门；只出旗，不拦截。 */
+/** 写门风险旗（§2.2 表）：迁入行属 `在途 / 待核销` 且 `task_book` 不可解析 / 指向档不存在 ⇒ 该行后续更新将拒于 §6.1 写门；只出旗，不拦截（判面与写门同源·#834——共享解析单点 `resolveDeclaredRef`：① 仓根解析 → ② 声明源前缀解析序）。 */
 function writeGateFlag(values, projectRoot) {
   const tb = values[5]
   if ((values[1] !== "在途" && values[1] !== "待核销") || tb == null || tb === "") return null
   const part = String(tb).split("§")[0].trim()
   if (!part) return `task_book 不可解析（缺文件部分）：${tb}`
-  const abs = resolve(projectRoot, part)
-  return isFile(abs) ? null : `task_book 指向的档不存在：${tb}（解析 = ${abs}）`
+  const { ok, abs } = resolveDeclaredRef(projectRoot, part)
+  return ok ? null : `task_book 指向的档不存在：${tb}（解析 = ${abs}）`
 }
 /** `--from` 指名键 = **补充源**：键形非 16 位小写十六进制 / 无对应库 / 不可开 ⇒ 拒跑（fail-closed，零写——显式指名不静默跳过；键形判防路径形 / 越目录形取值 join 出台账目录外）。 */
 function fromKeyRefusal(fromKeys, dir) {

package/ledger-read.mjs

@@ -0,0 +1,94 @@
+/**
+ * ledger-read.mjs — 只读数据接口（read-data-interface 批 · 设计档
+ * `docs/cli/design/READ-DATA-INTERFACE.md` §2.1 / §2.3 / §2.4 / §2.7 · 台账 #886 ∥ #887）。
+ *
+ * 面：① `ledgerExport({ cwd, family, full })` —— CLI `ledger list --json` ∥ ACP `ledger/list`
+ * 两出口共用的**统一序列化单源**（N1：零 SQL 复刻、零表名泄漏——行集直用核 `ledgerQuery`）；
+ * ② `runLedgerList(args, opts)` —— CLI 命令 runner（严格解析 · fail-closed——§2.7 / §3.1）。
+ *
+ * 载荷（§3.2 冻结形）：`{ projects: [{ root, name, schemaVersion, rows }] }`；行 = `id` + 12 数据列
+ * （列集单源 = `DATA_COLUMNS`——D-10 直引，不另立副本；`evidence` 仅 full 入行）；缺列（旧库）按
+ * null 归一；`schemaVersion` = 库 `PRAGMA user_version` 如实回读（旧库未标 = 0）；库不在 / 非台账库
+ * ⇒ 项目不出项（空集）。
+ * 范围（§2.4）：单范围 = 解析后项目根一项（`resolveProjectRoot(cwd) ?? resolve(cwd ?? ".")`——与库键
+ * 同源）；`--family` = `discoverFamily` 发现序逐项（不可读跳过——既有语义）。
+ *
+ * W8 契约②：本档静态入 `ledger-db.mjs`（node:sqlite）⇒ 消费侧一律**动态 import** 本档。
+ * D-11：`ledger.mjs` 零编辑——族发现只 import `discoverFamily`。
+ */
+import { basename, resolve } 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"
+
+/** 行出形（§3.2）：`id` + 数据列序（`evidence` 仅 full）；缺列按 null 归一。 */
+function exportRow(r, full) {
+  const row = { id: Number(r.id) }
+  for (const c of DATA_COLUMNS) {
+    if (c === "evidence" && !full) continue
+    row[c] = r[c] ?? null
+  }
+  return row
+}
+
+/** 单项目读（**两开均只读态**——版本探针开 + 行集开，§2.3）：库不在 / 非台账库 ⇒ null（项目不出项）。
+ *  不可读（坏档）⇒ 抛（单范围 = 读错转 exit 1；族范围 = 调用侧捕获跳过）。 */
+function readProject(root, full) {
+  const probe = openLedger(root, { readOnly: true })
+  if (!probe) return null
+  let schemaVersion
+  try { schemaVersion = Number(probe.prepare("PRAGMA user_version").get().user_version ?? 0) } finally { probe.close() }
+  const rows = ledgerQuery({ cwd: root })
+  return { root, name: basename(root), schemaVersion, rows: rows.map((r) => exportRow(r, full)) }
+}
+
+/** 统一序列化单源（N1——两出口共用；载荷 = §3.2 冻结形）。
+ *  单范围 = 当前项目一项；`family=true` = 族内发现序逐项（不可读跳过——余者照常）。 */
+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)
+    return { projects: item ? [item] : [] }
+  }
+  const projects = []
+  for (const p of discoverFamily(anchor).projects) {
+    try { const item = readProject(p.root, full); if (item) projects.push(item) } catch { /* 不可读跳过 */ }
+  }
+  return { projects }
+}
+
+/** CLI 命令 usage（冻结形——§3.1；解析错入 stderr）。 */
+const LIST_USAGE = "Usage: thincoder ledger list --json [--full] [--family] [--cwd <dir>]"
+
+/** CLI runner（§2.7）：严格解析——未知参 / 缺 `--json` / `--cwd` 缺值 ⇒ usage + exit 1（fail-closed，
+ *  与同族 migrate / audit 宽松面刻意不同）；`--cwd` 空格形（同族先例）。成功 = stdout 单段 JSON
+ *  （零杂行）+ exit 0（含空集）；解析类 / 读错 ⇒ stderr 一行消息（零栈泄）+ exit 1。 */
+export function runLedgerList(args, { cwd = process.cwd(), out = console.log, err = console.error } = {}) {
+  const argv = Array.isArray(args) ? args : []
+  let json = false, full = false, family = false, dir = null
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === "--json") json = true
+    else if (a === "--full") full = true
+    else if (a === "--family") family = true
+    else if (a === "--cwd") {
+      const v = argv[i + 1]
+      if (v === undefined || v.startsWith("--")) { err(LIST_USAGE); return 1 }
+      dir = String(v)
+      i++
+    } else { err(LIST_USAGE); return 1 }
+  }
+  if (!json) { err(LIST_USAGE); return 1 }
+  try {
+    out(JSON.stringify(ledgerExport({ cwd: dir ?? cwd, family, full })))
+    return 0
+  } catch (e) {
+    // 错误面「一行消息、零栈泄」（§3.1）：多行诊断（如歧义锚候选清单）折叠单行——内容零丢。
+    err(String(e?.message ?? e).replace(/\s*\r?\n\s*/g, " "))
+    return 1
+  }
+}

package/ledger-surface.mjs

@@ -1,76 +1,45 @@
 /**
- * ledger-surface.mjs — 台账可见面（核内结构归位；CORE-UNIFICATION §2.5 #174
- * 「融合：取一侧 + 渲染面按端注入」）。
+ * ledger-surface.mjs — 台账可见面（核内结构归位；CORE-UNIFICATION §2.5 #174「融合：取一侧」）。
  *
- * 来源 = `thincoder-cli/src/tui/ledger-surface.mjs`（CLI 住 `tui/`、VSC 住 `extension/`；
- * VSC 头注自述同构）——逐字随迁，**渲染面收核为注入**：原档 `import { C } from "./ansi.mjs"`
- * 是 TUI 专用件的颜色表 ⇒ ④ 端差，改由调用方传入 `colors`（未注入 ⇒ 空对象，输出纯文本，
- * 核内零端名分支——契约 5 / 10）。
- *
- * 三面：① 启动行（首扫、**任一项目可动作**才出——明细行集每项目一行）② 变化行（老化首次
- * 越线 / 池达阈值——一次性去重 + **送达门**：未送达不记账）③ 状态位（`state.ledger`——L1
- * 常驻标记，渲染端消费；**不受启动行门约束**——F2 按标记态照显）。
- * 只读台账；唯一写面 = 去重档（`~/.thincoder/ledger-notify.json`）。
+ * 面：族扫描 → 判活批量解析 → 状态位（`state.ledger`——L1 常驻标记，范围归约 `scopeMarkerOf`
+ * 单源 §7.2，渲染端消费）；只读台账，本面零写。
  */
-import { buildScan, detailScans, discoverFamily, formatDetailLine, formatMarker, loadNotifyState, NOTIFY_FILE, notifyKey, planChangeLines, REFRESH_MS, resolveExecutorStates, saveNotifyState } from "./ledger.mjs"
+import { buildScan, discoverFamily, REFRESH_MS, resolveExecutorStates, scopeMarkerOf } from "./ledger.mjs"
 
 /** 单次扫描（直驱面——timer 包装见 `startLedgerSurface`）。**async**（F-LX1：await 判活解析——
- *  LEDGER.md §7.3.1 ④ 读面不阻塞事件循环）。
- *  `startup=true` = 会话首扫（补启动行；变化行在前、明细行在后）。
- *  `colors` = 端注入的渲染色表（`{ warn, dim }`）；未注入 ⇒ `{}`（`undefined` 色值 = 纯文本）。 */
-export async function runLedgerScan({ state, agent = null, anchor = null, notifyFile = NOTIFY_FILE, pushLine = () => {}, render = () => {}, startup = false, colors = {} } = {}) {
+ *  LEDGER.md §7.3.1 ④ 读面不阻塞事件循环）。 */
+export async function runLedgerScan({ state, agent = null, anchor = null, render = () => {} } = {}) {
   const base = anchor ?? agent?.cwd ?? process.cwd()
   const family = discoverFamily(base)
   const scans = []
   for (const p of family.projects) {
     try { scans.push(buildScan({ cwd: p.root })) } catch { /* 台账不可读 → 该项目跳过（余者照常——N1/T110①） */ }
   }
-  const current = family.current ? scans.find((s) => s.root === family.current.root) ?? null : null
   await resolveExecutorStates(scans) // 判活批量解析（一次探束 + TTL 缓存；无在途零 exec）
-  const notify = loadNotifyState(notifyFile)
-  const plans = scans.map((s) => ({ s, plan: planChangeLines(notify.ledgers[notifyKey(s.ledger)], s) }))
-  const changeLines = plans.flatMap(({ plan }) => plan.lines)
-  const showStartup = startup && scans.some((s) => s.actionable)
-  const rows = showStartup
-    ? [...changeLines, ...detailScans(scans, current).map((s) => ({ text: formatDetailLine(s), warn: s.actionable }))]
-    : changeLines
-  let delivered = true
-  for (const line of rows) {
-    try { pushLine(line.text, line.warn ? colors.warn : colors.dim) } catch { delivered = false; break }
-  }
-  // 送达门（F5）：有事件行 → 仅在送达后记账；无事件行 → 仅状态确有变化时静默同步（跌回 false 即重置）
-  const changed = plans.some(({ s, plan }) => {
-    const prev = notify.ledgers[notifyKey(s.ledger)]
-    return !prev || JSON.stringify(prev.aged ?? []) !== JSON.stringify(plan.next.aged) || Boolean(prev.threshold) !== plan.next.threshold
-  })
-  if (changeLines.length ? delivered : changed) {
-    const ledgers = { ...notify.ledgers }
-    for (const { s, plan } of plans) ledgers[notifyKey(s.ledger)] = { ...plan.next, updatedAt: Date.now() }
-    saveNotifyState(notifyFile, { version: 1, ledgers })
-  }
-  // warn 判位钉在判活解析之后（裁定 #7）：属主已死也是可动作态
-  state.ledger = { marker: current ? formatMarker(current) : null, warn: Boolean(current && (current.aged > 0 || current.deadExecutors > 0)), scannedAt: Date.now() }
+  // 范围归约 = `scopeMarkerOf` 单源（§7.2——容器根锚求和 ∥ 具体项目锚只显自身）；warn 判位钉在
+  // 判活解析之后（裁定 #7）：属主已死也是可动作态
+  const { marker, warn } = scopeMarkerOf(scans, family)
+  state.ledger = { marker, warn, scannedAt: Date.now() }
   render()
 }
 
 /** 挂载：首扫（`setImmediate`——不抢首帧）+ 周期（`REFRESH_MS`；`state.processing` 期间跳过本轮）。
- *  端注入的渲染面（`ctx.colors`）与推送面（`ctx.pushLine` / `ctx.render`）照传。
  *  `tick` 异步化（F-LX1——runLedgerScan async）：await 且 catch 不崩（N1）。重叠防衛：
  *  判活探测秒级可达，上一轮未落定时跳过本轮（防探束堆积）。 */
 export function startLedgerSurface(ctx = {}) {
   let disposed = false
   let timer = null
   let inflight = false
-  const tick = async (startup) => {
+  const tick = async () => {
     if (disposed || inflight) return
-    if (!startup && ctx.state?.processing) return // 扫描不打断回合帧
+    if (ctx.state?.processing) return // 扫描不打断回合帧
     inflight = true
-    try { await runLedgerScan({ ...ctx, startup }) } catch { /* 可见面尽力——不崩（N1） */ } finally { inflight = false }
+    try { await runLedgerScan(ctx) } catch { /* 可见面尽力——不崩（N1） */ } finally { inflight = false }
   }
   setImmediate(() => {
     if (disposed) return
-    tick(true)
-    timer = setInterval(() => tick(false), REFRESH_MS)
+    tick()
+    timer = setInterval(() => tick(), REFRESH_MS)
     timer.unref?.()
   })
   return {