@fanchao8609/agent_brain_sync 1.8.8 → 1.8.9

package/src/store.js

@@ -7,6 +7,7 @@ import { requireUser, atTag, getUser } from './userconfig.js';
 import { stripStateMark, ensureStateMark, normalizeTodo, addTask, upsertTask, boardText, readTodo, ensureTodo, todoTemplate, today, localStamp, setBreakpoint, setStateMark, TASK_STATES, insertDoneGrouped, idOfTaskLine, archiveDoneInText, upsertArchiveSection, DONE_KINDS, withDoneKind, doneKindOf, doneDateOf, collapseDone, SEC, rebuildStructure } from './todo.js';
 import { editFile, SKIP } from './lock.js';
 import { appendWrapup, strandedFor } from './wrapup.js';
+import { keywords, pickRelevant, renderRelevant, recentFiles, rankPage } from './relevant.js';
 
 // ---------- init: 建 .brain/ 骨架 ----------
 const BRAIN_DIRS = ['entities', 'concepts', 'sources', 'syntheses', 'sessions'];
@@ -332,6 +333,27 @@ export async function cmdLoad({ dir }) {
       ''
     );
   }
+  // 卡点提取（2026-09-16，定位 = 看板可见性）：
+  // 从 todo 里抽出带 `阻塞:` / `等待:` 的断点行，集中展示。
+  // 为何需要：断点行在任务下方，一屏扫过去看不出"哪些事在等人/等外部"。
+  // 只提取不求全 —— 只有明确写了前缀的才被抽出，没写的不猜。
+  const blocks = extractBlocks(todo);
+  if (blocks.length) {
+    const at = sections.findIndex((s) => String(s).startsWith('--- Rules'));
+    sections.splice(at === -1 ? 1 : at, 0,
+      `⛔ 卡点 ${blocks.length} 条（在等外部条件）`,
+      ...blocks.map((b) => `  - ${b.id}: ${b.why}`),
+      '');
+  }
+  // 相关页提示（2026-09-16）：实测 abs_query 几乎不被调用（MCP 日志 task 234 / note 54 / load 53 vs query 2）。
+  // 根因：load 只列目录 → 模型觉得"我记过了" → 真需要时靠印象。模型不知道自己不知道什么。
+  // 解法（用户定）：不替它查 —— 而是【把该查的词直接给出来】，降低发起查询的成本。
+  //   自动带出正文是错的方向：那会让 query 更没人用，且无法按需求变化调整词。
+  // 失败静默：这只是 additive 提示，出任何错都不应弄坏 load。
+  try {
+    const rel = await queryHint(root, todo);
+    if (rel) sections.push('', rel);
+  } catch { /* 提示失败不影响 load */ }
   // sources 堆积提醒：与「滞留」同构 —— 放在每次开工必经的顶部，而不是等人跑 lint。
   // 只数目录条目（不读文件），零成本。提炼仍手工：这里只负责送达，不替判断。
   const nsrc = await countSources(root);
@@ -346,6 +368,61 @@ export async function cmdLoad({ dir }) {
   return sections.join('\n');
 }
 
