@fanchao8609/agent_brain_sync 1.23.0 → 1.25.0

package/bin/abs.js

@@ -2,7 +2,7 @@
 // bin/abs.js — abs CLI 入口。
 // 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 { cmdInit, cmdStatus, cmdLoad, cmdRecall, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdConcept, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive, cmdResolve, cmdSupersede, cmdReview } from '../src/store.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';
@@ -135,6 +135,8 @@ const FLAG_SPEC = {
   'by': { type: 'string' },
   'all': { type: 'boolean' },
   'keep-days': { type: 'string' },
+  // db evolve 用：多少天没动且无人链算 stale。未声明会被静默吞成 true（同 keep-days 坑）。
+  'stale-days': { type: 'string' },
   'help': { type: 'boolean' },
   'dry-run': { type: 'boolean' },
   'full': { type: 'boolean' },
@@ -145,7 +147,7 @@ const FLAG_SPEC = {
 };
 
 /** 已被"规范键"接管的 raw flag：不再原样漏出（见 parseArgv 返回处的白名单注释）。 */
-const KNOWN_RAW = new Set(['keep-days', 'dry-run', 'no-mcp', 'no-skill']);
+const KNOWN_RAW = new Set(['keep-days', 'stale-days', 'dry-run', 'no-mcp', 'no-skill']);
 
 function parseArgv(args) {
   // 坑: parseArgs 会把**任何** `-` 开头的 token 当选项，连正文一起吃：
@@ -220,6 +222,7 @@ function parseArgv(args) {
     repair: !!values.repair,
     full: !!values.full,
     keepDays: values['keep-days'],
+    staleDays: values['stale-days'],
     dryRun: !!values['dry-run'],
     mcp: !values['no-mcp'],
     skill: !values['no-skill'],
@@ -239,6 +242,7 @@ const usage = `abs — 跨会话记忆工具（.brain/ 图谱）
   abs todo add X --note "做什么"      登记任务 (done/state/note 管后续)
   abs note "经验一句话"               随手记经验; abs log "完成 X" 记成果
   abs query <词…>                   检索 .brain/; abs todo 看任务板
+  abs recall [词…]                  卡住时主动取相关页（不给词就按当前处境推）
 
 全部命令 (细节: abs <命令> --help):
   init [--repair]            建图谱 (当前目录)
@@ -363,6 +367,18 @@ const subUsage = {
     '参数:',
     '  --all    连 superseded(已失效)页一起返回',
   ].join('\n'),
+  recall: [
+    'abs recall — 卡住时主动取相关页（不需先想到检索词）',
+    '',
+    '用法:',
+    '  abs recall [词1 词2 …] [--limit N]',
+    '',
+    '不给词时，从当前处境推：活跃 todo 的关键词 + 最近改过的文件名。',
+    '给了词就只用你给的词，不混处境词。',
+    '',
+    '与 load 的区别: load 只在开工跑一次；recall 随时可跑（卡住/换方向时）。',
+    '与 query 的区别: query 枚全图命中；recall 只给按亮度亮的几页。',
+  ].join('\n'),
   config: [
     'abs config — 使用者姓名（写操作的作者标记）',
     '',
@@ -457,6 +473,11 @@ async function main() {
         rejectExtra(opts._, 'abs load');
         console.log(await cmdLoad({ dir: opts.dir }));
         break;
+      case 'recall': {
+        const limit = Number(opts.limit) > 0 ? Number(opts.limit) : 5;
+        console.log(await cmdRecall({ dir: opts.dir, terms: opts._, limit }));
+        break;
+      }
       case 'index':
         rejectExtra(opts._, 'abs index');
         console.log(await cmdShow({ dir: opts.dir, view: 'index' }));
@@ -582,7 +603,7 @@ 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, full: !!opts.full })); 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 === 'evolve') { console.log(await cmdDbEvolve({ staleDays: Number(opts.staleDays) || 90 })); break; }
         if (sub === 'add') {
           const r = await addProject(opts.dir || process.cwd());
           console.log(`✓ 已登记项目: ${r}\n  建库: abs db rebuild`);

package/bin/mcp.js

@@ -11,7 +11,7 @@ import { appendFile, mkdir } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { findBrainRoot, absLogDir } from '../src/index.js';
+import { findBrainRoot, absLogDir, AbsError } from '../src/index.js';
 import { cmdBoard, cmdLoad, cmdStatus, cmdTask, cmdQuery, cmdLint, cmdNote, cmdConcept, cmdWrapup, cmdRule, cmdResolve, cmdSupersede } from '../src/store.js';
 
 // ---------- 技术日志: MCP 请求跟踪（调试用, 与图谱 log.md 完全分开） ----------
@@ -40,6 +40,12 @@ function withTrace(name, handler) {
       return r;
     } catch (e) {
       await tlog(`tool=${name} cwd=${args?.cwd || '-'} args=${argBrief} → THROW ${Date.now() - t0}ms | ${String(e?.message || e).slice(0, 200)}`);
+      // 带 code 的 AbsError（如 requireUser 的 NO_USER）必须走 err() 结构化返回，
+      // 保留 code + fallback 自救指引 —— 裸 rethrow 只带 message，LLM 拿到后
+      // 不知道下一步跑什么（与 CLI 侧 `[CODE] + → fallback` 的既有行为不一致）。
+      if (e instanceof AbsError) {
+        return err(e.message, { code: e.code, fallback: e.fallback || undefined });
+      }
       throw e;
     }
   };

package/hooks/abs.omp.ts

@@ -341,10 +341,16 @@ const USER_NICKNAMES = [
 let sessionNickname = ''
 
 /** 抽一条昵称。传 rnd 便于测试注入；默认 Math.random。关掉：ABS_TODO_NICK=0。 */
+/** 昵称池每条存成「emoji + 空格 + 正文」，展示时剥掉 emoji，只留正文（2026-11-04 用户要求）。 */
+export function stripNicknameEmoji(s: string): string {
+  // 循环剥：🏴‍☠️、😮‍💨 这类 ZWJ 组合 emoji 由多段拼成，只剥一次会剩下后半截。
+  return s.replace(/^(?:\p{Extended_Pictographic}[\uFE0F\u200D\u{1F3FB}-\u{1F3FF}]*)+[\s]*/u, '').trim()
+}
+
 export function pickNickname(rnd: () => number = Math.random): string {
   if (String(process.env.ABS_TODO_NICK || '') === '0') return ''
   const i = Math.min(USER_NICKNAMES.length - 1, Math.floor(rnd() * USER_NICKNAMES.length))
-  return USER_NICKNAMES[Math.max(0, i)]
+  return stripNicknameEmoji(USER_NICKNAMES[Math.max(0, i)])
 }
 
 /** 解析 todo.md 的 ## Todo 区 —— 只收未完成行（- [ ]），Done 区不计。
@@ -516,19 +522,15 @@ export function renderPanelLines(
   // ★ 空看板不返回空数组：面板是「机制在不在」的常驻指示，进去就看不见 = 不知道机制活着。
   const colorOf = (state: string): string => (state === '搁置' ? 'dim' : state === '滞留中' ? 'muted' : state === '讨论中' ? 'dim' : 'accent')
   const lines: string[] = []
-  // 上描边用 `thinkingOff` —— 与输入框描边同一个色（pi 版排查三轮才确认：不能按名字猜主题色）。
-  // 满宽（不 -1）—— 对齐宿主自己的 DynamicBorder.render。
-  lines.push(fg('thinkingOff', '─'.repeat(Math.max(1, width))))
+  // 上描边行已删除（2026-11-04 与 pi 版同步，用户要求「去掉上边框」）。首行现在是标题行。
   const whoPart = who ? who + (nickname ? ` · ${nickname}` : '') : nickname
-  const title = whoPart ? `📋 todo (${data.total}) — ${whoPart}` : `📋 todo (${data.total})`
-  lines.push(clipToWidth(fg('accent', title), width))
+  const title = whoPart ? `Todo (${data.total}) — ${whoPart}` : `Todo (${data.total})`
+  // 前导一格空格：对齐输入框内文本（输入框左右竖线内侧各留一格，见 hooks/pi-rounded-editor.ts）。
+  lines.push(clipToWidth(' ' + fg('accent', title), width))
 
   const lastIdx = data.rows.length - 1
-  // 空看板：标题下摆一行事实。只摆事实、不写劝告。
-  if (data.total === 0) {
-    lines.push(clipToWidth(`  ${fg('dim', '（无未完成任务）')}`, width))
-    return lines
-  }
+  // 空看板只显示标题行（2026-11-04 用户要求去掉「（无未完成任务）」那行）。
+  if (data.total === 0) return lines
   data.rows.forEach((t, i) => {
     // `└─` 只给最后一条 —— 不管它有没有子项（否则末条带子项时全篇没有收尾）。
     const isLast = i === lastIdx
@@ -538,7 +540,7 @@ export function renderPanelLines(
     const box = fg('dim', '[ ]')
     const head = `${fg('dim', branch)} ${box} ${fg(colorOf(t.state), `[${t.state}]`)} ${fg('text', t.id)}${anim}`
     const desc = t.desc ? ` ${fg('dim', '—')} ${fg('muted', t.desc)}` : ''
-    lines.push(clipToWidth(head + desc, width))
+    lines.push(clipToWidth(' ' + head + desc, width))
     if (t.kids && t.kids.length) {
       // 子项：标准 md 嵌套列表 → 画成树
       const stem = isLast ? '  ' : fg('dim', '│ ')
@@ -552,7 +554,7 @@ export function renderPanelLines(
     }
   })
 
-  if (data.hidden > 0) lines.push(clipToWidth(fg('dim', `  +${data.hidden} more`), width))
+  if (data.hidden > 0) lines.push(clipToWidth(fg('dim', `   +${data.hidden} more`), width))
   return lines
 }
 

package/hooks/abs.pi.ts

@@ -231,6 +231,10 @@ const TODO_GUIDELINES = [
   // ⑦ 文档精简九条（用户 2026-10-22 定，原文见 skill 的「文档精简」一节）：
   // 管每一行写进 .brain 的文字；与上面六条行为规则不重叠，故不合并。
   'Every line you write into .brain/ (todo rows, log rows, knowledge pages, session snapshots) must pass the nine-bullet doc-slimming rule in the abs skill: only what serves the topic (drop the rest), no unverified summaries, ordered and layered, plain declarative wording (no rhetorical questions, no guessing), no duplication (cite the other doc instead), terse prohibitions, nothing the user did not ask for, plain Chinese.',
+  // ⑧ 有疑惑先查记忆（用户 2026-11-03 定）：主动搜索不是等报错才应激，
+  //   而是「心里形成关键词/有疑问的那一刻」自己查。上面七条只讲了登记，
+  //   没讲「记下来的东西怎么取」——实测一场会话从头到尾没查过一次记忆。
+  'When a doubt forms about something the project has likely dealt with before (a design choice, a past bug, a convention), run `abs recall <关键词>` (or `abs query <词>` for wider matches) BEFORE acting on the assumption. Do not wait for an error or for the user to remind you — asking the memory is your own decision, made the moment the question arises.',
 ]
 
 /** 当前项目是否有 .brain 图谱 —— 有才加指引（没图谱的项目里这指引是噪音）。
@@ -709,10 +713,16 @@ const USER_NICKNAMES = [
 let sessionNickname = ''
 
 /** 抽一条昵称。传 rnd 便于测试注入；默认 Math.random。关掉：ABS_TODO_NICK=0。 */
+/** 昵称池每条存成「emoji + 空格 + 正文」，展示时剥掉 emoji，只留正文（2026-11-04 用户要求）。 */
+export function stripNicknameEmoji(s: string): string {
+  // 循环剥：🏴‍☠️、😮‍💨 这类 ZWJ 组合 emoji 由多段拼成，只剥一次会剩下后半截。
+  return s.replace(/^(?:\p{Extended_Pictographic}[\uFE0F\u200D\u{1F3FB}-\u{1F3FF}]*)+[\s]*/u, '').trim()
+}
+
 export function pickNickname(rnd: () => number = Math.random): string {
   if (String(process.env.ABS_TODO_NICK || '') === '0') return ''
   const i = Math.min(USER_NICKNAMES.length - 1, Math.floor(rnd() * USER_NICKNAMES.length))
-  return USER_NICKNAMES[Math.max(0, i)]
+  return stripNicknameEmoji(USER_NICKNAMES[Math.max(0, i)])
 }
 
 /** 解析 todo.md 的 ## Todo 区 —— 只收未完成行（- [ ]），Done 区不计。
@@ -919,30 +929,19 @@ export function renderPanelLines(
   //   下面仍要画框和标题，所以这里只是不再提前 return。
   const colorOf = (state: string): string => (state === '搁置' ? 'dim' : state === '滞留中' ? 'muted' : state === '讨论中' ? 'dim' : 'accent')
   const lines: string[] = []
-  // 上描边：用 `thinkingOff` —— 跟 Pi 输入框描边**完全同一个色**。
-  // 排查过程（2026-10-03 用户两轮反馈）：
-  //   ① 用 dim = okhsl(229 8% 56%) → 用户说“太亮”（比输入框亮 7%）
-  //   ② 改 border = okhsl(231 57% 65%) → 用户说“怎么是蓝色的”（高饱和度蓝紫）
-  //   ③ 真相：输入框的描边是 theme.getThinkingBorderColor(level)，level=off 时
-  //      就是 thinkingOff = okhsl(229 8% 49%)（纯灰低饱和）。
-  // 教训：看到“跟宿主某个 UI 元素一致”的需求，必须去宿主源码查那个元素
-  // **实际**用了哪个主题色，不能按名字猜（border 听着像框线，其实不是输入框那个）。
-  // 满宽（不 -1）—— 对齐 pi 自己的 DynamicBorder.render：`"─".repeat(Math.max(1, width))`。
-  // 曾写 width-1 怕折行，但 pi 自己就满宽画，用户实报“右侧缺一小块”。
-  // 且我们传入的 fg() 包了一层 ANSI，ANSI 不占列宽，不会因此溢出。
-  lines.push(fg('thinkingOff', '─'.repeat(Math.max(1, width))))
+  // 上描边行已删除（2026-11-04 用户要求「去掉上边框」）。
+  // 历史：那行曾用 `thinkingOff` 对齐 pi 输入框描边色（排查三轮才定色）。
+  // 首行现在是标题行。
+  //
   // 昵称附在作者名后（会话内固定，启动时随机抽）。
   const whoPart = who ? who + (nickname ? ` · ${nickname}` : '') : nickname
-  const title = whoPart ? `📋 todo (${data.total}) — ${whoPart}` : `📋 todo (${data.total})`
-  lines.push(clipToWidth(fg('accent', title), width))
+  const title = whoPart ? `Todo (${data.total}) — ${whoPart}` : `Todo (${data.total})`
+  // 前导一格空格：对齐输入框内文本（输入框左右竖线内侧各留一格，见 hooks/pi-rounded-editor.ts）。
+  lines.push(clipToWidth(' ' + fg('accent', title), width))
 
   const lastIdx = data.rows.length - 1
-  // 空看板：标题下摆一行事实（与 system prompt 里的看板段同口径）。
-  // 只摆事实、不写劝告 —— 「记得登记」那类已被 13 次尝试证明无效（见 OPENING_RULES 注解）。
-  if (data.total === 0) {
-    lines.push(clipToWidth(`  ${fg('dim', '（无未完成任务）')}`, width))
-    return lines
-  }
+  // 空看板只显示标题行（2026-11-04 用户要求去掉「（无未完成任务）」那行）。
+  if (data.total === 0) return lines
   data.rows.forEach((t, i) => {
     // `└─` 只给最后一条 —— 不管它有没有子项。
     // （2026-10-03 审查修正：原条件 `i === lastIdx && !t.note` 会让“末条带子项”时
@@ -956,7 +955,7 @@ export function renderPanelLines(
     const box = fg('dim', '[ ]')
     const head = `${fg('dim', branch)} ${box} ${fg(colorOf(t.state), `[${t.state}]`)} ${fg('text', t.id)}${anim}`
     const desc = t.desc ? ` ${fg('dim', '—')} ${fg('muted', t.desc)}` : ''
-    lines.push(clipToWidth(head + desc, width))
+    lines.push(clipToWidth(' ' + head + desc, width))
     if (t.kids && t.kids.length) {
       // 子项：标准 md 嵌套列表 → 画成树
       //   ├─ [ ] 子项一
@@ -974,7 +973,7 @@ export function renderPanelLines(
     }
   })
 
-  if (data.hidden > 0) lines.push(clipToWidth(fg('dim', `  +${data.hidden} more`), width))
+  if (data.hidden > 0) lines.push(clipToWidth(fg('dim', `   +${data.hidden} more`), width))
   return lines
 }
 /** 隐藏面板。**必须主动 requestRender** —— 否则数据清了、屏幕还留着旧画面。
@@ -998,7 +997,7 @@ async function refreshTodoPanel(ui: any, cwd: string): Promise<void> {
     const md = await readFile(join(cwd, '.brain', 'todo.md'), 'utf8')
     const who = await currentUser()
     const data = parseOpenTasks(md, PANEL_MAX_ROWS, who)
-    // 任务为空**也显示面板**（摆一行「（无未完成任务）」），只有无图谱才隐藏。
+    // 任务为空**也显示面板**（只留标题行），只有无图谱才隐藏。
     // 曾写 data.total === 0 → hidePanel；用户 2026-10-06 要求改掉。
     // factory 形式：render(width) 每帧拿真实宽度 → 按宽度截断，不再断字。
     // 动画：phase 存在模块级，render 时读当前值；定时器只在本帧重绘，不重建 widget。

package/hooks/pi-rounded-editor.ts

@@ -0,0 +1,90 @@
+/**
+ * 圆角四边框输入框 + 右上角状态（pi 扩展）。
+ *
+ * 需求（2026-11-04 用户）：
+ *   ① 输入框左右都有竖线、四角圆角
+ *   ② working 不单独占一行，只在上边框显示运行图标（embedWorkingStatus）
+ *   ③ 上边框最右侧显示「上下文百分比/上限 模型名」，如 `8.0%/1.0M deepseek-v4.1-flash`
+ *   ④ 输入框下方原有 footer 两行全部隐藏
+ *
+ * 为什么要覆写 render()：
+ *   pi 的 Editor.render() 只画上下两条 `─`，每行是「左 padding + 文本 + 右 padding」，
+ *   源码注释明写 `no side borders`。左右竖线逐行拼，没有单独钩子，只能接管整个 render。
+ *
+ * 做法：调 super.render(width - 2) 拿原结果（光标、滚动、自动补全原样保留），
+ *   再给上下边换成圆角、给内容行两端各包一根 `│`。
+ *   不复制 pi 内部逻辑，pi 改光标/滚动时本扩展自动跟住。
+ *
+ * 注意：自动补全菜单行排在底边之下、且自带内容宽度，不套竖线（否则菜单被框住会错位）。
+ */
+import { CustomEditor } from '@earendil-works/pi-coding-agent'
+import { buildStatus, roundBorder, shortenModel } from './pi-rounded-format.ts'
+
+const SIDE = '│'
+
+/** 右上角状态文本，如 `8.0%/1.0M deepseek-v4.1-flash`。render() 拿不到 ctx，故由事件回调维护。 */
+let statusLabel = ''
+
+export class RoundedEditor extends CustomEditor {
+  render(width: number): string[] {
+    if (width < 4) return super.render(width)
+    // 内容窄 2 列，给左右竖线让位。
+    const lines = super.render(width - 2)
+    if (lines.length < 2) return lines
+
+    const borderColor = (this as any).borderColor?.bind(this)
+    const wrap = (s: string) => (borderColor ? borderColor(s) : s)
+    const out: string[] = []
+
+    // 上边框：原本是整行 `─`（含 working 图标与滚动提示），两端换圆角，右端贴状态。
+    out.push(roundBorder(lines[0], wrap, '╭', '╮', statusLabel))
+    // 下边框在原结果的倒数第 (1 + 自动补全行数) 位 —— 补全菜单排在它后面。
+    const autocompleteHeight = (this as any).renderedAutocompleteHeight ?? 0
+    const bottomIdx = lines.length - 1 - autocompleteHeight
+
+    for (let i = 1; i < bottomIdx; i++) {
+      out.push(wrap(SIDE) + lines[i] + wrap(SIDE))
+    }
+    out.push(roundBorder(lines[bottomIdx], wrap, '╰', '╯'))
+    // 自动补全行原样透传（不套竖线）。
+    for (let i = bottomIdx + 1; i < lines.length; i++) out.push(lines[i])
+    return out
+  }
+}
+
+/** 刷新右上角状态文本（每次渲染前由事件与定时器调用）。 */
+function refreshStatus(ctx: any): void {
+  try {
+    statusLabel = buildStatus(ctx?.getContextUsage?.(), ctx?.model?.id ?? '')
+  } catch {
+    statusLabel = shortenModel(ctx?.model?.id ?? '')
+  }
+}
+
+export default function piRoundedEditor(pi: any): void {
+  pi.on('session_start', (_event: unknown, ctx: any) => {
+    if (!ctx?.ui?.setEditorComponent) return
+    refreshStatus(ctx)
+    // 第四个参数 embedWorkingStatus: true —— working 状态进上边框，不再单独占一行。
+    ctx.ui.setEditorComponent(
+      (tui: any, theme: any, keybindings: any) =>
+        new RoundedEditor(tui, theme, keybindings, { embedWorkingStatus: true }),
+    )
+    // ④ 隐藏输入框下方的 footer 两行（路径/git/token、MCP/扩展状态），信息并入右上角。
+    ctx.ui.setFooter?.(() => ({ render: () => [], invalidate() {} }))
+  })
+
+  // 切模型时更新右上角名字（/model、Ctrl+P 都走这个事件）。
+  pi.on('model_changed', (_event: any, ctx: any) => {
+    refreshStatus(ctx)
+    ctx?.ui?.requestRender?.()
+  })
+
+  // 上下文占用随每轮对话变化 —— 轮次结束与消息结束时刷新。
+  for (const ev of ['turn_end', 'message_end', 'tool_execution_end']) {
+    pi.on(ev, (_event: any, ctx: any) => {
+      refreshStatus(ctx)
+      ctx?.ui?.requestRender?.()
+    })
+  }
+}

package/hooks/pi-rounded-format.ts

@@ -0,0 +1,60 @@
+/**
+ * 圆角输入框的纯格式化函数（无宿主依赖，可单测）。
+ *
+ * 单独成文件的原因：hooks/pi-rounded-editor.ts 要 import `@earendil-works/pi-coding-agent`，
+ * 测试进程里没有这个包；把纯函数抽出来才能直接 import 断言。
+ */
+
+/** 把模型 id 压短：只留最后一段，去掉日期后缀。deepseek/deepseek-v4.1-flash → deepseek-v4.1-flash */
+export function shortenModel(id: string): string {
+  if (!id) return ''
+  const tail = id.split('/').pop() || id
+  return tail.replace(/-\d{8}$/, '')
+}
+
+/** 把 token 数压成 1.0M / 280k 这种短写。 */
+export function shortTokens(n: number | null | undefined): string {
+  if (n == null || !Number.isFinite(n)) return '?'
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`
+  if (n >= 1e3) return `${Math.round(n / 1e3)}k`
+  return String(n)
+}
+
+/** 拼右上角状态：`8.0%/1.0M 模型名`。缺哪段就省哪段。 */
+export function buildStatus(usage: any, modelId: string): string {
+  const parts: string[] = []
+  if (usage && usage.percent != null) parts.push(`${usage.percent.toFixed(1)}%`)
+  if (usage && usage.contextWindow) parts.push(`/${shortTokens(usage.contextWindow)}`)
+  const model = shortenModel(modelId)
+  return [parts.join(''), model].filter(Boolean).join(' ')
+}
+
+export function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, '')
+}
+
+/**
+ * 把一行边框文本换成「左圆角 + 中段 + 右圆角」，可见宽度保持原样。
+ * 边框行内含 ANSI 时直接 slice 会切坏转义序列，所以先剥色、改字、再整行着色。
+ *
+ * label 贴在最右端；放不下就丢掉 label（宁可没有，也不让边框溢出折行）。
+ */
+export function roundBorder(
+  line: string,
+  fg: (s: string) => string,
+  left: string,
+  right: string,
+  label = '',
+): string {
+  // 宽度按字符数算（不是显示宽度）。成立的前提：line 只含 ASCII 的 `─` 与空格
+  // —— pi 的边框行正是如此。若将来边框里出现中日韩宽字符，这里要改用 visibleWidth。
+  const plain = stripAnsi(line)
+  if (plain.length === 0) return line
+  // 原边框行宽 = width-2；两端圆角各占 1 列，合起来正好 width。
+  let mid = plain
+  // label 两侧各留 1 空格；放不下就不要 label。
+  if (label && label.length + 2 < mid.length) {
+    mid = mid.slice(0, mid.length - label.length - 2) + ' ' + label + ' '
+  }
+  return fg(left + mid + right)
+}

