@fanchao8609/agent_brain_sync 1.9.6 → 1.9.8

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 } from '../src/store.js';
+import { cmdInit, cmdStatus, cmdLoad, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdConcept, cmdShow, cmdRepair, cmdWrapup, cmdRule, cmdTeardownCheck, cmdTodoArchive, cmdResolve, cmdSupersede, cmdReview } from '../src/store.js';
 import { setUser, getUser, userConfigPath } from '../src/userconfig.js';
 import { runInstall, runUninstall } from '../src/install.js';
 import { readFileSync } from 'node:fs';
@@ -76,6 +76,13 @@ const FLAG_SPEC = {
   'port': { type: 'string' },
   // note 的触发条件（何时该读这条经验）—— 供 load 的相关页推荐匹配。
   'when': { type: 'string' },
+  // note 可选：借本机 CodeGraph 带出「改某符号会影响哪些代码」。
+  'impact': { type: 'string' },
+  // note 可选：经验类型（fact/pref/constraint/event，对齐 TencentDB L1 四分类）。
+  'type': { type: 'string' },
+  // review 用：--accept / --reject 各跟一个页名列表（逗号分隔或位置参数）。
+  'accept': { type: 'string' },
+  'reject': { type: 'string' },
   // concept 骨架用: 不在 FLAG_SPEC 里的 `--title` 会被静默当布尔 true（见 parseArgv 注释），
   // 于是 `--title "一句话"` 的正文会进位置参数 → 必须在这声明。
   'title': { type: 'string' },
@@ -194,6 +201,7 @@ const usage = `abs — 跨会话记忆工具（.brain/ 图谱）
   query <词…> [--all]       检索知识页 (多词 OR)
   resolve <页名…>            反查页面路径
   supersede <页名> [--by 页] 标经验已失效
+  review [--accept 页…|--reject 页…]  待确认页队列 (draft 升 active/否决)
   lint                       图谱体检 (死链/超限)
   rule [add "一句话"]        硬规则读写
   install|uninstall [--agent <宿主>] [--no-mcp] [--no-skill]
@@ -281,11 +289,13 @@ const subUsage = {
     'abs note — 经验实时暂存 → sources/（幂等去重；先记后提炼）',
     '',
     '用法:',
-    '  abs note "一句话经验" [--tags 坑,docker] [--when "什么时候该读这条"]',
+    '  abs note "一句话经验" [--tags 坑,docker] [--when "什么时候该读这条"] [--impact 符号名] [--type fact|pref|constraint|event]',
     '',
     '说明:',
     '  • --tags 首个标签建议带类别（坑/技巧/决策…），检索按词 OR 命中',
     '  • --when 供 load 的相关页推荐匹配「何时该读」',
+    '  • --impact 借本机 CodeGraph 带出「改该符号会影响哪些代码」（未装则静默跳过）',
+    '  • --type 经验分类：fact 事实 / pref 偏好 / constraint 约束 / event 事件（默认不分类）',
     '  • sources 是暂存区: 提炼成 concept 后应清理',
   ].join('\n'),
   query: [
@@ -447,7 +457,7 @@ async function main() {
         break;
       }
       case 'note': {
-        console.log(await cmdNote({ dir: opts.dir, text: opts._.join(' '), tags: opts.tags, when: opts.when }));
+        console.log(await cmdNote({ dir: opts.dir, text: opts._.join(' '), tags: opts.tags, when: opts.when, impact: opts.impact, type: opts.type }));
         break;
       }
       case 'concept': {
@@ -496,6 +506,15 @@ async function main() {
         console.log(await cmdResolve({ dir: opts.dir, refs: opts._ }));
         break;
       }
+      case 'review': {
+        // 无 --accept/--reject → 列出全部 draft 页；有则对页名列表执行确认/否决。
+        const action = opts.accept ? 'accept' : opts.reject ? 'reject' : '';
+        const refs = action === 'accept' ? (opts.accept || '').split(',').map(s => s.trim()).filter(Boolean)
+          : action === 'reject' ? (opts.reject || '').split(',').map(s => s.trim()).filter(Boolean)
+          : opts._;
+        console.log(await cmdReview({ dir: opts.dir, refs, action }));
+        break;
+      }
       case 'lint': {
         rejectExtra(opts._, 'abs lint');
         console.log(await cmdLint({ dir: opts.dir }));

package/hooks/abs.opencode.ts

@@ -3,25 +3,16 @@
  * 纯触发: 生命周期事件 → 技术日志一行 (~/.abs/log/hooks.log, ABS_LOG_DIR 可覆盖)。fire-and-forget。
  * 纪律: 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 造任务
+ * 收尾注入已删除（2026-09-18）：曾用 session.idle + promptAsync 推一条收尾提醒, 用户实报
+ *   「每次干活干一会就出来, 任务就中断了」。根因同 pi 侧: 主动往对话里插 turn = 打断,
+ *   不是频率问题（2026-09-15 删登记注入时已得出同一结论）。保留 session.idle:seen 埋点。
  */
-import { appendFile, mkdir, readFile, stat } from "node:fs/promises"
+import { appendFile, mkdir, stat } from "node:fs/promises"
 import { homedir } from "node:os"
-import { join, dirname } from "node:path"
-const server = async ({ client, directory }) => {
-  // 本会话是否真改过文件 (由 tool.execute.after 观测)
-  let wroteFiles = false
-  let nudged = false
+import { join } from "node:path"
+const server = async ({ directory }) => {
+  // 本会话首次 idle 是否已埋点
   let idleSeen = false
-  // 当前 session id（由事件里拿）—— 收尾注入需要它找到会话。
-  let currentSessionID = ""
   async function logHook(evt) {
     try {
       const dir = process.env.ABS_LOG_DIR || join(homedir(), ".abs", "log")
@@ -39,94 +30,32 @@ const server = async ({ client, directory }) => {
     try { const st = await stat(join(d, ".brain")); return st.isDirectory() ? join(d, ".brain") : null } catch { return null }
   }
 
-  // 判定"今天是否收尾过": 只认【工作成果】条目(kind=dev)，行头 '## [YYYY-MM-DD HH:MM] [[name]] dev |'。
-  // 坑1: 曾用裸日期 substring, 正文/任务行里任何一处提到今天就把 nudge 永久压掉(守卫形同虚设)。
-  // 坑2(2026-09-13 实测, pi 侧先修): `abs note` 也写 log.md(kind=note),
-  //     旧判据只看「今天有没有行」会把「沉淀了一条经验」误判成「已收尾」→ 整天不再提醒。
-  //     三宿主(pi/CC/op​encode)判据必须一致 —— 见 [[hook-throttle-alignment]]。
-  async function loggedToday(brain) {
-    try {
-      const txt = await readFile(join(brain, "log.md"), "utf8")
-      const d = new Date()
-      const pad = (n) => String(n).padStart(2, "0")
-      const today = d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate())
-      return new RegExp("^## \\[" + today + " \\d{2}:\\d{2}\\] (?:\\[[^\\]]+\\]\\] )?dev \\|", "m").test(txt)
-    } catch { return false }
-  }
-
-
-  const TEARDOWN_MSG =
-    "[abs] 本会话改过文件，.brain/ 今日无记录。\n" +
-    "这条是信息不是命令：该登记/沉淀就登记，没有可沉淀的直接回一句「无可沉淀」，不用凑。\n" +
-    "先看任务：本会话做完的事有没有进看板？（abs todo / abs todo done <id>；干到一半 abs todo note <id> --note 断点）\n" +
-    "再看沉淀：经验/坑 → abs note \"...\"；成果流水 → abs log \"...\""
-
-  // 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/
-
-
-
-
+  // 收尾注入已停用（2026-09-18）：promptAsync 会在每轮 idle 抢一个 turn，用户实报
+  // 「每次干活干一会就出来, 任务就中断了」。wroteFiles / nudged / READONLY_CMD /
+  // tool.execute.after / loggedToday 随注入一起删除（注入没了，它们已无消费方）。
+  // 保留 session.idle:seen 埋点：区分「事件没触发」与「被守卫拦下」。
   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 || {}
-      if (["write", "edit", "patch", "multiedit", "apply_patch"].includes(t)) {
-        wroteFiles = true
-        return
-      }
-      // bash 里只有非只读命令算改文件(ls/cat/git status 之类不算)
-      if (t === "bash") {
-        const cmd = String(a.command || a.cmd || "")
-        if (cmd && !READONLY_CMD.test(cmd)) wroteFiles = true
-      }
-    },
-
     event: async ({ event }) => {
       const type = event && event.type
       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)
-        // 新会话 = 重置节流状态。坑(2026-09-13 pi 侧同构实测): 状态声明在 server 工厂闭包里,
-        // 同一进程的第二个会话会继承上个会话的 true → 永久不再提醒(后半场全部静默)。
+        // 新会话 = 重置埋点状态。坑(2026-09-13 pi 侧同构实测): 状态声明在 server 工厂闭包里,
+        // 同一进程的第二个会话会继承上个会话的 true → 永久不再留痕。
         // pi 侧在 session_start 里重置; op​encode 的对应事件就是 session.created。
         if (type === "session.created") {
-          wroteFiles = false
-          nudged = false
           idleSeen = false
         }
         return
       }
-      if (type !== "session.idle") return // idle = 每轮结束, 不记日志(太吵), 只做收尾判定
-      const sid0 = event.properties && event.properties.sessionID
-      if (sid0) currentSessionID = String(sid0)
+      if (type !== "session.idle") return // idle = 每轮结束, 不记日志(太吵), 只做可观测性埋点
       const cwd = directory || process.cwd()
       const brain = await findBrain(cwd)
-      // 可观测性: 首次 idle 无条件留一行痕(否则无法区分“事件没触发”与“被守卫拦下”)
+      // 可观测性: 首次 idle 留一行痕(否则无法区分“事件没触发”与“被守卫拦下”)
       if (!idleSeen) {
         idleSeen = true
         await logHook(`session.idle:seen cwd=${cwd} brain=${brain || 'none'}`)
       }
-      if (nudged || !wroteFiles) return
-      const sessionID = event.properties && event.properties.sessionID
-      if (!sessionID) return
-      if (!brain) return // 无图谱=不在这项目沉淀, 不打扰
-      if (await loggedToday(brain)) return // 今天已收尾过
-      nudged = true
-      await logHook("session.idle:teardown-nudge")
-      try {
-        await client.session.promptAsync({
-          path: { id: sessionID },
-          query: { directory: cwd },
-          body: { parts: [{ type: "text", text: TEARDOWN_MSG }] },
-        })
-      } catch {} // 注入失败不阻塞宿主
     },
   }
 }

package/hooks/abs.pi.ts

@@ -4,49 +4,22 @@
  * 纪律: hook 事件只进技术日志, 不进图谱 log.md (log.md 只收工作成果沉淀, 与 event.sh 同纪律)。
  * Pi 事件: session_start / session_shutdown (对应 host hook 的 SessionStart/SessionEnd)。
  * session_shutdown 额外触发 abs wrapup: 把当前项目未完成任务快照到 wrapup.log (跨会话收尾保险)。
- * agent_end 收尾注入: 本会话真改过文件 + .brain 今日无记录 → 注入一条收尾指令, 逼 agent 走收尾循环
- *   (被动记日志不够 —— 没人提醒就不会有人收尾)。每会话最多一次, 且已收尾后不再打扰。
+ * agent_end 只留可观测性埋点(agent_end:seen), 不再向对话注入任何东西。
  *
- * 素材累积 (B+C, 2026-09-13 用户定): 话题在会话中途连续产生, 而收尾提醒只在会话末尾——
- *   用一次性提醒追持续事件 = 记录率 7% (14 条话题只落 1 条)。故在能机械观察的锚点上累积素材:
- *     - before_agent_start (用户发话 = 天然话题边界) → 记用户原话
- *     - turn_end (每轮结束) → 记改过哪些文件
- *   累积在**内存**(下方 sessionNotes), 收尾时拼进注入提示 —— **不落盘**。
- *
- * 已删除（2026-09-15）：曾加过一个「写文件即任务开始 → 每轮注入登记提醒」的功能。
- *   已发布到 1.8.0 后用户实报「pi 里一直报 Follow-up」，判 C 整个删掉。
- *   教训：每次改文件就往对话里插一句话，本身就是设计错误，不是频率问题 ——
- *   改守卫（从每轮一次改成每会话一次）治不了它。别再加回来。
+ * 已删除（2026-09-15）：「写文件即任务开始 → 每轮注入登记提醒」。实报「pi 里一直报 Follow-up」。
+ * 已删除（2026-09-18）：收尾注入本身（agent_end + sendUserMessage deliverAs=followUp）。
+ *   实报「每次干活干一会出来, 任务就中断了」。两次同一个根因：
+ *   **往对话里插一句话本身就是设计错误，不是频率问题** —— 改守卫(每轮→每会话)治不了它。
+ *   别再加回来。素材锚点(before_agent_start/turn_end)随注入一起删除, 已无消费方。
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { appendFile, mkdir, readFile, stat } from "node:fs/promises"
+import { appendFile, mkdir, stat } from "node:fs/promises"
 import { homedir } from "node:os"
-import { join, dirname } from "node:path"
+import { join } from "node:path"
 import { spawn } from "node:child_process"
 
 const ABS_BIN = "@@ABS_BIN@@"
 
-// 素材累积锚点：会话内存里累积，收尾时拼进注入提示。**不落盘、不 spawn、不然上下文**。
-// 预算：只留最近几条（收尾回忆只需线索，不需全史）。
-const NOTES_MAX = 12
-const NOTE_LEN = 120
-const sessionNotes: string[] = []
-
-function addNote(kind: string, text: string): void {
-  const clean = String(text ?? "").replace(/\s+/g, " ").trim().slice(0, NOTE_LEN)
-  if (!clean) return
-  sessionNotes.push(`${kind}: ${clean}`)
-  if (sessionNotes.length > NOTES_MAX) sessionNotes.shift()
-}
-
-/** 把本会话素材拼成一段（收尾注入用）。无素材则空字符串。
- * 用途：让 AI 据线索**归纳**话题，而不是凭记忆回想整场对话（那正是 7% 记录率的原因）。 */
-function notesBlock(notes: string[]): string {
-  if (!notes.length) return ""
-  return "   本会话素材（hook 机械记录，供归纳）\n" +
-    notes.map((n) => "     · " + n).join("\n") + "\n"
-}
-
 async function logHook(evt: string): Promise<void> {
   const dir = process.env.ABS_LOG_DIR || join(homedir(), ".abs", "log")
   const d = new Date()
@@ -68,81 +41,30 @@ function snapshotWrapup(cwd: string): void {
   } catch {} // fire-and-forget
 }
 
-// ---- 收尾注入判定 ----
-// 真改过文件的工具（read/grep/ls 不算, 那些不产生可沉淀的产出）
-const WRITE_TOOLS = new Set(["write", "edit", "multi_edit", "apply_patch", "bash"])
-// bash 里只跑查询类命令不算改文件
-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/
-
-function hasWriteWork(toolResults: any[]): boolean {
-  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 (READONLY_CMD.test(cmd)) continue
-    }
-    return true
-  }
-  return false
-}
-
 /** 定位当前项目的 .brain/：只看 cwd 本身，不向上搜索（防爬到家目录图谱）。 */
 async function findBrain(cwd: string): Promise<string | null> {
   const d = cwd || process.cwd()
   try { const st = await stat(join(d, ".brain")); return st.isDirectory() ? join(d, ".brain") : null } catch { return null }
 }
 
-/**
- * .brain/log.md 今天有记录吗? 有=已收尾, 不再打扰。
- * 必须匹配条目头 '## [YYYY-MM-DD HH:MM]' —— 裸日期 substring 会被正文里任意一处
- * 今天的日期误命中, 导致"已收尾"误判、nudge 永不触发。
- */
-async function loggedToday(brain: string): Promise<boolean> {
-  try {
-    const txt = await readFile(join(brain, "log.md"), "utf8")
-    const d = new Date()
-    const pad = (n: number) => String(n).padStart(2, "0")
-    const today = d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate())
-    // 只认**工作成果**条目（kind=dev），不能只看“今天有没有行”。
-    // 坑（2026-09-13 实测）：`abs note` 也写 log.md（kind=note），
-    // 旧判据 (^## [今天 HH:MM]) 把“沉淀了一条经验”当成“今天已收尾”→
-    // 整天不再提醒 → 会话后半场全部漏登。
-    // 行格式: `## [YYYY-MM-DD HH:MM] [[name]] dev | 内容`。
-    return new RegExp("^## \\[" + today + " \\d{2}:\\d{2}\\] (?:\\[\\[[^\\]]+\\]\\] )?dev \\|", "m").test(txt)
-  } catch { return false }
-}
-
-
-/** 收尾注入的节流状态。
+/** agent_end 埋点状态。
  *
  * 为何在**模块级**而不在 absPiHook() 里（2026-09-17 实测）：扩展会被重复注册
- * （session_start 11 分钟内触发 8 次），每次注册都新建一份闭包 → flag 不共享 →
- * 实测同会话 5 分钟注入 6 次。模块级状态在同一进程内只有一份，注册多少次都共享。
+ * （session_start 11 分钟内触发 8 次），每次注册都新建一份闭包 → flag 不共享。
+ * 模块级状态在同一进程内只有一份，注册多少次都共享。
  *
- * teardownNudged  = 本会话已注入过（终态，session_start 才重置）
- * teardownInFlight = 正在判定中（抢在 await 之前置位，堵住并发重入）
- * agentEndSeen    = 本会话已留过 seen 痕（可观测性，同样每会话一次）
+ * agentEndSeen = 本会话已留过 seen 痕（可观测性，每会话一次）
  */
