@fanchao8609/agent_brain_sync 1.21.0 → 1.23.0

package/src/brain/load.js

@@ -5,7 +5,7 @@ import { brainPath, requireBrain } from '../index.js';
 import { getUser, placeholderWarn } from '../userconfig.js';
 import { boardText, readTodo, collapseDone } from '../todo.js';
 import { strandedFor } from '../wrapup.js';
-import { keywords, recentFiles, topicStrength } from '../relevant.js';
+import { keywords, recentFiles, topicStrength, digest } from '../relevant.js';
 import { readIfExists, recentLogLines } from '../text.js';
 import { listPages } from '../lint.js';
 import { SOURCES_MAX } from '../lint.js';
@@ -136,6 +136,12 @@ export async function cmdLoad({ dir }) {
     const rel = await queryHintSection(root, todo);
     if (rel) sections.push('', rel);
   } catch { /* 提示失败不影响 load */ }
+  // 最相关几页（2026-11-02）：queryHint 给「该查什么词」，这里给「该读哪几页」。
+  // 放最后 —— 它是「再深入一层」的东西，前面先给状态与待办。
+  try {
+    const hot = await hotPagesSection(root, todo);
+    if (hot) sections.push('', hot);
+  } catch { /* 同上，失败静默 */ }
   // sources 堆积提醒：与「滞留」同构 —— 放在每次开工必经的顶部，而不是等人跑 lint。
   // 只数目录条目（不读文件），零成本。提炼仍手工：这里只负责送达，不替判断。
   try {
@@ -174,6 +180,94 @@ export function extractBlocks(todoText) {
   return out;
 }
 
+/** 从「活跃 todo + 最近改动的文件」推出当前上下文的关键词。
+ *
+ * 抽成公共函数（2026-11-02）：queryHint（给查询词）与 hotPages（给正文）
+ * 都要用，两处各算一遍必然漂移。
+ *
+ * 已剔掉任务行的结构记号：`- [ ] [状态] <id> [[作者]] —` 里只有「—」后面是真内容。
+ * 实测教训（2026-09-17）：不剔的话 `<id>` 与 `[[作者]]` 会进入词表，
+ * 而作者名恰好有自己的 entities/<作者>.md 页 → 命中页名 → 提出「查你自己的名字」。
+ */
+async function contextKeywords(root, todoText) {
+  const active = String(todoText || '')
+    .split('\n')
+    .filter((l) => /^\s*-\s*\[\s*\]/.test(l))
+    .map((l) => l.replace(/^\s*-\s*\[\s*\]\s*(?:\[[^\]]*\]\s*)?(?:\S+\s*)?/, '').replace(/\[\[[^\]]*\]\]/g, ' '))
+    .join(' ');
+  const files = await recentFiles(root, { n: 5 }).catch(() => []);
+  const src = [active, files.map((f) => f.name).join(' ')].filter(Boolean).join(' ');
+  return { kws: keywords(src), files };
+}
+
+/**
+ * 开机带出「当前上下文最相关的几页」—— 只给页名 + 一句话摘要，不贴正文。
+ *
+ * 与 queryHint 的分工（2026-11-02 用户定）：
+ *   queryHint 给「该查什么词」，本函数给「该读哪几页」。两者都只是**送达线索**，
+ *   不替代 query / db search，也不贴正文。
+ *
+ * 为何不贴正文：既有判据是「自动带出正文会让 query 更没人用，且无法按需求变化调整词」。
+ *   只给页名 + 摘要把选择权留给人：想看再 abs resolve / 读文件。
+ *
+ * 输入是环境事实（活跃 todo 的关键词 + 最近改过的文件），不需要人先想到搜索词 ——
+ *   这正是不依赖「主动查询」的那条路。
+ *
+ * 降级：库不存在 / 库坏了 / 任何异常 → 返回空串，不影响 load。
+ *
+ * @param {string} root 项目根
+ * @param {string} todoText
+ * @param {number} limit 最多几页
+ */
+export async function hotPagesSection(root, todoText, { limit = 3 } = {}) {
+  try {
+    const { kws } = await contextKeywords(root, todoText);
+    if (!kws.length) return '';
+    const { openDb, search, illuminate, dbPath } = await import('./db.js');
+    const { promises: fsp } = await import('node:fs');
+    const exists = await fsp.stat(dbPath()).then(() => true).catch(() => false);
+    if (!exists) return '';   // 库没建 → 静默跳过（不是错误）
+
+    // 项目名要与入库时一致 —— 铁律按项目隔离，读错项目就是串味
+    const project = String(root).split('/').filter(Boolean).pop() || '';
+    const h = openDb(dbPath());
+    try {
+      // 用几个强词合并成一组种子：逐个查再按 id 去重取最高亮度
+      const seeds = new Map();
+      for (const kw of kws.slice(0, 5)) {
+        for (const s of search(h, kw, { limit: 6 })) {
+          const prev = seeds.get(s.id);
+          if (!prev || s.bright > prev.bright) seeds.set(s.id, s);
+        }
+      }
+      if (!seeds.size) return '';
+      const lit = illuminate(h, [...seeds.values()], { limit: limit + 6 })
+        // 只留本项目的页：跨项目的经验可以查，但不该在开机首屏默认塞进来
+        .filter((r) => r.project === project)
+        // 再按**纯亮度**重排 —— illuminate 用的是「层权重 × 亮度」，
+        // 那是为了让知识页压过流水页（搜索场景对）；但开机首屏要看的是
+        // 「跟我现在干的事最贴的」，不是「层级最高的」。
+        // 实测：不重排时 L3 的 0.925 会排在 L4 的 1.000 前面 —— 读起来反直觉。
+        .sort((a, b) => b.bright - a.bright)
+        .slice(0, limit);
+      if (!lit.length) return '';
+
+      const rows = ['--- 当前最相关（按亮度，纯线索不贴正文；要看用 abs resolve <页名>）---'];
+      for (const r of lit) {
+        const one = await fsp.readFile(brainPath(root, r.dir, `${r.slug}.md`), 'utf8').catch(() => '');
+        const about = one ? digest(one, 80) : '';
+        const tag = r.from === 'spread' ? ' ↝' : '';
+        rows.push(`  ${r.bright.toFixed(2)} L${r.layer} [[${r.slug}]]${tag}${about ? ' — ' + about : ''}`);
+      }
+      return rows.join('\n');
+    } finally {
+      h.close();
+    }
+  } catch {
+    return '';   // 任何异常都不该弄坏 load
+  }
+}
+
 /**
  * 开工提示：直接给出该查的几个词，降低发起 query 的成本。
  *
@@ -195,19 +289,7 @@ export function extractBlocks(todoText) {
  * @param {{name:string,body:string}[]} [pages] 已读好的页（省一次磁盘扫描）
  */
 async function queryHint(root, todoText, pages) {
-  const active = String(todoText || '')
-    .split('\n')
-    .filter((l) => /^\s*-\s*\[\s*\]/.test(l))
-    // 剔掉任务行的结构记号再分词：`- [ ] [状态] <id> [[作者]] —` 里只有「—」后面是真内容。
-    // 实测教训（2026-09-17）：不剔的话 `<id>` 与 `[[作者]]` 会进入词表，
-    // 而作者名恰好有自己的 entities/<作者>.md 页 → 命中**页名** → 强度 1 过了门槛，
-    // 于是提示语变成「查一下你自己的名字」。建议查作者页不是“别重踩的经验”。
-    // 用 task 行自身的形状剥（与 idOfTaskLine 同源），不维护人名/任务名黑名单。
-    .map((l) => l.replace(/^\s*-\s*\[\s*\]\s*(?:\[[^\]]*\]\s*)?(?:\S+\s*)?/, '').replace(/\[\[[^\]]*\]\]/g, ' '))
-    .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);
+  const { kws, files } = await contextKeywords(root, todoText);
   if (!kws.length) return '';
   const all = pages || await listPages(brainPath(root)).catch(() => []);
   const strength = topicStrength(all.map((p) => ({ name: p.slug, body: p.body })), kws);

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;
+}
+