@fanchao8609/agent_brain_sync 1.7.8 → 1.7.9

package/README.md

@@ -60,11 +60,11 @@ abs init          # 建 .brain/ 图谱，只需一次
 
 ```bash
 abs load                       # 开机读状态（Rules + 图谱计数 + 看板 + 最近流水）
-abs todo                       # 看板 Today / In Progress / Blocked / Done
+abs todo                       # 看板 Todo / Done（行首带状态标记）
 
 abs todo add     TASK-1 --note "要做什么"
 abs todo note    TASK-1 --note "改到 X 文件 L40"   # 实时断点
-abs todo blocked TASK-1 --note "卡在哪"
+abs todo state   TASK-1 --note "进行中|讨论中|滞留中"   # 改行首状态标记
 abs todo done    TASK-1
 
 abs note "一句话经验" --tags 坑,docker    # 经验暂存 → sources/

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, cmdTopic } from '../src/store.js';
+import { cmdInit, cmdStatus, cmdLoad, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive } from '../src/store.js';
 import { setUser, getUser, userConfigPath } from '../src/userconfig.js';
 import { runInstall, runUninstall } from '../src/install.js';
 import { readFileSync } from 'node:fs';
@@ -167,8 +167,7 @@ const usage = `abs — agent-brain-sync 记忆工具
 
 读:
   abs load                   开机读状态 (index/todo/log)
-  abs todo                   任务看板 Topics / Backlog / Today / Blocked / Done
-  abs topic                  话题树（讨论轨道，含已证伪）；无参=查看
+  abs todo                   任务看板 Todo / Done（未完成的都在这，行首带状态）
   abs index                  图谱索引 index.md
   abs log                    流水 log.md
   abs status                 当前项目 + 图谱概要
@@ -176,11 +175,7 @@ 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 state   <id> --note "进行中|讨论中|滞留中"    改状态标记（原地，不搬区）
   abs todo done    <id> [--as 落地|否决|仅方案]    完成；结语标明到底"做成了没有"
                                默认 落地。否决=评估后不做(含做了又撤)；仅方案=只设计过
                                不加结语或结语失真会让下一个会话把"想过"当成"做完了"。
@@ -274,7 +269,7 @@ const TODO_ACTIONS = {
   add: 'start',
   start: 'start', // add 的别名(老习惯保留)
   note: 'note',
-  blocked: 'blocked',
+  state: 'state', // 改行首状态标记：进行中|讨论中|滞留中（原地，不搬区）
   done: 'done',
 };
 