-let teardownNudged = false
-let teardownInFlight = false
 let agentEndSeen = false
 
-/** 会话边界重置节流（session_start 与注册时都调）。
- *  不重置 → 同进程第二个会话继承 true 永久静默（2026-09-13 实测过的坑）。 */
+/** 会话边界重置埋点状态。
+ *  不重置 → 同进程第二个会话继承 true 永久不留痕（2026-09-13 实测过的坑）。 */
 function resetThrottle(): void {
-  teardownNudged = false
-  teardownInFlight = false
   agentEndSeen = false
 }
 
 export default function absPiHook(pi: ExtensionAPI): void {
-  // 收尾注入的节流状态。故意声明在**模块级**（不在被反复调用的工厂函数里），
-  // 因为**扩展会被重复注册**：实测 session_start 在 11 分钟内触发 8 次
-  // （2026-09-17 00:07:58 一口气 3 次）。注册几份就得到几份独立闭包，
-  // 各自的 flag 彼此看不见 → “每会话一次”变成“每实例一次” → 实测同会话 5 分钟注入 6 次。
-  // 模块级状态在同一进程内共享，注册多少次都只有一份。
+  // 埋点状态同上，故意声明在**模块级**（不在被反复调用的工厂函数里）。
   resetThrottle()
 
   pi.on("session_start", (event: any, _ctx: any) => {
@@ -150,73 +72,19 @@ export default function absPiHook(pi: ExtensionAPI): void {
     return logHook("session_start").catch(() => {})
   })
 
-  // ---- 素材锚点（不烧上下文、不注入消息、不 spawn、不落盘）----
-  // 用户发话 = 天然的话题边界。这是 C 路线：你说的每句话都是一个锚点。
-  pi.on("before_agent_start", async (event: any, _ctx: any) => {
-    addNote("user", String(event?.prompt || ""))
-  })
-
-  // 每轮结束 = 这轮干了什么（改了哪些文件）。机械事实，供收尾时回忆。
-  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 || "")
-      if (!WRITE_TOOLS.has(name)) continue
-      if (r?.isError) continue
-      const f = r?.input?.file_path ?? r?.args?.file_path ?? r?.input?.path ?? r?.args?.path
-      if (f) files.add(String(f))
-      else if (name === "bash") {
-        const cmd = String(r?.input?.command ?? r?.args?.command ?? "")
-        if (!READONLY_CMD.test(cmd)) files.add("bash: " + cmd.slice(0, 60))
-      }
-    }
-    if (files.size) addNote("tool", [...files].join(", "))
-  })
-
-  // 收尾注入: 每个会话最多一次, 避免反复打扰。
+  // 收尾注入已停用（2026-09-18）：sendUserMessage(deliverAs:"followUp") 会在每轮
+  // agent_end 抢一个 follow-up turn，用户实报「每次干活干一会出来, 任务就中断了」。
   //
