@fanchao8609/agent_brain_sync 1.21.0 → 1.22.0

package/README.md

@@ -17,14 +17,17 @@ npm install -g @fanchao8609/agent_brain_sync
 abs install
 ```
 
-`abs install` 会交互式让你勾选智能体；也可以直接指定：
+**默认只装 pi**（其余宿主 opt-in）——装到不用的宿主上会往那边配置文件塞 hook/MCP 条目。
 
 ```bash
-abs install --agent pi            # 只装 pi
-abs install                       # 全部: claude-code / codex / opencode / pi / omp
+abs install                       # 默认: 只装 pi
+abs install --all                 # 全装: claude-code / codex / opencode / pi / omp
+abs install --agent claude-code   # 只装指定宿主
 abs install --agent pi --no-mcp   # 只装 hook + skill，不要 MCP
 ```
 
+交互模式下回车 = 只装 pi；输入 `all` 才全装。
+
 装了什么：
 
 | 宿主 | hook | MCP | skill |
@@ -122,6 +125,7 @@ abs db rebuild                            # 扫所有登记项目 → 建图数
 abs db search <词>                        # 走库检索：FTS 拿种子 + 亮度扩散，L1 铁律恒在最前
 abs db status                             # 库体检：七层分布 / 悬挂链接 / 已入库项目
 abs db add                                # 把当前项目登记进 ~/.abs/projects.json
+abs db evolve                             # 知识进化体检：被推翻/断链/主题堆积/僵化页
 abs summon [--mark|--status]              # 会话总结托底：列出未总结 / 有更新的会话（不写盘）
 abs resolve <页名或id>                    # 反查页面路径（页改名后 id 不变）
 abs supersede <页名> [--by <新页>]        # 标记经验已失效（不删文件，保留历史；query 默认不再返回）

package/bin/abs.js

@@ -3,7 +3,7 @@
 // abs <cmd> [args]
 // 命令: init / board / status / load / task / install / uninstall / help
 import { cmdInit, cmdStatus, cmdLoad, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdConcept, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive, cmdResolve, cmdSupersede, cmdReview } from '../src/store.js';
-import { cmdDbRebuild, cmdDbSearch, cmdDbStatus, addProject } from '../src/brain/db-cmd.js';
+import { cmdDbRebuild, cmdDbSearch, cmdDbStatus, cmdDbEvolve, addProject } from '../src/brain/db-cmd.js';
 import { cmdCapture } from '../src/brain/capture.js';
 import { cmdSummon } from '../src/brain/summon-cmd.js';
 import { setUser, getUser, userConfigPath } from '../src/userconfig.js';
@@ -249,7 +249,7 @@ const usage = `abs — 跨会话记忆工具（.brain/ 图谱）
   summon [--mark|--status]   会话总结托底: 列出未总结/有更新的会话 (不写盘)
   concept <slug> --title …   建概念页骨架
   query <词…> [--all]       检索知识页 (多词 OR)
-  db rebuild|search|status   图数据库: 建库 / 亮度搜索 / 体检
+  db rebuild|search|status|evolve  图数据库: 建库 / 亮度搜索 / 体检 / 进化体检
   resolve <页名…>            反查页面路径
   supersede <页名> [--by 页] 标经验已失效
   review [--accept 页…|--reject 页…]  待确认页队列 (draft 升 active/否决)