@@ -344,28 +339,6 @@ 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._;
@@ -385,7 +358,7 @@ async function main() {
         if (!action) {
           throw new Error(
             `✗ 未知子命令 "${sub}"\n` +
-            `  可用: add / start / note / blocked / done / archive\n` +
+            `  可用: add / start / note / state / done / archive\n` +
             `  看板: abs todo（不带参数）\n` +
             `  登记任务: abs todo add <id> --note "做什么"`,
           );

package/bin/mcp.js

@@ -104,12 +104,12 @@ tool(
 
 tool(
   'abs_task',
-  '任务实时落盘（幂等键 = id）。add/start 登记 / note 补断点(改到哪个文件哪行) / blocked 碰壁 / done 完成归位。',
+  '任务实时落盘（幂等键 = id）。start 登记进 Todo / note 补断点(改到哪文件哪行) / state 改状态 / done 完成归位 Done。',
   {
-    action: z.enum(['add', 'start', 'done', 'note', 'blocked']),
+    action: z.enum(['add', 'start', 'done', 'note', 'state']),
     id: z.string().describe('任务幂等键，如 TASK-xxx 或子任务名'),
     cwd: z.string().describe('项目根目录（.brain/ 所在处）'),
-    note: z.string().optional().describe('add/start=做什么; note=断点(文件/到哪步); blocked=卡点原因'),
+    note: z.string().optional().describe('add/start=做什么; note=断点(文件/到哪步); state=进行中|讨论中|滞留中'),
   },
   async ({ action, id, cwd, note }) => {
     const root = await findBrainRoot(cwd || process.cwd());
@@ -144,7 +144,7 @@ tool(
 
 tool(
   'abs_rule',
-  '读/写 index.md 的 ## Rules 硬规则区。action=list 列出；action=add 追加一条（只放一句话 + [[链接]]，展开写概念页）。',
+  '读/写 index.md 的 ## Rules 硬规则区。action=list 列出；action=add 追加一条（只放一句话，≤42 字符、不带链接；展开写概念页）。',
   {
     cwd: z.string().describe('项目根目录（.brain/ 所在处）'),
     action: z.enum(['list', 'add']).optional().describe('list=列出(默认)；add=追加一条'),

package/hooks/abs.opencode.ts

@@ -47,15 +47,10 @@ const server = async ({ client, directory }) => {
 
   const TEARDOWN_MSG =
     "[abs 收尾提醒] 本会话改过文件但 .brain/ 今天还没有记录。请立即走收尾循环：\n" +
-    "1) 跑 abs load 看 Today 还有哪些未完成；\n" +
+    "1) 跑 abs load 看 Todo 还有哪些未完成；\n" +
     "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

@@ -12,7 +12,6 @@
  *     - 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"
@@ -104,7 +103,7 @@ async function loggedToday(brain: string): Promise<boolean> {
     // 只认**工作成果**条目（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 }
@@ -160,8 +159,7 @@ export default function absPiHook(pi: ExtensionAPI): void {
     if (!brain) return // 无图谱=不在这项目沉淀, 不打扰
     if (!hasWriteWork(event?.messages ? collectToolResults(event.messages) : [])) return
     // 今日已收尾 → 只在**本会话还没真正干事**时才静默。
-    // 旧行为：今天 log 有一行就整天闭口 —— 于是「收尾过之后新冒的话题」全部没人提醒
-    // （2026-09-13 实报：web 版聊了一整轮，Topics 里一条没有）。
+    // 旧行为：今天 log 有一行就整天闭口 —— 于是收尾之后的产出全部没人提醒。
     // 注意不能用 sessionNotes.length 当判据：用户每说一句话就会 push 一条，
     // 那会让 nudge 每轮都触发（噪音）。判据保持「今天已收尾」但配合下面的笔记消费。
     if (await loggedToday(brain)) return
@@ -172,17 +170,10 @@ export default function absPiHook(pi: ExtensionAPI): void {
     try {
       pi.sendUserMessage(
         "[abs 收尾提醒] 本会话改过文件但 .brain/ 今天还没有记录。请立即走收尾循环：\n" +
-        "1) 跑 abs load 看 Today 还有哪些未完成；\n" +
+        "1) 跑 abs load 看 Todo 还有哪些未完成；\n" +
         "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.8",
+  "version": "1.7.9",
   "description": "agent-brain-sync: 跨会话 AI 编码记忆 — hook 纯触发 + CLI/MCP 读写 .brain markdown 图谱, 防并发写保护。",
   "type": "module",
   "license": "MIT",

package/skill/SKILL.md

@@ -25,7 +25,7 @@ abs lint                     # 图谱体检（死链/悬挂/超限/堆积/未提
 # 写
 abs todo add <id> --note "做什么"              # 登记任务（start 同义）
 abs todo note <id> --note "断点/进度"           # 实时落 ↳ 断点 行
-abs todo blocked <id> --note "卡点原因"         # 移入 Blocked
+abs todo state <id> --note "进行中|讨论中|滞留中"  # 改状态标记（原地）
 abs todo done <id> [--as 落地|否决|仅方案]      # 完成（默认 落地）
 abs log "完成 X：…"                            # 记一行工作成果（无参=查看）
 abs note "经验一句话" [--tags 坑,docker]        # 经验实时暂存 → sources/
@@ -105,9 +105,9 @@ abs config [set user <名字>]                   # 使用者姓名（写操作
 | `## Concepts` `## Entities` `## Sources` `## Syntheses` `## Sessions` | 各类页的清单 | 每页一行 `- [[slug]] — 一句话`（`abs note`/建归档页会自动登记），load 里折成计数 |
 
 **`## Rules` 区**：铁律清单，`abs load` 每次都全量读（代码里明确不折它）。
-- 一句一条；有概念页就用 `[[链接]]` 指过去，**不在此展开**。
+- 一句一条，**不带链接**（链接去概念页自己的「## 关联连接」挂），不展开。
 - 只有「违反会丢数据 / 静默失效 / 白干活」级才进 —— 普通经验进 `concepts/`。
-- 读写：`abs rule` / `abs rule add "一句话"`（>120 字符被拒）；`abs lint` 超 30 条会报。
+- 读写：`abs rule` / `abs rule add "一句话"`（>42 字符被拒；也不接受 `[[链接]]`/URL）；`abs lint` 超 30 条会报。
 
 ### `log.md` —— 工作成果流水
 
@@ -116,13 +116,15 @@ load 只展示最新 5 条、每条按语义边界收口。
 
 ### `todo.md` —— 活看板（进度唯一真源）
 
+**只有两区**（2026-09-13 精简）：未完成的一切都进 `## Todo`，状态用**行首标记**表达。
+
 | 分区 | 放什么 |
 |---|---|
-| `## Backlog` | 想做但没开工 |
-| `## Today / In Progress` | 正在做 |
-| `## Blocked` | 卡住（附原因，`abs todo blocked`） |
+| `## Todo` | 未完成的一切。行首 `[进行中]` / `[讨论中]` / `[滞留中]`（`abs todo state`） |
 | `## Done` | 已完成，**必须带结语 `【落地/否决/仅方案】` + `(完成 YYYY-MM-DD)`** |
 
+行形态：`- [ ] [进行中] <id> [[name]] — 说明 (认领 YYYY-MM-DD)`
+
 `abs todo done <id>` 会勾选并归位到 Done 的日期组顶部，断点（`↳` 行）随迁；
 Done 区由 `abs wrapup` 在会话结束时自动把「超 3 天且整天都已完成」的组迁到 `sessions/<日期>-todo归档.md`
 （任一天有未完成则整天不迁）。**什么时候动它见「进行中」一节。**
@@ -179,12 +181,24 @@ Done 区由 `abs wrapup` 在会话结束时自动把「超 3 天且整天都已
 
 **todo 不是收尾仪式，是随改随写的活看板。** 每个任务边界立即更新，与 git commit 同反射。
 
-| 时机 | 动作 |
-|---|---|
-| 认领新任务 | `abs todo add <id> --note "做什么"` |
-| 子任务做完 | `abs todo done <id>` |
-| 碰壁/阻塞 | `abs todo blocked <id> --note "卡点原因"` |
-| 被打断/干到一半 | `abs todo note <id> --note "改到哪个文件/到哪步"` |
+**看板只有两区**：`## Todo`（未完成的一切）+ `## Done`（已完成）。
+未完成的状态用**行首标记**表达：`[进行中]` `[讨论中]` `[滞留中]`。
+
+| 时机 | 动作 | 落到哪 |
+|---|---|---|
+| 认领新任务 / 聊出一个话题 | `abs_task {action:start, id:"T-1", note:"做什么"}` | Todo `[进行中]` |
+| 只在讨论、还没动手 | `abs_task {action:state, id:"T-1", note:"讨论中"}` | 原地改标记 |
+| 卡住了/等人等数据 | `abs_task {action:state, id:"T-1", note:"滞留中"}` | 原地改标记 |
+| 被打断/干到一半 | `abs_task {action:note, id:"T-1", note:"改到哪个文件/到哪步"}` | 原地 ↳断点 |
+| 子任务做完 | `abs_task {action:done, id:"T-1", note:"结语"}` | Done |
+| 总结出经验/坑/规律 | `abs_note {text:"一句话", tags:"坑,docker"}` | sources/ |
+
+> **为什么只有两区**（2026-09-13 实测）：跨 4 个项目，Backlog/Today 常年 **0 条**，而 log.md
+> 有 120 条。根因是 AI 的工作方式「一口气做完」——任务从开始到完成都在同一会话内走完，
+> 中间那个「挂到进行时分区」的动作既来不及也不需要。**进行时分区是符合直觉但不符合实际
+> 工作流的抽象**，故删掉，状态改用行首标记。
+
+**核心：事件发生的那一刻就落，别攒到收尾。** 动作一变，扫一眼属于哪行，调对应工具。
 
 **经验刚冒出来就落**：`abs note "一句话经验" --tags 坑,docker` → 暂存 `sources/`（幂等去重）。宁少勿滥。
 
@@ -208,15 +222,15 @@ Done 区由 `abs wrapup` 在会话结束时自动把「超 3 天且整天都已
 
 收到 Stop / "结束/先这样/切别的事" / 长任务告一段落，立即执行：
 
-1. **读 todo** → `abs load`，看 Today 还有哪些没完成。
+1. **读 todo** → `abs load`，看 Todo 还有哪些没完成。
 2. **判有没有做完没登记** → 实际完成了漏登记的 `abs todo done <id>`；做到一半补
-   `abs todo note <id> --note 断点`；碰壁 `abs todo blocked`。别让干完的事还停 Today。
+   `abs todo note <id> --note 断点`；卡住的 `abs todo state <id> --note 滞留中`。别让干完的事还留在 Todo。
 3. **沉淀经验（该沉淀才沉淀）** → 踩了值得记的坑/有可复用技巧/跨会话判断 → `abs note`
    暂存；值得深提炼的（规律/坑/决策）按 Teardown 走完整流程。
 4. **更新 index/log/todo** → 新页同步进 index；`log.md` 倒序记一行**工作成果**摘要
    （`abs log "完成 X：..."`，不是工具动作）；todo 对账。
    **新规律是「违反会丢数据/静默失效/白干活」级别 → 往 index 的 `## Rules` 加一行**
-   （短句 + `[[概念页]]`，不展开）。普通经验不进 Rules —— 否则会长成第二份概念库。
+   （短句，不带链接；链接去概念页挂）。普通经验不进 Rules —— 否则会长成第二份概念库。
    跑 `abs lint` 确认自洽。
 
 **完成标准**：看板反映真实状态（Done 无滞留半成品）、该沉淀已落、index/log/todo 与事实一致。
@@ -228,7 +242,7 @@ Done 区由 `abs wrapup` 在会话结束时自动把「超 3 天且整天都已
 1. **暂存线索**：`abs note`（或建 `sources/YYYY-MM-DD-slug.md`）记做了什么、改哪些文件、验证命令。
 2. **抽规律**：值得留的 → `concepts/<kebab-slug>.md`：触发场景/❌表现/🛠根因+解法+验证。挂双链。
 3. **沉淀实体**：碰了重要未记录的事物 → `entities/<TitleCase>.md`。
-4. **对账 todo**：滞留 Today 归位（Done 标日期 / Backlog 补断点）；遗留 bug 写 Backlog/Blocked。
+4. **对账 todo**：做完的归位 Done（标结语+日期），做一半的补断点，卡住的改 `[滞留中]`。
 5. **综合(可选)**：推进了选型/取舍 → `syntheses/`。
 6. **收拢 sources**：提炼成规律的删 source，**同步清指向它的引用**（防死链）。
 7. **修 index + 记 log**：新页同步 index；**过 Rules 门槛的规律加一行到 `## Rules`**；

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, topicTreeText, upsertTopicLine, TOPIC_STATES, TOPIC_CLOSED_STATES, parseTopicLine, topicTree, currentTopic, removeTopicLine, promoteTopic } from './todo.js';
+import { stripStateMark, ensureStateMark, normalizeTodo, addTask, upsertTask, boardText, readTodo, ensureTodo, todoTemplate, today, localStamp, setBreakpoint, setStateMark, TASK_STATES, insertDoneGrouped, idOfTaskLine, archiveDoneInText, renderArchivePage, renderArchiveBody, DONE_KINDS, withDoneKind, doneKindOf, doneDateOf, collapseDone, SEC, rebuildStructure } from './todo.js';
 import { editFile, SKIP } from './lock.js';
 import { appendWrapup, strandedFor } from './wrapup.js';
 
@@ -133,10 +133,7 @@ export function logTemplate() {
 export const BRAIN_SHAPE = {
   'todo.md': {
     h1: '# 📋 Todo Board',
-    // 分区（话题树）置顶：讨论轨道先于执行轨道（见 TODO_SECTIONS 注释）
-    order: ['## Topics', '## Backlog', '## Today / In Progress', '## Blocked', '## Done'],
-    // 旧文件标题归一（已在 todo.js 的 LEGACY_SECTION_RENAMES 里给出，这里引用以免双源漂移）
-    renames: [['## Topic', '## Topics'], ['## 话题', '## Topics'], ['## 话题树', '## Topics'], ['## 分区', '## Topics']],
+    order: ['## Todo', '## Done'],
   },
   'log.md': {
     h1: '# 🗒 Activity Log',
@@ -156,6 +153,13 @@ export const LEGACY_MARKS = [
   ['# 操作日志', '# 🗒 Activity Log'],
   ['# 图谱索引', '# 🗂 Graph Index'],
   ['# Todo 看板', '# 📋 Todo Board'],
+  // 四区 → 两区（2026-09-13 用户定）。**这条路径是 load 走的**（rebuildStructure），
+  // 与 todo.js 的 LEGACY_SECTION_RENAMES（normalizeTodo 用）是两条独立迁移路径 ——
+  // 只改一处会导致另一条认不出旧区名，把它们当"非标准分区"原样留末尾（未完成任务
+  // 留在文件里但不再被当 TODO）。测试 'load 也要能迁移' 钉住这一点。
+  ['## Backlog', '## Todo'],
+  ['## Today / In Progress', '## Todo'],
+  ['## Blocked', '## Todo'],
   ['## Done（只留近期，旧的迁 log.md/快照）', '## Done'],
   ['### 归档', '### Archived'],
   ['### （未标日期）', '### Undated'],
@@ -207,9 +211,24 @@ export async function checkBrainShape(root) {
     let changed = [];
     await editFile(p, (cur) => {
       if (cur === null) return SKIP;
-      const r = spec.order.length
-        ? rebuildStructure(cur, { ...spec, renames: LEGACY_MARKS.filter(([o]) => o.startsWith('## ') || o.startsWith('### ')) })
-        : fixMarks(cur, spec);
+      let next2 = cur;
+      if (spec.order.length) {
+        // todo.md 的四区 → 两区迁移**必须先走 normalizeTodo**：只有它知道
+        // `## Blocked` 区的任务该标 [滞留中]（语义信息），而 rebuildStructure 只按
+        // renames 改标题、看不到来源分区，只能一律给 [进行中]。
+        // 2026-09-13 实测坑：cmdLoad 先跑 checkBrainShape、后跑 readTodo，于是
+        // normalizeTodo 的 [滞留中] 映射在 load 路径上永远走不到 → 卡住的任务
+        // 被静默标成进行中，两条路径语义不一致。
+        const srcText = file === 'todo.md' ? normalizeTodo(cur) : cur;
+        const r0 = rebuildStructure(srcText, { ...spec, renames: LEGACY_MARKS.filter(([o]) => o.startsWith('## ') || o.startsWith('### ')) });
+        // 兜底：仍无状态标记的未完成任务补默认值（新格式文件本就有标记，此处不触发）。
+        next2 = file === 'todo.md'
+          ? r0.text.split('\n').map((l) => (l.startsWith('- [ ] ') ? ensureStateMark(l, '进行中') : l)).join('\n')
+          : r0.text;
+      } else {
+        next2 = fixMarks(cur, spec).text;
+      }
+      const r = { text: next2, changed: next2 === cur ? [] : ['结构按标准重排'] };
       if (!r.changed.length) return SKIP;
       changed = r.changed;
       return { text: r.text };
@@ -252,29 +271,6 @@ 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 每回都要读这三个文件，顺手把它们形状摆正（缺分区）或提个醒（无头）。
@@ -310,15 +306,9 @@ export async function cmdLoad({ dir }) {
     ...(rulesSection(index) ? [rulesSection(index), ''] : []),
     collapseIndex(index) || '(index.md 为空)',
     '',
-    // 只打「当前话题」一行：整棵树会被 load 反复读并带偏会话（同 Roadmap 之病）。
-    // 全貌用 `abs topic` 主动查——它是查看命令，不进开机首屏。
-    ...(currentTopic(todo) ? ['--- 当前话题 (todo.md) ---', currentTopicText(todo), ''] : []),
-    // 开局三类（2026-09-13 用户澄清）：①正在讨论=上面 Topics ②待办/已开工/已收尾=
-    // 下面 Board（Done 区就是已结束，折叠只是显示形式——归档才管前几天）。
-    // 曾加过「今日已结束」单列段：多余，撤掉（Done 区已表达同一信息）。
+    // 两区制：Todo（未完成，行首带状态标记）+ Done。
     '--- Todo Board (todo.md) ---',
-    // 看板里剔掉 Topics 区：它已在上面用树形打印过，原样再贴一遍是纯冗余。
-    stripTopics(collapseDone(todo).text) || '(todo.md 为空)',
+    collapseDone(todo).text || '(todo.md 为空)',
     '\n（Done 已按日期折叠计数；明细: abs todo --full）',
     '',
     '--- 最近动作 (log.md, 最新 5 条) ---',
@@ -393,9 +383,16 @@ export async function cmdRule({ dir, action, text }) {
   }
   const clean = String(text || '').replace(/\s+/g, ' ').trim();
   if (!clean) return '用法: abs rule add "一句话硬规则"';
-  // 门槛：一句话说完。太长说明该写概念页，Rules 只放指针。
-  if (clean.length > 120) {
-    return `✗ 太长（${clean.length} 字符 > 120）—— Rules 只放一句话摘要，展开写成概念页，\n  这里改成短句 + [[页面名]] 链接。`;
+  // 门槛：**纪律不是记事本**。Rules 是最前面的项目铁律，每条必须一眼扫完。
+  // 2026-09-13 用户定：不带链接、不带解释、不写细节 —— 细节进概念页，Rules 只留结论。
+  // 宽严：中文一字信息量大，按 40 字算（≈ 英文 80 字符的量）。实测现有 12 条最长 56 字符。
+  if (clean.length > 42) {
+    return `✗ 太长（${clean.length} > 42）—— Rules 是纪律不是记事本：\n`
+      + `  每条要一眼扫完。细节/出处/例子 → 写进 concepts/ 概念页，这里只留一句话结论。`;
+  }
+  if (/\[\[|\]\]|https?:\/\//.test(clean)) {
+    return '✗ 不带链接 —— Rules 区会被反复全量打印，链接占位且让纪律读起来像索引。\n'
+      + '  要挂概念页，去概念页自己的「## 关联连接」里挂。';
   }
   let added = null;
   await editFile(p, (cur) => {
@@ -605,7 +602,7 @@ export async function cmdTeardownCheck({ dir, payload }) {
       '0) 本机尚未设置使用者姓名 —— 先跑 abs config set user <你的名字>，否则下面 2/3/4 都会被拦下；',
     ]),
     '[abs 收尾提醒] 本会话改过文件但 .brain/ 今天还没有记录。请立即走收尾循环：',
-      '1) 跑 abs load 看 Today 还有哪些未完成；',
+      '1) 跑 abs load 看 Todo 还有哪些未完成；',
       '2) 实际做完漏登记的 abs todo done <id>，做到一半的 abs todo note <id> --note "断点"；',
       '3) 值得留的经验 abs note "..."（宁少勿滥，能从代码 grep 到的不记）；',
       '4) abs log "完成 X：..." 记一行工作成果，新页同步进 index。',
@@ -702,15 +699,29 @@ export async function cmdTask({ dir, action, id, section, note, as }) {
   const who = await requireUser();
   await ensurePersonPage(root, who); // 首次写操作即建人页（已存在不动）
   if (action === 'start') {
+    // 两区制：未完成一律进 Todo，行首带状态标记（默认 进行中）。
+    const st = section && TASK_STATES.includes(section) ? section : '进行中';
     const r = await upsertTask(root, {
-      section: section || 'Today / In Progress',
-      text: `${id} ${atTag(who)}${note ? ' — ' + note : ''} (认领 ${today()})`,
+      section: SEC.todo,
+      text: `[${st}] ${id} ${atTag(who)}${note ? ' — ' + note : ''} (认领 ${today()})`,
     });
-    return `✓ 任务${r.updated ? '更新(幂等)' : '登记'} → ${brainPath(root, 'todo.md')}\n  ${id} ${atTag(who)}${note ? ' — ' + note : ''}`;
+    return `✓ 任务${r.updated ? '更新(幂等)' : '登记'} → ${brainPath(root, 'todo.md')}\n  [${st}] ${id} ${atTag(who)}${note ? ' — ' + note : ''}`;
   }
-  if (action === 'blocked') {
-    const r = await moveBlocked(root, { id, reason: note });
-    return r.msg;
+  if (action === 'state') {
+    // 改状态标记（原地，不搬区）：进行中 / 讨论中 / 滞留中
+    if (!note) throw new Error(`✗ 用法: abs todo state <id> --note "${TASK_STATES.join('|')}"`);
+    if (!TASK_STATES.includes(note)) {
+      throw new Error(`✗ 状态只接受: ${TASK_STATES.join(' | ')}（收到 "${note}"）`);
+    }
+    const f = brainPath(root, 'todo.md');
+    let cc = [];
+    await editFile(f, (cur) => {
+      if (cur === null) return SKIP;
+      const r = setStateMark(cur, id, note);
+      cc = r.changed;
+      return r.changed.length ? { text: r.text } : SKIP;
+    });
+    return cc.length ? `✓ ${id} 状态 → [${note}]` : `(未找到含 "${id}" 的未完成任务行，或状态未变)`;
   }
   if (action === 'note') {
     if (!note) return '用法: abs todo note <id> --note "断点/进度"（实时落 ↳ 断点 行）';
@@ -741,7 +752,7 @@ async function markDone(file, id, kind = '落地') {
       if (!moved && idOfTaskLine(l) === wantId) {
         changed = true;
         const head = withDoneKind(
-          l.replace('- [ ]', '- [x]').replace(/\(认领[^)]*\)/, '') + ` (完成 ${today()})`,
+          stripStateMark(l).replace('- [ ]', '- [x]').replace(/\(认领[^)]*\)/, '') + ` (完成 ${today()})`,
           kind,
         );
         const bp = [];
@@ -1059,12 +1070,12 @@ export async function cmdLint({ dir }) {
     const idxTxt = await readFileOrNull(join(vault, 'index.md'));
     const { items, found } = readRules(idxTxt);
     if (found && items.length > RULES_MAX) {
-      issues.push(`RULES-PILED-UP: Rules 区 ${items.length} 条 > ${RULES_MAX}；把长条目提炼成概念页，这里只留一句 + 链接`);
+      issues.push(`RULES-PILED-UP: Rules 区 ${items.length} 条 > ${RULES_MAX}；把长条目提炼成概念页，这里只留一句话`);
     }
     // 该区是 load 必读的硬规则清单，条目却写得像段落 → 提醒改短句。
     const longOnes = items.filter((l) => l.trim().length > 160);
     if (longOnes.length) {
-      issues.push(`RULES-TOO-LONG: Rules 区 ${longOnes.length} 条超 160 字符（如 "${clip(longOnes[0].trim(), 40)}"）；展开写进概念页，这里只留短句 + [[链接]]`);
+      issues.push(`RULES-TOO-LONG: Rules 区 ${longOnes.length} 条超 160 字符（如 "${clip(longOnes[0].trim(), 40)}"）；展开写进概念页，这里只留一句话（不带链接）`);
     }
   }
 
@@ -1172,74 +1183,3 @@ 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

@@ -1,5 +1,5 @@
 // src/todo.js — todo.md 读写。CLI 的核心纯读写层（被 MCP 转接、可被 hook 直接调）。
-// 格式沿用 SKILL.md 契约：Backlog → Today / In Progress → Blocked → Done，半成品 `↳ 断点:`。
+// 格式：两区 `## Todo`（未完成，行首 `[进行中|讨论中|滞留中]`）+ `## Done`；半成品附属行 `↳ 断点:`。
 import { promises as fs } from 'node:fs';
 import { brainPath } from './index.js';
 import { editFile, SKIP } from './lock.js';
@@ -48,32 +48,27 @@ export async function ensureTodo(brainRoot) {
 /** 分区名常量（单一真源）。改名时只改这里 —— 之前散在 20+ 处，一改就漏。
  * 旧名（中文）留在 LEGACY_SECTION_RENAMES 作迁移用。 */
 export const SEC = {
-  backlog: 'Backlog',
-  today: 'Today / In Progress',
-  blocked: 'Blocked',
+  todo: 'Todo',
   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'],
   // ## 分区
+  // 四区 → 两区（2026-09-13 用户定：Backlog/Today 常年为空，进行时分区与实际工作流错配）。
+  // 未完成的一律归 Todo，状态改由**行首标记**表达（见 TASK_STATES）。
+  ['## Backlog', '## Todo'],
+  ['## Today / In Progress', '## Todo'],
+  ['## Blocked', '## Todo'],
   ['## Done（只留近期，旧的迁 log.md/快照）', '## Done'],
-  ['## Topic', '## Topics'],
-  ['## 话题', '## Topics'],
-  ['## 话题树', '## Topics'],
-  ['## 分区', '## Topics'],
   // ### 区内分组标题
   ['### 归档', '### Archived'],
   ['### （未标日期）', '### Undated'],
@@ -106,12 +101,18 @@ export function todoTemplate() {
   ).text;
 }
 
-/** 分区分区（话题树）：**置顶** —— 回答「我们在做什么、分了几叉、哪些已死」。
- * 设计取舍（2026-09-13 用户定）：讨论轨道与执行轨道必须分开。
- * 实测教训：一轮会话讨论了 14 条话题线，而 todo 只能反映 1 条（记录率 7%）——
- * 因为话题一旦「已结论/已证伪」就不该再占待办位，但也不该消失。
- * 故：分区置顶存话题状态（含已证伪），Backlog/Today 只存「要动手的事」。 */
-export const TODO_SECTIONS = ['Topics', 'Backlog', 'Today / In Progress', 'Blocked', 'Done'];
+// 只有两区（2026-09-13 用户定：精简）。为什么砍掉 Backlog/Today/Blocked：
+// 实测跨 4 个项目，Backlog 与 Today 常年为 **0 条** —— 而 log.md 有 120 条。
+// 根因：AI 的工作方式是「一口气做完」，任务从开始到完成都在同一会话内走完，
+// 中间那个「挂到进行时分区上」的动作既来不及也不需要发生。
+// 而 log 是在**结束时**写的，那个时点真实存在，所以它记满了。
+// 结论：进行时分区是符合直觉但不符合实际工作流的抽象 → 删掉，
+// 未完成的一律进 Todo，状态用**行首标记**表达（不靠分区区分）。
+export const TODO_SECTIONS = ['Todo', 'Done'];
+
+/** 任务状态标记（行首，方括号）。替代原 Backlog/Today/Blocked 三区的区分作用。
+ * 放在 id **之前**，与 Done 结语的 `【落地】` 形态区分开（那是行尾、结语用）。 */
+export const TASK_STATES = ['进行中', '讨论中', '滞留中'];
 
 /** 结构重建（B 档）：以标准分区表为准重排整个文件。
  *
@@ -185,8 +186,11 @@ function trimBlank(arr) {
 export function normalizeTodo(text) {
   const lines = text.split('\n');
   const has = (name) => lines.some((l) => l.trim() === `## ${name}`);
-  if (has('Backlog') || has('Today / In Progress')) return text; // 已是新格式
-  if (!has('In Progress') && !has('Todo')) return text;          // 不是老格式，不动
+  // 已是标准两区制 = 有 Todo 且**没有**任何进行时老分区。
+  // 坑（2026-09-13）：曾只判 has('Todo') 就 return —— 而最老格式里也可能有 `## Todo`
+  // （与 `## In Progress` 混用），于是旧文件永不迁移。
+  const legacy = ['Backlog', 'Today / In Progress', 'In Progress', 'Blocked'].some(has);
+  if (has('Todo') && !legacy) return text;
   const out = ['# 📋 Todo Board'];
   const grab = (name) => {
     const items = [];
@@ -198,16 +202,50 @@ export function normalizeTodo(text) {
     return items;
   };
   const done = grab('Done');
-  const blocked = grab('Blocked');
-  const inprog = grab('In Progress');
-  const todo = grab('Todo');
-  out.push('## Backlog', ...todo.length ? todo : []);
-  out.push('## Today / In Progress', ...inprog.length ? inprog : []);
-  out.push('## Blocked', ...blocked.length ? blocked : []);
-  out.push('## Done', ...done.length ? done : []);
+  // 未完成的一切（不论原来在 Backlog/In Progress/Todo/Blocked）→ 一律进 Todo。
+  // 状态信息由行首标记承接：原 Blocked 区的任务补 [滞留中]（其余默认 [进行中]，写入时补）。
+  const open = [];
+  for (const name of ['Backlog', 'Today / In Progress', 'In Progress', 'Todo']) {
+    open.push(...grab(name).map((l) => ensureStateMark(l, '进行中')));
+  }
+  open.push(...grab('Blocked').map((l) => ensureStateMark(l, '滞留中')));
+  out.push('## Todo', ...open);
+  out.push('## Done', ...done);
   return out.join('\n');
 }
 
+/** 给任务行补行首状态标记（已有则不覆盖）。`- [ ] id …` → `- [ ] [状态] id …` */
+export function ensureStateMark(line, state) {
+  const m = String(line).match(/^(- \[[ x]\] )(\[[^\]]+\]\s+)?(.*)$/);
+  if (!m) return line;
+  if (m[2] && TASK_STATES.includes(m[2].trim().replace(/[\[\]]/g, ''))) return line;
+  return `${m[1]}[${state}] ${m[3]}`;
+}
+
+/** 取任务行的状态标记；无标记返回 null。 */
+export function stateOfTaskLine(line) {
+  const m = String(line).match(/^- \[[ x]\] \[([^\]]+)\]/);
+  return m && TASK_STATES.includes(m[1]) ? m[1] : null;
+}
+
+/** 改任务行的状态标记（原地）。未找到或非法状态返回原样。 */
+export function setStateMark(text, id, state) {
+  if (!TASK_STATES.includes(state)) return { text, changed: [] };
+  const lines = String(text ?? '').split('\n');
+  const idx = findTaskLine(lines, id);
+  if (idx === -1) return { text, changed: [] };
+  const cur = lines[idx];
+  if (stateOfTaskLine(cur) === state) return { text, changed: [] };
+  const raw = stripStateMark(cur);          // 先剥旧标记，再补新的
+  lines[idx] = raw.replace(/^(- \[[ x]\] )/, `$1[${state}] `);
+  return { text: lines.join('\n'), changed: [`${id} 状态 → ${state}`] };
+}
+
+/** 剥掉行首状态标记。 */
+export function stripStateMark(line) {
+  return String(line).replace(/^(- \[[ x]\] )\[[^\]]+\] /, '$1');
+}
+
 /** 从已完成任务行提取 `(完成 YYYY-MM-DD)` 日期；无则返回 ''。兼容中英文括号。 */
 export function doneDateOf(line) {
   const m = String(line).match(/\(完成\s*(\d{4}-\d{2}-\d{2})[^)]*\)/);
@@ -497,7 +535,7 @@ export function insertDoneGrouped(text, movedLines) {
   const di = lines.findIndex((l) => l.startsWith('## Done'));
   const newUnit = { date, lines: movedLines };
   if (di === -1) {
-    const header = '## Done（只留近期，旧的迁 log.md/快照）';
+    const header = `## ${SEC.done}`;
     return [...lines, '', header, '', ...renderDoneGroups([newUnit])].join('\n').replace(/\n+$/, '\n');
   }
   const head = lines.slice(0, di + 1);
@@ -539,12 +577,6 @@ function insertTask(orig, section, text) {
   return lines.join('\n');
 }
 
-/** 任务行解析：`- [ ] <id> — note (认领 date)` / 附属断点行 `↳ 断点:`。 */
-export function parseTaskLine(line) {
-  const m = line.match(/^- \[( |x)\] (.*?)(?: — (.*?))? \(?(认领|完成 \d{4}-\d{2}-\d{2}[^)]*)?\)?$/);
-  return m; // 保守解析；不匹配返回 null（附属行等）
-}
-
 /** 幂等登记：同 id 已有未完成任务行则原位更新（新 note/新认领日期），否则插入。 */
 export async function upsertTask(brainRoot, { section, text }) {
   const p = await ensureTodo(brainRoot);
@@ -555,16 +587,21 @@ export async function upsertTask(brainRoot, { section, text }) {
     const lines = base.split('\n');
     // 在所有分区中找该 id 对应的未完成任务行（Done 的已完成行不重复动）；全等比对
     const idx = findTaskLine(lines, id);
+    // 状态标记：新建用 text 里带的（默认 进行中），更新保留原有的
+    const wanted = String(text).match(/^\[([^\]]+)\]/)?.[1];
+    const state = idx !== -1
+      ? (stateOfTaskLine(lines[idx]) || wanted || '进行中')
+      : (TASK_STATES.includes(wanted) ? wanted : '进行中');
     if (idx !== -1) {
-      // 原位更新：保留断点附属行 + 原@作者，只换任务行本体
-      const raw = lines[idx].replace(/^- \[ \] /, '');
+      // 原位更新：保留断点附属行 + 原@作者 + 原状态，只换任务行本体
+      const raw = stripStateMark(lines[idx]).replace(/^- \[ \] /, '');
       const author = extractAuthor(raw);
       const legacy = isLegacyAuthorTag(raw); // 旧行保持旧形态，不静默改写
       const oldNote = extractNote(raw);
       const merged = note && oldNote && oldNote.startsWith(note) ? `${note}${oldNote.slice(note.length)}` : note || oldNote;
       const at = author ? ` ${legacy ? '@' + author : '[['
         + author + ']]'}` : '';
-      const newLine = `- [ ] ${id}${at}${merged ? ' — ' + merged : ''} (认领 ${today()})`;
+      const newLine = `- [ ] [${state}] ${id}${at}${merged ? ' — ' + merged : ''} (认领 ${today()})`;
       lines[idx] = newLine;
       return { text: lines.join('\n'), updated: true };
     }
@@ -577,7 +614,9 @@ export async function upsertTask(brainRoot, { section, text }) {
 
 /** 从任务文本提取幂等键（行首 id，如 TASK-1 / T-2 / fix-hook）。 */
 export function extractId(text) {
-  const m = String(text).match(/^([A-Za-z][\w-]*)\b/);
+  // 先剥行首状态标记（`[进行中] <id>`），否则 id 会取成 "[进行中]"（2026-09-13 实测）。
+  const t = String(text).replace(/^\[[^\]]+\]\s+/, '');
+  const m = t.match(/^([A-Za-z][\w-]*)\b/);
   return m ? m[1] : null;
 }
 
@@ -617,7 +656,9 @@ export function isLegacyAuthorTag(text) {
  */
 export function idOfTaskLine(line) {
   if (!line || !line.startsWith('- [ ]')) return null;
-  const m = line.match(/^- \[ \] (\S+)/);
+  // 两区制下行首可带状态标记（`- [ ] [进行中] <id> …`）—— 必须先剥掉再取 id，
+  // 否则 id 会被读成 "[进行中]"，findTaskLine 全等比对永远落空（2026-09-13 实测）。
+  const m = line.match(/^- \[ \] (?:\[[^\]]+\] )?(\S+)/);
   return m ? m[1].replace(/\u200b/g, '') : null;
 }
 
@@ -649,35 +690,6 @@ export async function setBreakpoint(brainRoot, { id, text }) {
     : { ok: true, msg: `✓ 断点已落 → ${id}\n  ${bp.trim()}` };
 }
 
-/** 实时碰壁: 任务行原位勾成 blocked 语义（移入 Blocked 区 + 附原因）。 */
-export async function moveBlocked(brainRoot, { id, reason }) {
-  const p = await ensureTodo(brainRoot);
-  const res = await editFile(p, (orig) => {
-    const lines = orig.split('\n');
-    const idx = findTaskLine(lines, id);
-    if (idx === -1) return SKIP;
-    const taskLine = lines[idx];
-    const kept = [];
-    const moved = [taskLine];
-    for (let i = 0; i < lines.length; i++) {
-      if (i === idx) {
-        while (i + 1 < lines.length && lines[i + 1].trimStart().startsWith('↳')) moved.push(lines[++i]);
-        continue;
-      }
-      kept.push(lines[i]);
-    }
-    const bIdx = kept.findIndex((l) => l.startsWith('## Blocked'));
-    if (reason) moved.push(`  ↳ 卡点: ${reason}`);
-    const out = bIdx === -1
-      ? [...kept, '## Blocked', ...moved]
-      : [...kept.slice(0, bIdx + 1), ...moved, ...kept.slice(bIdx + 1)];
-    return { text: out.join('\n'), ok: true };
-  });
-  return res === SKIP
-    ? { ok: false, msg: `(未找到含 "${id}" 的未完成任务行)` }
-    : { ok: true, msg: `✓ 已标阻塞 → Blocked 区: ${id}${reason ? `\n  卡点: ${reason}` : ''}` };
-}
-
 // ---------- 看板输出 ----------
 export async function boardText(brainRoot, textOverride, { full = false } = {}) {
   const text = textOverride !== undefined ? textOverride : await readTodo(brainRoot);
@@ -688,242 +700,3 @@ 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');
-}

package/src/wrapup.js

@@ -51,6 +51,10 @@ export function extractOpenTasks(todoText) {
     const m = l.match(/^\s*- \[ \]\s*(.*)$/);
     if (m) {
       const taskBody = m[1]
+        // 先剥行首状态标记（`[进行中] <id> …`）—— 它是**易变**的：任务状态一改
+        // （abs todo state）body 就变，而 strandedFor 用 body 精确比对 →
+        // 跨会话滞留提醒会静默消失（2026-09-13 实测复现）。body 必须状态无关。
+        .replace(/^\[[^\]]+\]\s+/, '')
         .replace(/\s*\(认领[^)]*\)\s*$/, '')
         .replace(/\s*\(完成[^)]*\)\s*$/, '')
         .trim();