+/**
+ * 从 todo 正文抽出"卡点"行，供 load 集中展示。
+ *
+ * 识别的前缀：`阻塞:` / `等待:` / `等 `（在断点/附属行里）。
+ * 为何只认前缀（不靠语义猜）：没写就是没写，猜出来的卡点比不报更坑。
+ *
+ * @returns {{id:string, why:string}[]}
+ */
+export function extractBlocks(todoText) {
+  const out = [];
+  let curId = null;
+  for (const line of String(todoText || '').split('\n')) {
+    // 任务行（未完成）：`- [ ] [状态] ID [[who]] — 描述`
+    const t = line.match(/^\s*-\s*\[\s*\]\s*(?:\[[^\]]*\]\s*)?(\S+)/);
+    if (t) { curId = t[1]; continue; }
+    // 完成行：不再跟踪
+    if (/^\s*-\s*\[x\]/.test(line)) { curId = null; continue; }
+    if (!curId) continue;
+    // 附属行（↳ 开头或缩进行）里找卡点前缀
+    const m = line.match(/^\s*(?:↳\s*断点:\s*)?(?:阻塞|等待|等)[:：]\s*(.+)$/);
+    if (m && m[1].trim()) out.push({ id: curId, why: m[1].trim() });
+  }
+  return out;
+}
+
+/**
+ * 开工提示：直接给出该查的几个词，降低发起 query 的成本。
+ *
+ * 为何不是"替它查"（2026-09-16 用户定）：自动带出正文会让 query 更没人用，
+ * 且无法按需求变化调整词。正确做法是把词准备好，查询仍由调用方发。
+ *
+ * 词从两个环境事实推：活跃 todo 的关键词 + 最近改过的文件名。
+ * 输出保持极短（两行）—— 它只是提示，不是报告。
+ */
+async function queryHint(root, todoText) {
+  const active = String(todoText || '')
+    .split('\n')
+    .filter((l) => /^\s*-\s*\[\s*\]/.test(l))
+    .join(' ');
+  const files = await recentFiles(root, { n: 5 }).catch(() => []);
+  const src = [active, files.map((f) => f.name).join(' ')].filter(Boolean).join(' ');
+  const kws = keywords(src);
+  // 只取 3 个：英文词优先（中文 2-gram 单看无意义）
+  const en = kws.filter((k) => /^[a-z][a-z0-9_-]+$/.test(k));
+  const zh = kws.filter((k) => !/^[a-z][a-z0-9_-]+$/.test(k));
+  const pick = [...en.slice(0, 2), ...zh.slice(0, 1)].slice(0, 3);
+  if (!pick.length) return '';
+  const rows = [
+    '--- 开工前建议查一次（图谱里有相关经验，别重踩）---',
+    `  abs query ${pick.join(' ')}`,
+  ];
+  if (files.length) rows.push(`  （据最近改动: ${files.slice(0, 3).map((f) => f.name).join(', ')}）`);
+  return rows.join('\n');
+}
+
 /** 数 sources/ 下的 .md 文件数（只读目录，不解析内容）—— load 顶部提醒用。
  *  坑: root 是【项目根】，图谱在 root/.brain/ 下 —— 必须走 brainPath，
  *  直接用 join(root,'sources') 会 ENOENT 被 catch 吞成 0，成为又一个静默失效。 */
@@ -768,7 +845,12 @@ export async function cmdTeardownCheck({ dir, payload }) {
     // ② 己方节流: 以 session_id 落 mark。缺 id 时退化为按项目+日期节流,
     //    绝不"无节流"——否则一旦宿主张不到 id, decision:block 就会无限自激。
     const sid = String(ev.session_id || ev.sessionId || '').replace(/[^\w-]/g, '');
-    const key = sid || 'nosession-' + day + '-' + root.replace(/[^\w]/g, '_');
+    // 兼底 key 只用【项目名】而非 full path。
+    // 坑(2026-09-16 实测): 原用 root.replace(/[^\w]/g,'_') 会把 cwd 的 tmp 路径
+    //   (/var/folders/..._tmpXXXX) 也编进去 —— 而每个会话的 tmp 目录都不同,
+    //   于是"按项目+日期节流"根本没生效, 每次都新 key → ~/.abs/log/ 堆了 361 个 mark。
+    const projKey = root.split('/').filter(Boolean).pop() || 'unknown';
+    const key = sid || 'nosession-' + day + '-' + projKey;
     const mark = join(absLogDir(), `teardown-${key}.mark`);
     try {
       await fs.access(mark);
@@ -776,6 +858,15 @@ export async function cmdTeardownCheck({ dir, payload }) {
     } catch { /* 未推过 */ }
     await fs.mkdir(dirname(mark), { recursive: true });
     await fs.writeFile(mark, stamp).catch(() => {});
+    // mark 只增不减会堆成垃圾(实测 361 个)。只清【带旧日期】的 mark ——
+    // 节流只在当天有意义(判据是 day), 旧日期 mark 不可能再命中;
+    // 无日期的会话 mark(teardown-<sid>.mark)保留, 它靠自身存在与否判重。
+    try {
+      for (const f of await fs.readdir(absLogDir())) {
+        const m = f.match(/^teardown-.*-(\d{4}-\d{2}-\d{2})-.*\.mark$/);
+        if (m && m[1] !== day) await fs.unlink(join(absLogDir(), f)).catch(() => {});
+      }
+    } catch { /* 清理失败不影响主流程 */ }
 
     const msg = [
       // 未设姓名时把设置指令插到第0条 —— 否则后续 todo add/log/note 全会被守卫拦下。
@@ -899,10 +990,10 @@ export async function cmdTask({ dir, action, id, section, note, as }) {
       cc = r.changed;
       return r.changed.length ? { text: r.text } : SKIP;
     });
-    return cc.length ? `✓ ${id} 状态 → [${note}]` : `(未找到含 "${id}" 的未完成任务行，或状态未变)`;
+    return cc.length ? `✓ ${id} 状态 → [${note}]` : `[NO_MATCH] 未找到含 "${id}" 的未完成任务行，或状态未变`;
   }
   if (action === 'note') {
-    if (!note) return '用法: abs todo note <id> --note "断点/进度"（实时落 ↳ 断点 行）';
+    if (!note) return '用法: abs todo note <id> --note "进度"\n  建议前缀（load 会把它们单独抽出来，让人一眼看到）:\n    验证: <跑过的命令/结果>\n    边界: <这方案治不了什么>\n    阻塞: <在等什么，卡在哪>';
     const r = await setBreakpoint(root, { id, text: note });
     return r.msg;
   }
@@ -945,7 +1036,7 @@ async function markDone(file, id, kind = '落地') {
     return { text: insertDoneGrouped(kept.join('\n'), moved) };
   });
   return res === SKIP