-  // 坑（2026-09-17 实测定根因）：原实现是「先检查 flag → 若干 await → 才置位」，
-  // 而 agent_end **每轮 run 结束都触发**（官方 docs/extensions.md:569：它不等于会话结束，
-  // Pi 之后还可能继续跑 follow-up）。并发的多次调用因此**全部先通过 `if (nudged) return`**，
-  // 之后才各自置位 → 一起注入。实测同会话 5 分钟内注入 6 次，全日志 55 次。
-  // 修法：进函数**第一个动作**就抢占（置位在任何 await 之前），失败再把标志放回。
-  // 这样“检查+设置”之间没有让出点，并发调用只有一个能赢。
-  pi.on("agent_end", async (event: any, ctx: any) => {
-    if (teardownNudged || teardownInFlight) return
-    teardownInFlight = true
-    // 从这里往下任何提前 return 都必须解除 in-flight（否则本次会话永久不再提醒）。
-    const release = () => { teardownInFlight = false }
+  // 为何是删除而非调参：这跟 2026-09-15 删掉「写文件即注入登记提醒」是同一个错
+  // ——「往对话里插一句话」本身就不是频率问题（见文件头）。每轮弹、每会话弹、
+  // 每项目弹，都还是在打断用户。故不再有 teardownNudged/inFlight/loggedToday 判据。
+  // 只保留 agent_end:seen 埋点：区分「事件没触发」与「被守卫拦下」。
+  pi.on("agent_end", async (_event: any, ctx: any) => {
+    if (agentEndSeen) return
+    agentEndSeen = true
     const cwd = (ctx && ctx.cwd) || process.cwd()
     const brain = await findBrain(cwd)
-    // 可观测性: 本会话首次 agent_end 无条件留一行痕。
-    // 没有它就无法区分三种状态: ①事件没触发 ②触发了但被守卫拦下 ③真注入了。
-    if (!agentEndSeen) {
-      agentEndSeen = true
-      // 带上 cwd 与命中的 brain —— 否则事后无法解释“为何这条 nudge 会出现”
-      await logHook(`agent_end:seen cwd=${cwd} brain=${brain || 'none'}`).catch(() => {})
-    }
-    if (!brain) return release() // 无图谱=不在这项目沉淀, 不打扰
-    if (!hasWriteWork(event?.messages ? collectToolResults(event.messages) : [])) return release()
-    // 今日已收尾 → 只在**本会话还没真正干事**时才静默。
-    // 旧行为：今天 log 有一行就整天闭口 —— 于是收尾之后的产出全部没人提醒。
-    // 注意不能用 sessionNotes.length 当判据：用户每说一句话就会 push 一条，
-    // 那会让 nudge 每轮都触发（噪音）。判据保持「今天已收尾」但配合下面的笔记消费。
-    if (await loggedToday(brain)) return release()
-    teardownNudged = true
-    teardownInFlight = false
-    await logHook("agent_end:teardown-nudge").catch(() => {})
-    // 素材交给 AI 后清空：同一会话再触发时不该重复喂旧料。
-    const notes = sessionNotes.splice(0, sessionNotes.length)
-    try {
-      pi.sendUserMessage(
-        "[abs] 本会话改过文件，.brain/ 今日无记录。\n" +
-        "这条是信息不是命令：该登记/沉淀就登记，没有可沉淀的直接回一句「无可沉淀」，不用凑。\n" +
-        "先看任务：本会话做完的事有没有进看板？（abs todo / abs todo done <id>；干到一半 abs todo note <id> --note 断点）\n" +
-        "再看沉淀：经验/坑 → abs note \"...\"；成果流水 → abs log \"...\"" +
-        notesBlock(notes),
-        { deliverAs: "followUp" },
-      )
-    } catch {}
+    await logHook(`agent_end:seen cwd=${cwd} brain=${brain || 'none'}`).catch(() => {})
   })
 
   pi.on("session_shutdown", (_e: any, ctx: any) => {
@@ -225,12 +93,4 @@ export default function absPiHook(pi: ExtensionAPI): void {
   })
 }
 
-/** agent_end 的 event.messages 里翻出 toolResult 消息。 */
-function collectToolResults(messages: any[]): any[] {
-  const out: any[] = []
-  for (const m of messages || []) {
-    if (m && m.role === "toolResult") out.push(m)
-  }
-  return out
-}
 @@MARK@@

package/package.json

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

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

@@ -305,10 +305,12 @@ abs todo archive            # 一条命令搞定，无需手工搬
 > Stop 时 hook 把「未完成任务 + 断点」快照进 `~/.abs/log/wrapup.log`（`abs wrapup`，机械幂等），
 > 下会话 `abs load` 会自动把滞留顶到顶部（`⏳ 上会话滞留`）—— 所以收尾不靠自觉，是开场被强制接上。
 >
-> **主动注入**：pi 扩展在 `agent_end` 检测「本会话真改过文件」且「log.md 今日无记录」时注入
-> `[abs 收尾提醒]`（每会话最多一次）。**它是一条信息，不是命令** ——
-> 自己判断该不该沉淀；没有可沉淀的就回一句「无可沉淀」，不用强行凑。
-> Cl​aude/Co​dex 靠 `Stop` 事件达成同样效果。
+> **不再主动注入**（2026-09-18）：pi 扩展曾在 `agent_end` 往对话里推一条 `[abs 收尾提醒]`
+> （Claude/Co​dex 靠 `Stop` 事件、op​encode 靠 `session.idle` 达成同样效果）。
+> 已全部删除：用户实报「每次干活干一会就出来, 任务就中断了」。**主动往对话里插一个 turn
+> 就是打断，不是频率问题** —— 每轮弹、每会话弹都还是打断。收尾靠**你自己在该收尾时走**，
+> 以及 `wrapup.log` + `abs load` 的机制兵底（开场强制接上滞留任务）。
+> 挂钩只在 `~/.abs/log/hooks.log` 留痕，不再往对话里说话。
 
 当用户**明确说要收尾/结束/切别的事**时，按下面走（不是每个词都触发，见开头总则）：
 

package/src/codegraph.js

@@ -0,0 +1,87 @@
+// src/codegraph.js — 借用本机 CodeGraph 的「代码影响面」，写回 abs 图谱。
+//
+// 为何要这个模块（而非直接塞进 cmdNote）：
+//   abs 的定位是纯 markdown 图谱、零依赖、可进 git；CodeGraph 是二进制 SQLite、
+//   不可进 git、且不是每个机器都装。两者职责不同，唯一值得打通的点是一个维度：
+//   abs 的经验页里「这个改动会影响哪些代码」是空白的，而 codegraph impact 正是干这个的。
+//
+// 融合姿势 = 借结果、不引依赖：
+//   只在「用户显式传了 --impact <符号>」时才调 codegraph CLI，
+//   把它的纯文本输出写进 .brain/ 的 markdown 页（可进 git）。
+//   codegraph 不存在 / 调用失败 / 超时 → 静默降级为「无影响面」，绝不阻断 note 落盘。
+//
+// 为什么走 child_process 调 CLI、不引 npm 包、不走 MCP：
+//   - CLI 是 codegraph 自己装的稳定接口（impact/callers/callees），零依赖；
+//   - MCP 走宿主钩子，之前实测在 pi 下报 _elicitationHandler 错（宿主 bug），CLI 稳定。
+
+import { execFile } from 'node:child_process';
+
+const CG_BIN = 'codegraph';
+const CG_TIMEOUT_MS = 3000;
+
+/**
+ * 探测本机 codegraph 是否可用（不抛错，任何失败都返回 false）。
+ * 结果只影响「要不要在 note 里带影响面」，绝不影响 note 本身落盘。
+ */
+async function codegraphAvailable() {
+  return new Promise((resolve) => {
+    execFile(CG_BIN, ['--version'], { timeout: 1500 }, (err) => resolve(!err));
+  });
+}
+
+/**
+ * 索引是否新鲜（无 pending 改动）。
+ * codegraph 有文件 watcher，但 daemon 可能没在跑 / 停了很久，索引会过期。
+ * 过期时 impact 会返回旧数据 —— 把它写进经验页等于污染 abs 图谱。
+ * 用 `codegraph status --json` 的 pendingChanges 判定：全 0 才新鲜；
+ * 任何失败（命令不在/超时/解析失败）一律当「不新鲜」，宁缺毋滥。
+ */
+async function codegraphFresh(root) {
+  return new Promise((resolve) => {
+    execFile(
+      CG_BIN,
+      ['status', '--json', root],
+      { timeout: 2000 },
+      (err, stdout) => {
+        if (err) return resolve(false);
+        try {
+          const j = JSON.parse(stdout);
+          const pc = j.pendingChanges || {};
+          const fresh = (pc.added || 0) + (pc.modified || 0) + (pc.removed || 0) === 0;
+          resolve(fresh);
+        } catch {
+          resolve(false);
+        }
+      },
+    );
+  });
+}
+
+/**
+ * 拿某符号的「影响面」：改它会波及哪些函数/文件。
+ * @param {string} symbol 符号名（如 cmdTask、requireBrain）
+ * @param {string} root 项目根（codegraph -p 参数）
+ * @returns {Promise<string|null>} 纯文本影响面，失败/不可用/索引过期返回 null
+ */
+export async function impactOf(symbol, root) {
+  const s = String(symbol || '').trim();
+  if (!s) return null;
+  if (!(await codegraphAvailable())) return null;
+  // 索引不新鲜 → 不写影响面（避免把过期结构写进经验页）。
+  // 代价：用户刚改完代码立刻 note 时拿不到影响面；收益：绝不写错数据。
+  // 新鲜度恢复只需 codegraph 的 watcher 约 1s 同步，或手动 codegraph sync。
+  if (!(await codegraphFresh(root))) return null;
+  return new Promise((resolve) => {
+    execFile(
+      CG_BIN,
+      ['impact', s, '--depth', '2', '-p', root],
+      { timeout: CG_TIMEOUT_MS },
+      (err, stdout) => {
+        if (err) return resolve(null);
+        const text = String(stdout || '').trim();
+        // codegraph 无命中时输出形如 "No ..." 或空，统一当「无影响面」。
+        resolve(text ? text : null);
+      },
+    );
+  });
+}

package/src/install.js

@@ -822,11 +822,11 @@ async function installPi({ withMcp, withSkill, log }) {
   const p = join(dir, 'abs.ts');
   await atomicWrite(p, piPluginSource()); // Pi 用专用模板, 语法与 OpenCode 不同构
   steps.push(`✓ hook(ts extension) → ${p}`);
-  // MCP → ~/.pi/agent/mcp.json 的 mcpServers (stdio)
-  // 曾经只打印「走 extension 内桥接」而没有任何桥接代码 —— 靠 mcp-adapter 的
-  // hostConfigDiscovery 间接读到 claude 注册才"看起来能用"; 没有 claude 宿主的机器上直接缺失。
+  // MCP → ~/.pi/agent/mcp-adapter.json 的 mcpServers (stdio)
+  // 坑（2026-09-30 用户实报）：曾写 mcp.json，但 pi-mcp-adapter 已不再读它
+  //   （pi 自有 mcp.json 被 adapter 忽略，adapter 改读 mcp-adapter.json）→ 写了等于没写。
   if (withMcp) {
-    const mcpP = join(hostConfigRoot('pi'), 'agent', 'mcp.json');
+    const mcpP = join(hostConfigRoot('pi'), 'agent', 'mcp-adapter.json');
     await backup(mcpP);
     const cfg = await readJson(mcpP);
     cfg.mcpServers = cfg.mcpServers || {};
@@ -845,7 +845,7 @@ async function uninstallPi() {
   await fs.rm(join(hostConfigRoot('pi'), 'agent', 'extensions', 'abs.ts'), { force: true });
   steps.push(`✓ extension 已删除`);
   steps.push(...await uninstallSkills('pi'));
-  const mcpP = join(hostConfigRoot('pi'), 'agent', 'mcp.json');
+  const mcpP = join(hostConfigRoot('pi'), 'agent', 'mcp-adapter.json');
   const cfg = await readJson(mcpP, { strict: false });
   if (cfg === null) {
     steps.push(`⚠ ${mcpP} 无法解析为 JSON，已跳过（未改动你的配置）`);