package/package.json

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

package/skill/abs-agent-brain-sync/SKILL.md

@@ -5,6 +5,23 @@ description: "USE FOR abs / agent-brain-sync 跨会话记忆与任务续接。
 
 # abs — 跨会话记忆 (agent-brain-sync)
 
+## 你有知识库，随时都能查
+
+`.brain/` 是**你自己的跨会话记忆库**：踩过的坑、做过的决定、验证过的做法都在里面。
+
+**查它是你的决定，不是别人提醒你才做。** 干活中一旦心里形成关键词、对某件事有疑问（这个坑以前踩过吗？这个约定是谁定的？），那一刻就主动查，**不要等报错、不要等用户提醒、不要等开工那一秒**。
+
+怎么查：
+
+```bash
+abs recall <关键词>     # 有疑问时用：按亮度出最相关的几页（不给词就从当前处境推）
+ab query <词>           # 想拿更全：多词 OR，枚举全图命中
+db search <词>          # 更高级：种子扩散亮起相关页，先出铁律
+abs resolve <页名>      # 拿到页名后反查路径，只读那一页
+```
+
+查完只读命中那几页，**绝不通读 `.brain/`**。答用 `[[页面名]]` 标来源。
+
 ## 触发器
 
 **关键词不是触发器，意图才是。**句子里出现 todo / 沉淀 / load / note 这些词，若是谈论、提问、定规则，只回应不执行。
