update

scripts/check-trash.mjs

@@ -0,0 +1,677 @@
+// 一次性验证脚本：回收站语义 —— 删除即「移到回收站」，且任何删除都不可在软件内彻底丢弃。
+//
+// 关键：只检查内存状态是不够的 —— 用户的真相之源是 Markdown 文件。所以每个用例都做
+//   内存变更 → serialize() → parseMarkdown() → 重新数任务
+// 这才能证明被删的任务真的落在文件里的「# 回收站」下，而不是只活在内存里。
+//
+// 用法：node scripts/check-trash.mjs
+
+import { TaskStore, TRASH_NAME, OTHER_TASKS_NAME, COMPLETED_NAME } from '../src/task-store.js';
+import { check, ok, bad, summary, printSummary } from './_lib/check.mjs';
+import { makeStore } from './_lib/store-fixture.mjs';
+import { parseMarkdown, CategoryKind } from '../src/markdown-parser.js';
+
+// 往返：serialize 出来再 parse 回来，返回 parse 后的 categories
+// （parseMarkdown 直接返回数组，不是 { categories }）
+function roundTrip(store) {
+  return parseMarkdown(store.serialize());
+}
+
+function findCat(categories, name) {
+  return categories.find(c => c.name === name) || null;
+}
+
+function texts(cat) {
+  return (cat?.tasks || []).map(t => t.text);
+}
+
+function totalTasks(categories) {
+  return categories.reduce((n, c) => n + (c.tasks?.length || 0), 0);
+}
+
+const DOC = `# 当前任务
+
+- [ ] 今天写周报
+- [✓] today 已完成 ⭐
+
+# 全部任务
+
+## 工作
+
+- [ ] 工作任务A
+- [✓] 工作已完成B
+
+## 未分类
+
+- [ ] 杂事C
+`;
+
+// ============================================================
+// v3 起没有 TODAY 真实分类 —— DOC 里的 `# 当前任务` 章节在加载时被
+// _migrateTodayCategory 迁移到了「未分类」子分类（迁移策略优先未分类），
+// 任务打上 @当前 标记。所以测试用「未分类」代替 v2 时代的「当前任务」。
+// ============================================================
+const TODAY_SUB = '未分类';
+
+console.log('\n[1] 删除任务 = 移到回收站，且经 Markdown 往返仍在');
+{
+  const store = makeStore(DOC);
+  const before = totalTasks(store.categories);
+  const today = store.getCategory(TODAY_SUB);
+  const victim = today.tasks.find(t => t.text === '今天写周报');
+
+  const ok = store.deleteTask(TODAY_SUB, victim.id);
+  check('deleteTask 返回 true', ok === true, `实际 ${ok}`);
+  check('任务已离开原分类', !texts(store.getCategory(TODAY_SUB)).includes('今天写周报'));
+  check('任务出现在内存回收站', texts(store.getTrashCategory()).includes('今天写周报'));
+  check('任务总数不变（未丢弃）', totalTasks(store.categories) === before,
+    `${before} → ${totalTasks(store.categories)}`);
+
+  const md = store.serialize();
+  check('序列化出现「# 回收站」', md.includes(`# ${TRASH_NAME}`), md);
+  check('「# 回收站」排在所有 ## 子分类之后',
+    md.lastIndexOf('## ') < md.indexOf(`# ${TRASH_NAME}`),
+    `子分类末位 ${md.lastIndexOf('## ')} / 回收站 ${md.indexOf(`# ${TRASH_NAME}`)}`);
+
+  const rt = roundTrip(store);
+  check('往返后回收站里仍有该任务', texts(findCat(rt, TRASH_NAME)).includes('今天写周报'),
+    JSON.stringify(texts(findCat(rt, TRASH_NAME))));
+  check('往返后原分类里没有该任务',
+    !texts(findCat(rt, TODAY_SUB)).includes('今天写周报'));
+  check('往返后任务总数不变', totalTasks(rt) === before, `${before} → ${totalTasks(rt)}`);
+  check('往返后子分类没被吞掉（工作/未分类都在，且仍挂在容器下）',
+    findCat(rt, '工作')?.parentOtherTasks === true && findCat(rt, '未分类')?.parentOtherTasks === true,
+    JSON.stringify(rt.map(c => `${c.name}:${c.kind}:${c.parentOtherTasks}`)));
+  check('往返后回收站 kind=TRASH', findCat(rt, TRASH_NAME)?.kind === CategoryKind.TRASH);
+}
+
+// ============================================================
+console.log('\n[2] 回收站内不能彻底删除（软件里没有任何不可逆入口）');
+{
+  const store = makeStore(DOC);
+  const today = store.getCategory(TODAY_SUB);
+  store.deleteTask(TODAY_SUB, today.tasks[0].id);
+  const trash = store.getTrashCategory();
+  const inTrash = trash.tasks[0];
+
+  const ok = store.deleteTask(TRASH_NAME, inTrash.id);
+  check('deleteTask(回收站, …) 返回 false', ok === false, `实际 ${ok}`);
+  check('任务仍在回收站', store.getTrashCategory().tasks.length === 1);
+
+  check('clearCompleted(回收站) 不清空回收站', store.clearCompleted(TRASH_NAME) === 0);
+  check('deleteCategory(回收站) 返回 false', store.deleteCategory(TRASH_NAME) === false);
+  check('回收站分类仍存在', store.getTrashCategory() !== null);
+  check('renameCategory(回收站, …) 返回 false',
+    store.renameCategory(TRASH_NAME, '我的垃圾') === false);
+  // addTask / addSubCategory 的失败约定是返回 null（不是 false）
+  check('addTask(回收站, …) 返回 null', store.addTask(TRASH_NAME, '不该出现') === null);
+  check('回收站没被塞进新任务', store.getTrashCategory().tasks.length === 1);
+  check('addSubCategory 不能占用保留名「回收站」', store.addSubCategory('回收站') === null);
+  check('addSubCategory 不能占用别名「trash」', store.addSubCategory('trash') === null);
+}
+
+// ============================================================
+console.log('\n[3] 回收站排除于智能列表之外（删掉的任务不该继续出现在 重要/全部/已完成）');
+{
+  const store = makeStore(DOC);
+  // v3.4：DOC 里带 [✓] + ⭐ 的任务在加载时已被搬到「# 已完成任务」分类，
+  // 不能再去 TODAY_SUB 找（那里只剩「今天写周报」一条）。
+  // 测试本意是「删掉一条带 ⭐ 的任务，验证它不再出现在任何智能列表」——
+  // 任务从哪个分类删掉不影响语义，换个分类即可。
+  const completed = store.getCompletedCategory();
+  const starred = completed?.tasks?.find(t => t.important);
+  if (!starred) throw new Error('未找到 starred 任务（fixture 异常）');
+  store.deleteTask(COMPLETED_NAME, starred.id);
+
+  for (const key of ['important', 'allTasks', 'completed']) {
+    const view = store._buildSmartListView(key);
+    check(`智能列表「${key}」不含已删除任务`,
+      !view.tasks.some(t => t.id === starred.id),
+      JSON.stringify(view.tasks.map(t => t.text)));
+  }
+}
+
+// ============================================================
+console.log('\n[4] 清除已完成 = 移到回收站，而不是丢弃');
+{
+  const store = makeStore(DOC);
+  const before = totalTasks(store.categories);
+  const n = store.clearCompleted();
+  check('clearCompleted 返回移动条数 2', n === 2, `实际 ${n}`);
+  check('任务总数不变（都进了回收站）', totalTasks(store.categories) === before,
+    `${before} → ${totalTasks(store.categories)}`);
+  const rt = roundTrip(store);
+  check('往返后两条已完成都在回收站里',
+    texts(findCat(rt, TRASH_NAME)).length === 2,
+    JSON.stringify(texts(findCat(rt, TRASH_NAME))));
+  check('往返后总数仍不变', totalTasks(rt) === before, `${before} → ${totalTasks(rt)}`);
+}
+
+// ============================================================
+console.log('\n[5] 恢复：从回收站移回分类（复用 moveTask / restoreTask）');
+{
+  const store = makeStore(DOC);
+  const today = store.getCategory(TODAY_SUB);
+  store.deleteTask(TODAY_SUB, today.tasks.find(t => t.text === '今天写周报').id);
+  const trashTask = store.getTrashCategory().tasks[0];
+
+  const ok = store.moveTask(TRASH_NAME, trashTask.id, '工作');
+  // moveTask 现在返回实际生效的目标分类名（防御性改投语义），不再是布尔。
+  // 这里任务是 uncompleted → 不触发改投 → 返回值就是用户传的 '工作'。
+  check('moveTask(回收站 → 工作) 返回「工作"（uncompleted 不触发改投）',
+    ok === '工作', `实际 ${ok}`);
+  check('回收站已空', store.getTrashCategory().tasks.length === 0);
+  check('任务在「工作」里', texts(store.getCategory('工作')).includes('今天写周报'));
+
+  const md = store.serialize();
+  check('回收站空 → 文件里不写「# 回收站」', !md.includes(`# ${TRASH_NAME}`), md);
+  const rt = roundTrip(store);
+  check('往返后任务仍在「工作」', texts(findCat(rt, '工作')).includes('今天写周报'));
+  check('往返后子分类结构完好',
+    findCat(rt, '工作')?.parentOtherTasks === true && findCat(rt, '未分类')?.parentOtherTasks === true);
+}
+
+// ============================================================
+console.log('\n[6] restoreTask 默认回到原分类（v3.5.2+）；无原分类兜底到「未分类」');
+{
+  const store = makeStore(DOC);
+
+  // 7a) restoreTask 在垃圾任务 / 不存在任务时返回 { ok: false }
+  check('无回收站时 restoreTask 返回 { ok: false }', store.restoreTask('nope').ok === false);
+
+  // 7b) 普通路径：从「工作」删除 → trash 记 originalCategory='工作' →
+  // 默认 restoreTask 走 _resolveRestoreTarget 命中 'category'，归位到「工作」。
+  // 不再走「未分类」兜底（v3.5.1 的旧行为）。
+  const work = store.getCategory('工作');
+  store.deleteTask('工作', work.tasks.find(t => t.text === '工作任务A').id);
+  const id = store.getTrashCategory().tasks[0].id;
+  const result = store.restoreTask(id);
+  check('restoreTask 返回 { ok: true, restored: true }',
+    result.ok === true && result.restored === true,
+    `result=${JSON.stringify(result)}`);
+  check('默认按原分类归位（v3.5.2+ 新行为）',
+    texts(store.getCategory('工作')).includes('工作任务A'),
+    `work=${texts(store.getCategory('工作'))}`);
+  check('restoreHint.kind === "category" 且带 targetName',
+    result.restoreHint && result.restoreHint.kind === 'category' &&
+      result.restoreHint.targetName === '工作',
+    `restoreHint=${JSON.stringify(result.restoreHint)}`);
+
+  // 7c) 兜底：删另一条后抹掉 originalCategory（模拟很旧的文件） → fallback 到「未分类」
+  store.deleteTask('工作', work.tasks.filter(t => t.text === '工作任务A')[0].id);
+  const id2 = store.getTrashCategory().tasks[0].id;
+  store.getTrashCategory().tasks[0].originalCategory = null;
+  const fallbackResult = store.restoreTask(id2);
+  check('无 originalCategory 时 restoreHint.kind === "fallback"',
+    fallbackResult.restoreHint && fallbackResult.restoreHint.kind === 'fallback',
+    `restoreHint=${JSON.stringify(fallbackResult.restoreHint)}`);
+  check('fallback 落到「未分类」',
+    texts(store.getCategory('未分类')).includes('工作任务A'),
+    `uncategorized=${texts(store.getCategory('未分类'))}`);
+
+  // 7d) 显式 toCategoryName 传给非法目标（容器）→ 拒绝、任务留在 trash
+  // 用「今天写周报」（在「未分类」里，completed=false）做这条断言：
+  //   - completed=true 的任务会被 store 强制路由到「已完成任务」无视 toCategoryName，
+  //     不能拿来做"显式无效参数拒绝"的回归
+  const today = store.getCategory(TODAY_SUB);
+  store.deleteTask(TODAY_SUB, today.tasks.find(t => t.text === '今天写周报').id);
+  const id3 = store.getTrashCategory().tasks[0].id;
+  const rejectResult = store.restoreTask(id3, OTHER_TASKS_NAME);
+  check('不能恢复到容器「全部任务」 → ok: false 且任务留在 trash',
+    rejectResult.ok === false && store.getTrashCategory().tasks.length === 1);
+}
+
+// ============================================================
+console.log('\n[7] 已有「# 回收站」的文件能被认出来，且不会被当成普通分类');
+{
+  const withTrash = DOC + `
+# 回收站
+
+<!-- 手工编辑说明 -->
+
+- [ ] 早先删掉的东西
+`;
+  const store = makeStore(withTrash);
+  const trash = store.getTrashCategory();
+  check('解析出 kind=TRASH 的回收站', trash !== null && trash.kind === CategoryKind.TRASH);
+  check('回收站里有 1 条任务', trash?.tasks.length === 1, JSON.stringify(texts(trash)));
+  check('HTML 注释没被读成任务', !texts(trash).some(t => t.includes('<!--')));
+  check('回收站不出现在子分类列表里',
+    !store.getSubCategories().some(c => c.kind === CategoryKind.TRASH),
+    JSON.stringify(store.getSubCategories().map(c => c.name)));
+  check('回收站在 categories 末位',
+    store.categories[store.categories.length - 1].kind === CategoryKind.TRASH,
+    JSON.stringify(store.categories.map(c => c.name)));
+}
+
+// ============================================================
+console.log('\n[8] 手工编辑产物：回收站必须收敛成唯一一个，且不丢任务');
+{
+  // 8a: 两个 # 回收站 → 合并成一个，两边的任务都要在
+  const two = `# 当前任务
+
+- [ ] A
+
+# 回收站
+
+- [ ] 第一个回收站的
+
+# 回收站
+
+- [ ] 第二个回收站的
+`;
+  const s1 = makeStore(two);
+  const trashes1 = s1.categories.filter(c => c.kind === CategoryKind.TRASH);
+  check('多个「# 回收站」合并为 1 个', trashes1.length === 1,
+    `实际 ${trashes1.length} 个`);
+  check('两个回收站的任务都保留',
+    texts(s1.getTrashCategory()).includes('第一个回收站的') &&
+    texts(s1.getTrashCategory()).includes('第二个回收站的'),
+    JSON.stringify(texts(s1.getTrashCategory())));
+  check('合并后总数不变', totalTasks(s1.categories) === 3,
+    `实际 ${totalTasks(s1.categories)}`);
+  check('合并后往返仍不丢', totalTasks(roundTrip(s1)) === 3);
+
+  // 8b: ## 回收站 被写成子分类 → 提升为 TRASH，不能与新建的回收站重名
+  const asSub = `# 当前任务
+
+- [ ] A
+
+# 全部任务
+
+## 回收站
+
+- [ ] 我被写成了子分类
+
+## 工作
+
+- [ ] W1
+`;
+  const s2 = makeStore(asSub);
+  check('「## 回收站」被提升为 kind=TRASH',
+    s2.getTrashCategory()?.kind === CategoryKind.TRASH,
+    JSON.stringify(s2.categories.map(c => `${c.name}:${c.kind}`)));
+  check('提升后不再是子分类',
+    s2.getTrashCategory()?.parentOtherTasks === false);
+  check('原有任务跟着保留',
+    texts(s2.getTrashCategory()).includes('我被写成了子分类'),
+    JSON.stringify(texts(s2.getTrashCategory())));
+  check('回收站排到了末位',
+    s2.categories[s2.categories.length - 1].kind === CategoryKind.TRASH,
+    JSON.stringify(s2.categories.map(c => c.name)));
+
+  // 删一个任务后不能出现同名分类
+  // v3：A 在迁移时搬到了首个子分类「工作」（此 DOC 没有「未分类」，所以用 first sub 兜底）
+  const workCat = s2.getCategory('工作');
+  const aTask = workCat.tasks.find(t => t.text === 'A');
+  s2.deleteTask('工作', aTask.id);
+  const sameName = s2.categories.filter(c => c.name === TRASH_NAME);
+  check('删除任务后没有产生同名「回收站」分类', sameName.length === 1,
+    `实际 ${sameName.length} 个`);
+  check('被删任务进了唯一的那个回收站',
+    texts(s2.getTrashCategory()).includes('A'),
+    JSON.stringify(texts(s2.getTrashCategory())));
+  check('往返后任务总数不变（3 项）', totalTasks(roundTrip(s2)) === 3,
+    `实际 ${totalTasks(roundTrip(s2))}`);
+
+  // 8c: 别名（# trash）也要被认成回收站，且保留用户的写法
+  const alias = `# 当前任务
+
+- [ ] A
+
+# trash
+
+- [ ] 英文回收站里的
+`;
+  const s3 = makeStore(alias);
+  check('别名「# trash」识别为 TRASH',
+    s3.getTrashCategory()?.kind === CategoryKind.TRASH);
+  check('别名不丢任务', texts(s3.getTrashCategory()).includes('英文回收站里的'));
+}
+
+// ============================================================
+console.log('\n[9] 正看着回收站时把它恢复空了 —— 选中项要跟着任务走，不能停在隐藏的分类上');
+{
+  const store = makeStore(DOC);
+  const today = store.getCategory(TODAY_SUB);
+
+  // 只删一条 → 回收站里只有 1 项
+  store.deleteTask(TODAY_SUB, today.tasks.find(t => t.text === '今天写周报').id);
+  store.selectCategory(TRASH_NAME);
+  check('已选中回收站', store.getSelectedCategory()?.name === TRASH_NAME);
+
+  // 恢复最后一条 → 回收站空了，侧边栏会隐藏它，选中项必须转移
+  store.restoreTask(store.getTrashCategory().tasks[0].id, '工作');
+  check('回收站空后选中项跟到「工作」',
+    store.getSelectedCategory()?.name === '工作',
+    `实际停在「${store.getSelectedCategory()?.name}」`);
+  check('不会停在被隐藏的回收站上',
+    store.getSelectedCategory()?.kind !== CategoryKind.TRASH);
+
+  // 还有剩余时不该乱跳
+  const store2 = makeStore(DOC);
+  const t2 = store2.getCategory(TODAY_SUB);
+  store2.deleteTask(TODAY_SUB, t2.tasks[0].id);
+  store2.deleteTask(TODAY_SUB, t2.tasks[0].id);
+  store2.selectCategory(TRASH_NAME);
+  store2.restoreTask(store2.getTrashCategory().tasks[0].id, '工作');
+  check('回收站还有剩余时保持停留在回收站',
+    store2.getSelectedCategory()?.name === TRASH_NAME,
+    `实际跳到「${store2.getSelectedCategory()?.name}」`);
+
+  // moveTask 走的恢复路径同样要跟随
+  const store3 = makeStore(DOC);
+  const t3 = store3.getCategory(TODAY_SUB);
+  store3.deleteTask(TODAY_SUB, t3.tasks[0].id);
+  store3.selectCategory(TRASH_NAME);
+  store3.moveTask(TRASH_NAME, store3.getTrashCategory().tasks[0].id, '未分类');
+  check('moveTask 清空回收站后也跟随到目标分类',
+    store3.getSelectedCategory()?.name === '未分类',
+    `实际停在「${store3.getSelectedCategory()?.name}」`);
+}
+
+// ============================================================
+// [10] 手工编辑文件后重新加载 —— 这是「彻底删除」的唯一途径，绝不能吃任务
+//
+// 软件刻意不提供「清空回收站」，官方指引就是「自己打开 Markdown 删掉那一行」。
+// 所以「手工编辑过的文件」是一等公民路径，它上面的任何一处数据丢失都比普通
+// bug 严重：用户是照着我们的说明书操作，结果丢了别的任务。
+// ============================================================
+{
+  console.log('\n[10] 手工编辑过的文件重新加载：不吃任务、不误判归属');
+
+  // ---- 10a. 旧文件 id 注释 + 手工新增行混合 ----
+  // 旧文件中残留的 `<!-- id:tN -->`（写时器 v3+ 不再写入，但历史文件可能仍有）
+  // 会被解析器剥掉，然后所有任务由解析器末尾的统一计数器重新分配 t1/t2/...
+  // 这里验证：手工新增的没有 id 注释的行也能被正确收进来，不被忽略或丢弃。
+  const HAND_EDITED = [
+    '# 当前任务', '',
+    '- [ ] 任务一 <!-- id:t1 -->',
+    '- [ ] 手写任务甲',
+    '- [ ] 任务三 <!-- id:t3 -->',
+    '- [ ] 手写任务乙', '',
+    '# 回收站', '',
+    '- [ ] 我被删过 <!-- id:t2 -->', ''
+  ].join('\n');
+
+  const cats = parseMarkdown(HAND_EDITED);
+  const allTexts = cats.flatMap(c => c.tasks.map(t => t.text));
+  check('手工新增的无 id 行不会撞掉已有任务（5 条全在）',
+    allTexts.length === 5,
+    `实际 ${allTexts.length} 条：${allTexts.join(' | ')}`);
+  for (const want of ['任务一', '手写任务甲', '任务三', '手写任务乙', '我被删过']) {
+    check(`  保留「${want}」`, allTexts.includes(want));
+  }
+  const ids = cats.flatMap(c => c.tasks.map(t => t.id));
+  check('分配后 id 全局唯一', new Set(ids).size === ids.length, ids.join(','));
+  const hTrash = cats.find(c => c.kind === CategoryKind.TRASH);
+  check('回收站没有整节消失', !!hTrash && hTrash.tasks.length === 1);
+
+  // ---- 10b. 用户整行复制（含 id 注释）→ 两条真实任务 ----
+  // v3+ 解析器不再从文件里读 id，所以两行都会剥离 id 注释，
+  // 然后由解析器末尾的统一计数器分配独立 id。两条任务都保留。
+  const DUP_ID = [
+    '# 当前任务', '',
+    '- [ ] 原始 <!-- id:t1 -->',
+    '- [ ] 复制出来的 <!-- id:t1 -->', ''
+  ].join('\n');
+  const dupCats = parseMarkdown(DUP_ID);
+  const dupTexts = dupCats.flatMap(c => c.tasks.map(t => t.text));
+  check('复制行的两条任务都保留（不丢一条）',
+    dupTexts.length === 2 && dupTexts.includes('原始') && dupTexts.includes('复制出来的'),
+    dupTexts.join(' | '));
+  const dupIds = dupCats.flatMap(c => c.tasks.map(t => t.id));
+  check('两条任务由解析器分配不同的 id',
+    new Set(dupIds).size === 2, dupIds.join(','));
+
+  // ---- 10c. 在「# 回收站」后面接着写 ## 分类 ----
+  // 回收站是文件最后一节，手工编辑时在它后面往下写是很自然的动作。
+  // 若这些任务继承了回收站，活跃任务会被标成「已删除」，而且下次保存时
+  // 这个 `##` 标题会彻底消失。
+  const AFTER_TRASH = [
+    '# 当前任务', '',
+    '- [ ] 活着的', '',
+    '# 回收站', '',
+    '- [ ] 已删除的', '',
+    '## 我手写的分类', '',
+    '- [ ] 我不该被当成已删除', ''
+  ].join('\n');
+  const atCats = parseMarkdown(AFTER_TRASH);
+  const atTrash = atCats.find(c => c.kind === CategoryKind.TRASH);
+  check('回收站里只有真正被删的那条',
+    atTrash && atTrash.tasks.length === 1 && atTrash.tasks[0].text === '已删除的',
+    atTrash ? atTrash.tasks.map(t => t.text).join(' | ') : '(无回收站)');
+  const atAll = atCats.flatMap(c => c.tasks.map(t => t.text));
+  check('回收站之后的任务没有丢', atAll.includes('我不该被当成已删除'), atAll.join(' | '));
+
+  const atStore = makeStore(AFTER_TRASH);
+  const atRT = roundTrip(atStore);
+  const atRTTrash = atRT.find(c => c.kind === CategoryKind.TRASH);
+  check('往返后仍不在回收站里',
+    !atRTTrash || !atRTTrash.tasks.some(t => t.text === '我不该被当成已删除'));
+  check('往返后总数不变（3 条）',
+    atRT.reduce((n, c) => n + c.tasks.length, 0) === 3);
+
+  // ---- 10d. 叫 bin / trash / 垃圾桶 的**子分类**不该被改判成回收站 ----
+  // 需要「正名」的唯一理由是和软件自己创建的「回收站」重名冲突；别名不冲突，
+  // 强行改判会把用户一整个装着活跃任务的分类标成已删除，标题也随之消失。
+  for (const alias of ['bin', 'trash', '垃圾桶']) {
+    const ALIAS_SUB = [
+      '# 当前任务', '',
+      '# 全部任务', '',
+      `## ${alias}`, '',
+      '- [ ] 我是活跃任务', ''
+    ].join('\n');
+    const aStore = makeStore(ALIAS_SUB);
+    const aCat = aStore.getCategory(alias);
+    check(`子分类「${alias}」保持普通分类（不被判成回收站）`,
+      aCat && aCat.kind !== CategoryKind.TRASH,
+      aCat ? `kind=${aCat.kind}` : '(分类不见了)');
+    check(`  「${alias}」里的任务没被当成已删除`,
+      !aStore.getTrashCategory() ||
+      !aStore.getTrashCategory().tasks.some(t => t.text === '我是活跃任务'));
+    const aRT = roundTrip(aStore);
+    check(`  往返后「## ${alias}」这一节还在`,
+      !!findCat(aRT, alias) && findCat(aRT, alias).tasks.length === 1);
+  }
+}
+
+// ============================================================
+// [11] v3.6 起不再写顶部 # 当前任务 / # 重要任务 镜像段：[▶]/[⭐] 由 inline 标识
+// 承载，智能视图在内存中按标识聚合。文件里同一条任务只活一次 —— 顶部不再重复。
+//
+// 本节回归：v3.x 顶部镜像段在旧文件里可能仍然存在 ——
+//   - # 当前任务 → TODAY 分类（store 的 _migrateTodayCategory 搬到首个子分类并打 [▶]）
+//   - # 重要任务 → SMART_LIST_KEYS 命中，__skip__ 整段跳过、任务归「未分类」
+// 下一次保存即扁平化为新结构 —— 不会丢数据。
+//
+// 「# 已完成任务」v3.4 起是真实分类（kind=COMPLETED），与「回收站」同款；
+// 段下带 [✓] 的任务自动收入并标记 completed=true。
+// ============================================================
+{
+  console.log('\n[11] v3.6 不再写顶部镜像段：旧文件镜像段消化路径');
+
+  // ---- 11a. v3.6 writer 不再生成 # 当前任务 / # 重要任务 顶部镜像段 ----
+  //
+  // 从旧格式文件加载（# 当前任务 是 TODAY 临时分类），clearCompleted 把 [x] 的「做完了」
+  // 移入回收站后序列化为 v3.6 新格式 —— 文件开头**不再**含顶部镜像段。
+  const s = makeStore('# 当前任务\n\n- [x] 做完了\n- [ ] 重要的 ⭐\n- [ ] 普通的\n');
+  s.clearCompleted();
+  const md = s.serialize();
+  check('写入器不再输出「# 当前任务」顶部镜像段',
+    !md.includes('# 当前任务'), md.split('\n').slice(0, 6).join('\n'));
+  check('写入器不再输出「# 重要任务」顶部镜像段',
+    !md.includes('# 重要任务'), md.split('\n').slice(0, 6).join('\n'));
+  check('写入器不再带「顶部摘要」引导注释',
+    !md.includes('<!-- 顶部摘要'), md.split('\n').slice(0, 6).join('\n'));
+  // v3.4 起仍不输出 # 已完成任务 镜像段 —— 它是真实分类（kind=COMPLETED），
+  // 段下任务由 store 自动搬入（这里没有已完成任务，所以不写）。
+  check('写入器不输出「# 已完成任务」镜像段（无人打过勾）',
+    !md.includes('# 已完成任务'), md);
+  // v3：重要任务由 ⭐ inline 标识驱动，标识位置仍在每条任务行末
+  check('任务的 ⭐ 标识原样保留在文件中',
+    md.includes('⭐'), md);
+
+  const rt = parseMarkdown(md);
+  // 「做完了」在回收站里，源任务三条；新格式下镜像段不存在，不会翻倍。
+  check('v3.6 文件往返后总数仍是 3（已删除那条在回收站、未被翻倍计入）',
+    rt.reduce((n, c) => n + c.tasks.length, 0) === 3,
+    rt.flatMap(c => c.tasks.map(t => t.text)).join(' | '));
+  check('已删除的「做完了」仍在回收站',
+    rt.find(c => c.kind === CategoryKind.TRASH)?.tasks.some(t => t.text === '做完了'));
+
+  // 二次往返：确认不是「刚好第一次没翻倍」
+  const s2 = makeStore(md);
+  check('二次往返总数仍为 3',
+    parseMarkdown(s2.serialize()).reduce((n, c) => n + c.tasks.length, 0) === 3);
+
+  // ---- 11b. 旧文件里残留的「# 重要任务」段被消化 —— __skip__ 整段跳过 ----
+  // 这是手工升级路径最重要的保证：旧文件被打开 → 解析 → 第一次保存后扁平化。
+  // 「# 重要任务」作为 SMART_LIST_KEYS 命中被 parser 整体跳过；段下手写行落到「未分类」
+  // （保守策略 —— 宁可多一条需要用户挪动的任务，也不要少一条）。
+  //
+  // 「# 已完成任务」v3.4 起是真实分类（kind=COMPLETED），段下带 [✓] 的任务归入并标记 completed。
+  const LEGACY_FILE = [
+    '# 全部任务', '',
+    '## 工作', '',
+    '- [ ] 工作任务A', '',
+    '# 重要任务', '',
+    '- [ ] 镜像段里的工作A', '',
+    '# 已完成任务', '',
+    '- [x] 镜像段里的已完成A', '',
+    '# 回收站', '',
+    '- [ ] 已删除A', ''
+  ].join('\n');
+  const legacy = parseMarkdown(LEGACY_FILE);
+  const allTexts = legacy.flatMap(c => c.tasks.map(t => t.text));
+  check('「# 重要任务」旧镜像段没有进入 categories',
+    !legacy.some(c => c.name === '重要任务'),
+    legacy.map(c => c.name).join(' / '));
+  const legacyCompleted = legacy.find(c => c.name === '已完成任务');
+  check('「# 已完成任务」是真实分类（kind=COMPLETED）',
+    !!legacyCompleted && legacyCompleted.kind === CategoryKind.COMPLETED,
+    legacy.map(c => `${c.name}(${c.kind})`).join(' / '));
+  check('旧镜像段下带 [✓] 的「镜像段里的已完成A」进入「# 已完成任务」并带 completed=true',
+    legacyCompleted?.tasks?.some(t => t.text === '镜像段里的已完成A' && t.completed === true),
+    legacyCompleted?.tasks?.map(t => `${t.text}(${t.completed})`).join(' | '));
+  check('真实分类里的任务不丢',
+    allTexts.includes('工作任务A') && allTexts.includes('已删除A'),
+    allTexts.join(' | '));
+  // 「# 重要任务」镜像段下的手写行落到「未分类」—— 4 条全部保留
+  check('「# 重要任务」镜像段下的手写任务也未丢，归入「未分类」',
+    allTexts.length === 4 &&
+      allTexts.includes('镜像段里的工作A') &&
+      allTexts.includes('镜像段里的已完成A'),
+    allTexts.join(' | '));
+
+  // ---- 11c. 旧文件把「# 当前任务」段放到文件前面 —— TODAY 迁移路径 ----
+  //
+  // v3.6 解析器对用户手敲的 `# 当前任务` 仍然识别为 TODAY 分类（兼容旧文件），
+  // store 的 _migrateTodayCategory 会把任务搬到首个子分类、打上 [▶] 标记、
+  // 删除临时分类 —— 不会丢数据。
+  const REORDERED = [
+    '# 已完成任务', '',
+    '<!-- 所有已勾选的任务，从各分类自动聚合 -->', '',
+    '- [✓] 做完了 <!-- id:t1 -->', '',
+    '# 当前任务', '',
+    '- [✓] 做完了 <!-- id:t1 -->',
+    '- [ ] 没做完 <!-- id:t2 -->', ''
+  ].join('\n');
+  const ro = parseMarkdown(REORDERED);
+  // 「# 已完成任务」是真实分类，下面的「做完了」按真实分类归属
+  const roCompleted = ro.find(c => c.name === '已完成任务');
+  check('「# 已完成任务」是真实分类（kind=COMPLETED）',
+    !!roCompleted && roCompleted.kind === CategoryKind.COMPLETED,
+    ro.map(c => `${c.name}(${c.kind})`).join(' / '));
+  check('「# 已完成任务」下「做完了」带 completed=true',
+    roCompleted?.tasks?.some(t => t.text === '做完了' && t.completed === true),
+    ro.flatMap(c => c.tasks.map(t => `${t.text}(${t.completed})`)).join(' | '));
+  check('「# 当前任务」TODAY 分类下的两条任务都保留（待 store 迁移）',
+    ro.find(c => c.name === '当前任务')?.tasks.length === 2,
+    ro.flatMap(c => c.tasks.map(t => t.text)).join(' | '));
+  const roAll = ro.flatMap(c => c.tasks.map(t => t.text));
+  check('所有 3 条任务都在（不丢数据）',
+    roAll.length === 3 && roAll.filter(t => t === '做完了').length === 2 && roAll.includes('没做完'),
+    roAll.join(' | '));
+}
+
+// ============================================================
+// [12] 回收站内 toggleTask 原地切换完成态（不再搬到「已完成任务」）
+//
+// 旧行为：回收站里打勾 → 任务移到「# 已完成任务」，违背"回收站是删除前的
+// 暂存区、用户在那里可以预览/清理"的心智模型（用户报 bug：在回收站里点了
+// 「已完成」的打勾，应该还是在回收站里，而不是跑到「已完成任务」里面）。
+//
+// 修复后：
+//   - 回收站里打勾 → 任务**仍留在回收站**，只切 completed 标记
+//   - 回收站里清勾 → 同上，留在回收站
+//   - originalCategory 不动（恢复时还要靠它归位）
+//   - writer 在回收站段照样写出 [✓]，parser 加载时识别 task.completed=true
+// ============================================================
+console.log('\n[12] 回收站 toggleTask 原地切换完成态（不跨分类）');
+{
+  // 12a) 回收站里 [ ] → [✓] → 任务仍留回收站，不进「已完成任务」
+  const store = makeStore(DOC);
+  const today = store.getCategory(TODAY_SUB);
+  store.deleteTask(TODAY_SUB, today.tasks.find(t => t.text === '今天写周报').id);
+  const trashId = store.getTrashCategory().tasks[0].id;
+  const beforeCompleted = store.getCompletedCategory().tasks.length;
+
+  const result = store.toggleTask(TRASH_NAME, trashId);
+  check('toggleTask(回收站) 返回 { ok: true }',
+    result && result.ok === true, `actual=${JSON.stringify(result)}`);
+  check('任务仍在回收站', store.getTrashCategory().tasks.some(t => t.id === trashId));
+  check('「已完成任务」分类条数不变（没把任务搬过来）',
+    store.getCompletedCategory().tasks.length === beforeCompleted,
+    `before=${beforeCompleted} / after=${store.getCompletedCategory().tasks.length}`);
+  check('任务 completed === true',
+    store.getTrashCategory().tasks.find(t => t.id === trashId).completed === true);
+
+  // writer 写出 [✓]
+  const md = store.serialize();
+  const trashSection = md.split(`# ${TRASH_NAME}`)[1] || '';
+  check('writer 在回收站段写出 [✓]',
+    trashSection.includes('[✓]') && trashSection.includes('今天写周报'),
+    trashSection.slice(0, 200));
+
+  // 12b) Markdown 往返：task.completed=true 保留在回收站段，不丢、不搬到「已完成任务」
+  const rt = roundTrip(store);
+  const rtTrash = findCat(rt, TRASH_NAME);
+  check('往返后回收站里任务仍带 completed=true',
+    rtTrash?.tasks?.some(t => t.text === '今天写周报' && t.completed === true),
+    JSON.stringify(rtTrash?.tasks?.map(t => `${t.text}(${t.completed})`)));
+  // DOC 本身带 [✓] 任务（被 _consolidateCompleted 搬到「已完成任务」），
+  // 但我们刚 toggle 的「今天写周报」不该出现在那里：
+  check('往返后「今天写周报」不在「已完成任务」分类里',
+    !findCat(rt, COMPLETED_NAME)?.tasks?.some(t => t.text === '今天写周报'),
+    JSON.stringify(findCat(rt, COMPLETED_NAME)?.tasks?.map(t => t.text)));
+
+  // 12c) 回收站里 [✓] → [ ] → 任务仍在回收站、不回到「已完成任务」
+  store.toggleTask(TRASH_NAME, trashId);
+  check('再 toggle 回 [ ]，任务 completed === false',
+    store.getTrashCategory().tasks.find(t => t.id === trashId).completed === false);
+  check('再 toggle 回 [ ]，任务仍在回收站（不跑到其它分类）',
+    store.getTrashCategory().tasks.some(t => t.id === trashId));
+
+  // 12d) originalCategory 不动 —— 恢复时还要靠它归位
+  const work = store.getCategory('工作');
+  const originalId = work.tasks.find(t => t.text === '工作任务A').id;
+  store.deleteTask('工作', originalId);
+  const trashedWithOrig = store.getTrashCategory().tasks.find(t => t.text === '工作任务A');
+  check('删到回收站后 originalCategory === "工作"（前置）',
+    trashedWithOrig?.originalCategory === '工作');
+  store.toggleTask(TRASH_NAME, trashedWithOrig.id);
+  const afterToggle = store.getTrashCategory().tasks.find(t => t.text === '工作任务A');
+  check('回收站里勾选后 originalCategory 仍为 "工作"（不重写）',
+    afterToggle?.originalCategory === '工作',
+    `actual=${afterToggle?.originalCategory}`);
+  store.toggleTask(TRASH_NAME, trashedWithOrig.id); // 清回 [ ]
+  check('回收站里清勾后 originalCategory 仍为 "工作"（不重写）',
+    afterToggle?.originalCategory === '工作',
+    `actual=${store.getTrashCategory().tasks.find(t => t.text === '工作任务A')?.originalCategory}`);
+}
+
+// ============================================================
+console.log(`\n${'─'.repeat(48)}`);
+console.log(`通过 ${summary.pass} / 失败 ${summary.fail}`);
+process.exit(summary.fail === 0 ? 0 : 1);