@fanchao8609/agent_brain_sync 1.28.6 → 1.29.0

package/src/brain/load.js

@@ -17,9 +17,18 @@ import { digestFilled } from './layers.js';
  *  为何要限：会话页数量只增不减，全列会让 load 首屏随规模膨胀
  *  —— 违反本仓「读取侧输出不得随规模增长」。5 个够 agent 判断先填哪张。 */
 const SESSION_UNFILLED_SHOW = 5;
+/** 开机屏的使用方法（2026-11-08 用户定 load 三件套之一）。一行一个动作，别写成手册。 */
+const LOAD_USAGE = [
+  '--- 用法 ---',
+  '接经验   abs search <词> / abs recall     记一句   abs note "…"',
+  '立概念   abs concept <id> --title "…"      登记活   abs todo start <id> --note "做什么"',
+  '收尾     abs todo done <id> --as 落地|否决|仅方案 "结论"',
+  '体检     abs lint        看全量     abs show index|log|status',
+  '纪律: 绝不通读 .brain/；检索词一冒出来就查，别等报错。',
+].join('\n');
 import { checkBrainShape } from './shape.js';
-import { rulesSection } from './rules.js';
-import { collapseIndex } from '../page.js';
+import { readRules } from './rules.js';
+
 
 // ---------- board: 看板 ----------
 export async function cmdBoard({ dir, full }) {
@@ -95,19 +104,27 @@ export async function cmdLoad({ dir }) {
       ''
     );
   }