@@ -163,6 +180,26 @@ abs todo memo <id>                                                       # 查
 
 经验刚冒出来就 `abs_note` 暂存（幂等去重），宁少勿滥。**跨会话任务只用 abs todo**，别用宿主原生 todo（TodoWrite / `/list`），那些不写 `.brain/todo.md`，下会话接不上。
 
+## 主动提炼（不等人说「收尾」）
+
+提炼是**你的自觉**，不是等用户发指令。两个触发时机，任中一个就主动做：
+
+1. **sources 积压**：`abs load` 顶部出现「♻ 待消化」或 `abs lint` 报 `SOURCES-PILED-UP`（> 10 条）→ 主动收拢。
+2. **一段活收尾**：任务 `done`、或踩坑后刚 `abs_note` 暂存完 → 顺手看这条值不值得提炼成规律。
+
+动作只有一步判断 + 一个落点：
+
+```bash
+abs review                        # 列出待确认的 draft 页（concepts + sources）
+# 值得留 → 用自己的判断提炼成一句话，落到正确层：
+abs capture --layer 3 "某工具怎么用/有什么坑"     # 工具经验
+abs capture "踩坑的根因与解法"                    # 认知（默认 L4）
+# 不值得留 → 否决掉：
+abs review --reject <页名>
+```
+
+**判断力在你（agent），工具只做落点**——`capture` 不替你判「这条值不值得留、归哪一层」。提炼成规律后删原 source、清指向它的引用（防死链，见 Teardown 第 5 步）。
+
 ## 收尾循环（用户明确要求收尾时才走）
 
 1. **读 todo**：`abs load`，看还有哪些没完成。

