@fanchao8609/agent_brain_sync 1.7.7 → 1.7.8

package/README.md

@@ -59,7 +59,7 @@ abs init          # 建 .brain/ 图谱，只需一次
 ### 日常命令
 
 ```bash
-abs load                       # 开机读状态（路线 + 看板 + 最近流水）
+abs load                       # 开机读状态（Rules + 图谱计数 + 看板 + 最近流水）
 abs todo                       # 看板 Today / In Progress / Blocked / Done
 
 abs todo add     TASK-1 --note "要做什么"
@@ -83,7 +83,7 @@ abs update                                # 升级到最新版并刷新四宿主
 > `abs todo start` 与 `abs todo add` 等价（都登记任务）。
 > 旧版 `abs task ...` / `abs board` 已改名，会报错并提示新写法。
 > `abs wrapup` / `abs teardown-check` 是 hook 内部命令，无需手动调用。
-> **升级后分区名自动归一**：`abs load` 每次都会顺手核对 `index/log/todo` 三文件结构，旧的英文/中文分区名（如 `## 当前路线 (Roadmap)` → `## Roadmap`、`# 🗂 图谱索引` → `# 🗂 Graph Index`）会被自动改回标准；缺分区自动补建，无头文件只提醒不自动改。
+> **升级后分区名自动归一**：`abs load` 每次都会顺手核对 `index/log/todo` 三文件结构，旧的分区名（如 `# 🗂 图谱索引` → `# 🗂 Graph Index`）会被自动改回标准；缺分区自动补建，无头文件只提醒不自动改。
 
 ### 工作流
 

package/bin/abs.js

@@ -2,7 +2,7 @@
 // bin/abs.js — abs CLI 入口。
 // abs <cmd> [args]
 // 命令: init / board / status / load / task / install / uninstall / help
-import { cmdInit, cmdStatus, cmdLoad, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive } from '../src/store.js';
+import { cmdInit, cmdStatus, cmdLoad, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive, cmdTopic } from '../src/store.js';
 import { setUser, getUser, userConfigPath } from '../src/userconfig.js';
 import { runInstall, runUninstall } from '../src/install.js';
 import { readFileSync } from 'node:fs';
