@fanchao8609/agent_brain_sync 1.23.0 → 1.24.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.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 图谱 —— 有才加指引（没图谱的项目里这指引是噪音）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanchao8609/agent_brain_sync",
-  "version": "1.23.0",
+  "version": "1.24.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 这些词，若是谈论、提问、定规则，只回应不执行。

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/query.js

@@ -53,7 +53,7 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
           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,
@@ -68,11 +68,18 @@ export async function cmdQuery({ dir, terms, includeSuperseded }) {
   // 坑(2026-09-16 实测): 不加区分时查 file-write-locking 返回 26 页（几乎全图）——
   //   连字符词的 2-gram 太通用，模糊命中把无关页也拉进来。
   //   规则：只要有任何精确命中，模糊命中的就不排在前面（但也不丢弃，单列一段）。
+  // 流水页降权（2026-11-02 实测）：查「并发 写 锁」时前 10 位里挤进 4 页
+  // sessions/log-*，内容页被顶下去。流水页只是「那天做了什么」的草稿记录，
+  // 正文里碰巧出现检索词不代表它是这条经验所在。判据沿用 lint.js 的
+  // isTerminal（sources/ 与 sessions/log-*），不另造一套。
+  // 只降权不剔除：真要查某天的流水，它仍在结果里，只是排到内容页之后。
+  const isFlow = (h) => h.dir === 'sources' || (h.dir === 'sessions' && /^log-/.test(h.slug));
+  const rankBy = (h) => h.fuzzyScore - (isFlow(h) ? 20 : 0);
   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;

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';