+  // 2026-11-08 用户定：load 只留三样 —— 未完成 todo、使用方法、最近日志。
+  // Rules 全文 / 图谱计数 / Done 折叠明细 / 查询提示 / 热点页 撤出开机屏；
+  // 逃生口还在：abs rule / abs show index / abs todo --full / abs lint。
+  const board = collapseDone(todo);
+  const todoHead = String(board.text || '').split(/\n## Done/)[0].trim();
+  const { items: ruleItems } = readRules(index);
+  const blocks = extractBlocks(todo);
   sections.push(
-    // Rules 单独成段且放在最前（仅次于项目行/滞留）：它是硬规则，不是普通清单。
-    // 坑: 曾在 index 段内与页面清单平铺 —— AI 会当普通清单划过，而它每条都是付过代价的。
-    ...(rulesSection(index) ? [rulesSection(index), ''] : []),
-    collapseIndex(index) || '(index.md 为空)',
+    `📖 Rules ${ruleItems.length} 条（违反会丢数据/静默失效；全文: abs rule）`,
     '',
-    // 两区制：Todo（未完成，行首带状态标记）+ Done。
-    '--- Todo Board (todo.md) ---',
-    collapseDone(todo).text || '(todo.md 为空)',
-    '\n（Done 已按日期折叠计数；明细: abs todo --full）',
+    '--- 未完成 (todo.md) ---',
+    todoHead || '(无未完成任务)',
+    ...(blocks.length
+      ? [`  ⛔ 卡点 ${blocks.length} 条: ${blocks.map((b) => `${b.id}(${b.why})`).join('; ')}`]
+      : []),
+    `  Done ${board.doneCount} 条已折叠（明细: abs todo --full）`,
     '',
-    '--- 最近动作 (log.md, 最新 5 条) ---',
-    recentLogLines(log, 5) || '(log.md 为空)',
+    '--- 最近动作 (log.md, 最新 3 条) ---',
+    recentLogLines(log, 3, 140) || '(log.md 为空)',
+    '',
+    LOAD_USAGE,
   );
   if (stranded.length) {
     const rows = stranded.map((t) => {
@@ -123,55 +140,21 @@ export async function cmdLoad({ dir }) {
       ''
     );
   }
-  // 卡点提取（2026-09-16，定位 = 看板可见性）：
-  // 从 todo 里抽出带 `阻塞:` / `等待:` 的断点行，集中展示。
-  // 为何需要：断点行在任务下方，一屏扫过去看不出"哪些事在等人/等外部"。
-  // 只提取不求全 —— 只有明确写了前缀的才被抽出，没写的不猜。
-  const blocks = extractBlocks(todo);
-  if (blocks.length) {
-    const at = sections.findIndex((s) => String(s).startsWith('--- Rules'));
-    sections.splice(at === -1 ? 1 : at, 0,
-      `⛔ 卡点 ${blocks.length} 条（在等外部条件）`,
-      ...blocks.map((b) => `  - ${b.id}: ${b.why}`),
-      '');
-  }
-  // 相关页提示（2026-09-16）：实测 abs_query 几乎不被调用（MCP 日志 task 234 / note 54 / load 53 vs query 2）。
-  // 根因：load 只列目录 → 模型觉得"我记过了" → 真需要时靠印象。模型不知道自己不知道什么。
-  // 解法（用户定）：不替它查 —— 而是【把该查的词直接给出来】，降低发起查询的成本。
-  //   自动带出正文是错的方向：那会让 query 更没人用，且无法按需求变化调整词。
-  // 失败静默：这只是 additive 提示，出任何错都不应弄坏 load。
-  try {
-    const rel = await 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 { /* 同上，失败静默 */ }
-  // 未填会话页提醒（2026-11-05）：ingest/hook 落的是空骨架，内容要人填。
-  // 若不在开工时摆出来，「落了没填」就永远没人知道 —— 等于采集了不消化。
-  // 与 sources 提醒同一个位置、同一种语气：只给线索，判断仍归 agent。
+
+  // 未填会话页 / sources 堆积：只给一行计数，不列页名（细节走 abs ingest --list / abs lint）。
+  // 当年列页名是为送达；现在按总量预算收口，一线足够让人决定要不要深查。
   try {
-    const sessWarn = await unfilledSessionSection(root);
-    if (sessWarn) {
-      const at = sections.findIndex((s) => String(s).startsWith('--- Rules'));
-      sections.splice(at === -1 ? 1 : at, 0, ...sessWarn);
-    }
+    const sessWarn = await unfilledSessionSection(root, { oneLine: true });
+    if (sessWarn) sections.push('', sessWarn);
   } catch { /* 提醒失败不影响 load */ }
-  // sources 堆积提醒：与「滞留」同构 —— 放在每次开工必经的顶部，而不是等人跑 lint。
-  // 只数目录条目（不读文件），零成本。提炼仍手工：这里只负责送达，不替判断。
   try {
-    const srcWarn = await sourcesCountSection(root);
-    if (srcWarn) {
-      const at = sections.findIndex((s) => String(s).startsWith('--- Rules'));
-      sections.splice(at === -1 ? 1 : at, 0, ...srcWarn);
-    }
+    const srcWarn = await sourcesCountSection(root, { oneLine: true });
+    if (srcWarn) sections.push('', srcWarn);
   } catch { /* 提醒失败不影响 load */ }
   return sections.join('\n');
 }
 
+
 /**
  * 从 todo 正文抽出"卡点"行，供 load 集中展示。
  *
@@ -306,7 +289,7 @@ export async function hotPagesSection(root, todoText, { limit = 3 } = {}) {
  * @param {string} todoText
  * @param {{name:string,body:string}[]} [pages] 已读好的页（省一次磁盘扫描）
  */
-async function queryHint(root, todoText, pages) {
+export async function queryHint(root, todoText, pages) {
   const { kws, files } = await contextKeywords(root, todoText);
   if (!kws.length) return '';
   const all = pages || await listPages(brainPath(root)).catch(() => []);
@@ -335,10 +318,7 @@ async function countSources(root) {
   } catch { return 0; }
 }
 
-/** queryHint 的 load 端封装：返回提示文本（含标题行），无强词则空串。失败静默。 */
-async function queryHintSection(root, todo) {
-  return queryHint(root, todo);
-}
+
 
 /**
  * recall：卡住时主动取「跟当前处境相关的几页」，不需要先想到检索词。
@@ -447,7 +427,7 @@ export async function cmdRecall({ dir, terms, limit = 5 } = {}) {
  *   内容要读会话后填。但「落了没填」原来没有任何地方看得见 —— 落盘等于进了黑洞，
  *   正是本仓反复踩的「采集了不消化」。这里只判「填没填」，不判「该不该留」。
  *
- * 判据与 lint 的 hasTail 同源：段内除了占位注释与空行之外还有没有真内容。
+ * 判据是「骨架段里填过没有」，段标题层级不写死 —— 摘要并进当天页后骨架段是 `###`。
  * 只认 ingest 生成的三种骨架段名（见 ingest.js 的 SHAPES）——它们都带
  * `<!-- 提示 -->` 占位；任何一段有了真内容就算填过。
  *
@@ -457,24 +437,28 @@ export async function cmdRecall({ dir, terms, limit = 5 } = {}) {
  *
  * 守「读取侧输出不随规模增长」：只列表头最多 SESSION_UNFILLED_SHOW 个页名，
  * 其余折叠成条数。页名够用 —— agent 要读哪张再 abs resolve 那一张，别在这贴正文。 */
-async function unfilledSessionSection(root) {
+async function unfilledSessionSection(root, { oneLine = false } = {}) {
   let files;
   try {
     files = await fs.readdir(brainPath(root, 'sessions'));
   } catch { return null; }
   const unfilled = [];
   for (const f of files) {
-    if (!f.endsWith('.md') || !f.startsWith('session-')) continue;
+    if (!f.endsWith('.md') || f.startsWith('_')) continue;
     const body = await fs.readFile(brainPath(root, 'sessions', f), 'utf8').catch(() => '');
     if (!body) continue;
-    // 只认 ingest 落的页：它有 kind: session-digest。手写页不该被催。
+    // 只认 ingest 落的页：它有 `kind: session-digest`。手写页不该被催。
+    // 不再按文件名前缀筛（2026-11-08）：会话摘要已并进当天的 `log-<日期>.md`，
+    // 文件名里没有会话 id，前缀判据会把它整类漏掉。
     if (!/^kind:\s*session-digest$/m.test(body)) continue;
     if (!digestFilled(body)) unfilled.push(f.replace(/\.md$/, ''));
   }
   if (!unfilled.length) return null;
+  // 2026-11-08 load 三件套收口：只回一行计数，不列页名（列名那套留给 --list / 以后要用再传 oneLine:false）。
+  if (oneLine) return `📝 未填会话页 ${unfilled.length} 张（abs ingest --list 看哪几张；不进检索，不急着全填）`;
   // 按日期倒序（2026-11-05 实测修正）：原来按 readdir 顺序（≈文件名升序），
   // 60 张时列出来的是 18/27/36/45/54 —— 随机五张，既不是最近的也不是最该填的。
-  // 页名形如 session-<日期>-s<id8>，日期就在里面，直接按名字倒排即可。
+  // 页名现在是 `log-<日期>`，日期就在里面，直接按名字倒排即可。
   unfilled.sort((a, b) => b.localeCompare(a));
   const show = unfilled.slice(0, SESSION_UNFILLED_SHOW);
   const rows = [
@@ -494,9 +478,10 @@ async function unfilledSessionSection(root) {
 }
 
 /** sources 堆积提醒：返回 [标题行, ...内容行] 或 null。失败静默。 */
-async function sourcesCountSection(root) {
+async function sourcesCountSection(root, { oneLine = false } = {}) {
   const nsrc = await countSources(root);
   if (nsrc <= SOURCES_MAX) return null;
+  if (oneLine) return `♻ 待消化: sources/ 有 ${nsrc} 条 > ${SOURCES_MAX}（abs lint 看明细）`;
   return [
     `♻ 待消化: sources/ 有 ${nsrc} 条 > ${SOURCES_MAX}（采集了没提炼）`,
     '→ abs lint 看明细；提炼成 concepts/ 后删 source 并清引用',

package/src/brain/maintain.js

@@ -5,7 +5,7 @@ import { join, dirname } from 'node:path';
 import { brainPath, requireBrain, absLogDir } from '../index.js';
 import { editFile, SKIP } from '../lock.js';
 import { appendWrapup } from '../wrapup.js';
-import { readIfExists } from '../text.js';
+import { clip, readIfExists } from '../text.js';
 import { getUser } from '../userconfig.js';
 import { today, localStamp, archiveDoneInText, upsertArchiveSection, TODO_MAX_LINES } from '../todo.js';
 export async function cmdWrapup({ dir }) {
@@ -100,7 +100,20 @@ export async function cmdTodoArchive({ dir, keepDays = 3, dryRun = false } = {})
     const sIdx = index.indexOf('## Sessions');
     if (sIdx === -1) return SKIP;
     const after = index.indexOf('\n## ', sIdx + 1);
-    const add = missing.map((g) => `- [[${g.slug}]] — ${g.date}（会话快照 + 任务归档）`).join('\n');
+    // index 行要能回头查（2026-11-08 用户要求）：光写「日期（会话快照 + 任务归档）」
+    // 查不到那天干了什么。描述 = archiveBrief 的任务首段（截 110 字）；
+    // 老数据/无描述时退回原样 —— 不造假描述。
+    // 行是覆盖式登记（registerInIndex 同族），这里只在**首次登记**写，之后不追改。
+    const add = missing.map((g) => {
+      const b = String(g.brief || '').trim();
+      // 无首段时用任务 id 充当描述（是真的，不是编的）—— 光写日期模板会被 INDEX-ENTRY 打回。
+      const ids = (g.lines || []).filter((l) => /^- \[x\]/.test(l))
+        .map((l) => (String(l).match(/\s(\S+)[^\n]*$/) || [])[1])
+        .filter(Boolean).slice(0, 3);
+      const fallback = `完成任务 ${g.count} 条${ids.length ? '：' + ids.join('、') : ''}`;
+      const desc = `${g.date}（会话快照 + 任务归档）：${b ? clip(b, 110) : fallback}`;
+      return `- [[${g.slug}]] — ${desc}`;
+    }).join('\n');
     const next = after === -1
       ? `${index.replace(/\s*$/, '')}\n${add}\n`
       : index.slice(0, after) + `\n${add}` + index.slice(after);

package/src/brain/summon.js

@@ -136,28 +136,36 @@ export async function digestSession(file) {
   return out;
 }
 
-/** 已有快照的日期集合（从 .brain/sessions/*.md 文件名取）。
+/** 已总结状态（从 .brain/sessions/*.md 的正文取）：
+ *   ids  —— 页面里已有 `挂钩: session=<会话 id>` 的会话（已提炼过的那几场）
+ *   days —— 「整天快照」的日期集合（页里没有任何 `## 会话 ` 段）
  *
- * 为何要和 md5 账本并用（2026-11-01）：两条判据回答的是不同问题 ——
- *   · 有快照         → 那天**已经总结过**（人写的，最权威）
- *   · 账本记录 md5   → 那个**会话文件**提过了
+ * 两个判据回答的是不同问题：
+ *   · 该天页存在且是人写的快照 → 那天**已经总结过**（人写的，最权威）
+ *   · 页里有该会话 id 的段      → 那**场**会话已经提过
+ *   · 账本记 md5               → 那个**会话文件**提过了
  * 只按 md5 判会把「已有快照的日子」全列出来当未总结（实测 15 条全是已有快照的），
- * 那是把托底做成噪音。两条都要：有快照就跳过，没有才看账本。 */
-async function daysWithSnapshot(brainSessionsDir) {
+ *   那是把托底做成噪音；而只按日期跳过会把同一天没落的几场永久埋掉。
+ *
+ * 为何改成读正文（2026-11-08）：会话摘要不再是一場一文件（`session-<日期>-s<id8>.md`），
+ *   而是并进当天的 `log-<日期>.md` 里的 `## 会话 <id8>` 段 —— 文件名里不再有会话 id，
+ *   所以「这场提过没有」只能按段里的 `挂钩: session=` 查，不能按文件名猜。
+ *   而「那天已有人写快照」仍按天判：页里没有任何 `## 会话 ` 段就说明那天只有人写的内容。 */
+async function summarizedState(brainSessionsDir) {
   const days = new Set();
+  const ids = new Set();
   let files;
-  try { files = await fs.readdir(brainSessionsDir); } catch { return days; }
+  try { files = await fs.readdir(brainSessionsDir); } catch { return { days, ids }; }
   for (const f of files) {
-    // ★ 只认「整天快照」，不认单场会话页（2026-11-05 实测修正）：
-    //   `log-<日期>.md` 是人写的一天流水 —— 那天确实整理过了，跳过合理。
-    //   但 `session-<日期>-s<id8>.md` 是**一场会话一张**（abs ingest 的产物）。
-    //   按天跳过它，会让「同一天只落了一场」把其余几场永久埋掉：
-    //   实测真实项目有 14 天存在多场会话（最多一天 10 场），落一场就全跳过。
-    if (f.startsWith('session-')) continue;
+    if (!f.endsWith('.md')) continue;
+    const body = await fs.readFile(join(brainSessionsDir, f), 'utf8').catch(() => '');
+    if (!body) continue;
+    for (const m of body.matchAll(/^>\s*挂钩:\s*session=(\S+)/gm)) ids.add(m[1]);
+    if (/^##\s*会话\s/m.test(body)) continue;   // 含 ingest 摘要的页不整日跳过
     const m = f.match(/(\d{4}-\d{2}-\d{2})/);
     if (m) days.add(m[1]);
   }
-  return days;
+  return { days, ids };
 }
 
 /** 读账本。格式 { version, files: { "<相对文件名>": { md5, day, summarizedAt } } } */
@@ -225,8 +233,8 @@ export async function scanProject(projectRoot, { ledger, now = Date.now() } = {}
   }
   const ownBook = !ledger;              // 账本是自己读的（不是调用方给的）
   const book = ledger || await readLedger();
-  // 已有快照的日子整日跳过 —— 人已经总结过，托底不该再吵。
-  const haveSnapshot = await daysWithSnapshot(join(projectRoot, '.brain', 'sessions'));
+  // 已总结状态：整天快照的日期（整日跳过）+ 已提过的会话 id（逐场跳过）。
+  const { days: haveSnapshot, ids: haveDigest } = await summarizedState(join(projectRoot, '.brain', 'sessions'));
   const fresh = [], changed = [], skipped = [], active = [];
   let touched = false;   // 是否补记过 stat（需要回写账本，否则下次又得读全文）
 
@@ -258,6 +266,7 @@ export async function scanProject(projectRoot, { ledger, now = Date.now() } = {}
 
     const d = await digestSession(full);
     if (!d || !d.users.length) { skipped.push({ name, reason: '无真实用户输入' }); continue; }
+    if (d.id && haveDigest.has(d.id)) { skipped.push({ name, reason: '这一场已提炼过' }); continue; }
     if (d.day && haveSnapshot.has(d.day)) { skipped.push({ name, reason: `${d.day} 已有快照` }); continue; }
 
     // 到这里才需要 md5（要么文件变了，要么账本里没有）。

package/src/lint.js

@@ -193,6 +193,13 @@ async function checkRootFiles(vault) {
           `总结/报告/清单请分流：流水 → abs log，经验 → abs note，长设计 → sources/)`,
         );
       }
+      // 格式闸（2026-11-08 用户定）：Todo 区任务行必须有 ` — 描述`，只有 id 打回。
+      if (todoSectionOf(lines, i) === 'Todo' && /^- \[ \]/.test(l) && !l.includes(' — ')) {
+        issues.push(
+          `TODO-NO-DESC: ${BRAIN_DIR}/${file}:${i + 1} (任务行没有描述；` +
+          `只有 id 查不到、接不上 —— abs todo start <id> --note "一句话" 补上，或 state 搁置/删除)`,
+        );
+      }
       // 断点行（新旧格式同一个解析器 —— 不再自己切前缀）
       const bpLine = parseChild(l);
       if (!bpLine) continue;
@@ -260,6 +267,11 @@ function checkPage(pg, names, linkedNames, inbound) {
       issues.push(`OVER-SIZE: ${pg.rel} (${pg.lines}L/${pg.bytes}B > ${PAGE_MAX_LINES}L/${PAGE_MAX_BYTES / 1024}KB; 拆或外链)`);
     }
   }
+  if (pg.slug.includes('-todo归档')) {
+    // 旧归档页命名（`<日期>-todo归档`，2026-09-15 治理时已并进 `log-<日期>.md`）。
+    // 留一条命中即报的规则：漏一个就会在 todo.md 的 Archived 里留一条死名。
+    issues.push(`SESSIONS-OLD-NAME: ${pg.rel}（旧归档命名，应并进 sessions/log-<日期>.md）`);
+  }
   if (pg.dir === 'concepts' && !hasTail(pg.body)) {
     // 尾巴按 kind 分档（2026-11-05）：原来「必须写验证命令」对所有 concepts 页一律要求，
     // 后果是「当时为什么这样选」这类决策知识根本落不了地 —— 决策没有可跑的验证命令，
@@ -289,6 +301,14 @@ function checkPage(pg, names, linkedNames, inbound) {
 
 // ---------- 跨页图谱检查 ----------
 
+/** 页面 frontmatter 的标签列表。三处判据共用，避免各自写一份解析而漂移。
+ * 注意：**精确匹配标签**，不用 `\b` —— `\barchive\b` 会连 `todo-archive` 一起豁免
+ * （`-` 与 `a` 之间也是词边界），实测漏报 4 天旧命名归档页。 */
+function tagListOf(frontmatter) {
+  const tags = String(frontmatter || '').match(/^tags:\s*(.+)$/m)?.[1] || '';
+  return tags.replace(/^\[|\]$/g, '').split(',').map((t) => t.trim()).filter(Boolean);
+}
+
 /** 跨页检查：sources 堆积/超龄、sessions 命名、superseded 悬挂、draft 超龄。 */
 async function checkGraph(root, pages) {
   const issues = [];
@@ -307,20 +327,24 @@ async function checkGraph(root, pages) {
     }
   }
 
-  // SESSIONS-NAMING: sessions/ 的一天一文件契约
-  // 例外（2026-11-05）：`abs ingest` 落的会话页叫 `session-<日期>-s<id8>.md`，
-  // 它不是「当天工作流水」，而是**一场具体会话的结构化记录** ——
-  // 同一天可以有好几场，硬套「一天一个 log」会把它挤掉。
-  // 判据用 slug 前缀 `session-`：这是 ingest 独占的命名空间，与 log-<日期> 不交叉。
+  // SESSIONS-NAMING: sessions/ 只收 `log-<日期>[-<slug>].md`（2026-11-08 用户定）。
+  // 曾经的例外 `session-<日期>-s<id8>.md`（ingest 一场会话一张）已废：
+  // 同一天散成多份、且与 todo.md 归档行两套链接名 —— 正是「一天一文件」要治的病。
+  // 会话摘要现在并进当天页，写成 `## 会话 <id8>` 段（见 ingest 的 renderDayPage）。
+  // 豁免只给「独立 `archive` 标签」的外部产物全文归档（2026-09-15 定的）：
+  //   它不是当天工作流水，是别人仓库的产物整篇存进来，名字不由 abs 生成。
+  for (const pg of pages) {
+    if (pg.dir !== 'sessions') continue;
+    if (/^log-\d{4}-\d{2}-\d{2}(?:-.+)?$/.test(pg.slug)) continue;
+    if (tagListOf(pg.frontmatter).includes('archive')) continue;
+    issues.push(`SESSIONS-NAMING: ${pg.rel} 不是规范名；sessions/ 只收 \`log-<日期>[-<slug>].md\`（会话摘要并进当天页的 \`## 会话 <id8>\` 段）`);
+  }
   const sessByDate = new Map();
   for (const pg of pages) {
     if (pg.dir !== 'sessions') continue;
-    if (/^session-/.test(pg.slug)) continue;
     const m = pg.slug.match(/^(?:log-)?(\d{4}-\d{2}-\d{2})/);
     if (!m) continue;
-    const tags = String(pg.frontmatter).match(/^tags:\s*(.+)$/m)?.[1] || '';
-    const tagList = tags.replace(/^\[|\]$/g, '').split(',').map((t) => t.trim());
-    if (tagList.includes('archive')) continue;
+    if (tagListOf(pg.frontmatter).includes('archive')) continue;
     if (!sessByDate.has(m[1])) sessByDate.set(m[1], []);
     sessByDate.get(m[1]).push(pg.slug);
   }
@@ -328,19 +352,16 @@ async function checkGraph(root, pages) {
     if (slugs.length > 1) {
       issues.push(`SESSIONS-SPLIT: ${date} 在 sessions/ 有 ${slugs.length} 个文件（${slugs.join('、')}）；` +
         `一天只应有一个 \`log-${date}.md\`：归档写进其「## 📦 任务归档」段，多主题写成多个 ## 子段`);
-    } else if (!slugs[0].startsWith('log-')) {
-      issues.push(`SESSIONS-NAMING: ${date} 的文件 \`${slugs[0]}.md\` 不是规范名；` +
-        `应为 \`log-${date}.md\`（跑 abs todo archive 会并入；旧归档页可删）`);
     }
   }
 
   // SESSIONS-MISPLACED: sessions/ 里放了不属 sessions 的页
   for (const pg of pages) {
     if (pg.dir !== 'sessions') continue;
-    const tags = String(pg.frontmatter).match(/^tags:\s*(.+)$/m)?.[1] || '';
+    const tags = tagListOf(pg.frontmatter).join(', ');
     if (!/session-log|todo-archive|archive|session-digest/.test(tags)) {
       issues.push(`SESSIONS-MISPLACED: ${pg.rel}（tags: ${tags.trim()} 不属 sessions/；` +
-        `当天工作写进 \`log-<日期>.md\` 正文；一场会话的结构化记录用 \`abs ingest\`）`);
+        `当天工作写进 \`log-<日期>.md\` 正文；一场会话的结构化摘要用 \`abs ingest\`）`);
     }
   }
 
@@ -443,6 +464,52 @@ async function readFileOrNull(p) {
   try { return await fs.readFile(p, 'utf8'); } catch { return null; }
 }
 
+/** 取标题行之后、同级或更高级标题之前的行。找不到标题返回空数组。 */
+function blockAfter(text, heading) {
+  const lines = String(text || '').split('\n');
+  const i = lines.findIndex((l) => l.trim() === heading);
+  if (i === -1) return [];
+  const lvl = (lines[i].trim().match(/^#+/) || ['##'])[0].length;
+  let j = i + 1;
+  while (j < lines.length) {
+    const h = lines[j].trim().match(/^(#+)\s/);
+    if (h && h[1].length <= lvl) break;
+    j++;
+  }
+  return lines.slice(i + 1, j);
+}
+
+/** 机器生成的「文件双链」链接名必须**逐字等于磁盘文件名**（2026-11-08 用户定）。
+ *
+ * 为何单开一条规则：index.md 的 `## Sessions` 段与 todo.md 的 `### Archived` 段
+ * 都是机器生成、且指向 sessions/ 下文件的链接行。它们一旦与文件名脱钩就成了指向
+ * 不存在页的死名 —— 而 sessions/ 的页面豁免 DEAD-LINK（历史快照不改），
+ * 所以这类死名长期无人发现：实测 todo.md 里 `[[2026-09-12-todo归档]]` 挂了两个月，
+ * 真页早在 2026-09-15 治理时并成了 `log-2026-09-12`。
+ *
+ * 判据只有一条：链接名（去 .md、去 | 别名）=== sessions/ 下的某个文件名。
+ * 因此大小写、日期格式、前后缀漂移都会被抓到，不靠词表猜「哪个名字像标准」。 */
+export async function checkGeneratedFileLinks(vault) {
+  const issues = [];
+  const sessFiles = new Set();
+  for (const f of await fs.readdir(join(vault, 'sessions')).catch(() => [])) {
+    if (f.endsWith('.md') && !f.startsWith('_')) sessFiles.add(f.replace(/\.md$/, ''));
+  }
+  const check = (where, lines) => {
+    for (const l of lines) {
+      const m = l.match(/^\s*-\s*\[\[([^\]|]+)(?:\|[^\]]*)?\]\]/);
+      if (!m) continue;
+      const link = m[1].trim();
+      if (sessFiles.has(link)) continue;
+      issues.push(`LINK-NAME-STALE: ${where} -> [[${link}]]（sessions/ 里没有同名文件）。` +
+        `生成的链接名必须逐字等于磁盘文件名（不带 .md），改回真页名后重跑 abs lint`);
+    }
+  };
+  check('index.md ## Sessions', blockAfter(await readFileOrNull(join(vault, 'index.md')), '## Sessions'));
+  check('todo.md ### Archived', blockAfter(await readFileOrNull(join(vault, 'todo.md')), '### Archived'));
+  return issues;
+}
+
 // ---------- 入口 ----------
 
 export async function cmdLint({ dir, all = false }) {
@@ -472,6 +539,7 @@ export async function cmdLint({ dir, all = false }) {
   issues.push(...await checkGraph(root, pages));
   issues.push(...await checkFiles(vault, pages, indexLinks));
   issues.push(...await checkRootFiles(vault));
+  issues.push(...await checkGeneratedFileLinks(vault));
 
   const n = issues.length;
   // ★ 同类折叠（2026-10-05）：体检输出必须按问题**类型**折叠计数。

package/src/note.js

@@ -273,6 +273,13 @@ export async function cmdLog({ dir, title, kind = 'dev', summon = true }) {
       `  note=经验/踩坑 / dev=完成的工作 / concept=新建概念页 / ingest=沉淀资料`,
     );
   }
+  // 格式闸（2026-11-08 用户定）：空标题/纯空白的 log 打回。
+  if (!String(title || '').trim()) {
+    throw new Error(
+      `✗ log 必须有一句话结论 —— 空标题打回。\n` +
+      `  用法: abs log "做完什么 + 怎么验证的" --kind dev`,
+    );
+  }
   await ensurePersonPage(root, who); // 首次写操作即建人页（已存在不动）
   const p = brainPath(root, 'log.md');
   const stamp = localStamp();

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, cmdRecall, extractBlocks } from './brain/load.js';
+export { cmdBoard, cmdStatus, cmdLoad, cmdShow, cmdRecall, extractBlocks, queryHint } from './brain/load.js';
 
 // ---- Rules ----
 export { RULES_HEADING, RULES_MAX, RULE_BODY_MAX, readRules, cmdRule } from './brain/rules.js';

package/src/text.js

@@ -29,17 +29,48 @@ export function clip(text, n) {
   return `${keep.replace(/[\s,，、;；.。]+$/, '')}…`;
 }
 
-/** slug：取前 n 码点 → 非词字符折叠为 '-'。只用于**文件名**，完整标题另存 TITLE 行。
- * 在标点/空格边界收口，不在字中间切断（否则出 `...-硬切-不` 这种残尾）。 */
-export function slugOf(text, n = 24) {
+/** slug 上限（码点）。真需要这个上限的只有「一整句都没句读」的长句 —— 罕见路径。
+ *  为什么不要一个小的固定窗口（如 24）：见 slugOf 的注释。 */
+export const SLUG_MAX = 60;
+
+/** 在这个位置算「一句话的边界」吗。
+ *  强句读（。！？；：）、短语标点（，、）、换行、开括号（括号里的内容是补充，可以不要）、
+ *  以及**后面跟空格/结尾**的英文 . 与 ,（否则 `1.28.5`、`design.md` 里的点会把句子砍成两半）。 */
+function isClauseBoundary(cps, i) {
+  const c = cps[i];
+  if ('。！？；：，、\n（(「'.includes(c)) return true;
+  if (c === '.' || c === ',') {
+    const prev = cps[i - 1];
+    const next = cps[i + 1];
+    // 前面必须是字（否则 `i -g . 会把` 里那个孤立的 `.` 会把句子砍断）
+    return !!prev && /[\w一-鿿]/.test(prev) && (next === undefined || next === ' ');
+  }
+  return false;
+}
+
+/** slug：取**第一句话**（到第一个句读/开括号/换行为止）→ 非词字符折叠为 '-'、小写。
+ * 只用于**文件名**，完整标题另存 TITLE 行。
+ *
+ * 为何改成「按句取」而不是「按长度窗口切」（2026-11-08 用户实测）。窗口必然切在半句上，实测生成过：
+ *   `2026-11-08-abs-sleep-离线整理方案在`  ← 断在介词「在」
+ *   `2026-11-07-发版-1-28-5-时-npm-i-g`    ← 断在半条命令
+ *   `2026-11-03-…-主动取靠-触发规则写进`     ← 断在动词「写进」
+ * 而「末尾是不是半句」没法用结构判据认出来（中文没有词边界，靠虚词表就是猜），
+ * 所以判据反过来：**不切**。句子到边界就停，边界前的字一律完整收进名字。
+ * 实测效果：上面三条分别变成
+ *   `…-abs-sleep-离线整理方案在-docs-sleep-design-md`（“方案在 docs/…”是完整短语）
+ *   `…-发版-1-28-5-时-npm-i-g-会把全局包装成指向仓库的符号链接`
+ *   `2026-11-03-检索有效不等于记忆被用`
+ * 只有整句无边界且超过 SLUG_MAX（60 码点）时才退到窗口内的最后一个空格/开括号。 */
+export function slugOf(text, n = SLUG_MAX) {
   const s = String(text || '').trim();
-  // 同 clip：按码点切，避免把 emoji 切成半个代理对（见 clip 注释）。
   const cps = Array.from(s);
-  let head = cps.slice(0, n).join('');
-  if (cps.length > n) {
-    const cut = Math.max(head.lastIndexOf('，'), head.lastIndexOf('。'), head.lastIndexOf('、'),
-      head.lastIndexOf('：'), head.lastIndexOf(','), head.lastIndexOf('.'), head.lastIndexOf(' '));
-    if (cut > n / 2) head = head.slice(0, cut);
+  const end = cps.findIndex((_, i) => isClauseBoundary(cps, i));
+  let head = (end === -1 ? cps : cps.slice(0, end)).join('');
+  if (Array.from(head).length > n) {
+    const h = Array.from(head).slice(0, n).join('');
+    const cut = Math.max(h.lastIndexOf(' '), h.lastIndexOf('（'), h.lastIndexOf('('));
+    head = cut > 0 ? h.slice(0, cut) : h;
   }
   return head.replace(/[^\w一-鿿]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase();
 }
@@ -52,13 +83,13 @@ export async function readIfExists(p) {
 /** log.md 是"新在上"（cmdLog 把新行插在标题后）——取**最新** n 条，只认 `## [` 条目行。
  * 坑: 曾用 tailLines 取末尾 → 拿到的永远是最旧几条，而标签写着"最近动作"，
  * 于是"开机读状态"最该看的一节长期显示两天前的旧记录（今天的新条目从未显示）。 */
-export function recentLogLines(text, n) {
+export function recentLogLines(text, n = 5, clipLen = 220) {
   return String(text || '')
     .split('\n')
     .filter((l) => /^##\s*\[/.test(l))
     .slice(0, n)
     // 每条按语义边界收口：load 是开机读状态，只求"上会话做到哪"的线索，不须全文。
     // 坑: 不收口时 5 条能占 2.9KB（单条 800B），又是一处随日志变长而膨胀的上下文。
-    .map((l) => clip(l, 220))
+    .map((l) => clip(l, clipLen))
     .join('\n');
 }

package/src/todo/archive.js

@@ -231,6 +231,11 @@ export function archiveDoneInText(text, { keepDays = 3, from = today(), maxLines
       // 会把子项一起计数（实测：1 任务 + 1 子项 → 报 "完成任务 2 条"）。
       // 归档标记的语义是「完成了多少条任务」，子项不算。
       count: gLines.filter((l) => /^- \[x\]/.test(l)).length,
+      // index 行描述（2026-11-08 用户要求）：归档页在 index 里只有
+      // 「日期（会话快照 + 任务归档）」这种零信息量行，回头找某天的活查不到。
+      // 取每个任务的**第一段**（登记时 `--note` 的那句话）拼成摘要，给
+      // maintain.js 写 index 行用。纯函数放在这，cli/store 测试可直接断言。
+      brief: archiveBrief(gLines),
     });
   }
 
@@ -242,6 +247,22 @@ export function archiveDoneInText(text, { keepDays = 3, from = today(), maxLines
   return { text: rebuilt.join('\n').replace(/\n+$/, '\n'), archived, skipped, count };
 }
 
+/** 从任务行抽第一段描述：`<id> [[who]] — 第一段 — 结语 【kind】 (完成 …)`。
+ *  第一段 = 第一个 `—` 到下一个 `—`/`【`/`(完成` 之间（即登记时的 --note）。
+ *  没有的行（如老格式 `- [x] KEEP (完成 …)`）跳过；一行都没有返回空串。
+ *  给 index 行用 —— 只取每条任务的首段、截 60 字，别把结语也卷进来。 */
+export function archiveBrief(lines) {
+  const parts = [];
+  for (const raw of lines) {
+    if (!/^- \[x\]/.test(raw)) continue;    // 断点/子项行不参与
+    const s = raw.replace(/^\s*-\s*\[x\]\s*/, '');
+    const m = s.match(/—\s*([\s\S]*?)(?=\s*—|\s*【|\s*\(完成|$)/);
+    const t = m ? m[1].trim().replace(/\s+/g, ' ') : '';
+    if (t) parts.push(t);
+  }
+  return parts.join('；');
+}
+
 /** 归档页正文（按日期分组，原文保留）。供同日追写复用。 */
 
 export function renderArchiveBody(groups) {
@@ -267,7 +288,7 @@ export function upsertArchiveSection(body, group) {
       '',
       `# ${group.date} 记录`,
       '',
-      '> 本页 = 该日的会话快照（若有）+ 从 `todo.md` Done 区迁出的任务明细。',
+      '> 本页 = 该日的一切：会话摘要（一场一段 `## 会话 <id8>`）+ 从 `todo.md` Done 区迁出的任务明细。',
       '',
       ARCHIVE_SECTION,
       '',

package/src/todo/spec.js

@@ -79,6 +79,12 @@ export const ENTRY_SHAPES = {
         if (!/^-\s/.test(l)) return '链接区只能放 `- [[页名]] — 一句话`（正文段落/编号列表/代码块都不行）';
         if (!/^-\s*\[\[[^\]]+\]\]/.test(l)) return '应以 `- [[页名]] …` 开头';
         if (!/^-\s*\[\[[^\]]+\]\]\s*[—-]\s*\S/.test(l)) return '`[[页名]]` 后要跟 `— 一句话` 描述';
+        // 格式闸（2026-11-08 用户定）：机器模板行（只有日期+归档字样）不算描述，打回。
+        // 归档登记时必须带任务首段（见 maintain.js / archiveBrief）。
+        const dTpl = l.replace(/^\s*-\s*\[\[[^\]]+\]\]\s*[—-]\s*/, '').trim();
+        if (/^\d{4}-\d{2}-\d{2}（(?:会话快照 \+ )?任务归档）?$/.test(dTpl)) {
+          return '描述不能只是日期模板 —— 要写那天干了什么（任务首段，≥4 字）';
+        }
         // 摘要里不许带 Markdown 结构符（实测污染就是摘要取了页面正文开头）
         if (/^\s*-\s*\[\[[^\]]+\]\]\s*[—-]\s*#+\s/.test(l)) return '摘要不能带 `## ` 标题前缀（取页面首行标题了）';
         // ★ 2026-10-18 补：摘要正文本身必须是**纯文本一句话**。