@@ -73,6 +73,7 @@ const FLAG_SPEC = {
   'as': { type: 'string' },
   'payload': { type: 'string' },
   'tags': { type: 'string' },
+  'state': { type: 'string' },
   'keep-days': { type: 'string' },
   'help': { type: 'boolean' },
   'dry-run': { type: 'boolean' },
@@ -142,6 +143,7 @@ function parseArgv(args) {
     section: values.section,
     note: values.note,
     as: values.as,
+    state: values.state,
     payload: values.payload,
     tags: values.tags,
     help: !!values.help,
@@ -165,7 +167,8 @@ const usage = `abs — agent-brain-sync 记忆工具
 
 读:
   abs load                   开机读状态 (index/todo/log)
-  abs todo                   任务看板 Today / In Progress / Blocked / Done
+  abs todo                   任务看板 Topics / Backlog / Today / Blocked / Done
+  abs topic                  话题树（讨论轨道，含已证伪）；无参=查看
   abs index                  图谱索引 index.md
   abs log                    流水 log.md
   abs status                 当前项目 + 图谱概要
@@ -174,6 +177,10 @@ const usage = `abs — agent-brain-sync 记忆工具
   abs todo add     <id> [--note ..] [--section ..]  登记任务 (start 同义)
   abs todo note    <id> --note "断点/进度"   实时落 ↳ 断点 行
   abs todo blocked <id> --note "卡点原因"    移入 Blocked 区
+  abs topic new    "#1 标题" [--state 状态] [--note 结论]   登记/更新话题
+                    状态: 进行中|已结论|已否决|待验证|已落地|未落地
+                    子话题: abs topic new "#1.1 标题"（父子由 id 点分层级自动推）
+  abs topic promote <id>      讨论成熟、要动手 → 移进 Today（同 id 追踪，不复制）
   abs todo done    <id> [--as 落地|否决|仅方案]    完成；结语标明到底"做成了没有"
                                默认 落地。否决=评估后不做(含做了又撤)；仅方案=只设计过
                                不加结语或结语失真会让下一个会话把"想过"当成"做完了"。
@@ -337,6 +344,28 @@ async function main() {
         rejectExtra(opts._, 'abs status');
         console.log(await cmdStatus({ dir: opts.dir }));
         break;
+      // abs topic —— 分区（话题树）：无子命令=树视图；带子命令=话题写操作
+      case 'topic': {
+        const [sub, id, ...rest2] = opts._;
+        if (!sub) {
+          rejectExtra([id, ...rest2].filter(Boolean), 'abs topic');
+          console.log(await cmdTopic({ dir: opts.dir }));
+          break;
+        }
+        const r = await cmdTopic({
+          dir: opts.dir,
+          action: sub,
+          id,
+          // 标题 = 第 3 个位置参数起的全部（含空格），未给则用 id 本身
+          title: rest2.join(' ') || undefined,
+          state: opts.state,
+          conclusion: opts.note,
+          full: opts.full,
+          clear: opts.clear,
+        });
+        console.log(r);
+        break;
+      }
       // abs todo —— 无子命令=看板；带子命令=任务写操作
       case 'todo': {
         const [sub, id, ...rest2] = opts._;

package/bin/mcp.js

@@ -93,7 +93,7 @@ tool(
 
 tool(
   'abs_load',
-  '开机读状态：index 路线 + todo 看板 + 最近 log。跨会话续接的入口。',
+  '开机读状态：index 的 Rules + 图谱计数 + todo 看板 + 最近 log。跨会话续接的入口。',
   { cwd: z.string().describe('项目根目录（.brain/ 所在处）') },
   async ({ cwd }) => {
     const root = await findBrainRoot(cwd || process.cwd());

package/hooks/abs.opencode.ts

@@ -51,6 +51,11 @@ const server = async ({ client, directory }) => {
     "2) 实际做完漏登记的 abs todo done <id>，做到一半的 abs todo note <id> --note \"断点\"；\n" +
     "3) 值得留的经验 abs note \"...\"（宁少勿滥，能从代码 grep 到的不记）；\n" +
     "4) abs log \"完成 X：...\" 记一行工作成果，新页同步进 index。\n" +
+    // 话题对账：Topics 区只放「正在讨论」的话题。
+    "5) 话题对账 abs topic：本会话在讨论什么→abs topic new \"#N 标题\" --state 进行中；" +
+    "已收尾的话题用 --state 已结论/已否决（会自动移出树），停下来的事落 Blocked。\n" +
+    "   ⚠ Topics 区只放正在讨论的话题；五态（已结论/已否决/已落地/未落地/待验证）都会离开树，" +
+    "离开前先把结论写进 sources/（abs note），否则就丢了。\n" +
     "简洁执行，不要复述本条提醒。若本次确实没有可沉淀产出，直接回一句\"无可沉淀\"即可。"
 
   // bash 里只跑查询类命令不算改文件 (与 pi 侧 READONLY_CMD 同义, 但生成代码里要写进模板串)

package/hooks/abs.pi.ts

@@ -6,6 +6,13 @@
  * session_shutdown 额外触发 abs wrapup: 把当前项目未完成任务快照到 wrapup.log (跨会话收尾保险)。
  * agent_end 收尾注入: 本会话真改过文件 + .brain 今日无记录 → 注入一条收尾指令, 逼 agent 走收尾循环
  *   (被动记日志不够 —— 没人提醒就不会有人收尾)。每会话最多一次, 且已收尾后不再打扰。
+ *
+ * 素材累积 (B+C, 2026-09-13 用户定): 话题在会话中途连续产生, 而收尾提醒只在会话末尾——
+ *   用一次性提醒追持续事件 = 记录率 7% (14 条话题只落 1 条)。故在能机械观察的锚点上累积素材:
+ *     - before_agent_start (用户发话 = 天然话题边界) → 记用户原话
+ *     - turn_end (每轮结束) → 记改过哪些文件
+ *   累积在**内存**(下方 sessionNotes), 收尾时拼进注入提示 —— **不落盘**。
+ *   用户明确不要新文件(曾做过 .brain/topics.log, 已拆)。
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import { appendFile, mkdir, readFile, stat } from "node:fs/promises"
@@ -15,6 +22,27 @@ import { spawn } from "node:child_process"
 
 const ABS_BIN = "@@ABS_BIN@@"
 
+// 素材累积锚点：会话内存里累积，收尾时拼进注入提示。**不落盘、不 spawn、不然上下文**。
+// 预算：只留最近几条（收尾回忆只需线索，不需全史）。
+const NOTES_MAX = 12
+const NOTE_LEN = 120
+const sessionNotes: string[] = []
+
+function addNote(kind: string, text: string): void {
+  const clean = String(text ?? "").replace(/\s+/g, " ").trim().slice(0, NOTE_LEN)
+  if (!clean) return
+  sessionNotes.push(`${kind}: ${clean}`)
+  if (sessionNotes.length > NOTES_MAX) sessionNotes.shift()
+}
+
+/** 把本会话素材拼成一段（收尾注入用）。无素材则空字符串。
+ * 用途：让 AI 据线索**归纳**话题，而不是凭记忆回想整场对话（那正是 7% 记录率的原因）。 */
+function notesBlock(notes: string[]): string {
+  if (!notes.length) return ""
+  return "   本会话素材（hook 机械记录，供归纳）\n" +
+    notes.map((n) => "     · " + n).join("\n") + "\n"
+}
+
 async function logHook(evt: string): Promise<void> {
   const dir = process.env.ABS_LOG_DIR || join(homedir(), ".abs", "log")
   const d = new Date()
@@ -73,17 +101,51 @@ async function loggedToday(brain: string): Promise<boolean> {
     const d = new Date()
     const pad = (n: number) => String(n).padStart(2, "0")
     const today = d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate())
-    // 注意: 这里是真实 TS, 不是生成代码的模板字符串。用拼接形式避免反斜杠逃逸歧义。
-    return new RegExp("^## \\[" + today + " \\d{2}:\\d{2}\\]", "m").test(txt)
+    // 只认**工作成果**条目（kind=dev），不能只看“今天有没有行”。
+    // 坑（2026-09-13 实测）：`abs note` 也写 log.md（kind=note），
+    // 旧判据 (^## [今天 HH:MM]) 把“沉淀了一条经验”当成“今天已收尾”→
+    // 整天不再提醒 → 新冒的话题全部漏登（用户实报“话题还是没进 Topics”）。
+    // 行格式: `## [YYYY-MM-DD HH:MM] [[name]] dev | 内容`。
+    return new RegExp("^## \\[" + today + " \\d{2}:\\d{2}\\] (?:\\[\\[[^\\]]+\\]\\] )?dev \\|", "m").test(txt)
   } catch { return false }
 }
 
 export default function absPiHook(pi: ExtensionAPI): void {
-  pi.on("session_start", () => logHook("session_start").catch(() => {}))
-
-  // 收尾注入: 每个会话最多一次, 避免反复打扰。
+  // 收尾注入的节流状态。声明在**外层** + 在 session_start 里重置：
+  // 否则同一进程的第二个会话会继承上一个会话的 true，永久不再提醒
+  // （2026-09-13 实测：同一天多个会话时后半场全部静默）。
   let teardownNudged = false
   let agentEndSeen = false
+
+  pi.on("session_start", () => {
+    teardownNudged = false
+    agentEndSeen = false
+    return logHook("session_start").catch(() => {})
+  })
+
+  // ---- 素材锚点（不烧上下文、不注入消息、不 spawn、不落盘）----
+  // 用户发话 = 天然的话题边界。这是 C 路线：你说的每句话都是一个锚点。
+  pi.on("before_agent_start", async (event: any, _ctx: any) => {
+    addNote("user", String(event?.prompt || ""))
+  })
+
+  // 每轮结束 = 这轮干了什么（改了哪些文件）。机械事实，供收尾时回忆。
+  pi.on("turn_end", async (event: any, _ctx: any) => {
+    const files = new Set<string>()
+    for (const r of event?.toolResults || []) {
+      const name = String(r?.toolName || "")
+      if (!WRITE_TOOLS.has(name)) continue
+      if (r?.isError) continue
+      const f = r?.input?.file_path ?? r?.args?.file_path ?? r?.input?.path ?? r?.args?.path
+      if (f) files.add(String(f))
+      else if (name === "bash") {
+        const cmd = String(r?.input?.command ?? r?.args?.command ?? "")
+        if (!READONLY_CMD.test(cmd)) files.add("bash: " + cmd.slice(0, 60))
+      }
+    }
+    if (files.size) addNote("tool", [...files].join(", "))
+  })
+  // 收尾注入: 每个会话最多一次, 避免反复打扰。
   pi.on("agent_end", async (event: any, ctx: any) => {
     if (teardownNudged) return
     const cwd = (ctx && ctx.cwd) || process.cwd()
@@ -97,9 +159,16 @@ export default function absPiHook(pi: ExtensionAPI): void {
     }
     if (!brain) return // 无图谱=不在这项目沉淀, 不打扰
     if (!hasWriteWork(event?.messages ? collectToolResults(event.messages) : [])) return
-    if (await loggedToday(brain)) return // 今天已收尾过
+    // 今日已收尾 → 只在**本会话还没真正干事**时才静默。
+    // 旧行为：今天 log 有一行就整天闭口 —— 于是「收尾过之后新冒的话题」全部没人提醒
+    // （2026-09-13 实报：web 版聊了一整轮，Topics 里一条没有）。
+    // 注意不能用 sessionNotes.length 当判据：用户每说一句话就会 push 一条，
+    // 那会让 nudge 每轮都触发（噪音）。判据保持「今天已收尾」但配合下面的笔记消费。
+    if (await loggedToday(brain)) return
     teardownNudged = true
     await logHook("agent_end:teardown-nudge").catch(() => {})
+    // 素材交给 AI 后清空：同一会话再触发时不该重复喂旧料。
+    const notes = sessionNotes.splice(0, sessionNotes.length)
     try {
       pi.sendUserMessage(
         "[abs 收尾提醒] 本会话改过文件但 .brain/ 今天还没有记录。请立即走收尾循环：\n" +
@@ -107,6 +176,14 @@ export default function absPiHook(pi: ExtensionAPI): void {
         "2) 实际做完漏登记的 abs todo done <id>，做到一半的 abs todo note <id> --note \"断点\"；\n" +
         "3) 值得留的经验 abs note \"...\"（宁少勿滥，能从代码 grep 到的不记）；\n" +
         "4) abs log \"完成 X：...\" 记一行工作成果，新页同步进 index。\n" +
+        // 话题对账：只放「正在讨论」的话题。终止态（含已否决/已结论/未落地/待验证）
+        // 一律不入树 —— 结论落 abs note，暂停的事落 Blocked 当任务追踪。
+        "5) 话题对账 abs topic：据下方素材归纳本会话讨论过什么→" +
+        "abs topic new \"#N 标题\" --state 进行中；" +
+        "已收尾的用 --state 已结论/已否决（会自动移出树），停下来的落 Blocked。\n" +
+        "   正在动手的话题: `abs topic promote #N` 移进 Today（同 id 连续追踪）。\n" +
+        "   ⚠ Topics 区只放正在讨论的话题；五态都会离开树，离开前先把结论写进 sources/（abs note）。\n" +
+        notesBlock(notes) +
         "简洁执行，不要复述本条提醒。若本次确实没有可沉淀产出，直接回一句\"无可沉淀\"即可。",
         { deliverAs: "followUp" },
       )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanchao8609/agent_brain_sync",
-  "version": "1.7.7",
+  "version": "1.7.8",
   "description": "agent-brain-sync: 跨会话 AI 编码记忆 — hook 纯触发 + CLI/MCP 读写 .brain markdown 图谱, 防并发写保护。",
   "type": "module",
   "license": "MIT",

package/skill/SKILL.md

@@ -15,7 +15,7 @@ Obsidian 可直接打开的 Markdown 图谱（`.brain/`）做统一落点。
 
 ```bash
 # 读
-abs load                     # 开机读状态（Roadmap + Rules + todo + 最新 log）
+abs load                     # 开机读状态（Rules + 图谱计数 + todo + 最新 log）
 abs todo                     # 看板（Done 折成计数；明细 abs todo --full）
 abs index / abs log          # 完整 index.md / log.md
 abs status                   # 当前项目 + 图谱概要
@@ -101,8 +101,7 @@ abs config [set user <名字>]                   # 使用者姓名（写操作
 
 | 分区 | 放什么 | 怎么用 |
 |---|---|---|
-| `## Roadmap` | 方向：已落地 / 下一阶段候选 | **写方向不写版本号**（复述第三方状态必然漂移）。有界的，load 原样展示 |
-| `## Rules` | 本项目铁律 | 见下 |
+| `## Rules` | 本项目铁律 | 见下（load 里**原样全量**输出，不折） |
 | `## Concepts` `## Entities` `## Sources` `## Syntheses` `## Sessions` | 各类页的清单 | 每页一行 `- [[slug]] — 一句话`（`abs note`/建归档页会自动登记），load 里折成计数 |
 
 **`## Rules` 区**：铁律清单，`abs load` 每次都全量读（代码里明确不折它）。
@@ -153,7 +152,7 @@ Done 区由 `abs wrapup` 在会话结束时自动把「超 3 天且整天都已
 
 图谱已存在；收到第一个核心开发指令**之前**走这条链载入上下文：
 
-1. **读状态**：`abs load`（或 MCP `abs_load`）读 index 路线 + Rules + todo 看板 + 最近 log。
+1. **读状态**：`abs load`（或 MCP `abs_load`）读 index 的 Rules + 图谱计数 + todo 看板 + 最近 log。
    > **开工前先看 `## Rules`** —— 那是本项目踩过坑后定下的硬规则，每条都是曾经付过代价的。
    > 违反的代价一般是丢数据/静默失效/白干活，而它就在 load 输出里，没有理由不看。
    >
@@ -162,7 +161,7 @@ Done 区由 `abs wrapup` 在会话结束时自动把「超 3 天且整天都已
    > - **index 页面清单** → 各分区只给页数（concept 清单占 load 输出 64%，隨图谱线性增长）
    > - 「最近动作」每条按语义边界收口到 220 字符
    >
-   > **路线(Roadmap) 与 Rules 两区原样保留** —— 那是 load 要传达的状态本身（代码里明确不折）。
+   > **`## Rules` 区原样保留** —— 那是 load 要传达的状态本身（代码里明确不折）。
    > 要全量明细：`abs todo --full` / `abs index`，或直接读 `.brain/` 文件、
    > `.brain/sessions/<日期>-todo归档.md`。
 2. **对账滞留（强制，别跳过）**：若 `abs load` 顶部出现 `⏳ 上会话滞留`，说明上会话有任务做完/做到一半就断了。**先收尾再开工**：

package/src/store.js

@@ -4,7 +4,7 @@ import { promises as fs } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import { requireBrain, brainPath, absLogDir, BRAIN_DIR } from './index.js';
 import { requireUser, atTag, getUser } from './userconfig.js';
-import { addTask, upsertTask, boardText, readTodo, ensureTodo, todoTemplate, today, localStamp, setBreakpoint, moveBlocked, insertDoneGrouped, idOfTaskLine, archiveDoneInText, renderArchivePage, renderArchiveBody, DONE_KINDS, withDoneKind, doneKindOf, doneDateOf, collapseDone, SEC, rebuildStructure } from './todo.js';
+import { addTask, upsertTask, boardText, readTodo, ensureTodo, todoTemplate, today, localStamp, setBreakpoint, moveBlocked, insertDoneGrouped, idOfTaskLine, archiveDoneInText, renderArchivePage, renderArchiveBody, DONE_KINDS, withDoneKind, doneKindOf, doneDateOf, collapseDone, SEC, rebuildStructure, topicTreeText, upsertTopicLine, TOPIC_STATES, TOPIC_CLOSED_STATES, parseTopicLine, topicTree, currentTopic, removeTopicLine, promoteTopic } from './todo.js';
 import { editFile, SKIP } from './lock.js';
 import { appendWrapup, strandedFor } from './wrapup.js';
 
@@ -112,10 +112,12 @@ export function indexTemplate() {
   return rebuildStructure(
     ['# 🗂 Graph Index', '',
       '本文件唯一入口。每新建/大改一页，同步在此分类下加一行 [[页面名]] — 一句话。', '',
-      '## Roadmap', '## Rules', '## Concepts', '## Entities', '## Sources', '## Syntheses', '## Sessions'].join('\n'),
+      '## Rules', '## Concepts', '## Entities', '## Sources', '## Syntheses', '## Sessions'].join('\n'),
     {
       h1: '# 🗂 Graph Index',
-      order: ['## Roadmap', '## Rules', '## Concepts', '## Entities', '## Sources', '## Syntheses', '## Sessions'],
+      // 无 `## Roadmap`：它是 AI 自己写的方向总结，会被 load 反复读到并带偏后续会话
+      // （“看似是总结指引，其实是 AI 的总结指引” —— 2026-09-13 用户决策删除）。
+      order: ['## Rules', '## Concepts', '## Entities', '## Sources', '## Syntheses', '## Sessions'],
     },
   ).text;
 }
@@ -131,7 +133,10 @@ export function logTemplate() {
 export const BRAIN_SHAPE = {
   'todo.md': {
     h1: '# 📋 Todo Board',
-    order: ['## Backlog', '## Today / In Progress', '## Blocked', '## Done'],
+    // 分区（话题树）置顶：讨论轨道先于执行轨道（见 TODO_SECTIONS 注释）
+    order: ['## Topics', '## Backlog', '## Today / In Progress', '## Blocked', '## Done'],
+    // 旧文件标题归一（已在 todo.js 的 LEGACY_SECTION_RENAMES 里给出，这里引用以免双源漂移）
+    renames: [['## Topic', '## Topics'], ['## 话题', '## Topics'], ['## 话题树', '## Topics'], ['## 分区', '## Topics']],
   },
   'log.md': {
     h1: '# 🗒 Activity Log',
@@ -139,7 +144,7 @@ export const BRAIN_SHAPE = {
   },
   'index.md': {
     h1: '# 🗂 Graph Index',
-    order: ['## Roadmap', '## Rules', '## Concepts', '## Entities', '## Sources', '## Syntheses', '## Sessions'],
+    order: ['## Rules', '## Concepts', '## Entities', '## Sources', '## Syntheses', '## Sessions'],
   },
 };
 
@@ -151,7 +156,6 @@ export const LEGACY_MARKS = [
   ['# 操作日志', '# 🗒 Activity Log'],
   ['# 图谱索引', '# 🗂 Graph Index'],
   ['# Todo 看板', '# 📋 Todo Board'],
-  ['## 当前路线 (Roadmap)', '## Roadmap'],
   ['## Done（只留近期，旧的迁 log.md/快照）', '## Done'],
   ['### 归档', '### Archived'],
   ['### （未标日期）', '### Undated'],
@@ -248,6 +252,29 @@ async function listBrainFiles(root) {
 }
 
 // ---------- load: 开机读状态 ----------
+/// 从看板文本里剔掉 `## Topics` 区段（已由「当前话题」单独渲染）。
+/// 只删区标题到下一个 `## ` 之间；末尾多余空行一并收掉。
+export function stripTopics(text) {
+  const lines = String(text ?? '').split('\n');
+  const at = lines.findIndex((l) => l.trim() === `## ${SEC.topics}`);
+  if (at === -1) return text;
+  let end = at + 1;
+  while (end < lines.length && !/^## /.test(lines[end])) end++;
+  lines.splice(at, end - at);
+  return lines.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+/** 「当前话题」一行文本 —— load 首屏用。只给最深的活话题 + 它的父链，
+ * 让人（和 AI）一眼看到“此刻在哪条线上”，而不摄入整棵树。 */
+export function currentTopicText(text) {
+  const cur = currentTopic(text);
+  if (!cur) return '';
+  const byId = new Map(topicTree(text).map((n) => [n.id, n]));
+  const chain = [];
+  for (let n = cur; n; n = n.parent ? byId.get(n.parent) : null) chain.unshift(n);
+  return `⌖ ${chain.map((n) => `${n.id} ${n.title}`).join(' › ')}`;
+}
+
 export async function cmdLoad({ dir }) {
   const root = await requireBrain(dir || process.cwd());
   // 结构核对先跑：load 每回都要读这三个文件，顺手把它们形状摆正（缺分区）或提个醒（无头）。
@@ -281,11 +308,17 @@ export async function cmdLoad({ dir }) {
     // Rules 单独成段且放在最前（仅次于项目行/滞留）：它是硬规则，不是普通清单。
     // 坑: 曾在 index 段内与页面清单平铺 —— AI 会当普通清单划过，而它每条都是付过代价的。
     ...(rulesSection(index) ? [rulesSection(index), ''] : []),
-    '--- Roadmap (index.md) ---',
     collapseIndex(index) || '(index.md 为空)',
     '',
+    // 只打「当前话题」一行：整棵树会被 load 反复读并带偏会话（同 Roadmap 之病）。
+    // 全貌用 `abs topic` 主动查——它是查看命令，不进开机首屏。
+    ...(currentTopic(todo) ? ['--- 当前话题 (todo.md) ---', currentTopicText(todo), ''] : []),
+    // 开局三类（2026-09-13 用户澄清）：①正在讨论=上面 Topics ②待办/已开工/已收尾=
+    // 下面 Board（Done 区就是已结束，折叠只是显示形式——归档才管前几天）。
+    // 曾加过「今日已结束」单列段：多余，撤掉（Done 区已表达同一信息）。
     '--- Todo Board (todo.md) ---',
-    collapseDone(todo).text || '(todo.md 为空)',
+    // 看板里剔掉 Topics 区：它已在上面用树形打印过，原样再贴一遍是纯冗余。
+    stripTopics(collapseDone(todo).text) || '(todo.md 为空)',
     '\n（Done 已按日期折叠计数；明细: abs todo --full）',
     '',
     '--- 最近动作 (log.md, 最新 5 条) ---',
@@ -331,7 +364,7 @@ function rulesSection(indexText) {
   // 有引言句（> 开头）时一并带上，它解释了这个区是干什么的。
   const intro = body.split('\n').filter((l) => l.trim().startsWith('>')).join('\n');
   return [
-    `--- Rules (硬规则，先读) — ${items.length} 条 ---`,
+    `--- Rules (硬规则，先读, index.md) — ${items.length} 条 ---`,
     intro,
     ...items,
   ].filter((x) => x !== '').join('\n');
@@ -393,8 +426,7 @@ async function readFileOrNull(p) {
   try { return await fs.readFile(p, 'utf8'); } catch { return ''; }
 }
 
-/** index.md 在 `abs load` 里的折叠形态：保留「当前路线」（那是 load 要传达的状态，
- * 且有界），把页面清单各分区折成计数。
+/** index.md 在 `abs load` 里的折叠形态：把页面清单各分区折成计数。
  *
  * 坑: index 的 concept 清单带每一页的一句话描述，**隨图谱线性增长** —— 本仓库 17 条
  * 占 load 输出 2286/3571 tok（64%），另一台 40 条的项目约 2.3 倍。它刚成了 Done 之后
@@ -402,37 +434,38 @@ async function readFileOrNull(p) {
  *
  * 续接真正需要的只是「有哪些分区、各多少页」（据此知道去哪找），不需要每页写了什么 ——
  * 要那个用 `abs index`（或直接读 index.md / 按词 `abs query`）。
- * `## 当前路线` 不折（它是路线内容本身，非清单）。 */
+ *
+ * `## Rules` 也已不在本函数输出——它由 rulesSection 在**上方**单独成段（需要正文）；
+ * 这里再原样吐一遍 = 同一段硬规则在首屏出现两次（2026-09-13 实测发现）。
+ * 曾另有 `## Roadmap`：AI 自己写的方向总结，会被反复读到并带偏会话，已删。 */
 export function collapseIndex(text) {
   const s = String(text || '').trim();
   if (!s) return '';
   const out = [];
-  let mode = null;      // null=逐行透传（路线区/文件头）；字符串=当前在计数的分区名
+  let mode = null;      // null=逐行透传（文件头）；字符串=当前在计数的分区名
   let n = 0;            // mode 非 null 时的清单行计数
   const flush = () => {
     if (mode !== null) out.push(n ? `## ${mode}（${n} 页）` : `## ${mode}`);
     mode = null;
     n = 0;
   };
+  let skipping = false; // 跳过 Rules 正文（已在上方单独成段）
   for (const l of s.split('\n')) {
     const m = l.match(/^##\s+(.+?)\s*$/);
     if (m) {
       flush();
       const name = m[1].trim();
-      // 「Roadmap」与「Rules」都是**内容**不是清单：原样保留。
-      // Rules 区尤其不能折 —— 它的全部价值就是被读到；折成"（N 页）"等于把它静默删掉。
-      if (/路线|Roadmap|Rules?|规则/i.test(name)) {
-        out.push(l);
-        mode = null;
-      } else {
-        mode = name;   // 页面清单分区：只计数
-      }
+      skipping = /Rules?|规则/i.test(name);
+      if (skipping) continue;
+      mode = name;   // 页面清单分区：只计数
       continue;
     }
-    if (mode === null) out.push(l);      // 透传区（含文件头 H1、路线区正文）
+    if (skipping) continue;
+    if (mode === null) out.push(l);      // 透传区（含文件头 H1）
     else if (l.trim().startsWith('-')) n++;
   }
   flush();
+  // 文件头与首个分区之间可能因跳过 Rules 而留下多余空行
   return out.join('\n').replace(/\n{3,}/g, '\n\n').trim();
 }
 
@@ -1139,3 +1172,74 @@ async function listPages(vault) {
   }
   return pages;
 }
+
+/** abs topic —— 分区（话题树）读写。
+ * 两个关键修正（2026-09-13 实测踩坑）：
+ *  ① `id` 参数可能是“"#1" 标题”合一串 —— 必须切开，否则整串被当作 id，
+ *     upsert 找不到行 → 新插一行重复话题。
+ *  ② 未给标题时必须**保留现有标题**（不能回退成 id）：
+ *     `abs topic conclude "#1"` 曾把标题写成 `#1` 并丢掉结论。 */
+export async function cmdTopic({ dir, action, id, title, state, conclusion, full, clear }) {
+  const root = await requireBrain(dir || process.cwd());
+  const p = brainPath(root, 'todo.md');
+  if (!action || action === 'tree' || action === 'list') {
+    const text = await readTodo(root);
+    const t = topicTreeText(text);
+    return t || '（无话题。登记: abs topic new "#1 标题"）';
+  }
+  // 写操作：需姓名（与 todo 同守卫）；姓名同时写进话题行（[[name]]）
+  const who = await requireUser();
+  await ensureTodo(root);
+  // 拆 “#1 标题” → id / title（id 只取 # 开头的第一个 token）
+  let useId = id;
+  let useTitle = title;
+  if (useId && !/^#[\w.]+$/.test(useId)) {
+    const m = String(useId).match(/^(#[\w.]+)\s+(.*)$/);
+    if (m) { useId = m[1]; useTitle = (useTitle ? m[2] + ' ' + useTitle : m[2]).trim(); }
+  }
+  if (!useId) throw new Error(`✗ 缺 <id>\n  用法: abs topic ${action} "#1 标题" [--state 状态] [--note 结论]`);
+  if (!/^#[\w.]+$/.test(useId)) {
+    throw new Error(`✗ id 需以 # 开头（如 #1 / #2.1），收到 "${useId}"`);
+  }
+  const st = state || (action === 'reject' ? '已否决' : action === 'conclude' ? '已结论' : action === 'done' ? '已落地' : '进行中');
+  // `abs topic promote #N` —— 讨论成熟、要动手了 → 移进 Today（同 id 连续追踪）。
+  // 不是复制两份：话题变身任务，Topics 退位。
+  if (action === 'promote') {
+    if (!useId) throw new Error('✗ 缺 <id>\n  用法: abs topic promote "#1" [--to Today]');
+    const cur = await readTodo(root);
+    const section = state || SEC.today;   // --state 可指定目标分区（默认 Today）
+    const r = promoteTopic(cur, useId, section);
+    if (!r.changed.length) {
+      return `• 话题 ${useId} 未登记（或目标分区 ${section} 不存在），未动`;
+    }
+    await editFile(p, () => ({ text: r.text }));
+    return `✓ 话题 ${useId} 已移进 ${section}（同 id 连续追踪，不再是话题）`;
+  }
+  if (!TOPIC_STATES.includes(st)) {
+    throw new Error(`✗ --state 只接受: ${TOPIC_STATES.join(' | ')}（收到 "${st}"）`);
+  }
+  // 终止态不入 Topics 区（用户定：这里只放正在讨论的）。
+  // 不默默拒绝而是给明确出路：先把结论落 sources/，再从树上摘掉。
+  if (TOPIC_CLOSED_STATES.includes(st)) {
+    const cur = await readTodo(root);
+    const node = topicTree(cur).find((n) => n.id === useId);
+    if (node) {
+      await editFile(p, (c) => ({ text: removeTopicLine(c, useId) }));
+      return (
+        `✓ 话题 ${useId} [${st}] 已从 Topics 移出（终止态不留树上）\n` +
+        `  ⚠ 结论请用 \`abs note "..."\` 落 sources/，否则就丢了`
+      );
+    }
+    return `• 话题 ${useId} [${st}] 未登记（终止态不入 Topics 区）\n  ⚠ 结论请用 \`abs note "..."\` 落 sources/`;
+  }
+  const orig = await readTodo(root);
+  // 未给标题 → 沿用现有行（“只改状态”场景）
+  const existing = topicTree(orig).find((n) => n.id === useId);
+  const title2 = useTitle || existing?.title;
+  if (!title2) throw new Error(`✗ 话题 ${useId} 不存在，需给标题\n  用法: abs topic new "${useId} 标题"`);
+  const concl = conclusion !== undefined ? conclusion : existing?.conclusion;
+  const r = await editFile(p, (cur) => ({
+    text: upsertTopicLine(cur, { id: useId, title: title2, state: st, conclusion: concl, author: who }).text,
+  }));
+  return `✓ 话题 ${useId} [${st}] → ${p}\n  ${title2}${concl ? ' — ' + concl : ''}`;
+}

package/src/todo.js

@@ -52,20 +52,28 @@ export const SEC = {
   today: 'Today / In Progress',
   blocked: 'Blocked',
   done: 'Done',
+  // 分区（话题树总看板）：讨论层面的话题状态机，与「要落实的事」（Backlog/Today）分层。
+  // 讨论出话题 → 记分区；成熟到要动手 → 才落一行任务。
+  // 中文标题「分区」比 Topic 更直白；LEGACY 里把英文 Topic 也归一过来。
+  topics: 'Topics',
   archived: 'Archived',   // Done 区内部的归档标记区（原 '### 归档'）
   undated: 'Undated',     // Done 区内部无完成日期的尾组（原 '### （未标日期）'）
 };
 
 /** 旧名 → 新名。供 `abs init --repair` 一次性迁移（幂等）。
  * 只改匹配整行的标题，不动正文；不做模糊替换（防误改正文里提到的旧名）。 */
+// 分区标题归一（英文 Topic / 话题 都归一到「分区」）
 export const LEGACY_SECTION_RENAMES = [
   // H1（文件标题）
   ['# 🗂 图谱索引', '# 🗂 Graph Index'],
   ['# 🗒 操作日志', '# 🗒 Activity Log'],
   ['# 📋 Todo 看板', '# 📋 Todo Board'],
   // ## 分区
-  ['## 当前路线 (Roadmap)', '## Roadmap'],
   ['## Done（只留近期，旧的迁 log.md/快照）', '## Done'],
+  ['## Topic', '## Topics'],
+  ['## 话题', '## Topics'],
+  ['## 话题树', '## Topics'],
+  ['## 分区', '## Topics'],
   // ### 区内分组标题
   ['### 归档', '### Archived'],
   ['### （未标日期）', '### Undated'],
@@ -89,15 +97,21 @@ export function renameLegacySections(text) {
 export function todoTemplate() {
   // 由 rebuildStructure 生成，保证“模板”与“重排结果”逐字节一致
   // （否则 load 会把新建的模板又重排一次 = 无意义的写盘）。
+  // 注意（2026-09-13 踩坑）：rebuildStructure 的 order 要**带 `## ` 前缀**，
+  // 而 TODO_SECTIONS 是裸名（两者用途不同，不能复用 —— 曾误传裸名导致
+  // 生成出没有 `##` 的裸标题行，模板直接损坏、Backlog 分区消失）。
   return rebuildStructure(
-    ['# 📋 Todo Board', '## Backlog', '- [ ] 待办任务', '## Today / In Progress', '## Blocked', '## Done'].join('\n'),
-    { h1: '# 📋 Todo Board', order: ['## Backlog', '## Today / In Progress', '## Blocked', '## Done'] },
+    ['# 📋 Todo Board', ...TODO_SECTIONS.map((s) => `## ${s}`)].join('\n'),
+    { h1: '# 📋 Todo Board', order: TODO_SECTIONS.map((s) => `## ${s}`) },
   ).text;
 }
 
-/** 归一化 todo.md 分区：老格式（In Progress/Todo）迁移为 B4 定稿格式（Backlog→Today / In Progress→Blocked→Done）。
- * 幂等：已是新格式则原样返回。迁移原则——老 "In Progress" 内容进 "Today / In Progress"，老 "Todo" 内容进 "Backlog"。 */
-export const TODO_SECTIONS = ['Backlog', 'Today / In Progress', 'Blocked', 'Done'];
+/** 分区分区（话题树）：**置顶** —— 回答「我们在做什么、分了几叉、哪些已死」。
+ * 设计取舍（2026-09-13 用户定）：讨论轨道与执行轨道必须分开。
+ * 实测教训：一轮会话讨论了 14 条话题线，而 todo 只能反映 1 条（记录率 7%）——
+ * 因为话题一旦「已结论/已证伪」就不该再占待办位，但也不该消失。
+ * 故：分区置顶存话题状态（含已证伪），Backlog/Today 只存「要动手的事」。 */
+export const TODO_SECTIONS = ['Topics', 'Backlog', 'Today / In Progress', 'Blocked', 'Done'];
 
 /** 结构重建（B 档）：以标准分区表为准重排整个文件。
  *
@@ -674,3 +688,242 @@ export async function boardText(brainRoot, textOverride, { full = false } = {})
   const hint = full ? '' : '\n\n（Done 只给计数；看明细: abs todo --full）';
   return `${head}\n\n${body}${hint}`;
 }
+
+// ---------- 分区（话题树） ----------
+// 设计动机（2026-09-13 实测教训）：一轮长会话讨论了 14 条话题线，而看板只能反映 1 条
+// （记录率 7%）——因为「已结论/已证伪」的话题不该再占待办位，但也不该消失（否则下个
+// 会话重走死路）。故把「讨论轨道」独立成 `## 分区`：话题带状态，与「执行轨道」
+// （Backlog/Today）分层。讨论出话题 → 记分区；成熟到要动手 → 才落一行任务。
+
+/** 话题状态（与执行轨道共享的语义，但用于话题层面）。 */
+export const TOPIC_STATES = ['进行中', '已结论', '已否决', '待验证', '已落地', '未落地'];
+
+/** 终止态：这些话题**不该留在 Topics 区**（用户定：只放正在讨论的）。
+ * 理由：树的价值是「当前在哪」；死话题会把活话题淹掉。
+ * 归档去向：结论写进 sources/（abs note），那里可检索、不挤占 load 首屏。
+ *
+ * 2026-09-13 修正：`未落地`/`待验证` **也算离开 Topics**。
+ * 先前误把它们当“活跃”留在树上 → 结果 #8（方案已定、等客户端配合）/#3.4（等数据）
+ * 长期挂在“正在讨论”里变成僵尸。它们的真实语义是**暂停**（等人/等数据），
+ * 应落 Backlog/Blocked 当成任务追踪，而不是冒充“当前话题”。 */
+export const TOPIC_CLOSED_STATES = ['已结论', '已否决', '已落地', '待验证', '未落地'];
+
+/** 从 Topics 区移除一个话题（含其父指针行）。终止态话题用 —— 树只留活跃话题。 */
+export function removeTopicLine(text, id) {
+  const lines = String(text ?? '').split('\n');
+  const { at, lines: seg } = topicLines(lines.join('\n'));
+  if (at === -1) return text;
+  const rel = seg.findIndex((l) => {
+    const t = parseTopicLine(l);
+    return t && t.id === id;
+  });
+  if (rel === -1) return text;
+  const abs = at + 1 + rel;
+  const drop = 1 + (/^\s*└─\s*父:/.test(lines[abs + 1] || '') ? 1 : 0);
+  lines.splice(abs, drop);
+  return lines.join('\n');
+}
+
+/** 话题行格式（刻意做得极简、可手写可机器解析）：
+ *   - [ ] #12 [[name]] 减少决策步往返 [进行中] — 结论
+ *   - [x] #11 [[name]] 任务拆分       [已否决] — 子任务必 miss
+ *       └─ 父: #9
+ * 缩进 = 父子关系（纯缩进即树，不引入新语法）；[[name]] = 登记人（与 todo 行同约定）。
+ *
+ * 解析要点（2026-09-13 踩坑）：状态标记是**末尾** `[状态]`，不能用非贪婪匹配 ——
+ * 否则标题含 `[` 时会被第一个 `[` 截断。故：先切结论，再从剩余尾部抽状态。 */
+const TOPIC_RE = /^(\s*)- \[( |x)\]\s+(#[\w.]+)\s+(.*)$/;
+const TOPIC_STATE_TAIL = /\s*\[([^\]]+)\]\s*$/;
+const TOPIC_AUTHOR = /^\[\[([^\]]+)\]\]\s*/;
+
+/** 解析一行话题。返回 null 表示不是话题行（普通任务行/正文行）。 */
+export function parseTopicLine(line) {
+  const m = String(line).match(TOPIC_RE);
+  if (!m) return null;
+  const [, indent, box, id, rest] = m;
+  const body = rest.trim();
+  // 顺序很重要（2026-09-13 踩坑）：先切结论、再抽状态。
+  // 若颠倒，`… [已否决] — 结论` 的末尾是结论而非状态，会抽不到状态。
+  // 结论分隔：` — ` / ` -- `（全角/半角破折号、双连字符）
+  let head = body;
+  let conclusion = '';
+  const sep = body.match(/\s(?:—|--)\s/);
+  if (sep) {
+    head = body.slice(0, sep.index).trim();
+    conclusion = body.slice(sep.index + sep[0].length).trim();
+  }
+  // 抽作者标记（紧跟 id 后的 [[name]]）
+  let author = null;
+  const am = head.match(TOPIC_AUTHOR);
+  if (am) {
+    author = am[1];
+    head = head.slice(am[0].length).trim();
+  }
+  // 从 head 尾部抽 [状态]；只有识别为已知状态名才切除，否则归回标题
+  let state = null;
+  const st = head.match(TOPIC_STATE_TAIL);
+  if (st && TOPIC_STATES.includes(st[1])) {
+    state = st[1];
+    head = head.slice(0, st.index).trim();
+  }
+  return {
+    indent: indent.length,
+    done: box === 'x',
+    id,
+    author,
+    title: head,
+    state: state || (box === 'x' ? '已结论' : '进行中'),
+    conclusion,
+  };
+}
+
+/** 渲染一行话题（与 parseTopicLine 互逆，便于测试）。
+ * 结论用 ` — ` 分隔（与 parseTopicLine 的 sep 规则对称），否则回读时会把结论
+ * 误并回标题（先前实测：`#1 … [已否决] 六条…` → 标题被截断、状态被误读）。 */
+export function renderTopicLine(t) {
+  const ind = ' '.repeat(t.indent || 0);
+  const closed = ['已结论', '已否决', '已落地'].includes(t.state);
+  const b = closed ? 'x' : t.done ? 'x' : ' ';
+  const who = t.author ? ` ${`[[${t.author}]]`}` : '';
+  const head = `${ind}- [${b}] ${t.id}${who} ${t.title} [${t.state}]`;
+  return t.conclusion ? `${head} — ${t.conclusion}` : head;
+}
+
+/** 取 `## 分区` 区段的行（不含标题）。 */
+export function topicLines(text) {
+  const lines = String(text ?? '').split('\n');
+  const at = lines.findIndex((l) => l.trim() === `## ${SEC.topics}`);
+  if (at === -1) return { at: -1, lines: [] };
+  let end = at + 1;
+  while (end < lines.length && !/^## /.test(lines[end])) end++;
+  return { at, lines: lines.slice(at + 1, end) };
+}
+
+/** 幂等登记/更新一个话题。同 id 已存在则原位更新（标题/状态/结论），否则按缩进插入。 */
+export function upsertTopicLine(text, { id, title, state, conclusion, indent = 0, author = null }) {
+  const lines = String(text ?? '').split('\n');
+  const { at, lines: seg } = topicLines(lines.join('\n'));
+  const existing = seg.findIndex((l) => {
+    const t = parseTopicLine(l);
+    return t && t.id === id;
+  });
+  // 作者：优先新值，否则沿用已存在的行（“只改状态”不该把登记人抹掉）
+  const prev = existing === -1 ? null : parseTopicLine(seg[existing]);
+  const rendered = renderTopicLine({
+    id, title, state, conclusion, indent: prev ? prev.indent : indent,
+    author: author || prev?.author || null,
+  });
+  if (at === -1) {
+    // 无分区 → 补建在**最前**（Topics 是总览，必须先被看到）。
+    // 坑（2026-09-13 实测）：曾插到 `## Done` 之前 → 反而排在 Backlog/Today 之后，
+    // 与「置顶」意图相反。正确位置 = H1/前言之后的第一个分区位。
+    let insertAt = 0;
+    while (insertAt < lines.length && !/^## /.test(lines[insertAt])) insertAt++;
+    lines.splice(insertAt, 0, `## ${SEC.topics}`, rendered, '');
+    return { text: lines.join('\n'), changed: ['新增 Topics 区'] };
+  }
+  if (existing !== -1) {
+    const abs = at + 1 + existing;
+    if (lines[abs] === rendered) return { text, changed: [] };
+    lines[abs] = rendered;
+  } else {
+    let insertAt = at + 1;
+    while (insertAt < lines.length && !/^## /.test(lines[insertAt])) insertAt++;
+    // 插到该分区末尾（去掉尾部空行，保持紧凑）
+    while (insertAt - 1 > at && !lines[insertAt - 1].trim()) insertAt--;
+    lines.splice(insertAt, 0, rendered);
+  }
+  return { text: lines.join('\n'), changed: [`话题 ${id} → ${state}`] };
+}
+
+/** 把话题从 Topics 区**移进**指定分区（默认 Today），保留同一个 id。
+ *
+ * 模型根基（2026-09-13 用户定）：话题有生命周期，Topics 不是终点而是**入口**。
+ * 「讨论」与「执行」是**同一件事的两态**，不是两份记录——所以是**移动**（带同 id），
+ * 不是复制。这样 `#1.2` 从话题变成任务后，仍然能一路追到 Done。
+ *
+ * 落单格式用普通任务行（与 todo 同构），以便复用看板/归档/lint 全套；
+ * 原话题的**结论**捎带过去（丢了就没上下文）。
+ * 返回新文本；话题不存在则原样返回。 */
+export function promoteTopic(text, id, section = SEC.today) {
+  const src = String(text ?? '');
+  const nodes = topicTree(src);
+  const node = nodes.find((n) => n.id === id);
+  if (!node) return { text: src, changed: [] };
+  let out = removeTopicLine(src, id);
+  const lines = out.split('\n');
+  const at = lines.findIndex((l) => l.trim() === `## ${section}`);
+  if (at === -1) return { text: src, changed: [] };   // 目标分区不存在 → 不动（不猜）
+  let end = at + 1;
+  while (end < lines.length && !/^## /.test(lines[end])) end++;
+  while (end - 1 > at && !lines[end - 1].trim()) end--;
+  const who = node.author ? ` [[${node.author}]]` : '';
+  const tail = node.conclusion ? ` — ${node.conclusion}` : '';
+  lines.splice(end, 0, `- [ ] ${node.id}${who} ${node.title}${tail}`);
+  return { text: lines.join('\n'), changed: [`话题 ${id} → ${section}`] };
+}
+
+/** 取话题树（扁平列表 + 父指针）。父由 `└─ 父: #x` 行给出；未显式给出时
+ * 按 id 的层级默认（`#1.2` 的父是 `#1`）—— 否则 `abs topic new "#1.2 x"` 会白成一个孤根。
+ * 显式 `└─ 父:` 优先（允许手工把子话题挂到非 id 前缀的父上）。 */
+export function topicTree(text) {
+  const { lines: seg } = topicLines(text);
+  const out = [];
+  for (let i = 0; i < seg.length; i++) {
+    const t = parseTopicLine(seg[i]);
+    if (!t) continue;
+    const pm = seg[i + 1]?.match(/^\s*└─\s*父:\s*(#[\w.]+)/);
+    // 无显式父指针 → 从点分层级推（#a.b.c 的父 = #a.b）
+    const dot = t.id.lastIndexOf('.');
+    const implied = dot === -1 ? null : t.id.slice(0, dot);
+    out.push({ ...t, parent: pm ? pm[1] : implied });
+  }
+  return out;
+}
+
+/** 此刻正在推进的那条话题（供 load 首屏「当前话题」一行）。
+ * 判据：`进行中` 且是**叶子**（没有进行中的子话题）—— 最深的活话题才是当前在说的。
+ * 无活话题返回 null。
+ *
+ * 为什么不打印整棵树（2026-09-13 用户定）：整棵树会被 load 反复读取并**带偏后续会话**
+ * （跟刚删的 Roadmap 同一个病）。当前态要常驻眼前，全貌用 `abs topic` 主动查。 */
+export function currentTopic(text) {
+  const nodes = topicTree(text).filter((n) => n.state === '进行中');
+  if (!nodes.length) return null;
+  const hasActiveKid = new Set(
+    nodes.map((n) => n.parent).filter((p) => p && nodes.some((n) => n.id === p)),
+  );
+  return nodes.filter((n) => !hasActiveKid.has(n.id)).pop() || null;
+}
+
+/** 话题树的文本视图：**只输出话题行**，不写任何解释/统计标题。
+ * 理由（用户定）：这一段是状态数据，不是文档 —— 正文说明会被 load 反复打印、
+ * 挤占上下文，也让人分不清哪些是话题、哪些是说明。注释只留在源码里。
+ * 已证伪的用 ✘ 标出并在末尾单列一块（防下个会话重走死路）。 */
+export function topicTreeText(text) {
+  const nodes = topicTree(text);
+  if (!nodes.length) return '';
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const kids = new Map();
+  const roots = [];
+  for (const n of nodes) {
+    if (n.parent && byId.has(n.parent)) {
+      if (!kids.has(n.parent)) kids.set(n.parent, []);
+      kids.get(n.parent).push(n);
+    } else roots.push(n);
+  }
+  const icon = (s) => ({ 进行中: '▶', 已结论: '✔', 已否决: '✘', 待验证: '?', 已落地: '✓', 未落地: '·' }[s] || '·');
+  const out = [];
+  const draw = (n, depth) => {
+    // 格式与存储行一致（单层分隔，不用双空格夹状态），便于人眼与文件对照
+    out.push(`${'  '.repeat(depth)}${icon(n.state)} ${n.id} ${n.title} [${n.state}]${n.conclusion ? ' — ' + n.conclusion : ''}`);
+    for (const k of kids.get(n.id) || []) draw(k, depth + 1);
+  };
+  for (const r of roots) draw(r, 0);
+  const dead = nodes.filter((n) => n.state === '已否决' && !roots.includes(n) && !kids.has(n.parent));
+  if (dead.length) {
+    out.push('');
+    for (const d of dead) out.push(`✘ ${d.id} ${d.title}${d.conclusion ? ' — ' + d.conclusion : ''}`);
+  }
+  return out.join('\n');
+}