thincoder 0.12.66 → 0.12.68

package/src/tui/key-handler-ctrlc.mjs

@@ -15,7 +15,7 @@ export function handleCtrlCFamily(str, key, ctx) {
       popPicker(null)
       return
     }
-    // §17.6（2026-09-03）：武装窗口内第二次 Ctrl+C = 显式全停（D-C4 /abort 语义）。
+    // AGENT-LOOP-ASYNC-POOL.md §6.8（2026-09-03）：武装窗口内第二次 Ctrl+C = 显式全停（D-C4 /abort 语义）。
     // 在状态路由前检查（picker 取消分支例外——picker 打开时 Ctrl+C 语义 = 取消
     // picker，武装让位；场景极窄——3s 窗口内需另有 picker 被打开）——两次按下之间
     // 状态会迁移（首按停回合 → 释放窗口/挂起会话启动），武装必须跨态桥接：只查挂起
@@ -33,7 +33,7 @@ export function handleCtrlCFamily(str, key, ctx) {
         state.suspended
       if (hasStopTarget) {
         // 当前回合平 abort（无 interrupt——命中 agent.mjs 回合收尾清池分支——全停）
-        // §20.3 站点 #11（第 24 批）：整批 / 会话级停 = stop（reason 载荷）
+        // AGENT-LOOP-SUBAGENT.md §6.12 站点 #11（第 24 批）：整批 / 会话级停 = stop（reason 载荷）
         if (state.processing && state.controller) state.controller.abort({ abortTrigger: "stop", abortDetail: "session-stop" })
         // 会话 abort 集合 = 链条内全部 controller（含 Ctrl+I/ContinueError 重建的旧
         // controller——children 不逃逸，round1 偏差 #3）。挂起态才标记 _suspAborted +
@@ -51,10 +51,10 @@ export function handleCtrlCFamily(str, key, ctx) {
       // 无目标可停 → 落空继续到下方分支（processing 已停 → 空闲态 exitArmed 双确认）
     }
     if (state.suspended) {
-      // §17 D-S9 + round2 偏差 #4（2026-09-02）+ §17.6 修订（2026-09-03）：挂起态
+      // AGENT-LOOP-ASYNC-POOL.md §6.8 D-S9 + round2 偏差 #4（2026-09-02）+ AGENT-LOOP-ASYNC-POOL.md §6.8 修订（2026-09-03）：挂起态
       // Ctrl+C = 武装窗口两级中止——一次按键直接清池中止全部后台子代理的误触代价高
       // （digest 刷屏时用户可能只想停住当前回合）；仿空闲态退出武装语义（同下方空闲态
-      // exitArmed 双确认分支）。§17.6 修订 ①：中止当前回合的 abort 带 interrupt
+      // exitArmed 双确认分支）。AGENT-LOOP-ASYNC-POOL.md §6.8 修订 ①：中止当前回合的 abort 带 interrupt
       // （无 message）——此前平 abort 命中 agent.mjs 回合收尾清池分支（aborted &&
       // !reason.interrupt → 无条件 _asyncSubagents.clear()），一次首按即误杀全部后台
       // 子代理（2026-09-03 用户两次实测——提示"再按才杀"与实际"一次就全杀"不符）；
@@ -80,7 +80,7 @@ export function handleCtrlCFamily(str, key, ctx) {
       return
     }
     if (state.processing && state.controller) {
-      // §17.6 D-C1（2026-09-03 紧急修复——processing 态曾无武装窗口，第一按直接平
+      // AGENT-LOOP-ASYNC-POOL.md §6.8 D-C1（2026-09-03 紧急修复——processing 态曾无武装窗口，第一按直接平
       // abort() → 命中 agent.mjs 回合收尾清池分支 → 一次 Ctrl+C 误杀全部后台子代理，
       // 用户两次实测被坑）：首按 = interrupt 语义（无 message——停当前回合不续跑——
       // interrupt 排除 agent.mjs 清池分支——后台池保留——agent-turn 区分不重建续跑）

package/src/tui/key-handler-edit.mjs

@@ -1,8 +1,9 @@
 import { C } from "./ansi.mjs"
 import { readClipboardText, insertPastedText } from "./clipboard.mjs"
+import { QUEUED_MAX_ITEMS } from "./queued-merge.mjs"
 
 /** 编辑族（2026-09-22 structure-debt §2.1 分族 5 · #226）：Tab 补全 / Ctrl+U 清框 /
- *  退格·删除 / Enter（多行换行 · 挂起单槽 · submit）/ 剪贴板文本与图片粘贴 / 可打印字符；
+ *  退格·删除 / Enter（多行换行 · 挂起队列 · submit）/ 剪贴板文本与图片粘贴 / 可打印字符；
  *  各块自 key-handler.mjs createKeyHandler 逐字搬移（仅去缩进）。
  *  路由 = 分派器 createKeyHandler 末族（其后无可达分支 —— 块内 return 即终结本次按键）。 */
 export function handleEditKeys(str, key, ctx) {
@@ -50,15 +51,15 @@ export function handleEditKeys(str, key, ctx) {
       render()
     } else {
       const text = state.input.join("").trim()
-      // §17 D-S5/F3/F7 + 偏差 #1 + INPUT-LOCK 单槽化（F-6——2026-09-09）：挂起态
-      // （suspended 或释放窗口 _suspPending）Enter = 新回合输入（非打断）——填
-      // pendingInput 单槽（至多一条待交接）由挂起会话调度；挂起会话内 busy（含 digest）
-      // 提交经 busy 门禁入同槽（F16 §4.1——两分支同槽、同款清理与唤醒）；输入框零干扰（F3）。
-      // 槽满（竞态防御——不覆盖不丢失）→ 吞 + 提示，文本保留在输入框。
+      // AGENT-LOOP-ASYNC-POOL.md §6.8 D-S5/F3/F7 + 偏差 #1 + INPUT-LOCK 队列受理（F-6——2026-09-09 · queue-visible 多槽
+      // 容量 8——2026-09-24）：挂起态（suspended 或释放窗口 _suspPending）Enter = 新回合输入
+      // （非打断）——填 pendingInput 队列（容量 QUEUED_MAX_ITEMS）由挂起会话调度；挂起会话内
+      // busy（含 digest）提交经 busy 门禁入同队列（F16 §4.1——两分支同队列、同款清理与唤醒）；
+      // 输入框零干扰（F3）。满队（第 9 条——竞态防御——不覆盖不丢失）→ 吞 + 提示，文本保留在输入框。
       if ((state.suspended || state._suspPending) && text && !text.startsWith("/")) {
         state.pendingInput ??= []
-        if (state.pendingInput.length > 0) {
-          pushLine(`[主会话处理中 —— 已有一条消息待发送，请等其处理完成后再发送]`, C.warn)
+        if (state.pendingInput.length >= QUEUED_MAX_ITEMS) {
+          pushLine(`[主会话处理中 —— 已排队 ${QUEUED_MAX_ITEMS} 条消息，请等其处理完成后再发送]`, C.warn)
           render()
           return
         }
@@ -68,6 +69,9 @@ export function handleEditKeys(str, key, ctx) {
         state.historyIndex = -1
         state._draft = null
         state.pendingInput.push(text)
+        // F4「新提交消息 → 恢复跟随」（§7.5 跟随——排队提交同列；与 turn-face.mjs submit 同款两行）
+        state.scroll = 0
+        state._followTail = true
         state._suspWake?.()
         render()
         return

package/src/tui/key-handler-search.mjs

@@ -1,5 +1,5 @@
 /** Perform search on state.lines, update state.search.matches and clamp index
- *  TUI-OOM-ROOTCAUSE（TUI.md §15.3.1 SEARCH_MATCH_CAP）：匹配计数上限——超限截断 +
+ *  TUI-OOM-ROOTCAUSE（TUI-SESSION-VIEW.md §5.1 SEARCH_MATCH_CAP）：匹配计数上限——超限截断 +
  *  `state.search.capped` 提示标志（渲染面提示行；次要无界面）。
  */
 import { SEARCH_MATCH_CAP } from "./display-budget.mjs"

package/src/tui/key-handler.mjs

@@ -44,7 +44,7 @@ export function createKeyHandler(ctx) {
     // 第 33 批（TUI §14.3(e) 键盘点）：模态分派**之前**——任意按键 = 用户在场 ⇒ 清 attention
     // 位（仅复位呈现态字段，按键语义 / 模态判定 / busy 门禁零改）。
     clearAttention(state, render)
-    // permission confirm: y/n/a (a = approve + AUTO ON); batch (§16 D-B1): a/o/n (Esc = deny)
+    // permission confirm: y/n/a (a = approve + AUTO ON); batch (D-B1): a/o/n (Esc = deny)
     // ——模态实现 key-modes.mjs handlePermissionMode（2026-09-03 D-S4）
     if (handlePermissionMode(str, key, { state, agent, pushLine, render })) return
 
@@ -110,7 +110,7 @@ export function createKeyHandler(ctx) {
     if (key.name === "up" || key.name === "down") { handleHistoryKeys(key, ctx); return }
     if (key.name === "left" || key.name === "right" || key.name === "home" || key.name === "end") { handleCursorKeys(key, ctx); return }
 
-    // 序 4：busy 门禁（key-handler-busy.mjs）——Enter 单槽受理 + 吞面四 / Tab 吞
+    // 序 4：busy 门禁（key-handler-busy.mjs）——Enter 队列受理（容量 8）+ 吞面四 / Tab 吞
     // （守卫 = busy 块内返回条件：processing 期仅 tab 与无 meta 的 Enter/回车 被吞，余键落空至编辑族）
     if (state.processing && (key.name === "tab" || ((key.name === "return" && !key.meta) || (str === "\r" && !key.meta)))) {
       handleBusyEnter(str, key, state, ctx)

package/src/tui/key-modes.mjs

@@ -34,7 +34,7 @@ export function denyModalForOwner(state, key, { pushLine, render } = {}) {
   return true
 }
 
-/** permission 确认模态：y/n/a（a = approve + AUTO ON）；batch（§16 D-B1）：a/o/n（Esc = deny）。
+/** permission 确认模态：y/n/a（a = approve + AUTO ON）；batch（D-B1）：a/o/n（Esc = deny）。
  *  `continue` / `retry` = y/n-only 族（判据单源 `isYesNoModal`——X8 跟进①：`retry` 框不
  *  广告 `a`，零会话级 AUTO 副作用）。
  *  consume：valid 键或 Esc 走 resolve 分支；其余键静默吞掉（模态独占）。 */

package/src/tui/layout.mjs

@@ -5,10 +5,10 @@
  *
  *   header → conversation → subagent 面板 → todo → picker → permission → input → status
  * Running subagent activity renders in a FIXED bottom panel between the
- * conversation and the todo panel (AGENT-LOOP.md §7.2.1) — full adaptive height
+ * conversation and the todo panel (docs/cli/design/TUI.md §6.8) — full adaptive height
  * (the conversation shrinks); compressed away first on small terminals (to 0 =
  * hidden, data stays in the buffer). Done children are frozen into the
- * conversation stream (§7.2 D4, unchanged). Output panels abolished (§7.2 D6).
+ * conversation stream (unchanged). Output panels abolished.
  * Fixed panels deducted first, conditional panels allocated by priority, remaining space to conversation.
  */
 import { layoutInput, wrapText } from "./render.mjs"
@@ -109,7 +109,7 @@ export function computeLayout(state, { cols, rows }) {
   // Squeeze target: the divider line yields first under small terminals (the
   // task rows themselves never compress away — put() truncates by panel h).
 
-  // Subagent panel (§7.2.1 D1): RUNNING blocks only, between conversation and
+  // Subagent panel (docs/cli/design/TUI.md §6.8 D1): RUNNING blocks only, between conversation and
   // todo. Height = the FULL rendered height of every running block (F2 — fully
   // adaptive, no cap; the conversation shrinks accordingly). Precomputed here
   // via renderSubagentPanel (neutral module, no layout↔render-frame cycle);
@@ -152,7 +152,7 @@ export function computeLayout(state, { cols, rows }) {
   let todoFinalH = taskPanelH
   const overflow = fixedH + convH - rows
   if (overflow > 0) {
-    // 压缩链第 1 级（§7.2.1 NF1/评审 #2 措辞统一）：subagent 面板最先让位——
+    // 压缩链第 1 级（docs/cli/design/TUI.md §6.8 NF1/评审 #2 措辞统一）：subagent 面板最先让位——
     // 可压缩至 0 隐藏（运行中活动仍在缓冲区不丢），输入框/状态栏/会话区不可挤没。
     let afterSub = fixedH
     if (subagentH > 0) {
@@ -212,7 +212,7 @@ export function computeLayout(state, { cols, rows }) {
 }
 
 /**
- * §7.2.1 评审 #4：面板部分压缩（subagentFinalH < subagentLines.length）时 render-frame
+ * docs/cli/design/TUI.md §6.8 评审 #4：面板部分压缩（subagentFinalH < subagentLines.length）时 render-frame
  * 实际显示的行——**保底截断**：分隔线 + 末尾 (h-1) 行（最新启动区块优先；小终端上仍
  * 能看到最新子 agent 活动，旧 slice(0,h) 保留顶部会把最新活动裁掉）。分隔线始终保留
  * （面板边界语义）。h ≥ 全长 → 原样；h = 0 → []（layout 侧 panels.subagent 已为 null，

package/src/tui/ledger-surface.mjs

@@ -5,6 +5,11 @@
  *
  * 三面语义（启动行 / 变化行 / 状态位）见核档头注；判活展示（F-LX1）亦随归核自动带上——
  * 本档零实现、零复刻（KD-M2-3）。
+ *
+ * 两端契约（#233——端壳与核形一致）：`startLedgerSurface` **恒同步返回 `{ dispose }`**——
+ * 核句柄异步就绪（动态 import）后桥接；载入失败 ⇒ 空句柄（`dispose` 恒可调）；`dispose()`
+ * 早于核就绪 ⇒ 置位且**跳过启动**（核侧零调用——零周期；N1 降级不崩）。调用点因此恒可按
+ * 同步形态挂进程退钩（`process.on("exit", () => handle.dispose())`）。
  */
 import { C } from "./ansi.mjs"
 
@@ -18,15 +23,31 @@ function loadCore() {
   return _core
 }
 
+/** 测试注入缝（`_setLedgerDirForTest` 同款缝族）：`fn` ⇒ 载核改走该桩；`null` ⇒ 回退原生
+ *  `loadCore`（`??` 默认）；用例 `afterEach` 复位。 */
+let _loadCoreForTest = null
+export function _setLoadCoreForTest(fn) { _loadCoreForTest = fn }
+const loadCoreNow = () => (_loadCoreForTest ?? loadCore)()
+
 /** 单次扫描（直驱面——直通核实现；TUI 色表 `C` 注入）。 */
 export async function runLedgerScan(opts = {}) {
-  const core = await loadCore()
+  const core = await loadCoreNow()
   return core.runLedgerScan({ ...opts, colors: C })
 }
 
-/** TUI 挂载（首扫 + 周期——直通核实现；载入失败 → 空句柄 = 无周期，N1 降级不崩）。 */
+/** TUI 挂载（首扫 + 周期——直通核实现）：**恒同步返回 `{ dispose }`**——核句柄异步就绪后
+ *  桥接；载入失败 ⇒ 空句柄（无周期，N1 降级不崩）；`dispose()` 早于核就绪 ⇒ 置位且
+ *  **跳过启动**（核侧零调用——零周期）。 */
 export function startLedgerSurface(ctx = {}) {
-  return loadCore()
-    .then((core) => core.startLedgerSurface({ ...ctx, colors: C }))
-    .catch(() => ({ dispose() {} }))
+  let disposed = false
+  let handle = null
+  loadCoreNow()
+    .then((core) => { if (!disposed) handle = core.startLedgerSurface({ ...ctx, colors: C }) })
+    .catch(() => { /* 载入失败 ⇒ 空句柄（N1） */ })
+  return {
+    dispose() {
+      disposed = true
+      handle?.dispose?.()
+    },
+  }
 }

package/src/tui/lifecycle-records.mjs

@@ -0,0 +1,199 @@
+/**
+ * lifecycle-records.mjs — 消化生命周期面记录承载件（#726 跨端消化面恢复批 —— CLI 承接面）。
+ *
+ * 机制单源 = `docs/core/design/SESSION.md` §6.26（记录形 ∥ 写缝 ∥ 读缝 ∥ 重建义务 ∥ 容差登记）；
+ * CLI 承接细则 = `docs/cli/design/TUI-SESSION-VIEW.md` §6。本档 = 三写点 + 恢复面的**单一实现**：
+ *   ① 记录形构建：`digest` 三型（start ∥ cap ∥ end）∥ `subagent` 快照（meta ∥ rows——rows 保尾 ≤500）；
+ *   ② 痕行文本：digest 记录的可见行文案——live（`digestTurn` ∥ cap 分支）与重建（`historyToLines`）同调；
+ *   ③ 重建：`subagent` 记录 ⇒ `_frozenSubTask` 合成件（渲染端零改消费——折叠头 + tail-3）；
+ *   ④ 终态行回扫：end 记录页内缺席本轮 start ⇒ `store.page` 向更早逐段回读补齐 `n`（跨页零损）。
+ * 写点三处 = `suspension-drive.mjs` `digestTurn` ∥ `agent-turn.mjs` cap 分支 ∥ `subagent-freeze.mjs` `freezeSubTaskLines`。
+ */
+import { t } from "@thincoder/core/i18n.mjs"
+import { RECORD_SEG_MESSAGES } from "@thincoder/core/session-store.mjs"
+import { C } from "./ansi.mjs"
+
+/** rows 保尾上界（显示行——§6.26「有界保尾」：超界弃最旧 ⇒ 前置省略标记行，标记自身不占额度）。 */
+export const RECORD_ROWS_MAX_LINES = 500
+
+/** 写缝载体（`state._agent` ∥ `ctx.agent`——端侧钉定二源，生产同对象；双缺 ⇒ null ⇒ 核口零动作）。 */
+export function recordCarrier(state, agent) {
+  return state?._agent ?? agent ?? null
+}
+
+// ─── ① 记录形构建（写点三处）─────────────────────────────────────────────
+
+/** digest 起跑记录（起跑两行同点）：`n` = 起跑待消化数（可 0）；`tier` 两档；ask 档携 `from`/`msg`。 */
+export function digestStartRecord({ n, upstream, ask }) {
+  return { kind: "digest", status: "start", n, tier: upstream ? "ask" : "digest", ...(ask ?? {}) }
+}
+
+/** digest 撞帽记录（cap 行同点；CLI 现无 auto 档产者——读取面按契约前向兼容）。 */
+export function digestCapRecord(turns) {
+  return { kind: "digest", status: "cap", mode: "stop", turns }
+}
+
+/** digest 收尾记录（终态行同点）：`ok` ∥ `ms`（行文案 `seconds` 由同一 `ms` 派生——同值单算式）。 */
+export function digestEndRecord({ ok, ms }) {
+  return { kind: "digest", status: "end", ok, ms }
+}
+
+/** subagent 归档快照记录（冻结载体行插入同点）：meta = 冻结时点块头事实（含 `pool`/`queued?`——§6.26）
+ *  ∥ rows = 块内容行集（保尾 ≤500）。#790：`key` 写面归一 = 规范形 `sub:<role>#<id>`。 */
+export function subagentRecord(sub) {
+  const localKey = String(sub.key ?? "")
+  const meta = {
+    key: localKey.startsWith("sub:") ? localKey : `sub:${localKey}`,
+    role: sub.role ?? null,
+    model: sub.model ?? null,
+    startedAt: sub.started ?? null,
+    doneAt: sub.doneAt ?? null,
+    turn: sub.turn ?? null,
+    maxTurns: sub.maxTurns ?? null,
+    status: sub.stopped ? "stopped" : sub.lastError ? "error" : "done",
+  }
+  if (sub.queued) meta.queued = true // 排队（未启动）⇒ 重建面 waiting 标注（`pool` 不写——未知）
+  else meta.pool = sub.async === true // 非排队显式两写（VSC 头段在场性判据 = `pool != null`——缺省会藏段）
+  if (sub.lastError) meta.error = sub.lastError // §6.26 meta `error?`（块头事实——重建面还原冻结头 errPart）
+  return { kind: "subagent", meta, rows: boundRows(rowsOf(sub)).map(({ kind, text }) => ({ kind, text })) }
+}
+
+/** 块内容行集（条目形 `{kind,text}` 同备；trim 标记随行——保尾裁量时不占额度）。 */
+function rowsOf(sub) {
+  const out = []
+  for (const b of sub.blocks ?? []) {
+    if (!b || typeof b.text !== "string") continue
+    const row = { kind: typeof b.kind === "string" ? b.kind : "text", text: b.text }
+    if (b._trimMarker === true) row._trimMarker = true
+    out.push(row)
+  }
+  return out
+}
+
+/** 行显示行数（核 `countBlockLines` 同式：按 `\n` 切分、文末换行不计）。 */
+function rowLines(row) {
+  const lines = String(row?.text ?? "").split("\n")
+  return lines[lines.length - 1] === "" ? lines.length - 1 : lines.length
+}
+
+/** rows 保尾上界（§6.26「有界保尾」）：超界弃最旧 ⇒ 前置省略标记行（`N` = 实弃显示行数、
+ *  标记自身不占额度）；单行超界保末行（行 = 最小单元，不切行中——桌面归档先例同式）。 */
+function boundRows(rows) {
+  const list = Array.isArray(rows) ? rows : []
+  const isMarker = (r) => r?._trimMarker === true
+  const cost = (r) => (isMarker(r) ? 0 : rowLines(r))
+  let total = 0
+  let start = list.length
+  for (let i = list.length - 1; i >= 0; i -= 1) {
+    const n = cost(list[i])
+    if (total + n > RECORD_ROWS_MAX_LINES) break
+    total += n
+    start = i
+  }
+  if (start === list.length && list.length > 0) start = list.length - 1 // 单行超界：保末行（保尾）
+  const kept = [...list.slice(0, start).filter(isMarker), ...list.slice(start)]
+  if (kept.length === list.length) return list // 未超界：原引用（零写）
+  let dropped = 0
+  for (let i = 0; i < start; i += 1) dropped += cost(list[i])
+  return [{ kind: "meta", text: `… [rows truncated: ${dropped} lines omitted]` }, ...kept]
+}
+
+// ─── ② 痕行文本（live ∥ 重建同调——单一实现零副本）─────────────────────────
+
+/** digest 记录 ⇒ 痕行（文案与活流同算式）。`startN` = end 行的本轮起跑数（调用面解析——
+ *  页内直用 ∥ 存储回扫）；缺省 / 非正数 / `ms` 非数 ⇒ 零行（活流同门 `pend0 > 0`）。 */
+export function digestTraceLines(rec, startN = null) {
+  if (rec?.kind !== "digest") return []
+  if (rec.status === "start") {
+    const ask = rec.tier === "ask" && rec.from !== undefined ? { from: rec.from, msg: rec.msg } : null
+    const lines = [{ text: ask ? t("digest.turnLabelAsk", ask) : t("digest.turnLabel"), color: C.dim }]
+    if (rec.n > 0) lines.push({ text: t("digest.start", { n: rec.n }), color: C.dim })
+    return lines
+  }
+  if (rec.status === "cap") return [{ text: t("digest.capStop", { turns: rec.turns }), color: C.warn }]
+  if (rec.status === "end") {
+    if (!Number.isFinite(startN) || startN <= 0 || !Number.isFinite(rec.ms)) return []
+    const seconds = (rec.ms / 1000).toFixed(1) // 与记录 `ms` 同值单算式
+    return [{ text: t(rec.ok === false ? "digest.aborted" : "digest.done", { n: startN, seconds }), color: C.dim }]
+  }
+  return []
+}
+
+// ─── ③ 重建（读面）：subagent 记录 ⇒ 合成件 ────────────────────────────────
+
+/** subagent 记录 ⇒ `_frozenSubTask` 合成件（重建面；渲染端零改消费——折叠头 + tail-3 原式）。
+ *  meta 块头事实逐项回填（渲染端读面：started→elapsed ∥ turn/maxTurns ∥ stopped ∥ error→errPart）；
+ *  #790：`pool`/`queued` ⇒ CLI 本地两事实（`async`/`queued`）∥ `key` 剥 `sub:` 前缀（显示 = 本地无前缀形）。 */
+export function synthSubTask(rec) {
+  const meta = rec?.meta ?? {}
+  const rows = Array.isArray(rec?.rows) ? rec.rows : []
+  const blocks = rows.map((r) => ({ kind: typeof r?.kind === "string" ? r.kind : "text", text: String(r?.text ?? "") }))
+  const doneAt = Number.isFinite(meta.doneAt) ? meta.doneAt : null
+  const started = Number.isFinite(meta.startedAt) ? meta.startedAt : (doneAt ?? 0)
+  return {
+    key: String(meta.key ?? "").replace(/^sub:/, ""), // #790：读面容旧形——剥离判别（折叠键 ∥ 显示 = 本地无前缀形）
+    role: meta.role ?? null,
+    model: meta.model ?? null,
+    started,
+    done: true,
+    doneAt: doneAt ?? started,
+    turn: meta.turn ?? null,
+    maxTurns: meta.maxTurns ?? null,
+    async: meta.pool === true, // #790：记录 `pool` ⇒ 折叠头模式词（§6.26 命名映射：记录 pool ⇄ 本地 async）
+    queued: meta.queued === true, // #790：排队冻结 ⇒ 折叠头 waiting 标注
+    // #795 残项批：停止面词集扩三词（stopped ∥ cancelled ∥ terminated——词面判据单源 = §6.26；VSC/桌面写 cancelled）。
+    stopped: meta.status === "stopped" || meta.status === "cancelled"
+      || meta.status === "terminated",
+    lastError: typeof meta.error === "string" ? meta.error : null,
+    blocks,
+    _charCount: blocks.reduce((n, b) => n + b.text.length, 0), // 行集字符和（§5.4 账实一致——恢复直算同源）
+  }
+}
+
+// ─── ④ 终态行回扫（重建面：跨页分裂 ⇒ 存储逐段回读）─────────────────────────
+
+/** 页内（含 ±1 页沿）本轮 start 直用：自 `idx` 向前命中最近 digest start ⇒ 其 `n`（无 ⇒ null）。 */
+function pageStartN(records, idx) {
+  for (let j = idx - 1; j >= 0; j -= 1) {
+    const r = records[j]
+    if (r?.kind === "digest" && r.status === "start") return typeof r.n === "number" ? r.n : null
+  }
+  return null
+}
+
+/** end 记录本轮 start 的 `n`（重建面解析序 = 预解析注记 `_startN`（跨页回扫产物）→ 页内回扫）。 */
+export function resolvedStartN(records, idx) {
+  const m = records?.[idx]
+  if (m?._startN !== undefined) return m._startN
+  return pageStartN(records, idx)
+}
+
+/** 存储回扫：`store.page` 向更早逐段回读，至命中本轮 start 止（跨页零损——容差①于 CLI 不成立）。 */
+export function scanStoreForStartN(store, endIdx) {
+  if (!store?.page || !Number.isFinite(endIdx) || endIdx <= 0) return null
+  let hi = Math.floor(endIdx)
+  while (hi > 0) {
+    const lo = Math.max(0, hi - RECORD_SEG_MESSAGES)
+    let messages = []
+    try { messages = store.page(lo, hi, { margin: 0 })?.messages ?? [] } catch { return null }
+    for (let k = messages.length - 1; k >= 0; k -= 1) {
+      const r = messages[k]
+      if (r?.kind === "digest" && r.status === "start") return typeof r.n === "number" ? r.n : null
+    }
+    hi = lo
+  }
+  return null
+}
+
+/** 预解析（调用面 = `restoreLines` ∥ `createLoadOlder`——持有存储读口）：页内（含 ±1 页沿）缺席
+ *  本轮 start 的 end ⇒ 回扫 `n` 并注记 `_startN`（重建注记——不动存储形）。 */
+export function resolveSplitTerminalNs(records, base, store) {
+  if (!Array.isArray(records) || !store?.page || !Number.isFinite(base)) return
+  for (let k = 0; k < records.length; k += 1) {
+    const m = records[k]
+    if (m?.kind !== "digest" || m.status !== "end" || m._startN !== undefined) continue
+    if (pageStartN(records, k) !== null) continue // 页内直用——零回扫
+    const n = scanStoreForStartN(store, base + k)
+    if (n !== null) m._startN = n
+  }
+}