-    ? `(未找到含 "${id}" 的未完成任务行)`
+    ? `[NO_MATCH] 未找到含 "${id}" 的未完成任务行`
     : `✓ 已完成并归位 Done: ${id} 【${kind}】`;
 }
 
@@ -1002,8 +1093,9 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
       if (!f.endsWith('.md') || f.startsWith('_')) continue;
       const full = join(p, f);
       const body = await fs.readFile(full, 'utf8').catch(() => '');
-      const matched = words.filter((w) => body.toLowerCase().includes(w.toLowerCase()));
-      if (matched.length) {
+      const slug = f.replace(/\.md$/, '');
+      const rank = rankPage(body, slug, words);
+      if (rank) {
         // 作者从本页 frontmatter 读（权威来源）。不在 index 行里重复 ——
         // index 行是覆盖式更新的，作者会从"创建者"漂成"最后改的人"。
         const au = body.match(/^author:\s*(.+)$/m);
@@ -1012,28 +1104,34 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
         // 而不是回答"我上次怎么解決 X"（那会拿到一个已知错误的答案）。
         // 但它不是静默消失：计数里告知还有几条被隐藏（带 --all 能看）。
         if (st === 'superseded' && !includeSuperseded) {
-          hits.push({ hidden: true, slug: f.replace(/\.md$/, '') });
+          hits.push({ hidden: true, slug });
           continue;
         }
         hits.push({
-          full, slug: f.replace(/\.md$/, ''), matched,
+          full, slug, matched: rank.matched, kind: rank.kind, fuzzyScore: rank.score, via: rank.via,
           author: au ? au[1].trim() : '',
-          id: idOfPage(body, f.replace(/\.md$/, '')),
+          id: idOfPage(body, slug),
           status: st,
           supersededBy: supersededByOf(body),
-          snippet: firstHitLine(body, words),
+          snippet: firstHitLine(body, rank.matched.length ? rank.matched : words),
         });
       }
     }
   }
   const hidden = hits.filter((h) => h.hidden).length;
-  // 相关性排序：命中词多的排前面。
-  // 为什么不是严格 AND：26 页的量级下，「全词必须命中」经常直接归零（静默变成"查不到"）。
-  // 故先用命中数排序，让「全命中」自然浮顶；命中太稀（只 1 页）时才提示可加词。
-  // 实测痛点（2026-09-15）: 多词 OR 下查「安装 skill 报错」出 24/26 页（几乎全图）→ 相关性被稀释。
-  const shown = hits.filter((h) => !h.hidden)
-    .map((h) => ({ ...h, score: h.matched.length }))
+  // 分两区：精确命中优先，模糊只作补充。
+  // 坑(2026-09-16 实测): 不加区分时查 file-write-locking 返回 26 页（几乎全图）——
+  //   连字符词的 2-gram 太通用，模糊命中把无关页也拉进来。
+  //   规则：只要有任何精确命中，模糊命中的就不排在前面（但也不丢弃，单列一段）。
+  const exactHits = hits.filter((h) => !h.hidden && h.kind === 'exact')
+    .map((h) => ({ ...h, score: h.fuzzyScore }))
+    .sort((a, b) => b.score - a.score);
+  const fuzzyHits = hits.filter((h) => !h.hidden && h.kind === 'fuzzy')
+    .map((h) => ({ ...h, score: h.fuzzyScore }))
     .sort((a, b) => b.score - a.score);