@@ -556,7 +556,7 @@ async function main() {
       case 'uninstall': {
         // --help 已在 switch 前统一拦截（subUsage）。
         if (cmd === 'install') {
-          await runInstall({ agent: opts.agent, mcp: opts.mcp !== false, skill: opts.skill !== false, yes: opts.yes });
+          await runInstall({ agent: opts.agent, all: !!opts.all, mcp: opts.mcp !== false, skill: opts.skill !== false, yes: opts.yes });
         } else {
           await runUninstall({ agent: opts.agent, yes: opts.yes });
         }
@@ -581,12 +581,13 @@ async function main() {
         if (sub === 'rebuild') { console.log(await cmdDbRebuild({ dir: opts.dir })); break; }
         if (sub === 'search') { console.log(await cmdDbSearch({ query: rest.join(' '), limit: Number(opts.limit) || 8 })); break; }
         if (sub === 'status') { console.log(await cmdDbStatus()); break; }
+        if (sub === 'evolve') { console.log(await cmdDbEvolve({ staleDays: Number(opts['stale-days']) || 90 })); break; }
         if (sub === 'add') {
           const r = await addProject(opts.dir || process.cwd());
           console.log(`✓ 已登记项目: ${r}\n  建库: abs db rebuild`);
           break;
         }
-        console.log('用法: abs db rebuild | search <词> | status | add [--dir <项目根>]');
+        console.log('用法: abs db rebuild | search <词> | status | evolve | add [--dir <项目根>]');
         break;
       }
       case 'query': {

package/package.json

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

package/src/brain/capture.js

@@ -19,6 +19,7 @@ import { cmdLog } from '../note.js';
 import { clip, slugOf } from '../text.js';
 import { LAYERS, layerOf, DEFAULT_LAYER } from './layers.js';
 import { autoIndex } from './db-cmd.js';
+import { summonTail } from './summon.js';
 
 /** 层 → 落点目录。L1/L6 不立页，由下面的分支单独处理。 */
 const LAYER_DIR = {
@@ -153,18 +154,22 @@ export async function cmdCapture({ dir, text, layer, tags, title }) {
   const slug = file.replace(/\.md$/, '');
   const section = dirName === 'concepts' ? 'Concepts' : dirName === 'sessions' ? 'Sessions' : 'Sources';
   await registerInIndex(root, section, slug, head);
-  await cmdLog({ dir: root, title: clean, kind: 'note' });
+  await cmdLog({ dir: root, title: clean, kind: 'note', summon: false });
 
   // 落盘即入库 —— 否则用户以为记下了，检索却空手而归（静默失效）。
   // autoIndex 永不抛错也不阻塞：库坏了只是检索旧一点，不能让记笔记失败。
   const idx = await autoIndex();
 
+  // 每次总结都顺手查一遍会话历史，避免漏下没总结的会话（2026-11-02 用户要求）。
+  // 只给线索不写盘 —— 落哪一条仍是人的判断。
+  const tail = await summonTail(root);
+
   return [
     `✓ 已落入 L${L} ${meta.name}层 → ${dirName}/${file}`,
     `  ${clip(clean, 60)} ${atTag(who)}`,
     `  该层衰减 ${meta.decay}（${meta.note}）`,
     idx.ok ? '  已同步入库，abs db search 可查到' : `  （未入库：${idx.reason}）`,
-  ].join('\n');
+  ].join('\n') + tail;
 }
 
 export { LAYERS };

package/src/brain/db-cmd.js

@@ -6,12 +6,72 @@
 import { promises as fs } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import { findBrainRoot, brainPath } from '../index.js';
-import { openDb, rebuild, search, illuminate, rulesOf, stats, ensureDbDir, dbPath } from './db.js';
+import { openDb, rebuild, search, illuminate, rulesOf, stats, ensureDbDir, dbPath, lastOpenRebuilt } from './db.js';
 import { LAYERS } from './layers.js';
 
 const PAGE_DIRS = ['concepts', 'entities', 'sources', 'syntheses', 'sessions'];
 const FLAT_FILES = ['index.md', 'todo.md', 'log.md'];
 
+/** 项目根路径 → 项目名（入库时的 project 字段）。
+ *
+ * 取路径末段。为何不引入 UUID（2026-11-02 评估）：项目名是给人看的标识，
+ * 出现在每条检索结果里；UUID 会让输出不可读。末段同名的风险用 `db status` 暴露，
+ * 不做静默处理。
+ */
+function projectNameOf(root) {
+  return String(root).split('/').filter(Boolean).pop() || 'unknown';
+}
+
+/** 给一批项目根算出**互不重名**的项目名。
+ *
+ * 为何需要（2026-11-02 实测）：项目名默认取路径末段，而机器上同时存在
+ *   ~/.agents 与 ~/Documents/软件/.agents，两者末段都是 `.agents` →
+ *   入库时撞 UNIQUE(project, dir, slug) 约束，整个 rebuild 失败。
+ *
+ * 消歧规则：重名的那些改用「父目录-末段」，仍重名就继续往上加，直到唯一。
+ * 只给重名的项目加前缀 —— 没重名的保持短名（检索结果里读起来更清楚）。
+ */
+export function uniqueProjectNames(roots) {
+  const seg = (p) => String(p).split('/').filter(Boolean);
+  const base = new Map(roots.map((r) => [r, seg(r).pop() || 'unknown']));
+  const groups = new Map();
+  for (const [r, n] of base) {
+    if (!groups.has(n)) groups.set(n, []);
+    groups.get(n).push(r);
+  }
+  const out = new Map();
+  for (const [name, list] of groups) {
+    if (list.length === 1) { out.set(list[0], name); continue; }
+    // 重名 → 逐层加父目录前缀，直到组内唯一
+    for (let depth = 2; depth <= 4; depth++) {
+      const cand = new Map();
+      for (const r of list) {
+        const s = seg(r);
+        cand.set(r, s.slice(Math.max(0, s.length - depth)).join('-'));
+      }
+      const vals = [...cand.values()];
+      if (new Set(vals).size === vals.length) {
+        for (const [r, v] of cand) out.set(r, v);
+        break;
+      }
+      if (depth === 4) for (const [r, v] of cand) out.set(r, v);  // 兜底：认了
+    }
+  }
+  return out;
+}
+
+/** 当前所在项目名。查询时用它决定「读哪几条铁律」。
+ *
+ * 为何要单独一个函数（2026-11-02）：原来只在 cmdDbSearch 里内联算，
+ * 与 rebuild 用的算法是两份代码 —— 任一边改了项目名规则，铁律就会读错项目的。
+ * 判据：项目名的算法只能有一处。 */
+async function currentProjectName(dir) {
+  if (process.env.ABS_PROJECT) return process.env.ABS_PROJECT;
+  const from = dir || process.cwd();
+  const root = await findBrainRoot(from);
+  return root ? projectNameOf(root) : '';
+}
+
 /** 扫一个项目的 .brain/ → 页面数组（含 index/todo/log 三份平铺文件）。 */
 async function scanProject(root, project) {
   const out = [];
@@ -80,14 +140,19 @@ export async function cmdDbRebuild({ dir } = {}) {
     return '✗ 没有可入的项目。先在项目根跑: abs db add   或  abs db rebuild';
   }
 
+  // 先收集所有有效根，再统一算项目名 —— 名字要去重，必须看到全局才知道谁重名
+  const found = [];
+  for (const root of roots) {
+    const r = await findBrainRoot(root);
+    if (r) found.push(r);                       // 登记了但目录没了 → 跳过，不报错
+  }
+  const names = uniqueProjectNames([...new Set(found)]);
   const pages = [];
   const used = [];
-  for (const root of roots) {
-    const found = await findBrainRoot(root);
-    if (!found) continue;                       // 登记了但目录没了 → 跳过，不报错
-    const project = found.split('/').filter(Boolean).pop() || 'unknown';
-    pages.push(...await scanProject(found, project));
-    used.push(`${project} (${found})`);
+  for (const f of [...new Set(found)]) {
+    const project = names.get(f);
+    pages.push(...await scanProject(f, project));
+    used.push(`${project} (${f})`);
   }
   if (!pages.length) return '✗ 登记的项目都没有 .brain/ 图谱，无可入库内容。';
 
@@ -122,9 +187,7 @@ export async function cmdDbSearch({ query, limit = 8 } = {}) {
   const h = openDb(path);
   try {
     // L1 铁律永远先出 —— 「不可逾越」的代码保证，不靠读到文本才遵守
-    const project = process.env.ABS_PROJECT
-      || (await findBrainRoot(process.cwd()) || '').split('/').filter(Boolean).pop()
-      || '';
+    const project = await currentProjectName();
     const rules = rulesOf(h, project);
 
     const seeds = search(h, q, { limit: 12 });
@@ -136,17 +199,27 @@ export async function cmdDbSearch({ query, limit = 8 } = {}) {
       for (const r of rules) out.push(`- ${r}`);
     }
     if (!lit.length) {
-      out.push('', '（无命中。库可能是旧的：abs db rebuild 重扫）');
+      out.push('', lastOpenRebuilt()
+        ? '（库文件曾损坏被清空，现在没有内容：跑 abs db rebuild 重建）'
+        : '（无命中。库可能是旧的：abs db rebuild 重扫）');
       return out.join('\n');
     }
     out.push('', '--- 按亮度排序 ---');
     for (const p of lit) {
-      const bar = '█'.repeat(Math.max(1, Math.round(Math.min(p.bright, 3) / 3 * 12)));
+      // 亮度现在是 0.3~1.0（不再是早期可能到 165 万的异常值），
+      // 条长按 1.0 满格算：0.3 → 4 格，1.0 → 12 格。
+      const bar = '█'.repeat(Math.max(1, Math.round(Math.min(p.bright, 1) * 12)));
       const where = [p.project, p.dir, p.slug].filter(Boolean).join('/');
       const tag = p.from === 'spread' ? ' ↝' : '';
-      out.push(`${bar} ${p.bright.toFixed(2)} L${p.layer} ${where}${tag}`);
+      // 跨项目的结果要显式标出来 —— 用户得知道「这条是别的项目的经验」，
+      // 否则会以为是自己项目的结论（判据、上下文都可能不同）。
+      const other = project && p.project && p.project !== project ? '  [跨项目]' : '';
+      out.push(`${bar} ${p.bright.toFixed(2)} L${p.layer} ${where}${tag}${other}`);
     }
     out.push('', '（L1 铁律恒在最前；↝ 表示由邻居扩散点亮，非直接命中）');
+    if (project) {
+      out.push(`（铁律只显示本项目 "${project}" 的 —— 别的项目的铁律不外借）`);
+    }
     return out.join('\n');
   } finally {
     h.close();
@@ -161,9 +234,11 @@ export async function cmdDbStatus() {
 
   const h = openDb(path);
   try {
+    const rebuilt = lastOpenRebuilt();
     const s = stats(h);
     const out = [
       `📀 库: ${path}`,
+      ...(rebuilt ? ['⚠ 库文件曾损坏，已自动清空重建 —— 跑 abs db rebuild 恢复内容'] : []),
       `节点 ${s.nodes} | 边 ${s.edges} | 悬挂链接 ${s.dangling} | 断点词 ${s.anchors} | 铁律 ${s.rules}`,
       '',
       '--- 七层分布 ---',
@@ -231,14 +306,31 @@ async function cmdDbRebuildQuiet() {
   const here = await findBrainRoot(process.cwd());
   const roots = [...new Set([...registered, ...(here ? [here] : [])])];
   if (!roots.length) return;
-  const pages = [];
+  const found = [];
   for (const root of roots) {
-    const found = await findBrainRoot(root);
-    if (!found) continue;
-    const project = found.split('/').filter(Boolean).pop() || 'unknown';
-    pages.push(...await scanProject(found, project));
+    const r = await findBrainRoot(root);
+    if (r) found.push(r);
   }
+  const uniq = [...new Set(found)];
+  const names = uniqueProjectNames(uniq);
+  const pages = [];
+  for (const f of uniq) pages.push(...await scanProject(f, names.get(f)));
   if (!pages.length) return;
   const h = openDb(dbPath());
   try { rebuild(h, pages); } finally { h.close(); }
 }
+
+/** `abs db evolve` — 知识自我进化的体检：哪些被推翻、哪些堆积、哪些该合并。 */
+export async function cmdDbEvolve({ staleDays = 90 } = {}) {
+  const path = dbPath();
+  const exists = await fs.stat(path).then(() => true).catch(() => false);
+  if (!exists) return `库不存在: ${path}\n  先跑: abs db rebuild`;
+
+  const h = openDb(path);
+  try {
+    const { evolveSignals, renderEvolve } = await import('./evolve.js');
+    return renderEvolve(evolveSignals(h, { staleDays }), { staleDays });
+  } finally {
+    h.close();
+  }
+}

package/src/brain/db.js

@@ -24,16 +24,23 @@
 import { DatabaseSync } from 'node:sqlite';
 import { promises as fs } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolveLayer, anchorsOf, decayOf, DEFAULT_LAYER } from './layers.js';
 
-export const DB_VERSION = 2;
+export const DB_VERSION = 3;
 
 /** 库路径。ABS_DB 可覆盖（测试隔离 / 多库切换）。 */
 export function dbPath() {
   return process.env.ABS_DB || join(homedir(), '.abs', 'graph.db');
 }
 
+/** 本次进程里最后一次 openDb 是否因损坏而重建过库。
+ * 记录属内容决策，工具只报不改 —— 这里只标记，由调用方决定怎么告知，
+ * 不自己打印（库层不该有输出）。 */
+let _rebuiltAfterCorruption = false;
+export function lastOpenRebuilt() { return _rebuiltAfterCorruption; }
+
 export class DbError extends Error {
   constructor(message, cause) {
     super(message);
@@ -66,6 +73,11 @@ CREATE TABLE IF NOT EXISTS nodes (
   -- 因此任何查询都能命中它。实测（2026-11-01）刚 capture 一条「并发写」，log 页
   -- 亮度 3.87 排第一，压过真正的内容页 —— 这是纯噪音，必须从检索候选里排除。
   is_ledger  INTEGER NOT NULL DEFAULT 0,
+  -- 被哪一页推翻（对应 frontmatter 的 superseded-by）。
+  -- 为何要进库（2026-11-02）：知识自我进化的第一个需要 —— 能查「哪些页被推翻了、
+  -- 被谁推翻」。原来这关系只存在于 markdown 的一行 frontmatter 里，
+  -- 库只存 status 不存走向，于是「进化」在检索侧完全看不见。
+  superseded_by TEXT NOT NULL DEFAULT '',
   UNIQUE(project, dir, slug)
 );
 CREATE INDEX IF NOT EXISTS i_nodes_layer   ON nodes(layer);
@@ -129,14 +141,35 @@ export function bigrams(s) {
     const seg = m[0];
     for (let i = 0; i + 2 <= seg.length; i++) out.push(seg.slice(i, i + 2));
   }
-  // 单个汉字：query 是「锁」「锁」这类一字词时，2-gram 切不出来，
-  // 上面循环对 1 字串一次都不执行 → 恒返回空 → 搜不到（实测「锁」0 命中）。
-  // 补成单字 gram，存储侧同样产出它（见下）。
   for (const m of text.matchAll(/[\u4e00-\u9fa5]/g)) out.push(m[0]);
   for (const m of text.matchAll(/[A-Za-z][A-Za-z0-9_-]{1,}/g)) out.push(m[0].toLowerCase());
   return [...new Set(out)];
 }
 
+/** 按「词」切 2-gram，不加单字。用于**查询侧**构造 MATCH 表达式。
+ *
+ * 为何要和平分两套（2026-11-02 深度测试发现）：
+ *   把单字也放进查询表达式会放大误命中 —— 实测查 `zzzz不存在zzz` 时，
+ *   gram 里含「不」「存」「在」，任何提到这三个字的页都会命中，
+ *   于是「一个根本不存在的词」返回了 7 页。这不是模糊匹配有用，是噪音。
+ *
+ * 存储侧仍保留单字（bigrams 不动）：这样查询本身**就是一个字**时
+ * （如「锁」），还能通过单字 gram 命中；而多字查询不会靠单字瞎连。
+ * 两侧不要求同一函数 —— 要求的是「查询产出的每个 gram 在存储侧都存在」，
+ * 而存储侧是超集，恒成立。 */
+export function queryBigrams(s) {
+  const text = String(s || '');
+  const out = new Set();
+  for (const m of text.matchAll(/[\u4e00-\u9fa5]{2,}/g)) {
+    const seg = m[0];
+    for (let i = 0; i + 2 <= seg.length; i++) out.add(seg.slice(i, i + 2));
+  }
+  // 整条查询只有单个汉字时才用单字 gram（「锁」这种一字查询仍能搜到）
+  if (out.size === 0 && /^[\u4e00-\u9fa5]$/.test(text.trim())) out.add(text.trim());
+  for (const m of text.matchAll(/[A-Za-z][A-Za-z0-9_-]{1,}/g)) out.add(m[0].toLowerCase());
+  return [...out];
+}
+
 /** 丢掉所有表（版本升级用）。库是派生品，删了由 rebuild 从 markdown 重建。 */
 function dropAll(db) {
   for (const r of db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all()) {
@@ -146,6 +179,7 @@ function dropAll(db) {
 
 /** 打开（不存在就建）库。返回 { db, close }。 */
 export function openDb(path = dbPath()) {
+  _rebuiltAfterCorruption = false;
   let db;
   try {
     db = new DatabaseSync(path);
@@ -172,6 +206,24 @@ export function openDb(path = dbPath()) {
     }
   } catch (e) {
     try { db.close(); } catch { /* 已关 */ }
+
+    // 库文件根本不是 SQLite / 结构彻底坏掉 → 删掉重建。
+    // 为何不报错让用户手删（2026-11-02 深度测试发现）：库是**派生物**
+    //   （markdown 才是真相），删了由 rebuild 从 .brain/ 全量重扫，内容不丢。
+    //   原实现只报「库结构初始化失败: file is not a database」，而 rebuild 走同一条
+    //   打开路径 —— 于是用户被卡死：修不好也删不掉（不知道删哪），只能去查源码。
+    if (/not a database|file is encrypted|malformed/i.test(e.message || '')) {
+      try {
+        for (const suffix of ['', '-wal', '-shm']) {
+          try { unlinkSync(`${path}${suffix}`); } catch { /* 不存在 */ }
+        }
+        const h = openDb(path);   // 文件已删，重来一次走全新库
+        _rebuiltAfterCorruption = true;   // 告知调用方：刚重建过，库是空的
+        return h;
+      } catch (e2) {
+        throw new DbError(`库文件损坏且无法重建 ${path}: ${e2.message}`, e2);
+      }
+    }
     if (e instanceof DbError) throw e;
     throw new DbError(`库结构初始化失败: ${e.message}`, e);
   }
@@ -192,7 +244,8 @@ function metaOf(body) {
   const title = (t.match(/^title:\s*(.+)$/m) || [])[1]?.trim() || '';
   const tags = (t.match(/^tags:\s*(.+)$/m) || [])[1]?.replace(/^\[|\]$/g, '').trim() || '';
   const st = (t.match(/^status:\s*(.+)$/m) || [])[1]?.trim() || 'active';
-  return { title, tags, status: st };
+  const sup = (t.match(/^superseded-by:\s*(.+)$/m) || [])[1]?.trim() || '';
+  return { title, tags, status: st, supersededBy: sup };
 }
 
 /** 全量重建：清表 → 重扫所有注册项目 → 重建边与断点词。
@@ -207,8 +260,8 @@ export function rebuild(handle, pages) {
     db.exec('DELETE FROM anchors; DELETE FROM edges; DELETE FROM nodes; DELETE FROM rules; DELETE FROM nodes_bigram;');
     try { db.exec("INSERT INTO fts(fts) VALUES('delete-all')"); } catch { /* 空表时无可删 */ }
 
-    const insNode = db.prepare(`INSERT INTO nodes(project,dir,slug,layer,title,tags,status,body,mtime,is_ledger)
-      VALUES(?,?,?,?,?,?,?,?,?,?)`);
+    const insNode = db.prepare(`INSERT INTO nodes(project,dir,slug,layer,title,tags,status,body,mtime,is_ledger,superseded_by)
+      VALUES(?,?,?,?,?,?,?,?,?,?,?)`);
     const insGram = db.prepare('INSERT OR REPLACE INTO nodes_bigram(id,g) VALUES(?,?)');
     const insEdge = db.prepare('INSERT OR IGNORE INTO edges(src,dst,raw) VALUES(?,?,?)');
     const insAnchor = db.prepare('INSERT OR IGNORE INTO anchors(word,node) VALUES(?,?)');
@@ -217,11 +270,11 @@ export function rebuild(handle, pages) {
     // 第一遍：建节点，拿 id 映射 key = `project/dir/slug`
     const idOf = new Map();
     for (const p of pages) {
-      const { title, tags, status } = metaOf(p.body);
+      const { title, tags, status, supersededBy } = metaOf(p.body);
       const { layer } = resolveLayer(p.body, p.dir);
       const ledger = (p.dir === '' && LEDGER_SLUGS.has(p.slug)) ? 1 : 0;
       const r = insNode.run(p.project, p.dir, p.slug, layer, title, tags, status,
-        p.body, p.mtime || now, ledger);
+        p.body, p.mtime || now, ledger, supersededBy);
       const id = Number(r.lastInsertRowid);
       // FTS 源：正文 + 标题 + tags 切 2-gram。查询侧必须用同一个 bigrams()。
       insGram.run(id, bigrams([p.slug, title, tags, p.body].join('\n')).join(' '));
@@ -256,19 +309,38 @@ export function rebuild(handle, pages) {
       const isLedger = p.dir === '' && (p.slug === 'todo' || p.slug === 'log');
       if (isLedger) continue;
       for (const word of anchorsOf(p.body)) {
-        insAnchor.run(word, srcId);
+        const { project: explicitProj, page } = parseAnchor(word);
+        // 断点词（L6）只记页名，不记 @项目前缀 —— 那是链接语法不是索引词
+        insAnchor.run(page, srcId);
         stat.anchors++;
-        // 就近优先：本项目 → 再全局
-        const dstId = idOf.get(`${p.project}/concepts/${word}`)
-          ?? idOf.get(`${p.project}/entities/${word}`)
-          ?? idOf.get(`${p.project}/sessions/${word}`)
-          ?? findGlobal(idOf, word);
+        let dstId;
+        if (explicitProj) {
+          // 显式跨项目：只在这个项目里找，找不到就是悬挂，不退回全局兜底
+          // （退回会静默连到别的项目，正是这个语法要避免的）
+          dstId = idOf.get(`${explicitProj}/concepts/${page}`)
+            ?? idOf.get(`${explicitProj}/entities/${page}`)
+            ?? idOf.get(`${explicitProj}/sessions/${page}`)
+            ?? idOf.get(`${explicitProj}/syntheses/${page}`);
+          if (dstId === undefined) stat.crossProjectMissing = (stat.crossProjectMissing || 0) + 1;
+        } else {
+          // 就近优先：本项目 → 再全局
+          dstId = idOf.get(`${p.project}/concepts/${page}`)
+            ?? idOf.get(`${p.project}/entities/${page}`)
+            ?? idOf.get(`${p.project}/sessions/${page}`)
+            ?? findGlobal(idOf, page);
+        }
         if (dstId === undefined) {
-          insEdge.run(srcId, 0, word);
-          stat.dangling++;
+          // 平铺文件名（index/todo/log）当链接目标是**讨论语法的示例文本**，
+          // 不是真链接 —— 实测 .brain 里 `[[todo]]` 出现在「lint 误报它死链」这句里。
+          // 这类不记悬挂（它们不是死链，是正文引用了文件名）。
+          if (!LEDGER_SLUGS.has(page)) {
+            insEdge.run(srcId, 0, word);
+            stat.dangling++;
+          }
         } else {
           insEdge.run(srcId, dstId, word);
           stat.edges++;
+          if (explicitProj) stat.crossProject = (stat.crossProject || 0) + 1;
         }
       }
     }
@@ -284,8 +356,32 @@ export function rebuild(handle, pages) {
   return stat;
 }
 
-/** 同名页全局兜底：取第一个命中的（跨项目引用靠 @前缀 显式写，这里只做兜底）。 */
+/** 解析双链目标：`[[@项目/页面]]` → 显式跨项目；`[[页面]]` → 就近。
+ *
+ * 为何要这个语法（2026-11-02 用户定「跨项目双链连接」）：
+ *   默认就近（本项目优先）能覆盖绝大多数情况，但「我要明确引用另一个项目的某页」
+ *   就没法表达 —— 只能靠全局兜底，而那会撞上同名页。
+ *   `@` 前缀让跨项目引用显式，读页面时也一眼看得出「这条链出了项目」。
+ *
+ * 返回 { project: '项目名'|null, page: '页名' }。
+ */
+export function parseAnchor(word) {
+  const w = String(word || '').trim();
+  const m = w.match(/^@([^/\\]+)[/\\](.+)$/);
+  if (m) return { project: m[1].trim(), page: m[2].trim() };
+  return { project: null, page: w };
+}
+
+/** 同名页全局兜底：取第一个命中的（跨项目引用靠 @前缀 显式写，这里只做兜底）。
+ *
+ * 必须排除两类同名目标（2026-11-02 实测踩到）：
+ *   · 平铺文件 index/todo/log —— 每个项目都有一份，兜底会连到别的项目去。
+ *     实测 `[[index]]` 把 agent_brain_sync 的页连到了 pA/index，纯误连。
+ *   · 流水页（dir 为空）同理。
+ * 判据：兜底只在「知识页」之间发生，索引/流水不算知识页。
+ */
 function findGlobal(idOf, word) {
+  if (LEDGER_SLUGS.has(word)) return undefined;
   for (const [k, v] of idOf) {
     if (k.endsWith(`/${word}`)) return v;
   }
@@ -299,25 +395,96 @@ function findGlobal(idOf, word) {
  * 返回 [{ id, project, dir, slug, title, layer, score }]，按 FTS 相关度排序。 */
 export function search(handle, query, { limit = 20 } = {}) {
   const { db } = handle;
-  const grams = bigrams(query);
-  // 查询切成 2-gram 后用 OR 连 —— 越多 gram 命中越相关（bm25 自己会排序）。
+  const grams = queryBigrams(query);
   if (!grams.length) return [];
   const expr = grams.map((g) => `"${g.replace(/"/g, '""')}"`).join(' OR ');
+  // 命中门槛：按 gram 的**文档频率加权**算覆盖率，不再用「命中几个」的平均数。
+  //
+  // 为何要加权（2026-11-02 深度测试发现，两轮才修对）：
+  //   FTS 的 OR 语义是「命中任意 gram 就算」。先试「命中数 ≥ 一半」，
+  //   但中文高频组合会绕过它 —— 查 `zzzz不存在zzz` 时，「不存在」切出
+  //   [不存, 存在] 两个 gram，命中 2/4 就达标，而「不存在」在图谱里到处都是。
+  //   实测真实图谱：`验证` 出现在 84% 的页里、`关联` 79%、`连接` 79% ——
+  //   这些 gram 没有区分度，却和稀有 gram 等权。
+  // 现在每个 gram 的权重 = log((总页数+1)/(出现页数+0.5))：
+  //   稀有 gram（如专有名词）权重高，常见虚词组合权重低到几乎不计。
+  //   覆盖率 = 命中 gram 的权重和 / 查询 gram 的总权重，低于 MIN_COVER 丢弃。
+  const MIN_COVER = 0.35;
+  const totalNodes = db.prepare('SELECT count(*) c FROM nodes_bigram').get().c || 1;
+  const df = new Map();
+  for (const r of db.prepare('SELECT g FROM nodes_bigram').all()) {
+    for (const g of String(r.g).split(' ')) df.set(g, (df.get(g) || 0) + 1);
+  }
+  const wOf = (g) => {
+    const d = df.get(g) || 0;
+    return d === 0 ? 3 : Math.log((totalNodes + 1) / (d + 0.5));  // 库里没有的 gram 权重最高
+  };
+  const wantWeight = grams.reduce((a, g) => a + wOf(g), 0) || 1;
   try {
+    // 取 g 列才能数命中数；多取一些候选，过滤后仍可能不够 limit
     const rows = db.prepare(`
       SELECT n.id, n.project, n.dir, n.slug, n.title, n.layer,
-             bm25(fts) AS rank
-      FROM fts JOIN nodes n ON n.id = fts.rowid
+             bm25(fts) AS rank, b.g
+      FROM fts
+      JOIN nodes_bigram b ON b.id = fts.rowid
+      JOIN nodes n ON n.id = fts.rowid
       WHERE fts MATCH ? AND n.is_ledger = 0
+        -- 被推翻的经验不出现在检索里。
+        -- 它的存在意义是「别再用它」，而不是回答「我上次怎么解决 X」——
+        -- 那会拿到一个已知错误的答案。与 abs query 的既有判据一致。
+        AND n.status != 'superseded'
       ORDER BY rank
       LIMIT ?
-    `).all(expr, limit);
-    // bm25 返回**负值且越负越相关**，不能直接当亮度用（否则最相关的最暗）。
-    // 归一：取最相关的一条为 1.0，其余按比例落到 0.3~1.0 区间 ——
-    // 保留下限是为了让「勉强命中的种子」仍能扩散，只是传得更弱。
-    if (!rows.length) return [];
-    const worst = Math.abs(rows[rows.length - 1].rank) || 1e-9;
-    return rows.map((r) => ({ ...r, bright: Math.max(0.3, Math.abs(r.rank) / worst) }));
+    `).all(expr, Math.max(limit * 4, 40));
+
+    const kept = rows.map((r) => {
+      const hitGrams = grams.filter((q) => String(r.g).includes(q));
+      const cover = hitGrams.reduce((a, g) => a + wOf(g), 0) / wantWeight;
+      return { ...r, cover, hit: hitGrams.length };
+    }).filter((r) => r.cover >= MIN_COVER);
+    if (!kept.length) return [];
+
+    // bm25 返回**负值且越负越相关**。归一成 0.3~1.0 的亮度，保证「最相关 = 1.0」。
+    //
+    // 坑（2026-11-02 深度测试发现）：原来分母取 `kept[最后一条].rank` —— 而 kept 按
+    //   rank 升序（第一行最相关），最后一条恰恰是**最不相关**的那条，其 rank 接近 0。
+    //   实测一个 4 条结果的查询里，最相关那条亮度算出 1168694.07（= |−2.42| / 2e-6），
+    //   输出一行 165 万的亮度条。分母必须取最相关的那条（第一条）。
+    // 种子亮度里要体现「层」—— 否则分层只在扩散时起作用，种子仍按纯字面排。
+    // 实测（2026-11-02，14 个项目 586 页）：查「docker」时三个 sessions/ 流水页
+    // 排在最前，压过真正讲了 docker 的知识页 —— 流水页正文长、词频高，bm25 天然占优，
+    // 但对「我上次怎么解决 X」没有价值。
+    // 权重 = 1 - decay：L3 工具 0.6、L4 认知 0.4、L5 会话 0.25、L7 混沌 0.05。
+    // L1/L2 不参与（铁律不立页）。
+    const layerWeight = (layer) => Math.max(0.05, 1 - decayOf(layer));
+    const best = Math.abs(kept[0].rank) || 1e-9;
+    // 亮度 = 档位 × 档内名次。
+    //   档位由加权覆盖率决定（0.6~1.0）：全命中最高，勉强沾边压到 0.6 档再往下。
+    //   档内名次由相对 bm25 决定（0.1~1.0）：覆盖率相同但 bm25 不同的页仍可分。
+    // 下限 0.3 保留 —— 勉强命中的种子仍要能向外扩散，只是传得更弱。
+    return kept.slice(0, limit).map(({ g: _g, ...r }) => {
+      const rel = Math.min(1, Math.abs(r.rank) / best);
+      const band = 0.6 + 0.4 * r.cover;
+      // 亮度保持 0.3~1.0 的可读区间，**不乘层权重**。
+      // 坑（2026-11-02 实测）：把层权重乘进亮度后，L4 的满分页只剩 0.40，
+      // 输出里一片 0.3~0.5，用户看不出谁更相关 —— 亮度失去了「一眼看强弱」的作用。
+      // 层的作用改由**排序**承担（见下面 sort），亮度回归「这一页与查询多贴」本身。
+      const bright = Math.max(0.3, Math.min(1, band * (0.1 + 0.9 * rel)));
+      return { ...r, bright };
+    }).sort((a, b) => {
+      // 排序：层优先，同层再看亮度。
+      // 为何层要排第一（2026-11-02，586 页实测）：查「静默失效」的前三名全是 L7
+      // 混沌页（临时笔记），字面 cover=1.00 但内容与主题无关；
+      // 而 L4 认知层里真正讲这个主题的页被压到后面。
+      // 判据：知识层的页即便贴得稍微松一点，也比混沌层的碎片更该先看。
+      //
+      // 例外：L1/L2 不参与排序（铁律不立页，单独在最前输出）。
+      const wa = layerWeight(a.layer);
+      const wb = layerWeight(b.layer);
+      const sa = wa * a.bright;
+      const sb = wb * b.bright;
+      return (sb - sa) || (b.bright - a.bright) || (a.id - b.id);
+    });
   } catch {
     // 方言/语法问题不能让搜索整体挂掉 —— 退化成空种子，由调用方决定提示
     return [];
@@ -377,10 +544,20 @@ export function illuminate(handle, seeds, { hops = HOPS, limit = 10 } = {}) {
 
   const out = [];
   for (const [id, v] of bright) {
-    const n = db.prepare('SELECT id,project,dir,slug,title,layer FROM nodes WHERE id = ? AND is_ledger = 0').get(id);
+    // 扩散出口也要排除 superseded —— 入口（search）排了，出口不排就绕过去：
+    // 实测旧结论页自己不出现在种子里，却被邻居扩散点亮（亮度 0.24 带 ↝）。
+    const n = db.prepare("SELECT id,project,dir,slug,title,layer FROM nodes WHERE id = ? AND is_ledger = 0 AND status != 'superseded'").get(id);
     if (n) out.push({ ...n, bright: v.bright, from: v.from });
   }
-  return out.sort((a, b) => b.bright - a.bright || a.id - b.id).slice(0, limit);
+  // 排序口径必须与 search 一致：层优先，同层再比亮度。
+  // 坑（2026-11-02 实测）：原来这里只按 bright 排，把 search 已经排好的层序冲掉了 ——
+  // 于是 L7 混沌页（bright 1.00）又跑到 L4 认知页（bright 0.95）前面。
+  // 层权重在这里再乘一次，为的是「扩散进来的弱页不会因为某个邻居强就压过知识页」。
+  const weight = (layer) => Math.max(0.05, 1 - decayOf(layer));
+  return out
+    .sort((a, b) => (weight(b.layer) * b.bright - weight(a.layer) * a.bright)
+      || (b.bright - a.bright) || (a.id - b.id))
+    .slice(0, limit);
 }
 
 /** L1 铁律：按项目取出。检索任何东西都必须先带上它（「不可逾越」的代码保证）。 */

package/src/brain/evolve.js

@@ -0,0 +1,123 @@
+// src/brain/evolve.js — 知识自我进化：从图谱里看出「知识在往哪走」。
+//
+// 为何需要它（2026-11-02 用户定目标「可自我成长的知识库」）：
+//   图谱现在能存能查，但不会告诉人「哪里在变好、哪里在堆积、哪里该合并」。
+//   光靠人定期回头看，就是靠记忆维护记忆 —— 必然漏。
+//
+// 四条判据，都只**报告**不判断（判断是内容决策，程序不替人做）：
+//   1. 被推翻的：哪些页已 superseded、被谁取代、有没有留下空链
+//   2. 主题堆积：同一主题词下页数过多，说明该合并成规律页
+//   3. 只进不出：有新页被建立但没人链它，等于没接进网络
+//   4. stale：长期没改动、且没有任何入边的页 —— 考察是否该删
+//
+// 输出纪律：按类型折叠计数，同类超阈值只报条数 + 样例（见 read-side-output-must-not-scale）。
+
+/** 收集进化信号。只读，不改任何东西。 */
+export function evolveSignals(handle, { staleDays = 90, now = Date.now() } = {}) {
+  const { db } = handle;
+  const all = db.prepare("SELECT id, slug, project, layer, status, superseded_by, mtime FROM nodes WHERE is_ledger = 0").all();
+  const byId = new Map(all.map((r) => [r.id, r]));
+  const inbound = new Map();
+  for (const r of db.prepare('SELECT dst, count(*) c FROM edges WHERE dst > 0 GROUP BY dst').all()) inbound.set(r.dst, r.c);
+  const outbound = new Map();
+  for (const r of db.prepare('SELECT src, count(*) c FROM edges WHERE src > 0 GROUP BY src').all()) outbound.set(r.src, r.c);
+
+  // 1. 被推翻的
+  const superseded = all.filter((r) => r.status === 'superseded');
+  const danglingSupersede = superseded.filter((r) => {
+    if (!r.superseded_by) return true;                    // 标了推翻但没指向谁
+    return !all.some((x) => x.slug === r.superseded_by && x.project === r.project);
+  });
+
+  // 2. 主题堆积：按 tags 里的**业务标签**归类。
+  //
+  // 坑（2026-11-02 实测）：tags 的第一项是**页面类型**（concept/source/session-log/entity），
+  //   拿它归类必然把 58 页 concept 报成「一组堆积」—— 那是类型不是主题，全是噪音。
+  //   类型词是固定的几个，直接按白名单跳过；主题看第二项起。
+  // 另：会话流水页不参与主题堆积判断。
+  //   它们的 tags 里带 `todo-archive`/`历史`，按主题归类会把 13 个归档快照
+  //   报成「该合并成规律页」—— 但归档快照本来就该各自独立（一天一文件是目录契约）。
+  //   判据看 dir：sessions/ 下的都是流水，不是知识页。
+  const TYPE_TAGS = new Set(['concept', 'source', 'synthesis', 'entity', 'session-log']);
+  const tagBuckets = new Map();
+  for (const row of db.prepare("SELECT tags, slug FROM nodes WHERE is_ledger = 0 AND dir != 'sessions' AND tags != ''").all()) {
+    const parts = String(row.tags).replace(/^\[|\]$/g, '').split(',').map((s) => s.trim()).filter(Boolean);
+    const topic = parts.find((x) => !TYPE_TAGS.has(x.toLowerCase()));
+    if (!topic) continue;
+    if (!tagBuckets.has(topic)) tagBuckets.set(topic, []);
+    tagBuckets.get(topic).push(row.slug);
+  }
+  const piled = [...tagBuckets.entries()]
+    .filter(([, v]) => v.length >= 8)                      // 一个主题下 8 页以上算堆积
+    .sort((a, b) => b[1].length - a[1].length);
+
+  // 3. 只进不出：有入边但没有出边 —— 说明它是终点，不连回别处
+  const sinkOnly = all.filter((r) => (inbound.get(r.id) || 0) > 0 && !(outbound.get(r.id) || 0));
+
+  // 4. stale：长期没改 + 没人链
+  const staleMs = staleDays * 86400_000;
+  const stale = all.filter((r) => (now - (r.mtime || 0) > staleMs) && !(inbound.get(r.id) || 0));
+
+  return {
+    total: all.length,
+    superseded, danglingSupersede,
+    piled, sinkOnly, stale,
+    byId, inbound, outbound,
+  };
+}
+
+/** 渲染成给人看的报告。按类型分组，同类超阈值只报样例。 */
+export function renderEvolve(sig, { sample = 5, staleDays = 90 } = {}) {
+  const out = [];
+  const trunc = (arr, fmt) => {
+    const shown = arr.slice(0, sample).map(fmt);
+    if (arr.length > sample) shown.push(`  …另有 ${arr.length - sample} 条`);
+    return shown;
+  };
+
+  out.push(`📈 图谱进化体检 — ${sig.total} 页`);
+  out.push('');
+
+  // 好消息放前面：推翻说明知识在更新
+  if (sig.superseded.length) {
+    out.push(`✓ 已推翻 ${sig.superseded.length} 页（知识在更新，不是坏事）`);
+    out.push(...trunc(sig.superseded, (r) => `    ${r.slug} → ${r.superseded_by || '(未指向)'}`));
+  } else {
+    out.push('· 还没有被推翻的页 —— 要么知识很稳，要么没人回头修正');
+  }
+  out.push('');
+
+  if (sig.danglingSupersede.length) {
+    out.push(`⚠ ${sig.danglingSupersede.length} 页标了推翻但没指向新页（历史断了，看不出被谁取代）`);
+    out.push(...trunc(sig.danglingSupersede, (r) => `    ${r.slug}`));
+    out.push('  修: abs supersede <旧页> --by <新页>');
+    out.push('');
+  }
+
+  if (sig.piled.length) {
+    out.push(`⚠ 主题堆积 ${sig.piled.length} 组（同一主题下页数多，考虑合并成规律页）`);
+    out.push(...trunc(sig.piled, ([tag, list]) => `    ${tag}: ${list.length} 页`));
+    out.push('');
+  }
+
+  if (sig.sinkOnly.length) {
+    out.push(`· 只被链、不链别人 ${sig.sinkOnly.length} 页（是终点，不回连——若它其实是枢纽，该补出链）`);
+    out.push(...trunc(sig.sinkOnly, (r) => `    ${r.slug}  (入 ${sig.inbound.get(r.id)})`));
+    out.push('');
+  }
+
+  if (sig.stale.length) {
+    out.push(`· ${staleDays} 天没动且无人链 ${sig.stale.length} 页（可能该删或该接进网络）`);
+    out.push(...trunc(sig.stale, (r) => {
+      const days = Math.round((Date.now() - r.mtime) / 86400_000);
+      return `    ${r.slug}  (${days} 天前)`;
+    }));
+    out.push('');
+  }
+
+  const issues = sig.danglingSupersede.length + sig.piled.length + sig.stale.length;
+  out.push(issues === 0
+    ? '✓ 没有需要立刻处理的进化问题'
+    : `共 ${issues} 处待处理。这只是体检，改不改由你判断 —— 程序不替人做内容决策。`);
+  return out.join('\n');
+}

package/src/brain/summon.js

@@ -166,10 +166,12 @@ export async function scanProject(projectRoot, { ledger, now = Date.now() } = {}
   try { names = (await fs.readdir(dir)).filter((f) => f.endsWith('.jsonl')); } catch {
     return { error: `找不到会话目录: ${dir}`, fresh: [], changed: [], skipped: [], active: [] };
   }
+  const ownBook = !ledger;              // 账本是自己读的（不是调用方给的）
   const book = ledger || await readLedger();
   // 已有快照的日子整日跳过 —— 人已经总结过，托底不该再吵。
   const haveSnapshot = await daysWithSnapshot(join(projectRoot, '.brain', 'sessions'));
   const fresh = [], changed = [], skipped = [], active = [];
+  let touched = false;   // 是否补记过 stat（需要回写账本，否则下次又得读全文）
 
   for (const name of names.sort()) {
     const full = join(dir, name);
@@ -177,25 +179,60 @@ export async function scanProject(projectRoot, { ledger, now = Date.now() } = {}
     try { st = await fs.stat(full); } catch { continue; }
     if (now - st.mtimeMs < ACTIVE_MS) { active.push({ name, reason: '会话仍在写' }); continue; }
 
-    const md5 = await md5Of(full);
-    if (!md5) continue;
+    const rec = book.files[name];
+
+    // ── 便宜的预筛：文件大小 + mtime 都没变 → 内容必然没变 → 跳过，不读全文。
+    // 为何要它（2026-11-01 实测）：全读算 md5 在 63 个文件 / 55MB 上是 74ms，
+    // 而只读 stat 是 0ms（快 74 倍）。这条路径会被 abs log 每次收尾调用，
+    // 且文件数只增不减 —— 不预筛就是「读取侧随规模增长」。
+    // 漏判风险为零：改内容必动 mtime，内容变了而 size 与 mtime 都不变不可能发生。
+    if (rec && rec.size === st.size && rec.mtime === st.mtimeMs && rec.md5) {
+      skipped.push({ name, reason: 'size+mtime 未变' });
+      continue;
+    }
+
+    // 已有快照的日子，先看账本里记的 day —— 不必读文件就能判。
+    // 实测（2026-11-01）：63 个文件里有 41 个属于「已有快照」的日子，
+    // 原来要先 digestSession 读全文才知道日期，等于白读 41 次。账本里有 day 时先拦。
+    if (rec && rec.day && haveSnapshot.has(rec.day)) {
+      skipped.push({ name, reason: `${rec.day} 已有快照` });
+      continue;
+    }
+
     const d = await digestSession(full);
     if (!d || !d.users.length) { skipped.push({ name, reason: '无真实用户输入' }); continue; }
     if (d.day && haveSnapshot.has(d.day)) { skipped.push({ name, reason: `${d.day} 已有快照` }); continue; }
 
-    const rec = book.files[name];
-    if (rec && rec.md5 === md5) { skipped.push({ name, reason: 'md5 一致' }); continue; }
+    // 到这里才需要 md5（要么文件变了，要么账本里没有）。
+    const md5 = await md5Of(full);
+    if (!md5) continue;
+    if (rec && rec.md5 === md5) {
+      // size/mtime 变了但内容没变（如 touch、备份还原）→ 补记新的 stat，下次走预筛
+      book.files[name] = { ...rec, size: st.size, mtime: st.mtimeMs };
+      touched = true;
+      skipped.push({ name, reason: 'md5 一致（仅 stat 变化）' });
+      continue;
+    }
 
-    const item = { name, md5, day: d.day, digest: d, sizeKB: Math.round(st.size / 1024) };
+    const item = { name, md5, day: d.day, digest: d, sizeKB: Math.round(st.size / 1024), size: st.size, mtime: st.mtimeMs };
     if (rec) changed.push({ ...item, prevMd5: rec.md5 }); else fresh.push(item);
   }
+  // 补记的 stat 要落盘 —— 只改内存等于每次重读全文，预筛白做。
+  // 只在自己读的账本上回写：调用方传了 ledger 时，回写时机由它决定
+  // （cmdSummon 要等 --mark 才写，免得扫描顺手改了用户的账本）。
+  if (touched && ownBook) await writeLedger(book);
+
   return { fresh, changed, skipped, active, dir };
 }
 
 /** 记一笔：这些会话已提取（不管人是否落盘，账本只记「提过了」）。 */
+/** 记一笔：这些会话已提取。同时存 size+mtime —— 下次扫描靠它做便宜预筛，避免全读。 */
 export function markSummarized(ledger, items, when = new Date().toISOString()) {
   for (const it of items) {
-    ledger.files[it.name] = { md5: it.md5, day: it.day, summarizedAt: when };
+    ledger.files[it.name] = {
+      md5: it.md5, day: it.day, summarizedAt: when,
+      size: it.size, mtime: it.mtime,
+    };
   }
   return ledger;
 }
@@ -234,3 +271,33 @@ export function renderScan(result, { full = false, limit = 15 } = {}) {
   }
   return out.join('\n');
 }
+
+/** 收尾时顺手列出未总结/有更新的会话（给人看的尾巴）。
+ *
+ * 为何放在这里而不是各调用方（2026-11-02）：abs log 与 abs capture 都要用，
+ * 两处各写一份必然漂移。失败一律吞掉 —— 记流水/记经验不能因为扫会话而失败。
+ *
+ * @param {string} root 项目根
+ * @param {object} opts { limit } 最多列几场
+ * @returns {Promise<string>} 无待总结时返回空串（不占输出）
+ */
+export async function summonTail(root, { limit = 8 } = {}) {
+  try {
+    const r = await scanProject(root);
+    const pending = (r.fresh?.length || 0) + (r.changed?.length || 0);
+    if (!pending) return '';
+    const lines = ['', `--- 本项目有 ${pending} 场会话待总结 ---`];
+    for (const it of [...r.fresh, ...r.changed].slice(0, limit)) {
+      const tag = it.prevMd5 ? '（有更新）' : '';
+      lines.push(`  ${it.day}  ${it.sizeKB}KB${tag}`);
+      for (const u of (it.digest?.users || []).slice(0, 2)) {
+        lines.push(`     · ${u.replace(/\s+/g, ' ').trim().slice(0, 70)}`);
+      }
+    }
+    if (pending > limit) lines.push(`  …另有 ${pending - limit} 场（abs summon 看全量）`);
+    lines.push('  落哪条由你判断: abs capture --layer N "…"  |  abs summon --mark 记账不再提');
+    return '\n' + lines.join('\n');
+  } catch {
+    return '';
+  }
+}

package/src/install.js

@@ -919,8 +919,11 @@ export function installSummary() {
   return HOSTS.map((h) => `  ${h.key.padEnd(12)} ${h.label}`).join('\n');
 }
 
-export async function runInstall({ agent, mcp = true, skill = true, yes = false } = {}) {
-  const targets = agent ? [agent] : await pickAgents(yes);
+export async function runInstall({ agent, all = false, mcp = true, skill = true, yes = false } = {}) {
+  // all=true 是显式全选的官方入口。
+  // 为何要它（2026-11-02）：默认改成只装 pi 后，「装到所有宿主」这个能力
+  //   必须有明确表达方式 —— 否则测试只能靠 --yes 的旧语义，行为一变就全挂。
+  const targets = agent ? [agent] : (all ? Object.keys(INSTALLERS) : await pickAgents(yes));
   const failed = [];
   for (const key of targets) {
     const inst = INSTALLERS[key];
@@ -976,17 +979,28 @@ export async function runUninstall({ agent } = {}) {
 }
 
 // 交互式多选（无 TTY 时回退为全部）
+/** 默认装的宿主。
+ *
+ * 2026-11-02 用户定：默认只装 pi，其余宿主 opt-in。
+ * 理由：装到不用的宿主上会往那边的配置文件里塞 hook/MCP 条目 ——
+ * 用户没在用 Claude Code / Codex / OpenCode 时，那是纯污染。
+ * 要装别的：abs install --agent claude-code（可逐个装）。
+ */
+export const DEFAULT_AGENT = 'pi';
+
 async function pickAgents(yes = false) {
-  // --yes / 非 TTY: 直接全选，绝不弹交互。
+  // --yes / 非 TTY: 装默认宿主（pi），绝不弹交互。
   // 坑: 曾经只看 isTTY，--yes 被收下却从不使用 —— 在 TTY 里跑
   //     abs install --yes（自动化/脚本）仍会弹提示并挂起等输入。
-  if (yes || !process.stdin.isTTY) return Object.keys(INSTALLERS);
+  if (yes || !process.stdin.isTTY) return [DEFAULT_AGENT];
   const readline = await import('node:readline/promises');
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  console.log('选择要安装的智能体 (逗号分隔, 回车=全部):');
+  console.log(`选择要安装的智能体 (逗号分隔, 回车=只装 ${DEFAULT_AGENT}):`);
   console.log(installSummary());
   const ans = (await rl.question('> ')).trim();
   rl.close();
-  if (!ans) return Object.keys(INSTALLERS);
+  if (!ans) return [DEFAULT_AGENT];
+  // all / * 作为显式全选的逃生门，避免把「装全部」的能力彻底拿掉
+  if (ans === 'all' || ans === '*') return Object.keys(INSTALLERS);
   return ans.split(',').map((s) => s.trim()).filter(Boolean);
 }

package/src/note.js

@@ -11,6 +11,7 @@ import { today, localStamp, LOG_KINDS } from './todo.js';
 import { editFile, SKIP } from './lock.js';
 import { impactOf } from './codegraph.js';
 import { clip, slugOf } from './text.js';
+import { summonTail } from './brain/summon.js';
 
 
 /** 惰性调 autoIndex —— 断循环 import：note.js ← capture.js ← db-cmd.js ← note.js。
@@ -102,7 +103,7 @@ export async function cmdNote({ dir, text, tags, when, impact, type }) {
   // index Sources 区登记（锁内幂等：别页已登记则跳过，防并发重复） + log 一行
   const slug = file.replace(/\.md$/, '');
   await registerInIndex(root, 'Sources', slug, heading);
-  await cmdLog({ dir: root, title: clean, kind: 'note' });
+  await cmdLog({ dir: root, title: clean, kind: 'note', summon: false });
   // 落盘即入库（库已存在时）。失败不阻断 —— 见 autoIndex 的边界说明。
   await autoIndexLazy();
   return `✓ 经验暂存 → sources/${file}\n  ${clean} ${atTag(who)}`;
@@ -260,7 +261,7 @@ export async function registerInIndex(root, section, slug, desc) {
   });
 }
 // ---------- log: 追加工作成果沉淀摘要（用户/AI 主动 abs log "..." 记, 不收工具动作流水） ----------
-export async function cmdLog({ dir, title, kind = 'dev' }) {
+export async function cmdLog({ dir, title, kind = 'dev', summon = true }) {
   const root = await requireBrain(dir || process.cwd());
   const who = await requireUser(); // 写操作守卫
   // ★ kind 必须是枚举值（2026-10-05 加）：此前无校验，传什么写什么 ——
@@ -294,6 +295,16 @@ export async function cmdLog({ dir, title, kind = 'dev' }) {
     return { text: lines.join('\n') };
   });
   // 重复时不报「✓ 已写入」—— 那是在说假话（用户会以为多了一条）。
-  if (res === SKIP) return `• 同一分钟已有同一内容，已跳过 → ${p}\n  ${line}`;
-  return `✓ log → ${p}\n  ${line}`;
-}
+  const head = res === SKIP
+    ? `• 同一分钟已有同一内容，已跳过 → ${p}\n  ${line}`
+    : `✓ log → ${p}\n  ${line}`;
+
+  // 落盘顺手深读本项目下的会话：没总结过的、有更新的，一并提出来。
+  // 为何挂在 log 上（2026-11-01 用户定）：`abs log` 是收尾动作本身，
+  //   人在这里才愿意看「还有哪些会话没总结」；平时他不会主动跑 summon。
+  // 只给线索不写盘 —— 落哪一条仍是人的判断（见 summon.js 的边界说明）。
+  // summon=false 供 note/concept 内部调用时关闭：那些也是写 log，但不是收尾场景。
+  const tail = summon ? await summonTail(root) : '';
+  return head + tail;
+}
+