@fanchao8609/agent_brain_sync 1.9.5 → 1.9.7

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.5",
+  "version": "1.9.7",
   "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` 留痕，不再往对话里说话。
 
 当用户**明确说要收尾/结束/切别的事**时，按下面走（不是每个词都触发，见开头总则）：