+  // 有精确命中 → 模糊全藏起来（但不静默：告知数量 + 怎么看）
+  const fuzzySuppressed = exactHits.length > 0 && fuzzyHits.length > 0;
+  const shown = exactHits.length ? exactHits : fuzzyHits;
   if (!shown.length) {
     const extra = hidden ? `（另外 ${hidden} 页已标记 superseded，用 abs query ${words.join(' ')} --all 查看）` : '';
     return `query [${words.join(', ')}]: 无命中。${extra}用 abs lint 看图谱健康；首次使用先 abs init。`;
@@ -1045,13 +1143,19 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
     const id = h.id && h.id !== h.slug ? `  [id: ${h.id}]` : '';
     // draft = 未经核实。不拦使用，但必须让 AI 知道这是它自己没验证过的。
     const st = h.status === 'draft' ? '  [draft 未核实]' : '';
-    const full = words.length > 1 && h.score === words.length ? ' ★全命中' : '';
-    return `📄 ${h.slug}${by}${id}${st}  (命中: ${h.matched.join(', ')}${full})\n    ${h.snippet}`;
+    const full = h.kind === 'exact' && words.length > 1 && h.matched.length === words.length ? ' ★全命中' : '';
+    // 模糊命中必须显式标出 —— 否则用户会把"语义相近"当成"真的是这条"。
+    const fuzzy = h.kind === 'fuzzy' ? '  [模糊命中: 字面未出现，仅字形相近]' : '';
+    const hitTxt = h.matched.length ? h.matched.join(', ') : '(无字面命中)';
+    // 命中渠道：tag 最有价值（人工提炼的关键词），显式标出便于判断可信度
+    const viaTag = h.via && h.via.tag.length ? `  [tag: ${h.via.tag.join(', ')}]` : '';
+    return `📄 ${h.slug}${by}${id}${st}${fuzzy}  (命中: ${hitTxt}${full})${viaTag}\n    ${h.snippet}`;
   });
   // 多词且无全命中时告知降级了 —— 不静默给一堆弱相关结果。
-  const anyFull = shown.some((h) => h.score === words.length);
+  const anyFull = shown.some((h) => h.kind === 'exact' && h.matched.length === words.length);
   const tail = [];
   if (words.length > 1 && !anyFull) tail.push('', `（无页同时命中全部 ${words.length} 个词，以下按命中数排序）`);
+  if (fuzzySuppressed) tail.push('', `（另有 ${fuzzyHits.length} 页字形相近但字面未命中，已隐藏 —— 它们通常不相关）`);
   if (hidden) tail.push(``, `（${hidden} 页 superseded 已隐藏；--all 可看）`);
   return [`query [${words.join(', ')}] → ${shown.length} 页:`, '', ...lines, ...tail].join('\n');
 }
