@fanchao8609/agent_brain_sync 1.16.4 → 1.17.1

package/src/todo.js

@@ -1,1319 +1,10 @@
-// src/todo.js — todo.md 读写。CLI 的核心纯读写层（被 MCP 转接、可被 hook 直接调）。
-// 格式：两区 `## Todo`（未完成，行首 `[进行中|讨论中|滞留中]`）+ `## Done`；半成品附属行 `↳ 断点:`。
-import { promises as fs } from 'node:fs';
-import { brainPath } from './index.js';
-import { editFile, SKIP } from './lock.js';
-
-// 根文件行数上限（2026-10-05 从 lint.js 移来）：lint 用它报 ROOT-OVER-SIZE，
-// archive 用它在超限时放宽归档窗口。**放 todo.js 而非 lint.js** ——
-// lint 依赖 todo（checkFileShape），反向导入会成环。
-export const TODO_MAX_LINES = 60;
-export const LOG_MAX_LINES = 2000;
-export const INDEX_MAX_LINES = 200;
-
-// ---------- 本地日期 ----------
-export function today() {
-  // 用本地时区取 YYYY-MM-DD（toISOString 是 UTC, 会跨天错一天）
-  const d = new Date();
-  const p = (n) => String(n).padStart(2, '0');
-  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
-}
-
-// 本地日期时间 YYYY-MM-DD HH:MM（log 流水用）
-export function localStamp() {
-  const d = new Date();
-  const p = (n) => String(n).padStart(2, '0');
-  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
-}
-
-// ---------- 读取 todo.md ----------
-export async function readTodo(brainRoot) {
-  const p = brainPath(brainRoot, 'todo.md');
-  let text;
-  try {
-    text = await fs.readFile(p, 'utf8');
-  } catch {
-    return ''; // 尚未创建，按空处理（不在此创建，避免读操作写文件）
-  }
-  const norm = normalizeTodo(text);
-  const grouped = groupDoneSection(norm); // 平铺旧 Done → 按日期分组（幂等）
-  if (grouped !== text) {
-    // 惰性迁移也是写：走锁，避免与并发写互相覆盖（锁内 re-read 已是权威最新内容）
-    await editFile(p, (cur) => (cur === text ? { text: grouped } : SKIP));
-    return grouped;
-  }
-  return text;
-}
-
-export async function ensureTodo(brainRoot) {
-  const p = brainPath(brainRoot, 'todo.md');
-  // 缺失才建模板；经锁写盘保证原子性（避免与并发 editFile 读到半写内容）
-  await editFile(p, (cur) => (cur === null ? { text: todoTemplate() } : SKIP));
-  return p;
-}
-
-/** 分区名常量（单一真源）。改名时只改这里 —— 之前散在 20+ 处，一改就漏。
- * 旧名（中文）留在 LEGACY_SECTION_RENAMES 作迁移用。 */
-export const SEC = {
-  todo: 'Todo',
-  done: 'Done',
-  archived: 'Archived',   // Done 区内部的归档标记区（原 '### 归档'）
-  undated: 'Undated',     // Done 区内部无完成日期的尾组（原 '### （未标日期）'）
-};
-
-/** 旧名 → 新名。供 `abs init --repair` 一次性迁移（幂等）。
- * 只改匹配整行的标题，不动正文；不做模糊替换（防误改正文里提到的旧名）。 */
-// 分区标题归一（旧名 → 标准名）
-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'],
-  // ### 区内分组标题
-  ['### 归档', '### Archived'],
-  ['### （未标日期）', '### Undated'],
-];
-
-/** 把文件里的旧分区名就地改成新名（只改匹配整行的标题，不动正文）。
- * 返回 { text, changed:[旧名→新名] }。幂等：已改过的再跑 changed 为空。 */
-export function renameLegacySections(text) {
-  const lines = String(text ?? '').split('\n');
-  const changed = [];
-  const out = lines.map((l) => {
-    const t = l.trim();
-    for (const [oldN, newN] of LEGACY_SECTION_RENAMES) {
-      if (t === oldN) { changed.push(`${oldN} → ${newN}`); return newN; }
-    }
-    return l;
-  });
-  return { text: out.join('\n'), changed };
-}
-
-export function todoTemplate() {
-  // 由 rebuildStructure 生成，保证“模板”与“重排结果”逐字节一致
-  // （否则 load 会把新建的模板又重排一次 = 无意义的写盘）。
-  // 注意（2026-09-13 踩坑）：rebuildStructure 的 order 要**带 `## ` 前缀**，
-  // 而 TODO_SECTIONS 是裸名（两者用途不同，不能复用 —— 曾误传裸名导致
-  // 生成出没有 `##` 的裸标题行，模板直接损坏、Backlog 分区消失）。
-  return rebuildStructure(
-    ['# 📋 Todo Board', ...TODO_SECTIONS.map((s) => `## ${s}`)].join('\n'),
-    { h1: '# 📋 Todo Board', order: TODO_SECTIONS.map((s) => `## ${s}`) },
-  ).text;
-}
-
-// 只有两区（2026-09-13 用户定：精简）。为什么砍掉 Backlog/Today/Blocked：
-// 实测跨 4 个项目，Backlog 与 Today 常年为 **0 条** —— 而 log.md 有 120 条。
-// 根因：AI 的工作方式是「一口气做完」，任务从开始到完成都在同一会话内走完，
-// 中间那个「挂到进行时分区上」的动作既来不及也不需要发生。
-// 而 log 是在**结束时**写的，那个时点真实存在，所以它记满了。
-// 结论：进行时分区是符合直觉但不符合实际工作流的抽象 → 删掉，
-// 未完成的一律进 Todo，状态用**行首标记**表达（不靠分区区分）。
-export const TODO_SECTIONS = ['Todo', 'Done'];
-// todo 的 `###` 级标签（实测真实形态：`## Done` 下按日期分组 `### 2026-09-29`，
-// 归位的进 `### Archived`）。白名单只限这两类：日期组 + Archived。
-// 为什么必须列：`### ` 是 AI 最爱的「自建小节」位置（### 备忘 / ### 计划），
-// 只查 `## ` 会把它放过去。
-export const TODO_SUBSECTIONS = ['Archived'];
-/** `###` 标签是否放行：归档区 / 未标日期组 / 日期组 `YYYY-MM-DD`。
- *  `Undated` 是 LEGACY_MARKS 里的正式标准名（旧 `### （未标日期）` → `### Undated`），
- *  漏了它会把存量文件卡死（实测）。 */
-export function isAllowedTodoSub(name) {
-  return TODO_SUBSECTIONS.includes(name) || name === 'Undated' || /^\d{4}-\d{2}-\d{2}$/.test(name);
-}
-
-// ---------- 三份根文件的标签白名单与条目形状（2026-10-05 用户定）----------
-// 用户原话：「index Rules Concepts Entities Sources Syntheses Sessions 包含这些标签
-// 不允许增加新的标签，每个标签写内容的规则都是 - [[xx]]123 不允许乱写，同理 log todo 也是」
-//
-// 为什么需要：闸门只管骨架（分区顺序/H1/空行），**标签白名单与条目形状都没人管**。
-// rebuildStructure 的规矩 3 更是「非标准分区原样保留在末尾」（为了防丢人自加的内容）
-// → AI 新加一个 `## 备忘` 或 `## 计划` 永远合法，且会一直留在文件里。
-//
-// 注意 Rules 区是例外：它放的是**规矩短句**（「写代码前先读 docs/STRUCTURE.md」），
-// 不是页链接 —— 实测 13 条规则全是这个形态。不能拿 [[页名]] 去卡它。
-export const INDEX_SECTIONS = ['Rules', 'Concepts', 'Entities', 'Sources', 'Syntheses', 'Sessions'];
-/** 需要 `- [[页名]] …` 形状的区（Rules 除外）。 */
-export const INDEX_LINK_SECTIONS = ['Concepts', 'Entities', 'Sources', 'Syntheses', 'Sessions'];
-/** log 行的 kind 枚举（与 cmdLog 写入端同源；实测 238 条只有这 4 种）。 */
-export const LOG_KINDS = ['note', 'dev', 'concept', 'ingest'];
-
-/** 条目形状规则表：文件 → 每行的预期形状。
- *  校验器只报告「不像这个形状」的行，不自动改写内容（机器不猜语义）。 */
-/** 条目形状规则表：文件 → 每行的预期形状。
- *  校验器只报告「不像这个形状」的行，不自动改写内容（机器不猜语义）。 */
-export const H1_TO_FILE = {
-  '# 🗂 Graph Index': 'index.md',
-  '# 🗒 Activity Log': 'log.md',
-  '# 📋 Todo Board': 'todo.md',
-};
-
-export const ENTRY_SHAPES = {
-  'index.md': [
-    {
-      name: 'INDEX-ENTRY',
-      // 条目行：`- [[页名]] — 一句话`（是 6 个链接区里的一行）
-      test: (l) => {
-        if (!/^-\s/.test(l)) return null; // 非条目行（规则短句/说明）由分区规则另判
-        if (!/^-\s*\[\[[^\]]+\]\]/.test(l)) return '应以 `- [[页名]] …` 开头';
-        if (!/^-\s*\[\[[^\]]+\]\]\s*[—-]\s*\S/.test(l)) return '`[[页名]]` 后要跟 `— 一句话` 描述';
-        return null;
-      },
-    },
-  ],
-  'log.md': [
-    {
-      name: 'LOG-ENTRY',
-      test: (l) => {
-        if (!/^##\s/.test(l)) return null; // 非 `## ` 行（H1/注释）不管
-        // ★ log 没有分区概念：`## ` 开头的只能是条目。
-        //   否则 `## 2026-10-05 随便写点`（缺方括号/作者/竖线）会被当成「分区标题」滑过去 ——
-        //   而 log.md 的标签白名单是 null（不校验），这就是一个漏网口（实测）。
-        // 形状：## [YYYY-MM-DD HH:MM] [[作者]] kind | 正文
-        // ★ 放行历史旧模板的占位行 `## [YYYY-MM-DD] ingest | 沉淀 <slug>`：
-        //   它是早版 logTemplate 造出来的，不是人写的乱，而是模板自身的遗留。
-        //   新模板已改成 HTML 注释（见 store.js logTemplate）。存量这行由 lint 报。
-        if (/^##\s*\[YYYY-MM-DD\]/.test(l)) return null;
-        const m = l.match(/^##\s*\[(\d{4}-\d{2}-\d{2}(?:\s+\d{2}:\d{2})?)\]\s*\[\[([^\]]+)\]\]\s*([A-Za-z]+)\s*\|\s*(\S.*)$/);
-        if (!m) return '应为 `## [YYYY-MM-DD HH:MM] [[作者]] kind | 正文`（log 只能有这种行）';
-        if (!LOG_KINDS.includes(m[3])) return `kind 只能是 ${LOG_KINDS.join('/')}（收到 \`${m[3]}\`）`;
-        // 「正文只有个任务 id」不在这里拒（见下 lintOnly 规则）：它是**内容质量**
-        // 问题不是**结构格式**问题，当写入闸门会把存量脏库锁死（实测：真库仅一条
-        // 就让所有 abs log 失败）。留在此处只会误伤正常短标题（如 `log-0`）。
-        return null;
-      },
-      // 仅在 lint 阶段生效的额外规则（不阻写入，只报存量）。
-      lintOnly: (l) => {
-        const m = l.match(/^##\s*\[\d{4}-\d{2}-\d{2}[^\]]*\]\s*\[\[[^\]]+\]\]\s*[A-Za-z]+\s*\|\s*(\S.*)$/);
-        if (!m) return null;
-        if (/^[A-Z][A-Z0-9-]{2,}$/.test(m[1].trim())) return '正文只写了个任务 id（等于没记内容），补一句发生了什么';
-        return null;
-      },
-    },
-  ],
-  'todo.md': [
-    {
-      name: 'TODO-ENTRY',
-      // 任务行形状（实测）：
-      //   新写入（cmdTask）：`- [ ] [状态] id [[作者]] — 描述 (认领 日期)`
-      //   旧存量（四区制迁移）：`- [ ] 中文描述 (认领 日期)` ← 没有 id / 作者
-      //   已完成：`- [x] id …`（markDone 会 stripStateMark 去掉状态）
-      //
-      // ★ 为什么不强制要求 id：旧存量的 id 缺失是**历史事实**，机器不能凭空编造
-      //   （编了就是静默改写语义）。闸门只确保「结构可解析」：
-      //     未完成必须有 `[状态]`（归一后的标志）；已完成必须有内容。
-      //   而「新写入必须带 id」由 cmdTask 拼装保证 —— 那是入口的职责，
-      //   不是事后逐行猜（猜不出哪行是新的、哪行是旧的）。
-      test: (l) => {
-        if (/^#{1,3}\s/.test(l)) return null; // 标题行（## Done / ### 日期）不是条目
-        if (!/^-\s/.test(l)) return null; // 非条目行（如缩进的 ↳ 断点）由下面单独判
-        // Done 区的归档行：`- [[log-日期]] 完成任务 N 条`。
-        // ★ 历史命名不统一：还有 `[[2026-09-12-todo归档]]` 这种旧写法（实测），
-        //   只认 `log-` 前缀会把它误报为「缺状态标记」。状归档行与任务行的
-        //   区别不是命名而是**形态**：没有 `[ ]`/`[x]` 复选框的 [[链接]] 行。
-        if (/^-\s*\[\[[^\]]+\]\]\s+完成任务/.test(l)) return null;
-        if (/^-\s*\[\[log-\d{4}-\d{2}-\d{2}\]\]/.test(l)) return null;
-        const m = l.match(/^-\s*\[([ x])\]\s*(.*)$/);
-        if (!m) return '应以 `- [ ] ` 或 `- [x] ` 开头';
-        const rest = m[2].trim();
-        if (!rest) return '任务行不能只有复选框，要写做什么（已拒）';
-        // 未完成：必须有状态标记（新写法）——无标记的旧行由 enforceBrainFormat 自动补上，
-        // 走到这里还没标记 = 补不了（不是 `- [ ] ` 形状），报错。
-        if (m[1] === ' ' && !/^\[[^\]]+\]\s*\S/.test(rest)) {
-          return '未完成任务应为 `- [ ] [状态] …`（状态：进行中/讨论中/滞留中）';
-        }
-        // 断点附属行不能挤在同一行（应另起 `  ↳ 断点: `）
-        if (/↳\s*断点:/.test(rest)) return '断点要另起一行写 `  ↳ 断点: …`';
-        return null;
-      },
-    },
-  ], // 任务行/断点行另由 assertTodoContent 卡长度与报告体
-};
-
-/** 校验单个文件的分区标签白名单 + 条目形状。返回问题列表（不抛错，供 lint 与写入闸门共用）。
- *  reason 文案直接把出路写清楚 —— 报错不给出路等于让人挖坑。 */
-export function checkFileShape(file, text, { lintMode = false } = {}) {
-  const issues = [];
-  const lines = String(text ?? '').split('\n');
-  const allowed = file === 'index.md' ? INDEX_SECTIONS : file === 'todo.md' ? TODO_SECTIONS : null;
-
-  if (allowed) {
-    for (let i = 0; i < lines.length; i++) {
-      const l = lines[i];
-      // `## [` 开头是 log 的条目行，不是分区标签（否则会把 238 条流水全判非法）
-      if (/^##\s+\[/.test(l)) continue;
-      const m = l.match(/^##\s+(\S.*)$/);
-      const sub = l.match(/^###\s+(\S.*)$/);
-      if (!m && !sub) continue;
-      const name = (m ? m[1] : sub[1]).trim();
-      // todo 的 `###` 标签单独判（只许日期组 + Archived）
-      if (sub && file === 'todo.md') {
-        if (!isAllowedTodoSub(name)) {
-          issues.push({
-            code: 'SECTIONS-NOT-ALLOWED',
-            line: i + 1,
-            msg: `todo.md:${i + 1} 不允许的小节 \`### ${name}\`；` +
-              `todo.md 的 ### 只允许 \`### YYYY-MM-DD\`（Done 区日期组）、\`### Undated\` 与 \`### Archived\``,
-          });
-        }
-        continue;
-      }
-      if (!allowed.includes(name)) {
-        issues.push({
-          code: 'SECTIONS-NOT-ALLOWED',
-          line: i + 1,
-          msg: `${file}:${i + 1} 不允许的标签 \`${m ? '##' : '###'} ${name}\`；` +
-            `${file} 只允许 ${allowed.map((s) => `\`## ${s}\``).join(' / ')}${
-              file === 'todo.md' ? '（`###` 只许日期组与 `### Archived`）' : ''}。` +
-            `内容按语义归入现有标签，确实需要例外请先改白名单（见 src/todo.js 的 SECTIONS 常量）`,
-        });
-      }
-    }
-  }
-
-  // 条目形状
-  const shapes = ENTRY_SHAPES[file] || [];
-  if (shapes.length) {
-    // 先算每个行所属分区（形状只对被要求的区生效）
-    let section = null;
-    for (let i = 0; i < lines.length; i++) {
-      const l = lines[i];
-      // ★ 分区标题的识别不能吃掉 log 的条目行：log 的条目就是 `## [时间] …`，
-      //   若把它当分区标题就会 continue 掉本行，形状校验形同虚设（实测：
-      //   kind=node / 缺竖线 全部漏放）。判据：`## [` 开头 = 条目，不是分区。
-      // ★ 分区标题的识别不能吃掉 log 的条目行：log 的条目就是 `## [时间] …`，
-      //   若把它当分区标题就会 continue 掉本行，形状校验形同虚设（实测：
-      //   kind=node / 缺竖线 全部漏放）。
-      //   ★ log.md 特殊：它**没有分区**，`## ` 开头的只能是条目（含写错的），
-      //   所以 log 里绝不能把 `## ` 行当分区标题 —— 全交给形状规则判。
-      const sm = file === 'log.md' ? null : (/^##\s+\[/.test(l) ? null : l.match(/^##\s+(\S.*)$/));
-      if (sm) { section = sm[1].trim(); continue; }
-      if (!l.trim()) continue;
-      const needShape = file === 'log.md'
-        ? true
-        : file === 'todo.md'
-          ? true // todo 的任务行形状与分区无关（Todo/Done 都要 `- [ ] …`）
-          : indexLinkSectionNeeds(section);
-      if (!needShape) continue;
-      for (const rule of shapes) {
-        const bad = rule.test(l);
-        if (bad) issues.push({ code: rule.name, line: i + 1, msg: `${file}:${i + 1} ${bad}` });
-        // lintOnly 规则只在体检时跑（不阻写入）—— 用于「内容质量」类问题，
-        // 那些问题当闸门会把存量脏库锁死。
-        if (!lintMode) continue;
-        const bad2 = rule.lintOnly ? rule.lintOnly(l) : null;
-        if (bad2) issues.push({ code: `${rule.name}-QUALITY`, line: i + 1, msg: `${file}:${i + 1} ${bad2}` });
-      }
-    }
-  }
-  // 条目之间的空行（与写入闸门 assertNoStrayBlank 同判据）。
-  // lint 只能「报」，不能抛 —— 体检不能因格式坏而挂。
-  const isEntryLine = (l) => /^-\s/.test(l) || /^#{1,3}\s+\[/.test(l);
-  const isHeadingLine = (l) => /^#{1,3}\s/.test(l);
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim()) continue;
-    if (i > 0 && !lines[i - 1].trim()) continue; // 连续空行只报一次
-    let p = i - 1;
-    while (p >= 0 && !lines[p].trim()) p--;
-    let n = i + 1;
-    while (n < lines.length && !lines[n].trim()) n++;
-    const prev = p >= 0 ? lines[p] : null;
-    const next = n < lines.length ? lines[n] : null;
-    if (!prev || !next) continue;
-    if (isHeadingLine(prev)) continue; // 标签与首条目之间的空行是排版，不算乱
-    if (isEntryLine(prev) && isEntryLine(next)) {
-      issues.push({ code: 'STRAY-BLANK-LINE', line: i + 1, msg: `${file}:${i + 1} 条目之间不允许空行（条目必须紧贴）` });
-    }
-  }
-  return issues;
-}
-
-/** index 的某个区是否要求 `- [[页名]]` 形状（Rules 与未知区不要求）。 */
-function indexLinkSectionNeeds(section) {
-  return section !== null && INDEX_LINK_SECTIONS.includes(section);
-}
-
-/** 任务状态标记（行首，方括号）。替代原 Backlog/Today/Blocked 三区的区分作用。
- * 放在 id **之前**，与 Done 结语的 `【落地】` 形态区分开（那是行尾、结语用）。
- *
- * 「搁置」与「滞留中」的区别（2026-10-05 用户定，别合并）：
- *   滞留中 = 还要做，只是卡住了（等外部/等信息） → 下会话该捡起来
- *   搁置   = 不做了 / 用户改方向了           → 下会话不该捡，除非用户又提
- * 混在一起会让下会话分不清「该不该接着干」。 */
-export const TASK_STATES = ['进行中', '讨论中', '滞留中', '搁置'];
-
-/** 结构重建（B 档）：以标准分区表为准重排整个文件。
- *
- * 规则（保证内容不丢、不挪错）：
- *   1. 按 spec.order 顺序输出标准分区，每个分区下放**归属于它**的内容行；
- *   2. 归属判定：按行所处的原分区归入对应标准分区；旧名先按 spec.renames 归一；
- *   3. **非标准分区**（人自加的，如 `## 备忘`）→ 内容连同它自己的标题一起**原样保留在末尾**，
- *      绝不合入已有标准分区（机器不知道它的语义，猜错就是挪错内容）；
- *   4. 自由正文（不属于任何分区的行，如 H1 后的说明句）保留在 H1 之后；
- *   5. 幂等：已是标准结构 → 输出逐字节相同。
- *
- * 返回 { text, changed }；changed 为空的描述列表（空=无需改盘）。 */
-export function rebuildStructure(text, spec) {
-  const s = String(text ?? '');
-  const lines = s.split('\n');
-  const h1At = lines.findIndex((l) => l.trim().startsWith('# '));
-  const bodyStart = h1At === -1 ? 0 : h1At + 1;
-  const bucket = new Map();   // 标准分区名 -> 内容行
-  const extras = [];          // [{ title, lines }] 非标准分区，原样保留到末尾
-  const preamble = [];        // H1 与第一个 ## 之间的自由正文
-  let curStd = null;          // 当前在的标准分区名（null = 前言）
-  let curExtra = null;        // 当前在的额外分区对象
-  for (let i = bodyStart; i < lines.length; i++) {
-    const l = lines[i];
-    if (/^#{2,3}\s/.test(l)) {
-      const t = l.trim();
-      const renamed = (spec.renames?.find(([o]) => o === t) || [, t])[1];
-      if (spec.order.includes(renamed)) {
-        curStd = renamed;
-        curExtra = null;
-        if (!bucket.has(curStd)) bucket.set(curStd, []);
-      } else {
-        curExtra = { title: renamed, lines: [] };
-        extras.push(curExtra);
-        curStd = null;
-      }
-      continue;
-    }
-    if (curExtra) curExtra.lines.push(l);
-    else if (curStd) bucket.get(curStd).push(l);
-    else preamble.push(l);
-  }
-  const out = [spec.h1];
-  const pre = trimBlank(preamble);
-  if (pre.length) out.push('', ...pre);
-  // 每个分区标题前恒有一个空行（含空分区）。
-  // 坑（2026-10-06 定位）：旧写法对空分区走 `else out.push(name)` —— 不补空行，
-  // 于是「有内容分区 → 空分区」的接缝被挤成 `- [[页]] …` 紧贴 `## Sources`。
-  // 表现成「index 里那个空行反复丢」：人工补回 → 下次任意写操作(过 enforceBrainFormat)
-  // 又归一掉，来回拉锯（本机 corp_agent 实测，17961e5 补、f3f7e84 又丢）。
-  // 原注释担心「每次首跑都写盘一次」——实测不会：归一后自身就是稳定形态，
-  // 第二次跑 fixed 为空、零字节改动（幂等，见 test/todo 的自检）。
-  // H1 后必须恒有空行：`# H1` 与首个分区相贴是门面事故，不容忍。
-  for (const [idx, name] of spec.order.entries()) {
-    const body = trimBlank(bucket.get(name) || []);
-    out.push('', name, ...body);
-  }
-  for (const e of extras) {
-    const body = trimBlank(e.lines);
-    out.push('', e.title);
-    if (body.length) out.push(...body);
-  }
-  const next = out.join('\n').replace(/\n{3,}/g, '\n\n').replace(/\s+$/, '') + '\n';
-  return { text: next, changed: next === s ? [] : ['结构按标准重排'] };
-}
-
-/** 去掉首尾空行，不动中间（保留用户的分段）。 */
-function trimBlank(arr) {
-  const a = [...arr];
-  while (a.length && !a[0].trim()) a.shift();
-  while (a.length && !a[a.length - 1].trim()) a.pop();
-  return a;
-}
-
-/** 叶子条目行：log 的 `## [时间] …` 条目、todo/index 的 `- …` 行。
- * 空行落在两个叶子条目之间 = 人为排版漂移，会随条目增长把文件撑成两倍行数。
- * 注意（踩坑）：标题行不算 —— `## Done` 与 `### 日期` 之间的空行是分区排版，
- * 删了会把 Done 区挤成一片（首版误删）。 */
-const isLeafEntry = (l) => /^- |^#{1,3}\s+\[/.test(l);
-
-/** 已废弃的标准分区（2026-10-05 用户定，白名单只一条）。
- * `## Roadmap` 是 2026-09-13 用户亲手删的分区（`store.js` 注释写明原因：
- * “AI 自己写的方向总结，会被 load 反复读到并带偏后续会话”）。
- * 但 `rebuildStructure` 的规矩 3 是「非标准分区原样保留在末尾」——那条护栏是为了
- * 防丢失人自加的区（如 `## 备忘`），机器不猜语义。结果是 Roadmap 被当成“人自加的区”
- * 留了下来，而且 AI 每次重写 index 都能把它加回来：删一个分区的决策根本没生效。
- * 所以这里单列一张白名单，只放**被正式删过的标准分区**——它们进闸门就被整段丢弃；
- * 从没见过的（`## 备忘` 类）仍按护栏原样保留。不做通用机制，出现第二个再添。 */
-export const RETIRED_SECTIONS = ['## Roadmap'];
-
-/** 删除废弃分区的整段（标题到下一个同级/更高级标题前）。
- * 返回 { text, removed:[区名] }；只按整行精确匹配标题，不碰正文。 */
-export function dropRetiredSections(text) {
-  const lines = String(text ?? '').split('\n');
-  const removed = [];
-  const out = [];
-  let dropping = false;
-  let dropLevel = 0;
-  for (const l of lines) {
-    const m = l.match(/^(#{2,3})\s+(.*)$/);
-    if (m) {
-      const title = `${m[1]} ${m[2].trim()}`;
-      if (RETIRED_SECTIONS.includes(title)) {
-        removed.push(title);
-        dropping = true;
-        dropLevel = m[1].length;
-        continue;
-      }
-      // 遇到同级或更高级的标题 = 废弃区结束
-      if (dropping && m[1].length <= dropLevel) dropping = false;
-    }
-    if (!dropping) out.push(l);
-  }
-  return { text: out.join('\n'), removed };
-}
-
-/** 写入侧格式闸门：三个文件在**每次写盘前**都过这里，不是只在 load 时修。
- *
- * 规则（用户 2026-10-05 定）：
- *   1. 固定样式 — 标题/分区名必须逐字对标准，不符按 LEGACY_MARKS 归一；
- *   2. 不允许空行 — 条目之间不留空行（正文段落内的空行保留）；
- *   3. 结构固定 — 无 H1 的「无头文件」补回标准 H1，分区按标准顺序重排（rebuildStructure）。
- *
- * 入参 spec 与 checkBrainShape 的 BRAIN_SHAPE 同源（见 store.js）。
- * log.md 无分区（order 为空）→ 只做 H1/归一/去空行，不重排条目顺序（时间倒序自带语义）。
- * 返回 { text, fixed:[描述] }；fixed 为空 = 无需改盘。 */
-// ---------- 条目级闸门（2026-10-05 加）----------
-// 为什么加：闸门此前只管**骨架形状**（分区/H1/空行），不管条目**内容**。
-// 于是 AI 把 todo 当笔记本 —— 实施报告、测试数据、需求清单、架构分析全塞进
-// 断点行，文件涨到 232 行/上万字，而闸门与 lint 双双报「0 问题」。
-// 这里补上内容约束：todo 只能放 todo。长内容走 abs note（经验）/ abs log（流水）/ sources 页。
-//
-// 注意：**超长一律抛错，不静默截断**。截断会丢数据且无声 —— 正是要防的那种失效。
-export const BREAKPOINT_MAX = 200;
-export const TASK_LINE_MAX = 400;
-
-/** 一行的「违规签名」：去空白、截前 120 字。
- *  用途：比对「这条违规是不是写入前就有的」——新增的拒，存量的放。
- *  不按行号比对：插入一行会让后面所有行号位移，按行号会误判。 */
-function sigOfLine(l) {
-  return String(l).replace(/\s+/g, ' ').trim().slice(0, 120);
-}
-
-/** 把一份文本里所有「违规行」的签名收成集合（供存量/新增比对）。
- *  只有三个根文件用得上；非目标文件直接返回空集。
- *  ★ 空行特殊：签名取「上下两行拼接」不可靠 —— 插入一行就会让空行的
- *   相邻行变样，导致存量空行被当成新引入（实测：cmdNote 插一行后，
- *   同一处空行的签名就对不上了）。所以空行只记一个存在标记：
- *   入库前就有「条目间空行」这个毛病 → 后续写入全放行（lint 报）。 */
-export function violationSignatures(text) {
-  const set = new Set();
-  const lines = String(text ?? '').split('\n');
-  for (const l of lines) set.add(sigOfLine(l));
-  const isEntry = (l) => /^-\s/.test(l) || /^#{1,3}\s+\[/.test(l);
-  for (let i = 1; i < lines.length - 1; i++) {
-    if (lines[i].trim()) continue;
-    if (isEntry(lines[i - 1]) && isEntry(lines[i + 1])) {
-      set.add('HAS-STRAY-BLANK');
-      break;
-    }
-  }
-  return set;
-}
-/** 断点里出现这些 = 明显是在塞报告（列表/代码块/表格）。 */
-const REPORT_MARKERS = [
-  /^\s{0,4}[-*]\s+\S/m, // 列表项
-  /^\s{0,4}\d+[.)]\s+\S/m, // 有序列表
-  /```/, // 代码块
-  /^\s*\|.*\|\s*$/m, // 表格行
-];
-
-/** 数一个断点里有几个「句子」—— 断点是一件事，多句 = 在塞报告。
- *  分隔符只用**句末标点**（。！？!?）与带圈编号 ①②③。
- *  ★ 分号（；/;）**不算**分隔符：中文技术写作里它常用来连接同一个意思的两部分
- *  （「改到哪个文件；同类约束见 xx」），算成两句会误伤正常断点（实测：
- *  一条正常的「改到哪 + 同类约束 + 待确认」被判 3 句而拒绝写入）。
- *  为什么不用关键词表：关键词命中不稳（「功能/方案」正常描述也会出现），
- *  而「一句还是一段」是结构判据 —— 结构判据才可靠。 */
-function sentenceCount(s) {
-  return String(s)
-    .split(/[。！？!?]+|\s*[\u2460-\u2473]\s*/)
-    .map((x) => x.trim())
-    .filter(Boolean).length;
-}
-
-/** 「绝对不允许乱空行」（2026-10-05 用户定）：条目之间不能有空行。
- *  为什么必须拒而不只是修：旧实现是「自动删」（fixed.push('删除条目之间的空行')），
- *  但那是**默默改盘** —— 写进去的东西被改了而 AI 不知道，下次又写一遍。
- *  现在直接报错，让写入方自己写对。
- *  允许的位置：H1 与首个标签之间、标签与首条目之间、区与区之间（排版需要）。 */
-export function assertNoStrayBlank(text, file, prevSig = null) {
-  const lines = String(text ?? '').split('\n');
-  const isEntry = (l) => /^-\s/.test(l) || /^#{1,3}\s+\[/.test(l);
-  const isHeading = (l) => /^#{1,3}\s/.test(l);
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim()) continue;
-    // 找上一个/下一个非空行
-    let p = i - 1;
-    while (p >= 0 && !lines[p].trim()) p--;
-    let n = i + 1;
-    while (n < lines.length && !lines[n].trim()) n++;
-    const prev = p >= 0 ? lines[p] : null;
-    const next = n < lines.length ? lines[n] : null;
-    if (prev === null || next === null) continue; // 文件头尾空行不算
-    // 连续多个空行：报一次就够
-    if (i > 0 && !lines[i - 1].trim()) continue;
-    if (!isEntry(prev) && !isEntry(next)) continue; // 正文段落之间允许
-    // ★ 标题与首个条目之间必留一个空行（排版必需）—— H1/标签后紧跟条目反而难看。
-    //   实测踩坑：log 模板就是 `# H1` + 空行 + `## [日期] …`，不放行会把模板本身卡死。
-    if (isHeading(prev)) continue;
-    // 两个条目之间（含「条目 → 空行 → 条目」）不允许
-    if (isEntry(prev) && isEntry(next)) {
-      // 存量空行（写入前就有）→ 放行，交给 lint 报
-      if (prevSig !== null && prevSig.has('HAS-STRAY-BLANK')) continue;
-      throw new Error(
-        `✗ ${file} 不允许条目之间的空行（第 ${i + 1} 行）：\n` +
-        `  上一行: ${prev.slice(0, 50)}\n` +
-        `  下一行: ${next.slice(0, 50)}\n` +
-        `  条目必须紧贴；标签与首条目之间才留一个空行。已拒绝写入 —— 请删掉这个空行再写。`,
-      );
-    }
-  }
-  return true;
-}
-
-/** 校验 todo 全文的条目内容。抛错 = 拒绝写入（不是修正）。 */
-export function assertTodoContent(text, prevSig = null) {
-  const lines = String(text ?? '').split('\n');
-  /** 存量行（写入前就存在）→ 放行，交给 lint 报。 */
-  const isLegacy = (l) => prevSig !== null && prevSig.has(sigOfLine(l));
-  for (let i = 0; i < lines.length; i++) {
-    const l = lines[i];
-    const lineNo = i + 1;
-    if (l.startsWith('## ')) continue;
-    // 任务行
-    if (isTaskLine(l)) {
-      if (l.length > TASK_LINE_MAX && !isLegacy(l)) {
-        throw new Error(
-          `✗ 任务行太长（第 ${lineNo} 行 ${l.length} 字 > ${TASK_LINE_MAX}）—— todo 只放「要做什么」，一句话。\n` +
-          `  这么长的内容要么拆成多条任务，要么走 abs note（经验）/ abs log（流水）。\n` +
-          `  原文开头: ${l.slice(0, 60)}...`,
-        );
-      }
-      continue;
-    }
-    // 断点附属行
-    if (l.trimStart().startsWith('↳ 断点:')) {
-      if (isLegacy(l)) continue; // 存量超长断点：不阻写入（lint 报）
-      const body = l.trimStart().slice('↳ 断点:'.length).trim();
-      if (body.length > BREAKPOINT_MAX) {
-        throw new Error(
-          `✗ 断点太长（第 ${lineNo} 行 ${body.length} 字 > ${BREAKPOINT_MAX}）—— 断点只写「改到哪个文件哪一步」。\n` +
-          `  写不下的内容请分流：实施报告/验证数据 → abs log；经验与坑 → abs note；长设计 → .brain/sources/ 页。\n` +
-          `  原文开头: ${body.slice(0, 60)}...`,
-        );
-      }
-      if (REPORT_MARKERS.some((re) => re.test(body)) || sentenceCount(body) > 2) {
-        throw new Error(
-          `✗ 断点里像是塞了报告/清单（第 ${lineNo} 行）—— 断点是一句话（最多两句），不是文档。\n` +
-          `  todo 只能加 todo：要做的拆成任务，做完的写 abs log，经验写 abs note。\n` +
-          `  原文开头: ${body.slice(0, 60)}...`,
-        );
-      }
-      continue;
-    }
-  }
-  return true;
-}
-
-/** 删掉「条目之间的空行」（条目前后紧贴才是标准形态）。
- *  在 enforceBrainFormat 里跑两次：assertShape 前（清存量，否则存量空行会把写入全卡死）、
- *  重建后（重排会新建邻接关系）。幂等 —— 第二次通常零改动。
- *  为什么删而不是拒：空行不携带信息，删了不丢东西；而断点/条目形状带着内容，
- *  没有安全的自动修法，只能拒并让人处理。 */
-function stripStrayBlanks(body, fixed) {
-  const lines = String(body).split('\n');
-  const kept = [];
-  for (let i = 0; i < lines.length; i++) {
-    const l = lines[i];
-    if (!l.trim()) {
-      const prev = kept[kept.length - 1];
-      // 前瞻要跳过连续空行，否则「两个空行」里只有第一个被删（两个空行是常见形态，
-      // 首版留下一个 → 规则形同虚设）。
-      let j = i + 1;
-      while (j < lines.length && !lines[j].trim()) j++;
-      const next = lines[j];
-      if (prev !== undefined && next !== undefined && isLeafEntry(prev) && isLeafEntry(next)) {
-        fixed.push('删除条目之间的空行');
-        continue;
-      }
-    }
-    kept.push(l);
-  }
-  return kept.join('\n').replace(/\n{3,}/g, '\n\n').replace(/\s+$/, '') + '\n';
-}
-
-export function enforceBrainFormat(text, spec, prev) {
-  const src = String(text ?? '');
-  if (!src.trim()) return { text: src, fixed: [] };
-  // 内容闸门：形状归一之前先拒掉乱塞（超长断点/报告体），否则下面的 rebuild
-  // 会把它当「人自加的正文」好好保留下来 —— 越规整越难发现。
-  // ★ 存量宽容（2026-10-05 本机实测踩到）：只拒「本次写入新引入」的违规；
-  //   写入前就存在的违规放行（由 lint 报出）。
-  //   为什么：不做这个区分，库里只要有一条历史脏行，**所有写入全部失败** ——
-  //   实测真库（corp_agent）就因一条超长断点 + 8 条 `[]()` 条目，
-  //   连 `abs rule add` 都做不到，整个图谱变成只读。
-  const prevSig = prev == null ? null : violationSignatures(String(prev));
-  if (spec?.h1 === '# 📋 Todo Board') assertTodoContent(src, prevSig);
-  // ★ 标签白名单闸门放在**旧标记归一之后**（见下面 legacy 段之后）——
-  // 旧标签（`## Backlog` / `## Today / In Progress`）是**待迁移**的，不是非法新标签。
-  // 首版把校验放在归一之前，把存量老文件全卡死（7 个测试红，2026-10-05 实测）。
-  const fname = H1_TO_FILE[spec?.h1];
-  let checked = false;
-  const assertShape = (t) => {
-    if (!fname || checked) return;
-    checked = true;
-    // ★ 空行：直接拒绝（用户 2026-10-05：「绝对不允许乱空行」）。
-    //   存量库里本来就有空行的，在**写入前**先被归一清除（见 enforceBrainFormat 尾部），
-    //   所以走到这里仍有空行 = 本次写入引入的 → 拒。
-    assertNoStrayBlank(t, fname);
-    // ★ 标签/条目形状：存量脏行放行（不因历史数据锁死库），新增的拒。
-    //   为什么这类要宽容而空行不要：超长断点/`[]()` 条目**没有安全的自动修法**
-    //   （截断会丢数据、改格式会改语义），只能报给人看；而空行删了不丢任何信息。
-    const tLines = t.split('\n');
-    const bad = checkFileShape(fname, t).filter(
-      (it) => it.code !== 'STRAY-BLANK-LINE' &&
-              !(prevSig !== null && prevSig.has(sigOfLine(tLines[it.line - 1] || ''))),
-    );
-    if (bad.length) {
-      throw new Error(
-        `✗ ${fname} 格式不合规（写入被拒）：\n` +
-        bad.map((it) => `  · ${it.msg}`).join('\n') +
-        `\n  出路：内容归入现有标签，或走对应入口（页 → concepts/ 等子目录 + index 登记；流水 → abs log；经验 → abs note）。`,
-      );
-    }
-  };
-  const fixed = [];
-  // 旧标记 → 标准标记（H1 与分区/分组标题）。与 store.js 的 LEGACY_MARKS 同源，
-  // 由调用方通过 spec.renames 注入（todo.js 不反向依赖 store.js）。
-
-  // (0) 废弃分区：被正式删过的标准分区（如 Roadmap）整段丢弃，不等 rebuildStructure
-  // 把它当“人自加的区”留到末尾 —— 否则删分区的决策每次都被 AI 重写覆盖回去。
-  const retired = dropRetiredSections(src);
-  if (retired.removed.length) {
-    fixed.push(`删除已废弃分区: ${retired.removed.join(', ')}`);
-  }
-  // (1) 样式：旧标题名先归一到标准（LOG 无分区、不走 rebuildStructure，这条是它的唯一归一者）。
-  let body = retired.text;
-  const renames = spec.renames || [];
-  if (renames.length) {
-    const ls = body.split('\n');
-    for (let i = 0; i < ls.length; i++) {
-      const t = ls[i].trim();
-      const hit = renames.find(([o]) => o === t);
-      if (hit && ls[i] !== hit[1]) { ls[i] = hit[1]; fixed.push(`${hit[0]} → ${hit[1]}`); }
-    }
-    body = ls.join('\n');
-  }
-
-  // ★ 旧格式自动升级（2026-10-05）：闸门不能只会拒，还得会**修**。
-  //   用户要求「旧版本旧样式要能自动更新为新样式」。
-  //   这里把已知的旧形态归一为新形态，**归一之后再校验白名单** ——
-  //   否则存量老文件（无状态标记的裸任务行）会被当成违规而卡死（实测：
-  //   底层 addTask/upsertTask 传的就是裸文本，它们是内部 API，不是 AI 入口）。
-  if (fname === 'todo.md') {
-    const ls = body.split('\n');
-    for (let i = 0; i < ls.length; i++) {
-      // 裸任务行（`- [ ] id …` 无状态标记）→ 补默认「进行中」
-      if (/^- \[ \] /.test(ls[i]) && !/^- \[ \] \[[^\]]+\]/.test(ls[i])) {
-        const fixed2 = ensureStateMark(ls[i], '进行中');
-        if (fixed2 !== ls[i]) { ls[i] = fixed2; fixed.push('补回缺失的状态标记'); }
-      }
-    }
-    body = ls.join('\n');
-  }
-
-  // ★ 存量空行先清掉（2026-10-05）：必须跑在 assertShape **之前** ——
-  //   否则 assertShape 会看到存量空行而拒绝写入（实测把整个脏库锁成只读）。
-  //   删空行不丢任何信息，所以这里直接修，而不是报错。
-  body = stripStrayBlanks(body, fixed);
-
-  // ★ 白名单闸门在这里跑：旧格式已升级、旧标记已归一、存量空行已清，
-  //   剩下的违规才是真的本次引入。
-  assertShape(body);
-
-  // (3) 结构：先补 H1，再按标准重排分区。
-  const hasH1 = body.split('\n').some((l) => l.trim().startsWith('# '));
-  if (!hasH1) {
-    body = [spec.h1, '', body.replace(/^\n+/, '')].join('\n');
-    fixed.push(`补回缺失的 H1: ${spec.h1}`);
-  }
-  if (spec.order?.length) {
-    const r = rebuildStructure(normalizeTodoIf(body, spec), spec);
-    if (r.changed.length) fixed.push(...r.changed);
-    body = r.text;
-  }
-
-  // (2) 去条目间空行：同 stripStrayBlanks，但重建后再跑一次（重排会新建邻接关系）。
-  const out = stripStrayBlanks(body, fixed);
-  return { text: out, fixed };
-}
-
-/** todo.md 在重排前必须先走 normalizeTodo（知道旧的 Blocked → 滞留中 语义），
- * 其余文件原样进（rebuildStructure 自带旧分区名归一）。 */
-function normalizeTodoIf(body, spec) {
-  return spec.h1 === '# 📋 Todo Board' && spec.order?.[0] === '## Todo' ? normalizeTodo(body) : body;
-}
-
-export function normalizeTodo(text) {
-  const lines = text.split('\n');
-  const has = (name) => lines.some((l) => l.trim() === `## ${name}`);
-  // 已是标准两区制 = 有 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 = [];
-    let inSec = false;
-    for (const l of lines) {
-      if (l.startsWith('## ')) { inSec = l.trim() === `## ${name}`; continue; }
-      if (inSec && l.trim() && !isPlaceholder(l)) items.push(l);
-    }
-    return items;
-  };
-  const done = grab('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})[^)]*\)/);
-  return m ? m[1] : '';
-}
-
-// ---------- Done 结语契约 ----------
-// 为什么需要: `[x]` 原本同时表示「真落地」「评估后不做」「仅设计过」三种完全不同的状态，
-// 读的人(下一个会话/未来的自己)无法区分。实测翻车: 读 daemon 条的 [x] 当成已落地，
-// 实际它跑通后被撤销、代码全删 —— 基于假记录得出「daemon 是过配项」的错误结论。
-// 结论: 图谱的价值取决于「可被信任」，一条状态失真的记录比一百条冗长记录的危害大一个量级。
-export const DONE_KINDS = ['落地', '否决', '仅方案'];
-
-/** 从 Done 任务行提取结语标记；无标记返回 ''。 */
-export function doneKindOf(line) {
-  const m = String(line).match(/【(落地|否决|仅方案)】/);
-  return m ? m[1] : '';
-}
-
-/** 追写结语到任务行：插在 `(完成 …)` 之前，幂等（已有则原位替换）。 */
-export function withDoneKind(line, kind) {
-  if (!kind) return line;
-  const base = String(line).replace(/【(落地|否决|仅方案)】/g, '').replace(/\s{2,}/g, ' ').trimEnd();
-  const i = base.lastIndexOf(' (完成 ');
-  if (i === -1) return `${base} 【${kind}】`;
-  return `${base.slice(0, i)} 【${kind}】${base.slice(i)}`;
-}
-
-/** 判断一行是否为任务行（- [x] / - [ ]，允许缩进）。 */
-function isTaskLine(l) {
-  return /^\s*- \[[ x]\]/.test(l);
-}
-/** 判断一行是否为任务附属行（↳ 开头）。 */
-function isChildLine(l) {
-  return /^\s*↳/.test(l);
-}
-
-/** 把 Done 区文本（bodyLines，不含 `## Done` 标题）解析成任务单元 [{ date, lines:[main,...children] }]。
- * 剥 `### 日期` 分组标题与空行；任务行下紧跟的 ↳ 行并入该单元。 */
-function parseDoneUnits(bodyLines) {
-  const units = [];
-  let cur = null;
-  for (const l of bodyLines) {
-    if (/^### /.test(l.trim()) || l.trim() === '') { cur = null; continue; } // 分组标题/空行断开会话
-    if (isTaskLine(l)) {
-      cur = { date: doneDateOf(l), lines: [l] };
-      units.push(cur);
-    } else if (isChildLine(l) && cur) {
-      cur.lines.push(l); // 附属行挂到上一个任务
-    }
-  }
-  return units;
-}
-
-/** 按 (完成 date) 分组 Done 任务单元并重建文本行：新日期在前，未标日期归尾组。
- * 同组内保持输入顺序（幂等）。返回不含 `## Done` 标题的主体行。 */
-function renderDoneGroups(units) {
-  const byDate = new Map();
-  const undated = [];
-  for (const u of units) {
-    if (!u.date) undated.push(u);
-    else {
-      if (!byDate.has(u.date)) byDate.set(u.date, []);
-      byDate.get(u.date).push(u);
-    }
-  }
-  const dates = [...byDate.keys()].sort().reverse(); // 新日期在前
-  const out = [];
-  for (const d of dates) out.push(`### ${d}`, '', ...byDate.get(d).flatMap((u) => u.lines), '');
-  if (undated.length) out.push(`### ${SEC.undated}`, '', ...undated.flatMap((u) => u.lines), '');
-  return out;
-}
-
-/** 把 Done 区从「全量行」折叠为「按日期计数」，供 `abs load` / `abs todo` 这类
- * 给人（和 AI 上下文）看的视图用。
- *
- * 坑: 这两个命令此前直接 `todo.trim()` 全量打印，而 Done 区**无上限增长** ——
- * 本仓库一处就占 load 输出的 68.8%（19.6KB/28.4KB）。长历史机器上直接把
- * 上下文塞满（实报：「另一台机器 abs load 塞了 40%」）。
- * 这与 hooks.log / wrapup.log 同类问题（那两处有轮转），故这里只给计数，
- * 要看明细用 `abs todo` 加 `--full`，或直接看 todo.md / 归档页。
- *
- * `### 归档` 区（历史的「归档 N 条」标记行）体积小且是长期引用，原样保留。
- * 返回 { text, doneCount }；text 不含 `## Done` 标题行。 */
-export function collapseDone(text) {
-  const lines = String(text).split('\n');
-  const di = lines.findIndex((l) => l.startsWith('## Done'));
-  if (di === -1) return { text: String(text).trim(), doneCount: 0 };
-  const head = lines.slice(0, di);
-  const rest = lines.slice(di + 1);
-  const { groupLines, archiveLines } = splitDoneBody(rest);
-  const units = parseDoneUnits(groupLines);
-  // 按日期归组计数（新日期在前），未标日期的归尾
-  const byDate = new Map();
-  let undated = 0;
-  for (const u of units) {
-    if (!u.date) undated++;
-    else byDate.set(u.date, (byDate.get(u.date) || 0) + 1);
-  }
-  const counts = [...byDate.entries()]
-    .sort((a, b) => (a[0] < b[0] ? 1 : -1))
-    .map(([d, n]) => `${d} ${n} 条`);
-  if (undated) counts.push(`未标日期 ${undated} 条`);
-  // 只列最近 MAX_DONE_DATE_LINES 个日期组：日期组本身也随历史增长（实测 300 条跨 28 天
-  // 会把 load 输出从 660B 拉到 1203B）。载入视图只需"最近做了多少"，早期历史看归档页。
-  const MAX_DONE_DATE_LINES = 7;
-  const shown = counts.slice(0, MAX_DONE_DATE_LINES);
-  if (counts.length > MAX_DONE_DATE_LINES) {
-    const rest = counts.length - MAX_DONE_DATE_LINES;
-    shown.push(`… 另有 ${rest} 个更早日期组（abs todo --full 看全量）`);
-  }
-  const doneLines = units.length
-    ? [`## Done（${units.length} 条，按日期折叠）`, ...shown.map((c) => `- ${c}`)]
-    : ['## Done（0 条）'];
-  const out = [...head, ...doneLines, '', ...archiveLines].join('\n').replace(/\n{3,}/g, '\n\n').trim();
-  return { text: out, doneCount: units.length };
-}
-
-/** 归档标记区标题。它在 Done 区内部、日期分组之后，形如：
- *   ### Archived
- *   - [[2026-09-10-todo归档]] 完成任务 10 条
- * 这区不是任务行，不能被 parseDoneUnits 吃挂，否则 markDone 重建 Done 时会把它丢掉。
- * 故先切出去当"不透明区域"原样保留。 */
-const ARCHIVE_HEADING = `### ${SEC.archived}`;
-
-/** 把 Done 主体行切成 { groupLines, archiveLines }：把 `### 归档` 区当"不透明块"原样保留。
- * 注意不能简单"从标题切到文件尾" —— 否则一旦有日期组落在归档区之后（手改/旧数据），
- * 它会被当不透明内容除在分组之外，永远不参与归档。故只取到下一个 ###/## 标题为止。 */
-function splitDoneBody(bodyLines) {
-  const ai = bodyLines.findIndex((l) => l.trim() === ARCHIVE_HEADING);
-  if (ai === -1) return { groupLines: bodyLines, archiveLines: [] };
-  let end = ai + 1;
-  while (end < bodyLines.length && !/^#{2,3} \S/.test(bodyLines[end].trim())) end++;
-  return {
-    groupLines: [...bodyLines.slice(0, ai), ...bodyLines.slice(end)],
-    archiveLines: bodyLines.slice(ai, end),
-  };
-}
-
-/** 合并归档标记行：**每天一行** `- [[<日期>-todo归档]] 完成任务 N 条`。
- * 计数按 slug **累计**（同一天分两批归档时叠加，否则标记行与归档页实际内容不符）；
- * 已存在的其他天的标记行原样保留。返回含标题的行数组。 */
-function mergeArchiveLines(existing, entries) {
-  const out = existing.length ? [...existing] : [ARCHIVE_HEADING];
-  while (out.length && !out[out.length - 1].trim()) out.pop();
-  for (const { slug, count } of entries) {
-    const i = out.findIndex((l) => l.includes(`[[${slug}]]`));
-    const prev = i !== -1 ? Number((out[i].match(/完成任务 (\d+) 条/) || [])[1] || 0) : 0;
-    const line = `- [[${slug}]] 完成任务 ${prev + count} 条`;
-    if (i !== -1) out[i] = line;
-    else out.push(line);
-  }
-  out.push('');
-  // 标记行按日期倒序（与 Done 日期组同风格：新的在上）。
-  // 否则顺序 = 归档先后，多次归档后读起来是乱的（如 08/09/07）。
-  const dateOf = (l) => (String(l).match(/(\d{4}-\d{2}-\d{2})/) || [''])[0];
-  const body = out.slice(1).filter((l) => l.trim());
-  body.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
-  return [out[0], ...body, ''];
-}
-
-/** 本地日期减 n 天（YYYY-MM-DD）。纯字符串入出，避免时区漂移。 */
-function daysAgo(n, from) {
-  const [y, m, d] = String(from).split('-').map(Number);
-  const t = new Date(y, m - 1, d);
-  t.setDate(t.getDate() - n);
-  const pad = (x) => String(x).padStart(2, '0');
-  return `${t.getFullYear()}-${pad(t.getMonth() + 1)}-${pad(t.getDate())}`;
-}
-
-/** 一行是否为未完成任务行（- [ ]）。 */
-function isUndoneLine(l) {
-  return /^\s*- \[ \]/.test(l);
-}
-
-/**
- * 把 Done 区里"可归档"的日期组摘出来，并追回归档标记行。**纯函数**（不碰磁盘）。
- * 规则（用户定）：
- *   ① 只保留近 keepDays 天（含今天）；更早的才归档。
- *   ② 某一天只要还有未完成（- [ ]）任务，**整天都不归档**（不拆半天）。
- *   ③ 每**天**一个文件，slug 为 `log-<日期>`（由 slugFor 给）—— 即**归进那天的会话快照**
- *      （同一天的东西放一处，别为归档另建文件）。本函数只负责从 todo 文本里移除
- *      + 在 Done 区尾部的 `### 归档` 区**每天记一行** `- [[log-<日期>]] 完成任务 N 条`。
- * 无日期组（### （未标日期））无法判天数，**保守不归档**。
- * @returns {{text:string, archived:{date:string,lines:string[],slug:string,count:number}[], skipped:{date:string,reason:string}[], count:number}}
- */
-export function archiveDoneInText(text, { keepDays = 3, from = today(), maxLines = 0, slugFor = (d) => `log-${d}` } = {}) {
-  const lines = String(text || '').split('\n');
-  const di = lines.findIndex((l) => l.startsWith('## Done'));
-  if (di === -1) return { text, archived: [], skipped: [], count: 0 };
-  const head = lines.slice(0, di + 1);
-  const { groupLines, archiveLines } = splitDoneBody(lines.slice(di + 1));
-  const units = parseDoneUnits(groupLines);
-  if (!units.length) return { text, archived: [], skipped: [], count: 0 };
-
-  const keep = Math.max(1, Number(keepDays) || 3);
-  // 保留 cutoff..from 这 keep 天；比 cutoff 更早的才归档
-  let cutoff = daysAgo(keep - 1, from);
-  // 超限放宽（2026-10-05 加）：ROOT-OVER-SIZE 限看板 ≤60 行，而 keepDays≥1 意味着
-  //   密集工作日（一天几十条 Done）必然超限 —— 两条规则打架，且 archive 拒绝动，
-  //   于是每天提交都被 lint 拦一次。修法：**看板已超行数上限时，把 cutoff 推到当天**，
-  //   让「整天已完成」的组可以立刻归档（仍有 ② 未完成则整天不归档 的保护）。
-  // 注意裁到「今天之后」：判断是 `date >= cutoff → 保留`，若 cutoff = 今天，
-  // 今天的组仍被保留（首版就栽在这，dry-run 一看当天没进归档列表）。
-  if (maxLines && lines.length > maxLines) cutoff = daysAgo(-1, from);
-
-  const byDate = new Map();
-  const undated = [];
-  for (const u of units) {
-    if (!u.date) { undated.push(u); continue; }
-    if (!byDate.has(u.date)) byDate.set(u.date, []);
-    byDate.get(u.date).push(u);
-  }
-
-  const archived = [];
-  const skipped = [];
-  const keepUnits = [...undated];
-  if (undated.length) skipped.push({ date: '(未标日期)', reason: '无完成日期，无法判断天数（保守不归档）' });
-
-  for (const date of [...byDate.keys()].sort()) {
-    const us = byDate.get(date);
-    if (date >= cutoff) { keepUnits.push(...us); continue; }        // ① 近 N 天：保留
-    const undone = us.filter((u) => isUndoneLine(u.lines[0]));
-    if (undone.length) {                                            // ② 有未完成：整天不归档
-      skipped.push({ date, reason: `有 ${undone.length} 条未完成，整天不归档` });
-      keepUnits.push(...us);
-      continue;
-    }
-    const gLines = us.flatMap((u) => u.lines);                       // ③ 可归档
-    archived.push({
-      date,
-      lines: gLines,
-      slug: slugFor(date),
-      count: gLines.filter((l) => /^\s*- \[x\]/.test(l)).length,
-    });
-  }
-
-  if (!archived.length) return { text, archived: [], skipped, count: 0 };
-
-  const count = archived.reduce((n, g) => n + g.count, 0);
-  const entries = archived.map((g) => ({ slug: g.slug, count: g.count }));
-  const rebuilt = [...head, ...renderDoneGroups(keepUnits), ...mergeArchiveLines(archiveLines, entries)];
-  return { text: rebuilt.join('\n').replace(/\n+$/, '\n'), archived, skipped, count };
-}
-
-/** 归档页正文（按日期分组，原文保留）。供同日追写复用。 */
-export function renderArchiveBody(groups) {
-  const out = [];
-  for (const g of groups) out.push(`### ${g.date}`, '', ...g.lines, '');
-  return out.join('\n').replace(/\n+$/, '\n');
-}
-
-/** 归档区标题。归档内容全部落在这个二级标题下，**与 AI 手写的会话快照共存**：
- *  同一天的记录（快照 + 任务明细）放一个文件里，而不是分两个文件。
- *  写入侧只动这一段：标题之前的内容原样保留（已存在的人工内容一律不覆盖）。 */
-export const ARCHIVE_SECTION = '## 📦 任务归档';
-
-/** 把「任务归档」段合并进已有正文。**纯函数**（不碰磁盘）。
- *
- * 为何不再「每天一个文件」（2026-09-15 用户定）：
- *   归档页与 `log-<日期>.md` 会话快照是**同一天的记录**，分两处查着要开两个文件。
- *   改为：归档写进当天快照的 `ARCHIVE_SECTION` 段。
- *
- * 两个边界（都有测试钉住）：
- *   ① 文件不存在 → 建一个**只有归档段**的页（那天可能没写快照，仍只落这一个文件）。
- *   ② 文件已存在（含 AI 手写的快照）→ **只替换归档段**，段外内容逐字保留。
- *      同日重复归档（罕见）则把新日期组接在段内已有内容之后，不重复建段。
- *
- * @param body   现有全文（null = 文件不存在）
- * @param group  { date, lines, count }
- */
-export function upsertArchiveSection(body, group) {
-  const chunk = renderArchiveBody([group]);
-  if (body == null) {
-    // ① 新文件：只有归档段（无手写快照也合法 —— 那天本来就只有任务记录）
-    const fm = [
-      '---',
-      'tags: [session-log, todo-archive, 历史]',
-      `updated: ${group.date}`,
-      'status: reviewed',
-      '---',
-      '',
-      `# ${group.date} 记录`,
-      '',
-      '> 本页 = 该日的会话快照（若有）+ 从 `todo.md` Done 区迁出的任务明细。',
-      '',
-      ARCHIVE_SECTION,
-      '',
-      chunk.trimEnd(),
-      '',
-    ];
-    return fm.join('\n');
-  }
-  // ② 已存在：只动归档段，段外原样
-  const lines = body.split('\n');
-  const i = lines.findIndex((l) => l.trim() === ARCHIVE_SECTION);
-  if (i === -1) {
-    // 有文件但还没归档段 → 追加到末尾（不搅动已有内容）
-    return `${body.replace(/\s*$/, '')}\n\n${ARCHIVE_SECTION}\n\n${chunk.trimEnd()}\n`;
-  }
-  // 找到本段结束（下一个同级或更高级标题）
-  let j = i + 1;
-  while (j < lines.length && !/^#{1,2} \S/.test(lines[j].trim())) j++;
-  const head = lines.slice(0, i + 1);
-  const tailPart = lines.slice(j);
-  const existingInner = lines.slice(i + 1, j).join('\n').trim();
-  const merged = existingInner ? `${existingInner}\n\n${chunk.trimEnd()}` : chunk.trimEnd();
-  return [...head, '', merged, '', ...tailPart].join('\n').replace(/\n{3,}/g, '\n\n');
-}
-
-/** 幂等：把 todo 全文里平铺的旧 Done 区按日期分组（新日期在前，未标日期归尾）。
- * 已是分组态(### date)则原样返回——惰性迁移用，避免每次读都动文件。 */
-export function groupDoneSection(text) {
-  const lines = String(text || '').split('\n');
-  const di = lines.findIndex((l) => l.startsWith('## Done'));
-  if (di === -1) return text;
-  const body = lines.slice(di + 1);
-  const first = body.find((l) => l.trim());
-  if (first && /^### /.test(first.trim())) return text; // 已分组，幂等不动
-  const { groupLines, archiveLines } = splitDoneBody(body); // 归档标记区原样保留
-  const units = parseDoneUnits(groupLines);
-  if (!units.length) return text;
-  return [...lines.slice(0, di + 1), ...renderDoneGroups(units), ...archiveLines]
-    .join('\n').replace(/\n+$/, '\n');
-}
-
-/** 把 moved 单元（已完成任务行+附属行）放入 Done 区并整体按日期分组重建。
- * 供 markDone 用，锁内一次完成「归位 + 分组」。无 Done 区则文件尾补建。 */
-export function insertDoneGrouped(text, movedLines) {
-  const date = doneDateOf(movedLines[0]) || today();
-  const lines = String(text || '').split('\n');
-  const di = lines.findIndex((l) => l.startsWith('## Done'));
-  const newUnit = { date, lines: movedLines };
-  if (di === -1) {
-    const header = `## ${SEC.done}`;
-    return [...lines, '', header, '', ...renderDoneGroups([newUnit])].join('\n').replace(/\n+$/, '\n');
-  }
-  const head = lines.slice(0, di + 1);
-  const body = lines.slice(di + 1);
-  const { groupLines, archiveLines } = splitDoneBody(body); // 归档标记区原样保留
-  // 新完成单元置前：同日期组内新在最上（renderDoneGroups 按 encounter 顺序保持，日期再倒序排）
-  const units = [newUnit, ...parseDoneUnits(groupLines)];
-  return [...head, ...renderDoneGroups(units), ...archiveLines].join('\n').replace(/\n+$/, '\n');
-}
-
-// 占位/空任务行（老模板的 "（无）"/"无"/纯 - [ ]）不迁移
-function isPlaceholder(line) {
-  const t = line.trim();
-  if (!/^- \[[ x]\]/.test(t)) return false; // 只判任务行
-  const body = t.replace(/^- \[[ x]\]\s*/, '').replace(/\(认领[^)]*\)/g, '').trim();
-  return !body || /^(无|（无）|None|null)$/.test(body);
-}
-/** 在指定分区段落后插入一行任务；找不到分区则在文件末尾追加回退。写前惰性迁移老格式。 */
-export async function addTask(brainRoot, { section, text }) {
-  const p = await ensureTodo(brainRoot);
-  await editFile(p, (orig) => ({ text: insertTask(orig, section, text) }));
-  return { file: p, text };
-}
-
-/** 纯函数：把任务行插到分区标题后。供 editFile mutator 复用（upsert 也用它）。 */
-function insertTask(orig, section, text) {
-  const base = normalizeTodo(orig);
-  const lines = base.split('\n');
-  const header = `## ${section}`;
-  let idx = lines.findIndex((l) => l.startsWith(header));
-  if (idx === -1) {
-    lines.push('', header, `- [ ] ${text}`);
-  } else {
-    // 在该分区标题后、下一个分区标题前插入
-    let insertAt = idx + 1;
-    while (insertAt < lines.length && !lines[insertAt].startsWith('## ')) insertAt++;
-    lines.splice(insertAt, 0, `- [ ] ${text}`);
-  }
-  return lines.join('\n');
-}
-
-/** 幂等登记：同 id 已有未完成任务行则原位更新（新 note/新认领日期），否则插入。 */
-export async function upsertTask(brainRoot, { section, text }) {
-  const p = await ensureTodo(brainRoot);
-  const id = extractId(text);
-  const note = extractNote(text);
-  const out = await editFile(p, (orig) => {
-    const base = normalizeTodo(orig);
-    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 = 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 = `- [ ] [${state}] ${id}${at}${merged ? ' — ' + merged : ''} (认领 ${today()})`;
-      lines[idx] = newLine;
-      return { text: lines.join('\n'), updated: true };
-    }
-    return { text: insertTask(base, section, text), updated: false };
-  });
-  return out.updated
-    ? { file: p, text, updated: true }
-    : { file: p, text, updated: false };
-}
-
-/** 从任务文本提取幂等键（行首 id，如 TASK-1 / T-2 / fix-hook）。 */
-export function extractId(text) {
-  // 先剥行首状态标记（`[进行中] <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;
-}
-
-/** 提取 " — " 后的 note 部分（剥掉紧跟在 id 后的 `@author` 标记及尾部 `(认领 ...)`）。
- * 格式: `<id> @author — <note> (认领 date)`。@author 可选（旧行/未设置姓名时无）。 */
-export function extractNote(text) {
-  const i = String(text).indexOf(' — ');
-  if (i === -1) return '';
-  return String(text).slice(i + 3).replace(/\s*\(认领[^)]*\)\s*$/, '').trim();
-}
-
-/** 提取 id 后的作者标记（无则空）。供 upsertTask 原位重建行时保留作者。
- * 两种形态都要认：
- *   - 新: `- [ ] ID [[fanchao]] — note`   (wikilink 到人页)
- *   - 旧: `- [ ] ID @fanchao — note`      (裸 at 标记, 历史行)
- * 旧行只在原位更新时按原形态保留, 不做批量回填(原文/现场已不在, 回填等于编造)。
- * 返回的是**纯姓名**（不含 [[ ]] 与 @），由调用方决定用什么形态重写。 */
-export function extractAuthor(text) {
-  const s = String(text);
-  const link = s.match(/^\S+\s+\[\[([^\]]+)\]\]/);
-  if (link) return link[1].trim();
-  const at = s.match(/^\S+\s+@([\w\u4e00-\u9fff.-]+)/);
-  return at ? at[1] : '';
-}
-
-/** 判断行里的作者标记是旧裸 `@name` 形态（保留旧形态，不擅自升级）。 */
-export function isLegacyAuthorTag(text) {
-  return !/^\S+\s+\[\[/.test(String(text)) && /^\S+\s+@/.test(String(text));
-}
-
-/**
- * 从任务行取出行首 id token（`- [ ] <id> …` 里的 <id>）。
- * 坑: 不能用 l.includes(id) 定位任务 —— 那是子串匹配，`T1` 会命中 `T11`（同理
- * TASK-1/TASK-10、fix-hook/fix-hook-2），导致 upsert 误判"已存在"而原地改写别的任务、
- * 新任务静默消失。必须取出 id token 做全等比对。
- * id 里可能混入零宽字符(历史瑕疵)，比对前先剥掉。
- */
-export function idOfTaskLine(line) {
-  if (!line || !line.startsWith('- [ ]')) return null;
-  // 两区制下行首可带状态标记（`- [ ] [进行中] <id> …`）—— 必须先剥掉再取 id，
-  // 否则 id 会被读成 "[进行中]"，findTaskLine 全等比对永远落空（2026-09-13 实测）。
-  const m = line.match(/^- \[ \] (?:\[[^\]]+\] )?(\S+)/);
-  return m ? m[1].replace(/\u200b/g, '') : null;
-}
-
-/** 定位 id 对应的未完成任务行下标；附属断点行（↳ 开头）不算任务行。
- *  全等比对，不用 includes（否则 T1 会误命中 T11）。 */
-export function findTaskLine(lines, id) {
-  if (!id) return -1;
-  const want = String(id).replace(/\u200b/g, '');
-  return lines.findIndex((l) => idOfTaskLine(l) === want);
-}
-
-/** 实时断点: 在 id 任务行下原位补/换 `↳ 断点:` 附属行（不挪任务位置）。 */
-export async function setBreakpoint(brainRoot, { id, text }) {
-  const p = await ensureTodo(brainRoot);
-  const bp = `  ↳ 断点: ${text}`;
-  const res = await editFile(p, (orig) => {
-    const lines = orig.split('\n');
-    const idx = findTaskLine(lines, id);
-    if (idx === -1) return SKIP;
-    if (lines[idx + 1] && lines[idx + 1].trimStart().startsWith('↳ 断点:')) {
-      lines[idx + 1] = bp; // 幂等: 更新原附属行
-    } else {
-      lines.splice(idx + 1, 0, bp);
-    }
-    return { text: lines.join('\n'), ok: true };
-  });
-  return res === SKIP
-    ? { ok: false, msg: `[NO_MATCH] 未找到含 "${id}" 的未完成任务行` }
-    : { ok: true, msg: `✓ 断点已落 → ${id}\n  ${bp.trim()}` };
-}
-
-// ---------- 看板输出 ----------
-export async function boardText(brainRoot, textOverride, { full = false } = {}) {
-  const text = textOverride !== undefined ? textOverride : await readTodo(brainRoot);
-  const head = `📂 abs → 项目: ${brainRoot}`;
-  if (!text.trim()) return `${head}\n\n（todo.md 为空，先 abs todo add 登记任务）`;
-  // Done 区折叠：它无上限增长，全量打印会把上下文塞满（见 collapseDone 注释）
-  const body = full ? text.trim() : collapseDone(text).text;
-  const hint = full ? '' : '\n\n（Done 只给计数；看明细: abs todo --full）';
-  return `${head}\n\n${body}${hint}`;
-}
+// src/todo.js — 对外入口（re-export）。真正的实现在 src/todo/*.js。
+// 保留这一层是为了对外接口稳定：store.js / lint.js / note.js / wrapup.js / 测试的
+// import 路径与名字都不用改。
+
+export { TODO_MAX_LINES, LOG_MAX_LINES, INDEX_MAX_LINES, today, localStamp, SEC, extractId, extractNote, extractAuthor, isLegacyAuthorTag, claimOf, sessionOf } from './todo/common.js';
+export { LEGACY_SECTION_RENAMES, TODO_SECTIONS, TODO_SUBSECTIONS, isAllowedTodoSub, INDEX_SECTIONS, INDEX_LINK_SECTIONS, LOG_KINDS, H1_TO_FILE, ENTRY_SHAPES, TASK_STATES, RETIRED_SECTIONS, BREAKPOINT_MAX, TASK_LINE_MAX, DONE_KINDS, ARCHIVE_SECTION } from './todo/spec.js';
+export { todoTemplate, rebuildStructure, dropRetiredSections, enforceBrainFormat, normalizeTodo, ensureStateMark, stateOfTaskLine, stripStateMark } from './todo/structure.js';
+export { checkFileShape, violationSignatures, assertNoStrayBlank, assertTodoContent } from './todo/validate.js';
+export { doneDateOf, doneKindOf, withDoneKind, collapseDone, archiveDoneInText, renderArchiveBody, upsertArchiveSection, groupDoneSection, insertDoneGrouped } from './todo/archive.js';
+export { readTodo, ensureTodo, setStateMark, addTask, upsertTask, idOfTaskLine, findTaskLine, setBreakpoint, setMemo, readMemo, boardText } from './todo/tasks.js';