@fanchao8609/agent_brain_sync 1.7.8 → 1.8.0

package/README.md

@@ -60,16 +60,18 @@ abs init          # 建 .brain/ 图谱，只需一次
 
 ```bash
 abs load                       # 开机读状态（Rules + 图谱计数 + 看板 + 最近流水）
-abs todo                       # 看板 Today / In Progress / Blocked / Done
+abs todo                       # 看板 Todo / Done（行首带状态标记）
 
 abs todo add     TASK-1 --note "要做什么"
 abs todo note    TASK-1 --note "改到 X 文件 L40"   # 实时断点
-abs todo blocked TASK-1 --note "卡在哪"
+abs todo state   TASK-1 --note "进行中|讨论中|滞留中"   # 改行首状态标记
 abs todo done    TASK-1
 
 abs note "一句话经验" --tags 坑,docker    # 经验暂存 → sources/
 abs log "完成 X"                          # 记一行流水；abs log 无参 = 查看
-abs query <词>                            # 检索图谱（多词 OR）
+abs query <词>                            # 检索图谱（多词 OR）；已被推翻的经验默认隐藏（--all 可看）
+abs resolve <页名或id>                    # 反查页面路径（页改名后 id 不变）
+abs supersede <页名> [--by <新页>]        # 标记经验已失效（不删文件，保留历史；query 默认不再返回）
 abs status                                # 当前项目 + 图谱概要
 abs lint                                  # 体检：死链/孤岛/超尺寸/堆积
 abs rule                                  # 列出 index.md 的 ## Rules 硬规则

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, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive, cmdTopic } from '../src/store.js';
+import { cmdInit, cmdStatus, cmdLoad, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive, cmdResolve, cmdSupersede } from '../src/store.js';
 import { setUser, getUser, userConfigPath } from '../src/userconfig.js';
 import { runInstall, runUninstall } from '../src/install.js';
 import { readFileSync } from 'node:fs';
@@ -74,6 +74,8 @@ const FLAG_SPEC = {
   'payload': { type: 'string' },
   'tags': { type: 'string' },
   'state': { type: 'string' },
+  'by': { type: 'string' },
+  'all': { type: 'boolean' },
   'keep-days': { type: 'string' },
   'help': { type: 'boolean' },
   'dry-run': { type: 'boolean' },
@@ -144,6 +146,8 @@ function parseArgv(args) {
     note: values.note,
     as: values.as,
     state: values.state,
+    by: values.by,
+    all: !!values.all,
     payload: values.payload,
     tags: values.tags,
     help: !!values.help,
@@ -167,8 +171,7 @@ const usage = `abs — agent-brain-sync 记忆工具
 
 读:
   abs load                   开机读状态 (index/todo/log)
-  abs todo                   任务看板 Topics / Backlog / Today / Blocked / Done
-  abs topic                  话题树（讨论轨道，含已证伪）；无参=查看
+  abs todo                   任务看板 Todo / Done（未完成的都在这，行首带状态）
   abs index                  图谱索引 index.md
   abs log                    流水 log.md
   abs status                 当前项目 + 图谱概要
@@ -176,11 +179,7 @@ const usage = `abs — agent-brain-sync 记忆工具
 写:
   abs todo add     <id> [--note ..] [--section ..]  登记任务 (start 同义)
   abs todo note    <id> --note "断点/进度"   实时落 ↳ 断点 行
-  abs todo blocked <id> --note "卡点原因"    移入 Blocked 区
-  abs topic new    "#1 标题" [--state 状态] [--note 结论]   登记/更新话题
-                    状态: 进行中|已结论|已否决|待验证|已落地|未落地
-                    子话题: abs topic new "#1.1 标题"（父子由 id 点分层级自动推）
-  abs topic promote <id>      讨论成熟、要动手 → 移进 Today（同 id 追踪，不复制）
+  abs todo state   <id> --note "进行中|讨论中|滞留中"    改状态标记（原地，不搬区）
   abs todo done    <id> [--as 落地|否决|仅方案]    完成；结语标明到底"做成了没有"
                                默认 落地。否决=评估后不做(含做了又撤)；仅方案=只设计过
                                不加结语或结语失真会让下一个会话把"想过"当成"做完了"。
@@ -188,7 +187,12 @@ const usage = `abs — agent-brain-sync 记忆工具
   abs note "经验一句话" [--tags 坑,docker]    经验实时暂存 → sources/
 
 维护:
-  abs query <词1> [词2 …]    检索 .brain/ 知识页 (多词 OR)
+  abs query <词1> [词2 …] [--all]
+                            检索 .brain/ 知识页 (多词 OR)；superseded 默认隐藏
+  abs resolve <id-or-slug> [更多…]
+                            按 id/页面名反查路径 (页改名后 id 不变，仍能找回)
+  abs supersede <页名> [--by <取代它的页>]
+                            标记一条经验已失效 (不删文件；query/load 默认不再展示)
   abs todo archive [--keep-days N] [--dry-run]
                             归档 Done 区旧日期组 → sessions/<日期>-todo归档.md
                             (默认保留近 3 天; 任一天有未完成则整天不归档)
@@ -274,7 +278,7 @@ const TODO_ACTIONS = {
   add: 'start',
   start: 'start', // add 的别名(老习惯保留)
   note: 'note',
-  blocked: 'blocked',
+  state: 'state', // 改行首状态标记：进行中|讨论中|滞留中（原地，不搬区）
   done: 'done',
 };
 
@@ -344,28 +348,6 @@ async function main() {
         rejectExtra(opts._, 'abs status');
         console.log(await cmdStatus({ dir: opts.dir }));
         break;
-      // abs topic —— 分区（话题树）：无子命令=树视图；带子命令=话题写操作
-      case 'topic': {
-        const [sub, id, ...rest2] = opts._;
-        if (!sub) {
-          rejectExtra([id, ...rest2].filter(Boolean), 'abs topic');
-          console.log(await cmdTopic({ dir: opts.dir }));
-          break;
-        }
-        const r = await cmdTopic({
-          dir: opts.dir,
-          action: sub,
-          id,
-          // 标题 = 第 3 个位置参数起的全部（含空格），未给则用 id 本身
-          title: rest2.join(' ') || undefined,
-          state: opts.state,
-          conclusion: opts.note,
-          full: opts.full,
-          clear: opts.clear,
-        });
-        console.log(r);
-        break;
-      }
       // abs todo —— 无子命令=看板；带子命令=任务写操作
       case 'todo': {
         const [sub, id, ...rest2] = opts._;
@@ -385,7 +367,7 @@ async function main() {
         if (!action) {
           throw new Error(
             `✗ 未知子命令 "${sub}"\n` +
-            `  可用: add / start / note / blocked / done / archive\n` +
+            `  可用: add / start / note / state / done / archive\n` +
             `  看板: abs todo（不带参数）\n` +
             `  登记任务: abs todo add <id> --note "做什么"`,
           );
@@ -427,7 +409,15 @@ async function main() {
         break;
       }
       case 'query': {
-        console.log(await cmdQuery({ dir: opts.dir, terms: opts._ }));
+        console.log(await cmdQuery({ dir: opts.dir, terms: opts._, includeSuperseded: opts.all }));
+        break;
+      }
+      case 'supersede': {
+        console.log(await cmdSupersede({ dir: opts.dir, refs: opts._, by: opts.by }));
+        break;
+      }
+      case 'resolve': {
+        console.log(await cmdResolve({ dir: opts.dir, refs: opts._ }));
         break;
       }
       case 'lint': {

package/bin/mcp.js

@@ -12,7 +12,7 @@ import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { findBrainRoot, absLogDir } from '../src/index.js';
-import { cmdBoard, cmdLoad, cmdStatus, cmdTask, cmdQuery, cmdLint, cmdNote, cmdWrapup, cmdRule } from '../src/store.js';
+import { cmdBoard, cmdLoad, cmdStatus, cmdTask, cmdQuery, cmdLint, cmdNote, cmdWrapup, cmdRule, cmdResolve, cmdSupersede } from '../src/store.js';
 
 // ---------- 技术日志: MCP 请求跟踪（调试用, 与图谱 log.md 完全分开） ----------
 // 落 ~/.abs/log/mcp.log: 每次工具调用一行 [时间] tool cwd 参数摘要 → 耗时/结果摘要。
@@ -66,7 +66,12 @@ function tool(name, description, schema, handler) {
   server.tool(name, description, schema, withTrace(name, handler));
 }
 
-// 工具面（narrow on purpose — 只暴露读/查/记状态，不做深提炼）
+// 工具面（narrow on purpose — 只暴露读/查/记状态，不做深提炼）。
+// 分级标注（借 OpenContext 的 P0/P1/P2 惯例）：P0=每次开机必调；P1=干活中按需；P2=诊断/收尾。
+// 后来人（和 AI）照这个顺序调，别一上来就 lint。
+//   P0  abs_resolve_project / abs_load
+//   P1  abs_board / abs_task / abs_query / abs_note / abs_resolve
+//   P2  abs_status / abs_rule / abs_lint / abs_wrapup
 tool(
   'abs_resolve_project',
   '定位当前项目的 .brain 图谱根（只认给定目录本身的 .brain/，不向上搜索）。多项目隔离的唯一入口。',
@@ -74,7 +79,10 @@ tool(
   async ({ cwd }) => {
     const root = await findBrainRoot(cwd || process.cwd());
     if (!root) {
-      return { content: [{ type: 'text', text: `未找到 .brain/（${cwd} 下没有，不向上搜索）。先在该目录运行: abs init` }] };
+      return err(`目录 ${cwd} 下没有 .brain/ 图谱（不向上搜索）。`, {
+        code: 'NO_BRAIN',
+        fallback: '先在该目录运行: abs init',
+      });
     }
     return { content: [{ type: 'text', text: root }] };
   }
@@ -86,7 +94,7 @@ tool(
   { cwd: z.string().describe('项目根目录（.brain/ 所在处）') },
   async ({ cwd }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
+    if (!root) return errNoBrain(cwd || process.cwd());
     return { content: [{ type: 'text', text: await cmdBoard({ dir: root }) }] };
   }
 );
@@ -97,36 +105,75 @@ tool(
   { cwd: z.string().describe('项目根目录（.brain/ 所在处）') },
   async ({ cwd }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
+    if (!root) return errNoBrain(cwd || process.cwd());
     return { content: [{ type: 'text', text: await cmdLoad({ dir: root }) }] };
   }
 );
 
 tool(
   'abs_task',
-  '任务实时落盘（幂等键 = id）。add/start 登记 / note 补断点(改到哪个文件哪行) / blocked 碰壁 / done 完成归位。',
+  '任务实时落盘（幂等键 = id）。start 登记进 Todo / note 补断点(改到哪文件哪行) / state 改状态 / done 完成归位 Done。',
   {
-    action: z.enum(['add', 'start', 'done', 'note', 'blocked']),
+    action: z.enum(['add', 'start', 'done', 'note', 'state']),
     id: z.string().describe('任务幂等键，如 TASK-xxx 或子任务名'),
     cwd: z.string().describe('项目根目录（.brain/ 所在处）'),
-    note: z.string().optional().describe('add/start=做什么; note=断点(文件/到哪步); blocked=卡点原因'),
+    note: z.string().optional().describe('add/start=做什么; note=断点(文件/到哪步); state=进行中|讨论中|滞留中'),
   },
   async ({ action, id, cwd, note }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
+    if (!root) return errNoBrain(cwd || process.cwd());
     // add 是 start 的别名（与 CLI `abs todo add` 对齐）
     const act = action === 'add' ? 'start' : action;
     return { content: [{ type: 'text', text: await cmdTask({ dir: root, action: act, id, note }) }] };
   }
 );
 
+tool(
+  'abs_resolve',
+  '按页面 id（或页面名 slug）反查文件路径。页改名后 id 不变，引用请用返回的路径/id。',
+  {
+    cwd: z.string().describe('项目根目录（.brain/ 所在处）'),
+    refs: z.array(z.string()).min(1).describe('页面 id 或页面名，如 "file-write-locking"'),
+  },
+  async ({ cwd, refs }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return errNoBrain(cwd || process.cwd());
+    const text = await cmdResolve({ dir: root, refs });
+    // 全部未命中才算错 —— 部分命中时整体标 isError 会让 Agent 以为调用失败，
+    // 把已经拿到的正确路径丢掉（实测：1 中 1 不中 → 整个结果被当错）。
+    if (/✗/.test(text) && !/✓/.test(text)) {
+      return err(text, { code: 'NOT_FOUND', fallback: 'abs query <词> 全文搜，或直接读 index.md' });
+    }
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
+tool(
+  'abs_supersede',
+  '标记一条经验/知识页已失效（被推翻），不删文件、保留历史。之后 abs_query 默认不再返回它。核实后发现仍有效可手动把 status 改回 active。',
+  {
+    cwd: z.string().describe('项目根目录（.brain/ 所在处）'),
+    refs: z.array(z.string()).min(1).describe('页名或 id，如 "old-approach"'),
+    by: z.string().optional().describe('取代它的页名（可选；给了则必须已存在）'),
+  },
+  async ({ cwd, refs, by }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return errNoBrain(cwd || process.cwd());
+    const text = await cmdSupersede({ dir: root, refs, by });
+    if (/✗/.test(text) && !/✓/.test(text)) {
+      return err(text, { code: 'NOT_FOUND', fallback: '用 abs_query <词> 找到正确的页名后重试' });
+    }
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
 tool(
   'abs_status',
   '当前项目 + 图谱概要（各类页数）。',
   { cwd: z.string().describe('项目根目录（.brain/ 所在处）') },
   async ({ cwd }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
+    if (!root) return errNoBrain(cwd || process.cwd());
     return { content: [{ type: 'text', text: await cmdStatus({ dir: root }) }] };
   }
 );
@@ -134,17 +181,26 @@ tool(
 tool(
   'abs_query',
   '检索当前项目 .brain/ 知识页（多词 OR）：以前踩过什么坑、哪页记了 X。',
-  { cwd: z.string().describe('项目根目录（.brain/ 所在处）'), terms: z.array(z.string()).min(1).describe('检索词') },
-  async ({ cwd, terms }) => {
+  { cwd: z.string().describe('项目根目录（.brain/ 所在处）'), terms: z.array(z.string()).min(1).describe('检索词'), include_superseded: z.boolean().optional().describe('true=连已标记失效的经验一起返回（默认隐藏）') },
+  async ({ cwd, terms, include_superseded }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
-    return { content: [{ type: 'text', text: await cmdQuery({ dir: root, terms }) }] };
+    if (!root) return errNoBrain(cwd || process.cwd());
+    const text = await cmdQuery({ dir: root, terms, includeSuperseded: include_superseded });
+    // 无命中时给逃生口：query 是全文匹配，猜的词不对就换词/看全貌，别以为图谱是空的。
+    // 收口在这里（不散在 store.js）—— CLI 侧是一行提示，MCP 侧需要可自救的结构。
+    if (/无命中/.test(text)) {
+      return err(text, {
+        code: 'NO_MATCH',
+        fallback: '换更具体的词重试（支持多个词 OR）；或读 .brain/index.md 看完整清单',
+      });
+    }
+    return { content: [{ type: 'text', text }] };
   }
 );
 
 tool(
   'abs_rule',
-  '读/写 index.md 的 ## Rules 硬规则区。action=list 列出；action=add 追加一条（只放一句话 + [[链接]]，展开写概念页）。',
+  '读/写 index.md 的 ## Rules 硬规则区。action=list 列出；action=add 追加一条（只放一句话，≤42 字符、不带链接；展开写概念页）。',
   {
     cwd: z.string().describe('项目根目录（.brain/ 所在处）'),
     action: z.enum(['list', 'add']).optional().describe('list=列出(默认)；add=追加一条'),
@@ -152,7 +208,7 @@ tool(
   },
   async ({ cwd, action, text }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
+    if (!root) return errNoBrain(cwd || process.cwd());
     return { content: [{ type: 'text', text: await cmdRule({ dir: root, action: action || 'list', text }) }] };
   }
 );
@@ -163,8 +219,14 @@ tool(
   { cwd: z.string().describe('项目根目录（.brain/ 所在处）') },
   async ({ cwd }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
-    return { content: [{ type: 'text', text: await cmdLint({ dir: root }) }] };
+    if (!root) return errNoBrain(cwd || process.cwd());
+    const text = await cmdLint({ dir: root });
+    // lint 报的是「哪不对」，得补一句「下一步怎么办」，否则 Agent 只能把问题复述给用户。
+    const fallback = /无问题|0 个问题|健康/.test(text)
+      ? null
+      : '按条目里的文件名/H1 直接改；死链可删或改指向；index 漏列用 abs_rule 同区手工补一行';
+    if (!fallback) return { content: [{ type: 'text', text }] };
+    return err(text, { code: 'LINT_ISSUES', fallback });
   }
 );
 
@@ -178,7 +240,7 @@ tool(
   },
   async ({ cwd, text, tags }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
+    if (!root) return errNoBrain(cwd || process.cwd());
     return { content: [{ type: 'text', text: await cmdNote({ dir: root, text, tags }) }] };
   }
 );
@@ -189,13 +251,31 @@ tool(
   { cwd: z.string().describe('项目根目录（.brain/ 所在处）') },
   async ({ cwd }) => {
     const root = await findBrainRoot(cwd || process.cwd());
-    if (!root) return err('未找到 .brain/，先 abs init');
+    if (!root) return errNoBrain(cwd || process.cwd());
     return { content: [{ type: 'text', text: await cmdWrapup({ dir: root }) }] };
   }
 );
 
-function err(msg) {
-  return { content: [{ type: 'text', text: msg }], isError: true };
+// 错误带逃生口：Agent 收到错要能自救，而不是回来问人。
+// 借 OpenContext 的做法——错误里直接给「退一步怎么做」，且带结构化 code 供程序判分支。
+// 判据：凡 isError 的返回，调用方读完应知道下一步跑什么命令。
+function err(msg, { code, fallback } = {}) {
+  const body = [
+    code ? `[${code}] ${msg}` : msg,
+    fallback ? `→ ${fallback}` : null,
+  ].filter(Boolean).join('\n');
+  const res = { content: [{ type: 'text', text: body }], isError: true };
+  // 结构化字段：MCP 客户端可读 structuredContent 判分支（code=NO_BRAIN 等）
+  if (code) res.structuredContent = { error: code, message: msg, fallback: fallback || null };
+  return res;
+}
+
+/** 无图谱专用：所有工具共用同一条自救路径，收口在这里（改一处即全改）。 */
+function errNoBrain(cwd) {
+  return err(`目录 ${cwd} 下没有 .brain/ 图谱（不向上搜索）。`, {
+    code: 'NO_BRAIN',
+    fallback: `先在该目录运行: abs init  （或在含图谱的目录重调本工具）`,
+  });
 }
 
 await server.connect(new StdioServerTransport());

package/hooks/abs.opencode.ts

@@ -4,6 +4,13 @@
  * 纪律: hook 事件只进技术日志, 不进图谱 log.md (log.md 只收工作成果沉淀, 与 event.sh 同纪律)。
  * Op​encode 事件: session.created / session.idle / session.deleted (idle = 每轮结束, 对应 pi 的 agent_end)。
  * 收尾注入: session.idle 且本会话真改过文件 + .brain 今日无记录 → promptAsync 推 agent 走收尾循环。
+ *
+ * 登记注入 (2026-09-15 用户定): 写文件 = 任务开始的机械信号。
+ *   旧设计只在 idle(轮末) 提醒收尾 —— 那时用户已想结束, AI 只想收尾不想登记。
+ *   故 tool.execute.after 检测到**项目文件**写入即注入登记提示(不等 idle):
+ *     · 频繁没关系 —— 每次写都提醒(用户明确要求)
+ *     · 判据 = 整个项目, 但**排除 .brain/ 自身**(写图谱是记录行为, 不是任务)
+ *     · 文案明说「纯讨论可跳过」—— 不逼 AI 造任务
  */
 import { appendFile, mkdir, readFile, stat } from "node:fs/promises"
 import { homedir } from "node:os"
@@ -14,6 +21,10 @@ const server = async ({ client, directory }) => {
   let wroteFiles = false
   let nudged = false
   let idleSeen = false
+  // 登记提醒计数：只为日志/诊断，不做去重 —— 用户要「频繁一点」，每次写文件都提醒。
+  let registerNudged = 0
+  // 当前 session id（由事件里拿），tool.execute.after 没带 sessionID 时靠它补。
+  let currentSessionID = ""
 
   async function logHook(evt) {
     try {
@@ -45,36 +56,72 @@ const server = async ({ client, directory }) => {
     } catch { return false }
   }
 
+  // 登记提醒：注入失败不阻塞宿主。每次写文件都提醒（用户明确要「频繁一点」）。
+  async function registerNudge(files) {
+    registerNudged++
+    await logHook(`tool.execute.after:register-nudge #${registerNudged} files=${files.length}`)
+    if (!currentSessionID) return // 拿不到 session 就无法注入，静默跳过（不抛）
+    const cwd = directory || process.cwd()
+    if (!(await findBrain(cwd))) return // 无图谱 = 不在这项目沉淀，不打扰
+    try {
+      await client.session.promptAsync({
+        path: { id: currentSessionID },
+        query: { directory: cwd },
+        body: { parts: [{ type: "text", text: REGISTER_MSG(files) }] },
+      })
+    } catch {}
+  }
+
   const TEARDOWN_MSG =
     "[abs 收尾提醒] 本会话改过文件但 .brain/ 今天还没有记录。请立即走收尾循环：\n" +
-    "1) 跑 abs load 看 Today 还有哪些未完成；\n" +
+    "1) 跑 abs load 看 Todo 还有哪些未完成；\n" +
     "2) 实际做完漏登记的 abs todo done <id>，做到一半的 abs todo note <id> --note \"断点\"；\n" +
     "3) 值得留的经验 abs note \"...\"（宁少勿滥，能从代码 grep 到的不记）；\n" +
     "4) abs log \"完成 X：...\" 记一行工作成果，新页同步进 index。\n" +
-    // 话题对账：Topics 区只放「正在讨论」的话题。
-    "5) 话题对账 abs topic：本会话在讨论什么→abs topic new \"#N 标题\" --state 进行中；" +
-    "已收尾的话题用 --state 已结论/已否决（会自动移出树），停下来的事落 Blocked。\n" +
-    "   ⚠ Topics 区只放正在讨论的话题；五态（已结论/已否决/已落地/未落地/待验证）都会离开树，" +
-    "离开前先把结论写进 sources/（abs note），否则就丢了。\n" +
     "简洁执行，不要复述本条提醒。若本次确实没有可沉淀产出，直接回一句\"无可沉淀\"即可。"
 
   // bash 里只跑查询类命令不算改文件 (与 pi 侧 READONLY_CMD 同义, 但生成代码里要写进模板串)
   const READONLY_CMD = /^\s*(ls|cat|grep|rg|find|head|tail|wc|git\s+(status|log|diff|show|branch)|pwd|which|echo|node\s+-v|npm\s+(ls|view)|curl)\b/
 
+  // 写文件 = 任务开始的机械信号。排除 .brain/ 自身（`abs note`/`abs log` 也写文件，
+  // 但那是记录行为不是任务 —— 不排除则每落一条经验都弹登记提醒，纯噪音）。
+  const BRAIN_PATH = /\.brain[\\/]/
+  function isProjectWrite(p, cmd) {
+    if (cmd !== undefined) return !!cmd && !READONLY_CMD.test(cmd)
+    if (!p) return false
+    return !BRAIN_PATH.test(String(p))
+  }
+
+  const REGISTER_MSG = (files) =>
+    "[abs 登记提醒] 本轮改了项目文件，说明有任务在进行。\n" +
+    "改了：" + files.slice(0, 6).join(", ") + (files.length > 6 ? ` 等 ${files.length} 个` : "") + "\n" +
+    "若这属于某个任务，立刻登记（别等到会话结束才回忆——那时必漏）：\n" +
+    "  · 新任务: abs todo add <id> --note \"做什么\"\n" +
+    "  · 已有任务: abs todo note <id> --note \"改到哪/下一步\"\n" +
+    "  · 纯讨论/调研/改图谱自身 → 无需登记，回「跳过」即可。\n" +
+    "简洁执行，不要复述本条提醒。"
+
   return {
     // 观测真实写操作: write/edit/patch 类工具成功即标记。
     // 坑: 曾漏掉 bash —— op​encode 里很多修改是经 bash(heredoc/sed) 完成的, 纯 bash 会话
     //     永远不置位 wroteFiles, 于是收尾提醒静默不发。与 pi 侧 WRITE_TOOLS 保持一致。
     "tool.execute.after": async ({ tool, args }) => {
       const t = String(tool || "").toLowerCase()
+      const a = args || {}
+      const fp = a.file_path || a.filePath || a.path || a.filename
       if (["write", "edit", "patch", "multiedit", "apply_patch"].includes(t)) {
         wroteFiles = true
+        // 登记提醒：项目文件被写 = 任务已开始，立刻推（不等 idle）
+        if (isProjectWrite(fp)) await registerNudge([String(fp)])
         return
       }
       // bash 里只有非只读命令算改文件(ls/cat/git status 之类不算)
       if (t === "bash") {
-        const cmd = String((args && (args.command || args.cmd)) || "")
-        if (cmd && !READONLY_CMD.test(cmd)) wroteFiles = true
+        const cmd = String(a.command || a.cmd || "")
+        if (isProjectWrite(undefined, cmd)) {
+          wroteFiles = true
+          await registerNudge(["bash: " + cmd.slice(0, 60)])
+        }
       }
     },
 
@@ -83,9 +130,14 @@ const server = async ({ client, directory }) => {
       if (!type) return
       if (type === "session.created" || type === "session.deleted") {
         await logHook(type)
+        // session.created / idle 等事件带 sessionID —— 存下来供 tool.execute.after 用
+        const sid = event.properties && event.properties.sessionID
+        if (sid) currentSessionID = String(sid)
         return
       }
       if (type !== "session.idle") return // idle = 每轮结束, 不记日志(太吵), 只做收尾判定
+      const sid0 = event.properties && event.properties.sessionID
+      if (sid0) currentSessionID = String(sid0)
       const cwd = directory || process.cwd()
       const brain = await findBrain(cwd)
       // 可观测性: 首次 idle 无条件留一行痕(否则无法区分“事件没触发”与“被守卫拦下”)

package/hooks/abs.pi.ts

@@ -12,7 +12,14 @@
  *     - before_agent_start (用户发话 = 天然话题边界) → 记用户原话
  *     - turn_end (每轮结束) → 记改过哪些文件
  *   累积在**内存**(下方 sessionNotes), 收尾时拼进注入提示 —— **不落盘**。
- *   用户明确不要新文件(曾做过 .brain/topics.log, 已拆)。
+ *
+ * 登记提醒 (2026-09-15 用户定): 写文件 = 任务开始的机械信号。
+ *   旧设计只在 agent_end 提醒收尾 —— 但那时用户已想结束, AI 只想收尾不想登记;
+ *   且「任务何时开始」只有写文件那一刻清楚, 事后回忆必漏。
+ *   故 turn_end 检测到**项目文件**写入即注入登记提示(不等 agent_end):
+ *     · 频繁没关系 —— 每轮改文件都提醒(用户明确要求), 用 nudgeCount 防同一轮重复
+ *     · 判据 = 整个项目, 但**排除 .brain/ 自身**(写图谱不是任务, 是记录行为)
+ *     · 文案明说「纯讨论可跳过」—— 不逼 AI 造任务(否则会长出假条目污染看板)
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import { appendFile, mkdir, readFile, stat } from "node:fs/promises"
@@ -104,22 +111,61 @@ async function loggedToday(brain: string): Promise<boolean> {
     // 只认**工作成果**条目（kind=dev），不能只看“今天有没有行”。
     // 坑（2026-09-13 实测）：`abs note` 也写 log.md（kind=note），
     // 旧判据 (^## [今天 HH:MM]) 把“沉淀了一条经验”当成“今天已收尾”→
-    // 整天不再提醒 → 新冒的话题全部漏登（用户实报“话题还是没进 Topics”）。
+    // 整天不再提醒 → 会话后半场全部漏登。
     // 行格式: `## [YYYY-MM-DD HH:MM] [[name]] dev | 内容`。
     return new RegExp("^## \\[" + today + " \\d{2}:\\d{2}\\] (?:\\[\\[[^\\]]+\\]\\] )?dev \\|", "m").test(txt)
   } catch { return false }
 }
 
+// 写文件 = 任务开始的机械信号。
+// 注: `abs note` / `abs log` 也会写文件 —— 但那是**记录行为**不是任务，
+// 所以要排除 .brain/ 自身（否则每落一条经验都弹一次登记提醒，纯噪音）。
+// ponytail: 用路径前缀判，不解析项目根（子目录/软链场景可能漏判；
+// 漏判的代价只是少提醒一次，不丢数据）。
+const BRAIN_PATH = /\.brain[\/]/;
+
+function isProjectWrite(p: string | undefined, cmd?: string): boolean {
+  if (cmd !== undefined) return !READONLY_CMD.test(cmd); // bash: 非只读就算
+  if (!p) return false;
+  return !BRAIN_PATH.test(String(p));
+}
+
+/** 从一轮的 toolResults 里抽出「改过的项目文件」。排除 .brain/ 自身。 */
+function projectWrites(toolResults: any[]): string[] {
+  const out = new Set<string>();
+  for (const r of toolResults || []) {
+    const name = String(r?.toolName || "");
+    if (!WRITE_TOOLS.has(name)) continue;
+    if (r?.isError) continue;
+    if (name === "bash") {
+      const cmd = String(r?.input?.command ?? r?.args?.command ?? "");
+      if (!isProjectWrite(undefined, cmd)) continue;
+      out.add("bash: " + cmd.slice(0, 60));
+      continue;
+    }
+    const f = r?.input?.file_path ?? r?.args?.file_path ?? r?.input?.path ?? r?.args?.path;
+    if (isProjectWrite(f ? String(f) : undefined)) out.add(String(f));
+  }
+  return [...out];
+}
+
 export default function absPiHook(pi: ExtensionAPI): void {
   // 收尾注入的节流状态。声明在**外层** + 在 session_start 里重置：
   // 否则同一进程的第二个会话会继承上一个会话的 true，永久不再提醒
   // （2026-09-13 实测：同一天多个会话时后半场全部静默）。
   let teardownNudged = false
   let agentEndSeen = false
+  // 登记提醒节流：只需防**同一轮内**重复注入（一个 turn_end 只提醒一次）。
+  // 跨轮不去重 —— 用户明确要「频繁一点」：同一文件改第二回仍是新任务进展，
+  // 该提醒。曾经用「文件列表」当去重键 → 同一文件再改就永不提醒（实测 step②失败）。
+  let lastNudgedTurn = -1
+  let turnSeq = 0
 
   pi.on("session_start", () => {
     teardownNudged = false
     agentEndSeen = false
+    lastNudgedTurn = -1
+    turnSeq = 0
     return logHook("session_start").catch(() => {})
   })
 
@@ -130,7 +176,8 @@ export default function absPiHook(pi: ExtensionAPI): void {
   })
 
   // 每轮结束 = 这轮干了什么（改了哪些文件）。机械事实，供收尾时回忆。
-  pi.on("turn_end", async (event: any, _ctx: any) => {
+  // 同时：写文件 = 任务开始 → **立刻**提醒登记（不等 agent_end）。
+  pi.on("turn_end", async (event: any, ctx: any) => {
     const files = new Set<string>()
     for (const r of event?.toolResults || []) {
       const name = String(r?.toolName || "")
@@ -144,6 +191,28 @@ export default function absPiHook(pi: ExtensionAPI): void {
       }
     }
     if (files.size) addNote("tool", [...files].join(", "))
+
+    // ---- 登记提醒：项目文件被写 = 任务已经开始 ----
+    const touched = projectWrites(event?.toolResults || [])
+    if (!touched.length) return
+    const me = ++turnSeq
+    if (me === lastNudgedTurn) return // 同一轮不重复（turn_end 理论上只来一次，防御）
+    lastNudgedTurn = me
+    const cwd = (ctx && ctx.cwd) || process.cwd()
+    if (!(await findBrain(cwd))) return // 无图谱 = 不在这项目沉淀，不打扰
+    await logHook(`turn_end:register-nudge files=${touched.length}`).catch(() => {})
+    try {
+      pi.sendUserMessage(
+        "[abs 登记提醒] 本轮改了项目文件，说明有任务在进行。\n" +
+        "改了：" + touched.slice(0, 6).join(", ") + (touched.length > 6 ? ` 等 ${touched.length} 个` : "") + "\n" +
+        "若这属于某个任务，立刻登记（别等到会话结束才回忆——那时必漏）：\n" +
+        "  · 新任务: abs todo add <id> --note \"做什么\"\n" +
+        "  · 已有任务: abs todo note <id> --note \"改到哪/下一步\"\n" +
+        "  · 纯讨论/调研/改图谱自身 → 无需登记，回「跳过」即可。\n" +
+        "简洁执行，不要复述本条提醒。",
+        { deliverAs: "followUp" },
+      )
+    } catch {}
   })
   // 收尾注入: 每个会话最多一次, 避免反复打扰。
   pi.on("agent_end", async (event: any, ctx: any) => {
@@ -160,8 +229,7 @@ export default function absPiHook(pi: ExtensionAPI): void {
     if (!brain) return // 无图谱=不在这项目沉淀, 不打扰
     if (!hasWriteWork(event?.messages ? collectToolResults(event.messages) : [])) return
     // 今日已收尾 → 只在**本会话还没真正干事**时才静默。
-    // 旧行为：今天 log 有一行就整天闭口 —— 于是「收尾过之后新冒的话题」全部没人提醒
-    // （2026-09-13 实报：web 版聊了一整轮，Topics 里一条没有）。
+    // 旧行为：今天 log 有一行就整天闭口 —— 于是收尾之后的产出全部没人提醒。
     // 注意不能用 sessionNotes.length 当判据：用户每说一句话就会 push 一条，
     // 那会让 nudge 每轮都触发（噪音）。判据保持「今天已收尾」但配合下面的笔记消费。
     if (await loggedToday(brain)) return
@@ -172,17 +240,10 @@ export default function absPiHook(pi: ExtensionAPI): void {
     try {
       pi.sendUserMessage(
         "[abs 收尾提醒] 本会话改过文件但 .brain/ 今天还没有记录。请立即走收尾循环：\n" +
-        "1) 跑 abs load 看 Today 还有哪些未完成；\n" +
+        "1) 跑 abs load 看 Todo 还有哪些未完成；\n" +
         "2) 实际做完漏登记的 abs todo done <id>，做到一半的 abs todo note <id> --note \"断点\"；\n" +
         "3) 值得留的经验 abs note \"...\"（宁少勿滥，能从代码 grep 到的不记）；\n" +
         "4) abs log \"完成 X：...\" 记一行工作成果，新页同步进 index。\n" +
-        // 话题对账：只放「正在讨论」的话题。终止态（含已否决/已结论/未落地/待验证）
-        // 一律不入树 —— 结论落 abs note，暂停的事落 Blocked 当任务追踪。
-        "5) 话题对账 abs topic：据下方素材归纳本会话讨论过什么→" +
-        "abs topic new \"#N 标题\" --state 进行中；" +
-        "已收尾的用 --state 已结论/已否决（会自动移出树），停下来的落 Blocked。\n" +
-        "   正在动手的话题: `abs topic promote #N` 移进 Today（同 id 连续追踪）。\n" +
-        "   ⚠ Topics 区只放正在讨论的话题；五态都会离开树，离开前先把结论写进 sources/（abs note）。\n" +
         notesBlock(notes) +
         "简洁执行，不要复述本条提醒。若本次确实没有可沉淀产出，直接回一句\"无可沉淀\"即可。",
         { deliverAs: "followUp" },

package/package.json

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