@@ -1092,9 +1196,9 @@ function firstHitLine(body, words) {
 // ---------- note: 经验实时暂存（source 页，一念一落，防流失） ----------
 const NOTE_DEDUP_MS = 60 * 1000;
 
-export async function cmdNote({ dir, text, tags }) {
+export async function cmdNote({ dir, text, tags, when }) {
   const clean = String(text || '').trim();
-  if (!clean) return '用法: abs note "经验/坑/技巧一句话"（落 sources/ 暂存页，实时不流失）';
+  if (!clean) return '用法: abs note "经验/坑/技巧一句话" [--when "何时该读它"]（落 sources/ 暂存页，实时不流失）';
   let root;
   try {
     root = await requireBrain(dir || process.cwd());
@@ -1118,6 +1222,9 @@ export async function cmdNote({ dir, text, tags }) {
   const slugSrc = slugOf(clean);
   const file = `${today()}-${slugSrc || 'note'}.md`;
   const heading = clip(clean, 80); // 页面标题: 完整优先, 超长才收口
+  // 触发条件（2026-09-16）：经验"写入多读得少"的根因之一是存的是结论、不是"何时该看"。
+  // 带上 --when 后，load 的相关页推荐能按当前在做的事匹配，而不是按主题词。
+  const whenText = String(when || '').trim();
   const body = [
     '---',
     `tags: [${fmTags}]`,
@@ -1130,9 +1237,11 @@ export async function cmdNote({ dir, text, tags }) {
     `# 来源：${heading}`,
     '',
     `TITLE: ${clean}`,
+    ...(whenText ? ['', `WHEN: ${whenText}`] : []),
     '',
     `## 记录（实时暂存，Teardown 时提炼进 concepts/ 后本页可删）`,
     `- ${clean}`,
+    ...(whenText ? [`- 何时读：${whenText}`] : []),
     '',
     '## 关联连接',
     `- ${atTag(who)} — 本页沉淀者`,

package/src/todo.js

@@ -724,7 +724,7 @@ export async function setBreakpoint(brainRoot, { id, text }) {
     return { text: lines.join('\n'), ok: true };
   });
   return res === SKIP
-    ? { ok: false, msg: `(未找到含 "${id}" 的未完成任务行)` }
+    ? { ok: false, msg: `[NO_MATCH] 未找到含 "${id}" 的未完成任务行` }
     : { ok: true, msg: `✓ 断点已落 → ${id}\n  ${bp.trim()}` };
 }
 

package/src/userconfig.js

@@ -54,12 +54,16 @@ export async function setUser(name) {
 export async function requireUser() {
   const u = await getUser();
   if (u) return u;
-  throw new Error(
-    '✗ 尚未设置使用者姓名 —— 图谱需要标记每条记录的作者。\n' +
-    '  请任选其一设置后重试:\n' +
-    '    abs config set user <你的名字>     (写入 ~/.abs/config.json, 一次即可)\n' +
-    '    ABS_USER=<你的名字> abs ...        (仅本次生效)'
+  const e = new Error(
+    '✗ 尚未设置使用者姓名 —— 图谱需要标记每条记录的作者。'
   );
+  // 错误码：hook/脚本靠它区分「需先配置」与真故障（借 Anneal templateRefusal）。
+  e.code = 'NO_USER';
+  e.fallback =
+    '任选其一:\n' +
+    '    abs config set user <你的名字>     (写入 ~/.abs/config.json, 一次即可)\n' +
+    '    ABS_USER=<你的名字> abs ...        (仅本次生效)';
+  throw e;
 }
 
 /** 标记串：`[[name]]`（wikilink 到人页 entities/<name>.md）。

package/skill/abs-think-tree/SKILL.md

@@ -1,194 +0,0 @@
----
-name: abs-think-tree
-description: 回答前的固定思考骨架 —— 三层下坠式自问, 每层出多个候选互相竞争, 最后一个问题可给多个答案。用于减少"急于表达、只给一个答案、把无答案伪装成有答案"。
----
-
-# 三层思考骨架
-
-## 为什么需要它
-
-默认失败模式有三个，且都不是"不够聪明"造成的：
-
-| 失败模式 | 表现 |
-|---------|------|
-| 急于表达 | 还没想清就写答案，答案是第一个想到的 |
-| 只给一个答案 | 明明有几种合理解读，只交付一种，另外几种当没想过 |
-| 无答案装成有答案 | 问题本身没有确定答案，硬凑一个自圆其说的 |
-
-**不是让模型变聪明，是让它的偷懒可见。** 骨架填不满 = 露怯，比给个像样的答案更有价值。
-
-## 核心：下坠 + 竞争
-
-```
-根: 用户原话（外部给定，不可改）
- └ L1 他为什么问    出 n 个候选，留最贴合原话的     ← 防答非所问
-    └ L2 边界在哪  三条轴上定位，留最贴合 L1 的    ← 防答错方向（默认留 2）
-       └ L3 他要什么 写出可验收产出形态，留最贴合 L2 的 ← 防给不出东西
-          ↓
-        回答：沿存活路径给，有几条活路径就给几个答案
-```
-
-**三层职能各自独立，不可合并**：L1 定动机 / L2 定边界 / L3 定产出。
-少了 L2，答案容易落在错的轴上（问主观答客观、问当下答长期）。
-
-**竞争的关键：每层的裁判是父节点，不是答案。** 兄弟候选共享同一个父，所以能横向比较——
-"这两条哪个更贴合上面的问题"，这是相对判断，不是自评，也不是造证据。
-
-**父节点始终是外部给定的**（L1 的父是用户原话），所以裁判链是外部的，模型无法自己定标准。
-
-## 留几个（关键）
-
-留几个**不看你想要几个，看有没有依据**：
-
-| 同层候选之间的差距 | 留 k | 依据 |
-|---|---|---|
-| 有明显差距（有候选明显不贴合父节点） | 可以留 1 | 竞争胜出，有裁判 |
-| **无差距（都同样贴合）** | **必须留 2** | 竞争无法裁决，砍任何一个都是无依据 |
-
-**默认留 2。** 因为大多数情况下同时存在几个同样合理的视角，而**同样合理时砍掉一个，是拿单一视角冒充完整回答**——这正是这套骨架要防的病。
-
-**无差距时强行留 1 的后果**（实测）：问"要不要迁移到新框架"，两个 L1 候选（评估成本收益 / 遇瓶颈想换）都贴合原话，
-它们的 L2 边界差别只在"当下/长期"一条轴。留 1 就必须砍掉一边——
-**但这里没有胜者，砍谁都是丢掉一个合法视角。**
-
-**竞争结构的边界**：它只能淘汰差的，不能淘汰同样好的。兄弟差距为零时，没有裁判。
-
-## 流程
-
-### L1 他为什么问 —— 出 3 个，留 2
-
-写 3 个**具体的后续动作**，不是心情。
-
-- ✅ "想快速定位原因"、"想确认是不是自己改错了"、"想让测试通过"
-- ❌ "想了解这个技术"、"想学习一下"（空泛，等于没写）
-
-**基准**：用户原话。写不出的直接标"原话不足以判断"。
-
-### L2 他在问什么 —— 每支出 2 个，留 1~2（同上：无差距时留 2）
-
-**L2 的职能是划定问题边界，不是复述问题。** 复述不产生信息；划边界产生信息。
-
-对每个存活的 L1，在三条轴上定位这个问题的边界：
-
-| 轴 | 两端 | 划错的后果 |
-|---|---|---|
-| 主观 / 客观 | "好不好吃" vs "营养成分" | 答成客观数据 |
-| 当下 / 长期 | "这顿吃啥" vs "长期吃水果好不好" | 答成养生建议 |
-| 判断 / 操作 | "要不要买" vs "怎么挑" | 给方法但没给结论 |
-
-- **每条轴必须落到一端**，不许写"两者都有"。
-- 必须能跟 L1 对上。
-
-**落不下去时，区分两种原因（路径生死相同，输出描述不同）：**
-
-| 原因 | 含义 | 输出里怎么说 |
-|---|---|---|
-| 落不下去，因为候选本身空泛 | 动机没说清（如"想了解苹果"） | "剪掉：动机不具体" |
-| 落不下去，因为信息不够 | 动机成立但原话没有线索 | "悬置：需要你补充 X" |
-
-两者都使这一支不往下走，**但前者是判断，后者是缺信息**。不要把缺信息写成判断。
-
-- 不同 L1 可能落到同一个边界 → **汇聚 = 强信号**，记录下来。
-
-**示例**："苹果好吃吗"
-- L1 = 想选水果 → L2 = 主观 + 当下 + 判断
-- 这个边界直接挡住"富含维 C"（客观）和"长期吃水果的好处"（长期）—— 那是在答另一个问题
-
-**L2 是没它就容易答错方向的一层。** 跳过 L2 直接由 L1 生成答案，最常见的失败是答案落在错的轴上。
-
-### L3 他要什么 —— 写出可验收的产出形态
-
-这一层是**全流程的地基**。
-
-- ✅ "一段能跑的代码"、"一个明确结论"、"2-3 个选项让我选"、"一个追问"
-- ❌ "一个全面的回答"、"一些建议"（不可验收）
-
-**写不出可验收形态时，不许硬写。** 直接说明：
-> 这个问题没有可验收的标准，我给的是参考，不是答案。
-
-这一条是本骨架最重要的产物——它把"无答案"从失败变成一个合法输出。
-
-### 回答
-
-沿存活路径写。四条规矩：
-
-1. **每条不同的 L2/L3 路径对应一个答案，不合并。** 有 3 条活路径就给 3 个答案。
-2. **汇聚优先，分歧附为例外**（不是并列）：
-   - 多条路径汇聚 → 当作**主结论**，可标"多条路径汇聚于此"
-   - 少数路径分歧 → 当作**例外**附在后面，写明它在哪条轴上不同
-   - ❌ 不要写成两个平行答案 —— 那会让用户以为两者同等重要
-
-   **示例**（三选一汇聚、一条分歧）：
-   > 主：问的是**主观口味**，苹果甜脆多汁，这几个维度自己判断。
-   > 例外：**如果你要给小孩吃，问题就变成安全性（客观轴）**，那是另一个问题，得单独说。
-
-3. **不选最优。** 骨架禁止输出"综合来看最佳答案是……"这种合并。
-4. **不回头改上层。** L3 写不出可验收形态时，不许回头改 L2 的边界。
-   **理由：下级不能改上级。** L3 没有比 L2 更高的裁判，让它改 L2 = 自证。
-   正确做法：直接在 L3 露怯（"这题我给参考不是答案"）。
-
-## 能力边界（不是 bug，无法靠本骨架解决）
-
-竞争结构的裁判链是"父节点"，而父节点有它看不到的地方：
-
-| 边界 | 说明 |
-|---|---|
-| **只能淘汰差的，不能淘汰同样好的** | 兄弟候选同样贴合父节点时，没有裁判 |
-| **只能一致地错，不能发现自己错了** | 父节点错了（如 L1 动机判断错），子节点会沿着它一致错下去；竞争范围只在兄弟之间，淘汰不了父 |
-| **无外部信号** | 要发现"父错了"，只能靠用户纠正或可运行的验证（编译/测试/算数） |
-
-**本骨架保证一致性，不保证方向。** 它防的是"同一套逻辑内部自相矛盾"；
-不防"整套逻辑从根上就错了"——那需要外部裁判。
-
-## 自检（答完前扫一眼）
-
-| 检查项 | 不合格的样子 |
-|-------|-------------|
-| L1 三条是否互斥？ | 三条其实是同一件事的换说法 |
-| L1 是否具体到动作？ | "想了解一下" |
-| L2 三条轴是否都落到一端？ | 写"两者都有"、没划边界就进 L3 |
-| L2 能否对回 L1？ | 对不上还留着 |
-| L3 是否可验收？ | "给出好的回答" |
-| 是否偷偷合并了多解？ | 说了三种可能，最后只答一种 |
-| 分歧是否被藏起来了？ | 两条路径结论冲突，装作没看见 |
-| 无答案时是否露怯？ | 硬凑一个"综合"答案 |
-
-## 陷阱
-
-| 陷阱 | 正确做法 |
-|------|---------|
-| 把 L1 写成用户心情 | 写成具体后续动作 |
-| L2 复述问题（废层） | L2 必须划边界：主观/客观 · 当下/长期 · 判断/操作 |
-| L2 写"两者都有" | 每条轴必须落到一端，落不下去就作废这一支 |
-| 所有层都填满还答错 | 填满是必要不充分；基准是父节点，不是自评 |
-| 层层筛选只剩一条 | k 至少留 2 条到终点，否则退回"急于表达" |
-| 同层候选无差距却留 1 | 无差距必须留 2；只有有明显差距时才能靠竞争留 1 |
-| 为了填满而编候选 | 编不出来时写"原话不足以判断"，这本身是结论 |
-| 用"综合来看"合并多解 | 禁止。分歧就是分歧，列出来 |
-| 无答案时硬凑 | 明确说"这题没有可验收标准" |
-| 把骨架当形式走一遍 | 填完还是答第一个想到的 = 没走 |
-
-## 边界（这套骨架不适用的时候）
-
-- **问题本身有唯一正确答案时**（算术、编译）：不需要分叉，直接答 + 验证。
-- **用户明确要一个答案时**：给一个，别列 3 个让用户挑。
-- **纯闲聊**：走这套会显得像官僚流程。
-
-**本骨架真正的适用面：需求模糊、可能有多种合理解读、或根本没有确定答案的问题。**
-
-## 成本
-
-一次思考内完成，不是 n 次调用。**n 条线是同一个 forward pass 里的 n 个位置**，
-上下文共享，token 只比直接回答多约 30%。不烧 token 的关键是**不来回**——
-不在生成和外部判定之间反复起调用。
-
-## 收尾：结论必须明确
-
-答完必须让用户能判断：
-
-1. **给了几个答案**（一条路径就一个，多条就列全）
-2. **哪几条汇聚了**（置信较高处）
-3. **哪几条分歧了**（需要用户定夺处）
-4. **是否无答案**（若 L3 写不出，明确说）
-
-不许用"综合来看建议……"把分歧抹平。

package/skill/abs-think-tree/check.js

@@ -1,119 +0,0 @@
-/**
- * think-tree 自证器 —— 检查一次三层思考的填写质量。
- *
- * 用法:
- *   node skill/abs-think-tree/check.js <填好的答案文件.md>
- *
- * 输入格式(答案文件):
- *   ## L1
- *   - [动作] 想快速定位原因
- *   - [动作] 想确认是不是自己改错了
- *   ## L2
- *   - [客观][当下][判断] 在问因果
- *   ## L3
- *   - [产出] 一个嫌疑点 + 证据 + 验证方法
- *
- * 各类标签是硬判据: 不写 = 报错, 不是"提醒"。
- * 目的: 把"贴合用户原话"这句软话, 拆成能失败的检查。
- */
-
-const ACTION_VERBS = /(定位|确认|判断|决定|选择|选定|挑选|修改|查找|比较|评估|验证|交付|得到|知道|排除|复现|区分|排查|了解|收尾|继续|停止|给出|输出|回答|说明|解释|分析|检查|拆|推|排|定|学)/;
-
-/** L2 三轴标签。必须三轴齐全, 缺一轴 = 边界没划全。 */
-const AXES = ["主观|客观", "当下|长期", "判断|操作"];
-
-/** L3 可验收产出类型的白名单。 */
-const OUTPUT_KINDS = ["代码", "结论", "选项", "追问", "证据", "复现条件", "命令"];
-
-function fail(list, msg) {
-  list.push(msg);
-}
-
-/** L1: 每个候选必须是"动作", 不能是"心情"。 */
-function checkL1(lines, errs) {
-  if (!lines.length) return fail(errs, "L1 为空: 至少写 1 个动机候选");
-  if (lines.length < 2) fail(errs, "L1 只有 1 个候选: 无兄弟则无法竞争");
-  lines.forEach((l, i) => {
-    const m = l.match(/^-\s*\[动作\]\s*(.+)$/);
-    if (!m) return fail(errs, `L1[${i}] 缺 [动作] 标签: "${l}"`);
-    const body = m[1].trim();
-    if (!body) return fail(errs, `L1[${i}] 标签后为空`);
-    if (!ACTION_VERBS.test(body))
-      fail(errs, `L1[${i}] 不像动作(无动词): "${body}"`);
-    // 心情词黑名单
-    if (/(了解一下|学习一下|感兴趣|好奇|随便看看)/.test(body))
-      fail(errs, `L1[${i}] 是心情不是动作: "${body}"`);
-  });
-}
-
-/** L2: 三轴必须齐全, 且每轴只能落一端。 */
-function checkL2(lines, errs) {
-  if (!lines.length) return fail(errs, "L2 为空: 边界没划");
-  lines.forEach((l, i) => {
-    const m = l.match(/^-\s*((?:\[[^\]]+\])+)\s*(.+)$/);
-    if (!m) return fail(errs, `L2[${i}] 缺轴标签: "${l}"`);
-    const tags = [...m[1].matchAll(/\[([^\]]+)\]/g)].map((x) => x[1]);
-    AXES.forEach((ax) => {
-      const ends = ax.split("|");
-      const hit = tags.filter((t) => ends.includes(t));
-      if (!hit.length) fail(errs, `L2[${i}] 缺轴 [${ax}]: 边界没划全`);
-      if (hit.length > 1) fail(errs, `L2[${i}] 轴 [${ax}] 落了两端: 必须只落一端`);
-    });
-    if (/(两者都有|都算|不确定|看情况)/.test(m[2]))
-      fail(errs, `L2[${i}] 边界含糊(写了"两者都有"之类): "${m[2]}"`);
-  });
-}
-
-/** L3: 必须能指出可验收产出类型, 或明确露怯。 */
-function checkL3(lines, errs) {
-  if (!lines.length) return fail(errs, "L3 为空: 既没给产出也没露怯");
-  lines.forEach((l, i) => {
-    // 露怯分支: 明确说没有可验收标准 —— 合法
-    if (/\[无验收标准\]/.test(l)) {
-      if (!/给(的)?是参考|不是答案|无法验收/.test(l))
-        fail(errs, `L3[${i}] 标了无验收标准但没明说给的是参考: "${l}"`);
-      return;
-    }
-    const m = l.match(/^-\s*\[产出\]\s*(.+)$/);
-    if (!m) return fail(errs, `L3[${i}] 缺 [产出] 或 [无验收标准] 标签: "${l}"`);
-    if (!OUTPUT_KINDS.some((k) => m[1].includes(k)))
-      fail(errs, `L3[${i}] 产出不可验收(不含白名单类型 ${OUTPUT_KINDS.join("/")}): "${m[1]}"`);
-  });
-}
-
-/** L2 是否逐条能对回 L1 的存活支 —— 需要显式写的 [父:N], 且不得越界。 */
-function checkTrace(lines, l1count, errs) {
-  lines.forEach((l, i) => {
-    const m = l.match(/\[父:(\d+)\]/);
-    if (!m) return fail(errs, `L2[${i}] 缺 [父:N] 标注: 无法证明它来自哪个 L1 支`);
-    const n = Number(m[1]);
-    if (n >= l1count)
-      fail(errs, `L2[${i}] [父:${n}] 越界: L1 只有 ${l1count} 条, 指向不存在的父`);
-  });
-}
-
-export function check(text) {
-  const errs = [];
-  const sec = { L1: [], L2: [], L3: [] };
-  let cur = null;
-  for (const raw of text.split("\n")) {
-    const h = raw.match(/^##\s*(L[123])\s*$/);
-    if (h) { cur = h[1]; continue; }
-    if (cur && raw.trim().startsWith("-")) sec[cur].push(raw.trim());
-  }
-  checkL1(sec.L1, errs);
-  checkL2(sec.L2, errs);
-  checkTrace(sec.L2, sec.L1.length, errs);
-  checkL3(sec.L3, errs);
-  return { ok: errs.length === 0, errors: errs, counts: { L1: sec.L1.length, L2: sec.L2.length, L3: sec.L3.length } };
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const fs = await import("node:fs");
-  const p = process.argv[2];
-  if (!p) { console.log("用法: node check.js <答案文件.md>"); process.exit(2); }
-  const r = check(fs.readFileSync(p, "utf8"));
-  console.log(`L1=${r.counts.L1} L2=${r.counts.L2} L3=${r.counts.L3}`);
-  if (r.ok) console.log("PASS");
-  else { console.log(`FAIL (${r.errors.length})`); r.errors.forEach((e) => console.log("  ✗ " + e)); process.exit(1); }
-}