package/src/brain/db-cmd.js

@@ -54,7 +54,21 @@ export function uniqueProjectNames(roots) {
         for (const [r, v] of cand) out.set(r, v);
         break;
       }
-      if (depth === 4) for (const [r, v] of cand) out.set(r, v);  // 兜底：认了
+      if (depth === 4) {
+        // 深度到 4 仍重名（如 ~/a/x/软件/.agents 与 ~/b/y/软件/.agents 共享 4 层尾路径）：
+        // 不能「认了」直接塞 —— 那会让两个项目拿到同一个项目名，rebuild 撞
+        // UNIQUE(project,dir,slug) 约束整体崩溃（正是本函数要避免的场景）。
+        // 给仍碰撞的条目追加序号（-2/-3…），保证互不重名且可读。
+        const byVal = new Map();
+        for (const [r, v] of cand) {
+          if (!byVal.has(v)) { byVal.set(v, []); }
+          byVal.get(v).push(r);
+        }
+        for (const [v, rs] of byVal) {
+          if (rs.length === 1) { out.set(rs[0], v); continue; }
+          rs.forEach((r, i) => out.set(r, `${v}-${i + 2}`));
+        }
+      }
     }
   }
   return out;

package/src/brain/load.js

@@ -322,6 +322,107 @@ async function queryHintSection(root, todo) {
   return queryHint(root, todo);
 }
 
+/**
+ * recall：卡住时主动取「跟当前处境相关的几页」，不需要先想到检索词。
+ *
+ * 为何要它（2026-11-03 实测）：hotPages 只挂在 load 上，于是只有开工那一刻会送页。
+ *   实测一场完整会话从头到尾没调过一次 abs —— 不是检索不准（命中确实准），
+ *   而是「要人先想到发起查询」这一步天然被跳过。一个出口只开一次，就等于没开。
+ *
+ * 与 hotPages 的分工：hotPages 是开机首屏（自动、固定 3 页）；
+ *   recall 是随时可调（agent 卡住/换方向时自己跑），且能补词。
+ *   两者共用 contextKeywords + 亮度搜索，不各算一套。
+ *
+ * 词从哪来：
+ *   - 传了词 → 用它（这时它就是个带上下文的搜索，仍会补处境词）
+ *   - 没传词 → 纯靠处境（活跃 todo 的关键词 + 最近改过的文件）
+ * 全部凭空无词 → 说清楚缺什么，不返回空列表充数。
+ *
+ * @param {{dir?:string, terms?:string[], limit?:number}} opts
+ */
+export async function cmdRecall({ dir, terms, limit = 5 } = {}) {
+  const given = (terms || []).flatMap((t) => String(t).trim().split(/\s+/)).filter(Boolean);
+  let root;
+  try {
+    root = await requireBrain(dir || process.cwd());
+  } catch {
+    return '未找到 .brain/ 图谱（无记忆可查）。先在项目根运行: abs init';
+  }
+  const todo = await readTodo(root).catch(() => '');
+  let kws = [];
+  let files = [];
+  try {
+    ({ kws, files } = await contextKeywords(root, todo));
+  } catch {
+    // 拔词失败不该拦住整个 recall
+  }
+  // 手动传的词优先级最高：用户/agent 已经想清楚要什么，就别把处境词混进去稀释
+  const words = given.length ? given : kws.slice(0, 5);
+  if (!words.length) {
+    return 'recall: 无从判断当前处境（todo 空、近期无改动、也没给词）。\n'
+      + '→ 直接给词: abs recall <词1> <词2>；或先 abs todo add 把在干的事登记上。';
+  }
+  try {
+    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 'recall: 图数据库还没建（亮度检索需要它）。先跑: abs db rebuild';
+
+    const project = String(root).split('/').filter(Boolean).pop() || '';
+    const h = openDb(dbPath());
+    let lit;
+    try {
+      const seeds = new Map();
+      // 整串先查（实测：`db search "并发 锁"` 能出 file-write-locking，
+      // 而逐词分开查的种子表里根本没它 —— 2-gram 索引对整串和单词的切法不同，
+      // 拆开就把最有用的命中拆没了。所以整串优先，再用逐词兜底补漏。
+      const whole = given.length ? words.join(' ') : words.join(' ');
+      for (const s of search(h, whole, { limit: 12 })) seeds.set(s.id, s);
+      for (const w of words) {
+        for (const s of search(h, w, { limit: 6 })) {
+          const prev = seeds.get(s.id);
+          if (!prev || s.bright > prev.bright) seeds.set(s.id, s);
+        }
+      }
+      if (!seeds.size) {
+        return `recall [${words.join(', ')}]: 库里没搜到相关页。\n`
+          + '→ 换个说法: abs recall <别的词>；看图谱全貌: abs query <词>。';
+      }
+      // 流水页降权（2026-11-03 实测）：不加时前 5 位里挤进 2 页 sessions/log-*，
+      // 还被排到第一，把 file-write-locking 这种真经验页顶下去。
+      // 与 query 用同一套判据（lint.js 的 isTerminal），不另造。只降权不剔除。
+      const isFlow = (r) => r.dir === 'sources' || (r.dir === 'sessions' && /^log-/.test(r.slug));
+      lit = illuminate(h, [...seeds.values()], { limit: limit * 8 })
+        .filter((r) => r.project === project)
+        .sort((a, b) => (b.bright - (isFlow(b) ? 1 : 0)) - (a.bright - (isFlow(a) ? 1 : 0)))
+        .slice(0, limit);
+    } finally {
+      h.close();
+    }
+    if (!lit.length) {
+      return `recall [${words.join(', ')}]: 搜到了种子，但本项目的页没有亮起来。\n`
+        + '→ 试试 abs query <词> 看全图命中。';
+    }
+    const rows = [`recall [${words.join(', ')}] → ${lit.length} 页（按亮度；看全文: abs resolve <页名>）`];
+    if (!given.length) {
+      const why = [
+        files.length ? `近期改动 ${files.length} 个文件` : '',
+        todo ? '活跃 todo' : '',
+      ].filter(Boolean).join(' + ');
+      if (why) rows.push(`  处境: ${why}`);
+    }
+    rows.push('');
+    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) : '';
+      rows.push(`  ${r.bright.toFixed(2)} L${r.layer} [[${r.slug}]]${about ? ' — ' + about : ''}`);
+    }
+    return rows.join('\n');
+  } catch (e) {
+    return `recall 失败: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
 /** sources 堆积提醒：返回 [标题行, ...内容行] 或 null。失败静默。 */
 async function sourcesCountSection(root) {
   const nsrc = await countSources(root);

package/src/brain/maintain.js

@@ -57,38 +57,45 @@ export async function cmdTodoArchive({ dir, keepDays = 3, dryRun = false } = {})
     return `[dry-run] 将归档 ${plan.archived.length} 天 / ${plan.count} 条（每天一个文件）\n  ${brief}${why}`;
   }
 
-  // 1) 归档目标 = 当天的会话快照文件（log-<日期>.md），写进其「任务归档」段。
+  // 1) todo.md：锁内重算（拿最新内容，避免与并发 done 互相覆盖），
+  //    todo 是权威 —— 会话页/ index 都跟随它，不反向。
+  //    先写 todo 再写会话页：todo 写失败（闸门拒绝/SKIP）时会话页不写，
+  //    避免「会话页已写、看板没动」的两边不一致（原顺序相反，且会话页裸写绕过锁）。
+  let archivedFinal = [];
+  await editFile(todoP, (cur) => {
+    // 坑（2026-10-05 实测抓到）: 这里漏传 maxLines → 锁内重算的 archived 为空 →
+    // 返回 SKIP → 磁盘上的 todo.md 一个字没动（而 sessions/ 归档页已经写了，
+    // 两边不一致）。**同参数的每个调用点都要一起改**。
+    const p2 = archiveDoneInText(cur ?? '', { keepDays: days, from: today(), maxLines: TODO_MAX_LINES });
+    if (!p2.archived.length) return SKIP;
+    archivedFinal = p2.archived;   // 锁内算出的权威清单，后续写会话页/index 用它
+    return { text: p2.text };
+  });
+  if (!archivedFinal.length) {
+    return `（todo 锁内重算无归档项，已跳过）${why}`;
+  }
+
+  // 2) 归档目标 = 当天的会话快照文件（log-<日期>.md），写进其「任务归档」段。
   //    为何合一（2026-09-15 用户定）: 归档与会话快照是**同一天的记录**，分两个文件查着要开两处。
   //    边界: ① 文件不存在→建只有归档段的页（那天可能没写快照）
   //          ② 文件已存在（含 AI 手写快照）→ 只替换归档段，段外逐字保留
   //    （硬规则「已存在的人工内容一律不覆盖」由 upsertArchiveSection 保证）。
+  //    走 editFile 锁（2026-11-03 审查修复）：append 语义必须与 setMemo 同一路数，
+  //    裸 readFile+tmp+rename 会让并发 archive 互相覆盖，丢一批归档任务行。
   const sessDir = brainPath(root, 'sessions');
-  for (const g of plan.archived) {
+  await fs.mkdir(sessDir, { recursive: true });
+  for (const g of archivedFinal) {
     const pageP = join(sessDir, `${g.slug}.md`);
-    let page = null;
-    try { page = await fs.readFile(pageP, 'utf8'); } catch { /* 首次 */ }
-    const nextPage = upsertArchiveSection(page, g);
-    const tmp = join(sessDir, `.${g.slug}.tmp-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`);
-    await fs.writeFile(tmp, nextPage, 'utf8');
-    await fs.rename(tmp, pageP);
+    await editFile(pageP, (cur) => ({ text: upsertArchiveSection(cur, g) }));
   }
 
-  // 2) todo.md：锁内重算（拿最新内容，避免与并发 done 互相覆盖）
-  await editFile(todoP, (cur) => {
-    // 坑（2026-10-05 实测抓到）: 这里漏传 maxLines → 锁内重算的 archived 为空 →
-    // 返回 SKIP → 磁盘上的 todo.md 一个字没动（而 sessions/ 归档页已经写了，
-    // 两边不一致："说归档了但看板没变"）。**同参数的每个调用点都要一起改**。
-    const p2 = archiveDoneInText(cur ?? '', { keepDays: days, from: today(), maxLines: TODO_MAX_LINES });
-    return p2.archived.length ? { text: p2.text } : SKIP;
-  });
-
   // 3) index 登记（每个日期页一行，幂等）
   // 坑（2026-09-15 修）: 原先把归档页登记到 `## Sources` 区 —— 但它们在 sessions/ 里，
   // 旧数据实测就是错位的（09-10/09-12 两条曾键在 Sources 段，人工才发现）。现改登 `## Sessions`。
   const iP = brainPath(root, 'index.md');
   await editFile(iP, (index) => {
     if (!index) return SKIP;
-    const missing = plan.archived.filter((g) => !index.includes(`[[${g.slug}]]`));
+    const missing = archivedFinal.filter((g) => !index.includes(`[[${g.slug}]]`));
     if (!missing.length) return SKIP;
     const sIdx = index.indexOf('## Sessions');
     if (sIdx === -1) return SKIP;
@@ -100,8 +107,10 @@ export async function cmdTodoArchive({ dir, keepDays = 3, dryRun = false } = {})
     return { text: next };
   });
 
-  const files = plan.archived.map((g) => `sessions/${g.slug}.md`).join('\n  ');
-  return `✓ 已归档 ${plan.archived.length} 天 / ${plan.count} 条\n  ${brief}\n  → ${files}${why}`;
+  const files = archivedFinal.map((g) => `sessions/${g.slug}.md`).join('\n  ');
+  const count = archivedFinal.reduce((n, g) => n + g.count, 0);
+  const briefFinal = archivedFinal.map((g) => `${g.date}(${g.count})`).join(' ');
+  return `✓ 已归档 ${archivedFinal.length} 天 / ${count} 条\n  ${briefFinal}\n  → ${files}${why}`;
 }
 
 /**

package/src/install.js

@@ -818,6 +818,15 @@ async function installPi({ withMcp, withSkill }) {
   const p = join(dir, 'abs.ts');
   await atomicWrite(p, piPluginSource()); // Pi 用专用模板, 语法与 OpenCode 不同构
   steps.push(`✓ hook(ts extension) → ${p}`);
+  // 圆角四边框输入框（纯 UI，与记忆功能无关，pi 专属）。
+  // 为什么要独立成第二个扩展文件：它是可选样式，用户不想要时删掉这一个文件即可，
+  // 不必动 abs.ts 这个核心 hook。模板无占位符，直接拷。
+  // 两个文件必须一起装：editor 里 import 了 format 的纯函数（抽出来是为了能单测）。
+  const roundedFiles = ['pi-rounded-editor.ts', 'pi-rounded-format.ts'];
+  for (const f of roundedFiles) {
+    await atomicWrite(join(dir, f), renderPluginTemplate(f, {}));
+  }
+  steps.push(`✓ editor(rounded box) → ${join(dir, 'pi-rounded-editor.ts')}`);
   // MCP → ~/.pi/agent/mcp-adapter.json 的 mcpServers (stdio)
   // 坑（2026-09-30 用户实报）：曾写 mcp.json，但 pi-mcp-adapter 已不再读它
   //   （pi 自有 mcp.json 被 adapter 忽略，adapter 改读 mcp-adapter.json）→ 写了等于没写。
@@ -839,6 +848,9 @@ async function installPi({ withMcp, withSkill }) {
 async function uninstallPi() {
   const steps = [];
   await fs.rm(join(hostConfigRoot('pi'), 'agent', 'extensions', 'abs.ts'), { force: true });
+  for (const f of ['pi-rounded-editor.ts', 'pi-rounded-format.ts']) {
+    await fs.rm(join(hostConfigRoot('pi'), 'agent', 'extensions', f), { force: true });
+  }
   steps.push(`✓ extension 已删除`);
   steps.push(...await uninstallSkills('pi'));
   const mcpP = join(hostConfigRoot('pi'), 'agent', 'mcp-adapter.json');

package/src/query.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { requireBrain, brainPath } from './index.js';
 import { rankPage } from './relevant.js';
 import { statusOfPage, idOfPage, supersededByOf, clip } from './store.js';
+import { DIR_LAYER, decayOf } from './brain/layers.js';
 
 // ---------- query: 检索知识图谱（多词 OR，扫全 .md 页） ----------
 const KNOWN_SLUG_HINT = /模板残留|\[\[slug\]\]/;
@@ -49,11 +50,27 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
         // 而不是回答"我上次怎么解決 X"（那会拿到一个已知错误的答案）。
         // 但它不是静默消失：计数里告知还有几条被隐藏（带 --all 能看）。
         if (st === 'superseded' && !includeSuperseded) {
-          hits.push({ hidden: true, slug });
+          hits.push({ hidden: 'superseded', slug });
+          continue;
+        }
+        // 流水页默认不进结果（2026-11-03 修）：sessions/log-* 是「那天做了什么」
+        // 的草稿记录，不是知识页。它正文里碰巧出现检索词不代表它是这条经验所在 ——
+        // 与 db search 对齐（db 里层权重把 L5 会话页压到底，query 扫 md 没有这层，
+        // 只能显式隐藏）。不是静默消失：计数告知 + --all 可看。
+        const isFlow = d === 'sessions' && /^log-/.test(slug);
+        if (isFlow && !includeSuperseded) {
+          hits.push({ hidden: 'flow', slug });
+          continue;
+        }
+        // draft（未核实）默认也隐藏（2026-11-03 修）：主动 recall 要的是「可信的
+        // 知识」，draft 是没核实的草稿，与 db search 对齐（db 里 L7 草稿被层权重
+        // 压到底、L4 draft 骨架亮度低）。与 superseded/flow 同待遇：--all 可看。
+        if (st === 'draft' && !includeSuperseded) {
+          hits.push({ hidden: 'draft', slug });
           continue;
         }
         hits.push({
-          full, slug, matched: rank.matched, kind: rank.kind, fuzzyScore: rank.score, via: rank.via,
+          full, slug, dir: d, matched: rank.matched, kind: rank.kind, fuzzyScore: rank.score, via: rank.via,
           author: au ? au[1].trim() : '',
           id: idOfPage(body, slug),
           status: st,
@@ -63,22 +80,34 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
       }
     }
   }
-  const hidden = hits.filter((h) => h.hidden).length;
+  const hiddenSup = hits.filter((h) => h.hidden === 'superseded').length;
+  const hiddenFlow = hits.filter((h) => h.hidden === 'flow').length;
+  const hiddenDraft = hits.filter((h) => h.hidden === 'draft').length;
+  const hidden = hiddenSup + hiddenFlow + hiddenDraft;
   // 分两区：精确命中优先，模糊只作补充。
   // 坑(2026-09-16 实测): 不加区分时查 file-write-locking 返回 26 页（几乎全图）——
   //   连字符词的 2-gram 太通用，模糊命中把无关页也拉进来。
   //   规则：只要有任何精确命中，模糊命中的就不排在前面（但也不丢弃，单列一段）。
+  // 层权重（2026-11-03 修）：query 之前只按分数排，流水页（sessions/log-*）和
+  // 草稿（sources/）与内容页同分竞争，于是 log 页挤进前 10。db search 干净的本质
+  // 是它按层权重排序 —— sessions=L5(decay 0.75)、sources=L7(decay 0.95)，亮度被
+  // 压到 0.25/0.05，而 concepts/entities/syntheses=L4(decay 0.6) 权重 0.4。
+  // 这里复用同一套 DIR_LAYER + decayOf，与 db search 对齐，不再用笼统的「降 20 分」
+  // （那个修法在命中分数接近时失效，实测「长期记忆 提炼 主动回忆」前 10 仍混 3 个 log 页）。
+  // 权重 = 1 - decay（与 db.js 的 layerWeight 同口径）。
+  const layerWeight = (h) => Math.max(0.05, 1 - decayOf(DIR_LAYER[h.dir] ?? 4));
+  const rankBy = (h) => h.fuzzyScore * layerWeight(h);
   const exactHits = hits.filter((h) => !h.hidden && h.kind === 'exact')
-    .map((h) => ({ ...h, score: h.fuzzyScore }))
+    .map((h) => ({ ...h, score: rankBy(h) }))
     .sort((a, b) => b.score - a.score);
   const fuzzyHits = hits.filter((h) => !h.hidden && h.kind === 'fuzzy')
-    .map((h) => ({ ...h, score: h.fuzzyScore }))
+    .map((h) => ({ ...h, score: rankBy(h) }))
     .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 查看）` : '';
+    const extra = hidden ? `（另外 ${hidden} 页被隐藏，用 abs query ${words.join(' ')} --all 查看）` : '';
     return `query [${words.join(', ')}]: 无命中。${extra}用 abs lint 看图谱健康；首次使用先 abs init。`;
   }
   // 输出条数上限（2026-09-30 补）：落实 read-side-output-must-not-scale 规则。
@@ -107,7 +136,9 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
   const tail = [];
   if (words.length > 1 && !anyFull) tail.push('', `（无页同时命中全部 ${words.length} 个词，以下按命中数排序）`);
   if (fuzzySuppressed) tail.push('', `（另有 ${fuzzyHits.length} 页字形相近但字面未命中，已隐藏 —— 它们通常不相关）`);
-  if (hidden) tail.push(``, `（${hidden} 页 superseded 已隐藏；--all 可看）`);
+  if (hiddenSup) tail.push(``, `（${hiddenSup} 页 superseded 已隐藏；--all 可看）`);
+  if (hiddenFlow) tail.push(``, `（${hiddenFlow} 页流水已隐藏；--all 可看）`);
+  if (hiddenDraft) tail.push(``, `（${hiddenDraft} 页 draft 未核实已隐藏；--all 可看）`);
   if (overflow > 0) tail.push(``, `（另有 ${overflow} 页未展示 —— 用更具体的词收窄：abs query <词1> <词2>）`);
   return [`query [${words.join(', ')}] → ${shown.length} 页（展示前 ${displayed.length} 页）:`, '', ...lines, ...tail].join('\n');
 }

package/src/store.js

@@ -19,7 +19,7 @@ export { BRAIN_SHAPE, LEGACY_MARKS, checkBrainShape } from './brain/shape.js';
 import './brain/gate.js';
 
 // ---- 只读呈现 ----
-export { cmdBoard, cmdStatus, cmdLoad, cmdShow, extractBlocks } from './brain/load.js';
+export { cmdBoard, cmdStatus, cmdLoad, cmdShow, cmdRecall, extractBlocks } from './brain/load.js';
 
 // ---- Rules ----
 export { RULES_HEADING, RULES_MAX, RULE_BODY_MAX, readRules, cmdRule } from './brain/rules.js';