@akasha-book/sleep 1.5.4 → 1.7.1

package/README.md

@@ -1,56 +1,29 @@
 # @akasha-book/sleep
 
-> 1.5.4 起新增**称呼行**（`akasha:address`，order 133）：每回合 runtime context 注入「对用户称 Master；用户对你是『大肥鱼』」+ 执行点要求——
-> 成因见 `docs/observation-ledger.md` 与 `canon-address-drift-fix-20261010`：**规则躺在会话开头的注入里、执行点看不到 ⇒ 长会话中期必漂移**；
-> 修法＝接进每回合必然经过的面。
+阿卡夏之书睡眠器 v1.5.5 —— **调度与注入**（蒸馏逻辑归核心库 `<AKASHA_DIR>/sleep.mjs`；手动触发 `node akasha.mjs sleep [--dry]` 与之共用同一水位线）。
 
-> 阿卡夏之书（Akasha Book）· 睡眠器插件
+- **v1.5.5（2026-10-07 复查修复）**：移除死代码 `source==='compact'` 早退（官方 `agent/created` 的 source 只有 startup/resume；压缩信号是 session 事件 `compaction/*`）；子代理守卫沿用官方 `header.origin/delegationDepth`（已核真实字段）。
 
-阿卡夏之书睡眠器 v1.5.1 —— **调度与注入**（蒸馏逻辑归核心库 `../../core/sleep.mjs`；手动触发 `node akasha.mjs sleep [--dry]` 与之共用同一水位线）。
+- **触发**：`agent/status → idle`，去抖 `minIntervalHours`（默认 6）；另一路定时兜底 `ctx.interval`（`timerCheckMs`，默认 1h——timer 属混入服务，必须 `inject:['timer']` 才能访问 `ctx.interval`）。跳过也留痕（`sleep-skip`）；首次激活即跑一次（`activate`）。
+- **蒸馏（v1.4 起在核心库 `akasha\sleep.mjs`）**：`akasha\logs\hooks.jsonl` 增量（水位线 `processedLines`）→ turns / tools / errors / denials 统计 + 失败备注 + 待办（`buildTodos`：审计警告 → review；工具失败 / 门控拦截 / agent 错误 → 孤案候选）；报告 `sleep-<date>.json`（**同日重复跑加时间戳后缀，不覆盖**）；有待办时追加 `akasha\logs\inbox.jsonl`。
+- **条子一（每回合）**：`systemPrompt.context`（`akasha:sleep`，order 130）——每个新回合的 runtime context 自动带上「最近一次睡眠」一行（含待办数；渲染自核心库）。
+- **条子二（新会话·唤醒条）**：`agent/created` → 经 `agent.inject()` 把「起床包」摘要递进 next-step inbox（**不唤醒、不打断**；仅当 无睡眠记录 / 有待办 / 审计警告 才发；子代理与 compact 不打扰；消息 `source.kind = "akasha-wake"`）。
+- **条子三（每回合·库脉搏 + 回查）**：`akasha:pulse`（order 132）——六库当前计数 + 最近写入（**写→可见通道**：任何会话 / 脚本写入库后，活跃会话下一回合即见）；**v1.5 起**，窗口内（默认 30 分钟）有工具 / agent 失败时，追一行「回查提示」（错误钩子的注入级动作——只提示、不拦截；渲染幂等，同窗口重复渲染结果一致）。
+- **降级（v1.4 切分）**：核心库不可用 → `sleep-error` 观测线 + 条子提示文案；不炸、不失活（插件不再内置蒸馏逻辑，拒绝双份实现）。
+- 观测线：`sleep-armed` / `sleep-done` / `sleep-skip` / `sleep-error` / `wake-note` / `wake-note-error` / `wake-note-llm-error` / `sleep-report-error` / `sleep-state-error` / `sleep-inbox-error` 全部写进 `hooks.jsonl`（报告 / 状态 / inbox 三条由核心库发出）。
+- 自测：`node selftest.mjs`（纯函数直测 `../../core/sleep.mjs`——含 v1.5 `renderRecallLine`；桩 ctx 端到端（含失败→回查行）+ 写失败线 + 无核心降级；临时目录，不碰真库水位线）。
 
-- **触发**：`agent/status → idle`，去抖 `minIntervalHours`（默认 6）；另一路定时兜底 `ctx.interval`（默认 1h——timer 属混入服务，需 `inject:['timer']`）。跳过也留痕（`sleep-skip`）；首次激活即跑一次（`activate`）。
-- **蒸馏**：`hooks.jsonl` 增量（水位线 `processedLines`）→ 统计 + 失败备注 + 待办（审计警告 → review；工具失败 / 拦截 / agent 错误 → 孤案候选；**失败前未查库的回合 → review `recall-miss`（召回复盘，带会话样本；不自动转孤案），wave1.1**）；报告 `sleep-<date>.json`（**同日重复跑加时间戳后缀，不覆盖**）；有待办时追加 `logs/inbox.jsonl`。
-- **条子一（每回合）**：`akasha:sleep`（order 130）——最近一次睡眠摘要（含待办数）。
-- **条子二（新会话·唤醒条）**：`agent/created` → 经 `agent.inject()` 递「起床包」摘要（不唤醒、不打断；仅当 无睡眠记录 / 有待办 / 审计警告 才发）。
-- **条子三（每回合·库脉搏 + 回查）**：`akasha:pulse`（order 132）——六库计数 + 最近写入（**写→可见通道**）；窗口内（默认 30 分钟）有失败时追一行**回查提示**（注入级，不拦截）。
-- **配置**：`akashaDir` / `log` / `stateFile` / `inboxFile` / `appModulesDir`（唤醒条用的宿主模块目录；**留空则跳过并留痕 `wake-note-llm-skip`**）/ `minIntervalHours` / `timerCheckMs` / `contextOrder` / `pulseOrder`。
-- 观测线：`sleep-armed` / `sleep-done` / `sleep-skip` / `sleep-error` / `wake-note` / `wake-note-error` / `wake-note-llm-error` / `wake-note-llm-skip` / `sleep-report-error` / `sleep-state-error` / `sleep-inbox-error`。
-- 自测：`node selftest.mjs`（纯函数 + 桩 ctx 端到端 + 写失败线 + 无核心降级；不碰真实水位线）。
+## 版本与重启
 
-## ⚠️ 版本纪律
-替换已安装包的 JS **无法进程内热更**（模块代缓存）——升级后需重启宿主载入。
+- v1.1.0 事故：访问 `ctx.setInterval` 未 `inject` → 属性访问本身抛错、**apply 整段失败且零日志**（诊断靠 `plugin_manager` 的返回或 `*-armed` 观测线）。v1.1.2 修复 + 入口改 `lib/index.js`。
+- **替换已装包的 JS 无法进程内热更**（toggle / remove+reinstall 都无效）——v1.1.2 / v1.1.1 / v1.2.0 / v1.3.0 / v1.3.1 / v1.4.0 / **v1.5.0** 均需**重启**载入。
+- v1.3.0：库脉搏（写→可见通道）；v1.3.1：写路径静默失败补观测线；v1.4.0：逻辑归库（`akasha\sleep.mjs`）+ 手动触发；**v1.5.0：回查提示（失败窗口 → 脉搏条追一行）**。
+- ⚠️ 注意：`ctx.on('tools/result')` 与 `ctx.on('agent/error')` 的监听是 v1.5 新增——宿主 Event 名以 `cordis_inspect_query`（host Event 目录）为准，两个事件均为 emit 语义（失败不打断宿主）。
 
-## 打包 / 安装（DSH 宿主）
+## 打包 / 安装
 
-```bash
+```powershell
+cd <LOCAL_PATH>
 npm pack
-# 然后：plugin_manager install_bundle <tgz 绝对路径>（新 bundle 热生效；替换已装包需重启宿主）
+# 然后：plugin_manager install_bundle <tgz 绝对路径>（首次安装会 HMR 热生效；替换需重启）
 ```
-
-依赖：DSH 宿主（`systemPrompt` / `timer` 服务与事件面）；核心库 `../../core/sleep.mjs` + `lib.mjs`（经 `akashaDir` 动态加载）。
-
-<!-- store-status -->
-## 兼容与状态（DSH STORE 口径 · 2026-10-10）
-
-**固定源（immutable source）**：本版本的源码冻结于 Commit `d311ad54d1dc2cd2697c7b9eeac57eaa6466fc04`（对应 `plugins/akasha-sleep/package.json` 的 version）。
-兼容声明见 manifest 的 `dsh.compatibility.dshReleases`：**0.2.0-rc.2 = compatible**（本机实测运行），
-`0.2.1-alpha.1` / `0.2.1-alpha.2` 尚未实测 ⇒ 按契约如实写 `unknown`（不猜、不吹）。
-
-| 证据层 | 状态 | 依据 |
-|---|---|---|
-| 静态契约（manifest / Bundle Patch / 许可证 / 入口 ID） | **verified** | 官方 `build-dsh-plugin` 审计：静态分见本包审计输出；入口 ID 为插件自有，不 disable/replace 任何 `@deepseek-ai/*` |
-| 单元与边界测试（`npm test`） | **verified** | `node selftest.test.mjs` 全绿；覆盖 malformed 输入、并发/节流、replay 一致性；**含"用户消息形状"契约测试**（与宿主 `createUserMessage` 逐字段比对，见 [`docs/upstream-contracts.md`](../../docs/upstream-contracts.md) C1） |
-| 一次性 Profile 安装·启动·卸载（E3） | **verified** | 2026-10-10 一次性 DSH_HOME 实跑：install → cold start（HTTP 就绪）→ stop → uninstall → `--dump-config` 逐字回到基线；dsh 0.2.0-rc.2；证据见同目录 `EVIDENCE.json` |
-| 真实 Profile 运行 | **verified（本机）** | 桌面端 0.2.0-rc.2 实跑；**他人机器 unverified**（未做外部验收）；**称呼行 `akasha:address`（1.5.4，order 133）已活体可见**——每回合 runtime context 带「对用户称 Master / 用户称你大肥鱼」并写明执行点（交付 / 验收 / 复盘开口句） |
-| 独立安全审计 / 公开分发（E5） | **unverified** | 未做独立审计；分发前应重评 |
-
-**下一道门（next gate）**：① 在 0.2.1-alpha.x 上按同一套用例复测（一次性 DSH_HOME），把 `unknown` 改为精确结论（`compatible` 或 `incompatible`）；
-② 提交 DSH STORE 上架申请（monorepo 子路径：`tree/main/plugins/<name>`）并跟进机器人预检。
-若任一版本复测失败，该版本标注为 `blocked`（不兼容）并保持其余版本声明不动。
-
-**权限 / 非目标 / 边界（permissions · non-goals · boundaries）**
-- 读取：`logs/hooks.jsonl`（蒸馏输入）；写入：**仅在触发时**写睡眠报告、`logs/inbox.jsonl`（候选待办）与水位线 `sleep-state.json`；
-  失败路径**不推进水位线**（回滚语义，见测试断言）；注入失败只降级显示，不抛。
-- **统一非目标（non-goals）**：不修改 DSH 核心与官方包；不替换、禁用或遮蔽任何官方组件；不写真实 Profile（测试一律用系统临时目录）；
-  不在日志/输出里暴露凭据、完整用户文件或注入上下文。
-- **测试隔离**：所有自测只使用 `os.tmpdir()` 下的临时目录；不读写真实库（`~/.akasha`）与真实会话档案。

package/cordis.patch.yml

@@ -2,7 +2,11 @@
     - id: akasha-sleep
       name: '@akasha-book/sleep'
       config:
-        # 路径默认 ~/.akasha（见 lib/index.js 的 DEFAULTS）；调度参数如下
+        akashaDir: '<AKASHA_DIR>'
+        log: '<AKASHA_DIR>/logs\hooks.jsonl'
+        stateFile: '<AKASHA_DIR>/logs\sleep-state.json'
+        inboxFile: '<AKASHA_DIR>/logs\inbox.jsonl'
+        reportDir: '<AKASHA_DIR>/reports'
         minIntervalHours: 6
         timerCheckMs: 3600000
         contextOrder: 130

package/lib/index.js

@@ -43,7 +43,9 @@ const DEFAULTS = {
   timerCheckMs: 3600000,
   contextOrder: 130,
   pulseOrder: 132,
-  addressOrder: 133
+  addressOrder: 133,
+  preflightOrder: 135, // C1｜易错点前置
+  statefulOrder: 134   // C3｜断言前把关（order 134 < 135 ⇒ 先渲染，命中时 C1 让位）
 };
 
 /** 唤醒条是否值得推（有内容才说话）：无睡眠记录 / 有待办 / 审计有警告。 */
@@ -64,6 +66,13 @@ export function buildWakeNote(k) {
 }
 
 export function apply(ctx, config = {}) {
+
+  // A/B 实验开关（2026-10-10 用户解冻，见 docs/ab-experiment-design.md §6）：
+  // abOff=true ⇒ **关闭臂**——本插件不注册任何守卫/注入/工具，只记一行观测；库文件与日志照旧（便于事后复盘）。
+  if (config.abOff === true) {
+    try { (ctx.logger?.info ?? (() => {}))('sleep: abOff=true（A/B 关闭臂）——本插件不注册任何面'); } catch { /* 静默 */ }
+    return;
+  }
   const cfg = { ...DEFAULTS, ...config };
   const require_ = createRequire(import.meta.url);
   const reportDir = join(cfg.akashaDir, 'logs');
@@ -149,14 +158,45 @@ export function apply(ctx, config = {}) {
 
   // 回查提示（v1.5，错误钩子的注入级动作）：进程内记录近期失败（工具 / agent），窗口内幂等渲染。
   const recentFailures = [];
+  const usedTools = new Set();                                    // 本会话用过哪些工具（首用预告的判据）
+  const announcedTraps = new Set();                               // 已预告过的陷阱工具（每工具一次）
   const noteFailure = (tool) => {
     try {
       recentFailures.push({ ts: Date.now(), tool: String(tool ?? '?') });
       if (recentFailures.length > 20) recentFailures.splice(0, recentFailures.length - 20);
     } catch { /* 静默 */ }
   };
-  ctx.on('tools/result', (exec, result) => { if (result?.isError === true) noteFailure(exec?.name); });
+  // 极限观测（2026-10-11 用户令）：把「该查库了」变成**可见信号**，不靠记性——针对"200 轮后忘记查库"的观察。
+  const obs = { turn: 0, steps: 0, compactions: 0, usedToolsN: 0, lastRecallTurn: null, lastCompactionTurn: null };
+  const clip = (s) => (s.length <= 80 ? s : s.slice(0, 79) + '…');   // 行宽硬约束的统一裁剪（模块级，供多行共用）
+  const isRecallTool = (name) => /^mcp__akasha__/.test(String(name || ''));
+  ctx.on('tools/result', (exec, result) => {
+    const tool = String(exec?.name ?? '?');
+    usedTools.add(tool);                                          // 首用预告用（2026-10-11）
+    obs.usedToolsN = usedTools.size;
+    if (isRecallTool(tool)) obs.lastRecallTurn = obs.turn;         // MCP 召回 ⇒ 刷新"距上次查库"
+    else {
+      // CLI 查库也算召回（2026-10-11 实测：本会话大量查库走 `node akasha.mjs …`，只认 MCP 会显示"尚未查库"＝自欺）
+      try {
+        const blob = JSON.stringify(exec?.args ?? exec?.input ?? exec?.params ?? '');
+        if (/akasha\.mjs|session\.mjs|mcp\.mjs/.test(blob)) obs.lastRecallTurn = obs.turn;
+      } catch { /* 忽略 */ }
+    }
+    if (result?.isError === true) noteFailure(exec?.name);
+  });
   ctx.on('agent/error', () => noteFailure('agent'));
+  // 轮次与压缩真值：能拿到就用真值，拿不到就保持 0（宁缺勿假）
+  try { ctx.on('agent/turn-stopping', (p) => { if (p && typeof p.turn === 'number') obs.turn = p.turn; }); } catch { /* 事件不存在 */ }
+  try { ctx.on('agent/turn-end', (p) => { if (p && typeof p.turn === 'number') obs.turn = Math.max(obs.turn, p.turn); }); } catch { /* 事件不存在 */ }
+  try {
+    ctx.on('session/event', (p) => {
+      const t = String(p?.type ?? p?.name ?? p?.eventType ?? '');
+      if (t.startsWith('compaction/end') || (t === 'compaction' && p?.phase === 'end')) {
+        obs.compactions++;
+        obs.lastCompactionTurn = obs.turn;      // 脆弱窗判据（压缩补偿行用）
+      }
+    });
+  } catch { /* 事件不存在 */ }
 
   // 库脉搏（v1.3；v1.5 起附加回查行）：写→可见通道——并行会话 / 脚本写入库后，下一回合即可见并命名新内容。
   ctx.systemPrompt.context({
@@ -191,6 +231,269 @@ export function apply(ctx, config = {}) {
     }
   });
 
+  // C3｜断言前把关（stateful-fact gate，2026-10-10；评审 v2 定稿＝触发改到提问侧）
+  // 为什么改触发：context 行在回合开始渲染、回复尚未产生；且本插件看不到用户消息事件 ⇒
+  //   取**会话层最近一条 intent 段**（跳过注入样式的段）做 6 类关键词判定。
+  // 只提醒不阻断；statefulGate:false ⇒ 提示与事件双停。
+  const gateState = { c3Cat: null, c3At: 0, c3Fired: false };
+  if (cfg.statefulGate !== false) {
+    const STATEFUL = [
+      { cat: "发布", re: /已发布|未发布|上架|没过审|已过审|待审/ },
+      { cat: "安装", re: /已安装|未安装|装好了|装上了/ },
+      { cat: "版本", re: /版本|version/i },
+      { cat: "开关/运行", re: /开关|启用|禁用|默认开|默认关|开着|关着|在跑|跑着|还在吗|开着吗|装着吗|有没有开/ },
+      { cat: "存在", re: /是否存在|有没有|在不在|还在吗/ },
+    ];
+    ctx.systemPrompt.context({
+      name: "akasha:stateful",
+      order: cfg.statefulOrder,
+      text: () => {
+        try {
+          const path = join(cfg.akashaDir, "data", "session.jsonl");
+          const lines = readFileSync(path, "utf8").split("\n").slice(-200);
+          let gist = null;
+          for (let i = lines.length - 1; i >= 0; i--) {
+            if (!lines[i].includes("\"kind\":\"intent\"")) continue;
+            let r; try { r = JSON.parse(lines[i]); } catch { continue; }
+            const g = String(r.gist || "");
+            if (!g) continue;
+            // 规则化跳过注入段（2026-10-10 生产核对发现：除 runtime context 外还有 openviking / hindsight 等注入块被记成 intent）
+            const injected = g.startsWith("<") || g.length > 800
+              || /Current runtime context|Relevant memory from|Hindsight|openviking-context|阿卡夏·/.test(g);
+            if (injected) continue;
+            gist = g; break;
+          }
+          if (!gist) return null;
+          const hit = STATEFUL.find((k) => k.re.test(gist));
+          if (!hit) return null;
+          const now = Date.now();
+          if (gateState.c3Cat === hit.cat && now - gateState.c3At < 30 * 60 * 1000) return null;  // 同类 30 分钟去重
+          gateState.c3Cat = hit.cat; gateState.c3At = now; gateState.c3Fired = true;
+          try {
+            appendFileSync(join(cfg.akashaDir, "logs", "hooks.jsonl"),
+              JSON.stringify({ ts: new Date().toISOString(), kind: "stateful-reminder", cat: hit.cat }) + "\n", "utf8");
+          } catch { /* 事件失败不影响提示 */ }
+          return "[断言提醒] 状态性事实——先查再答（例：versions + dist-tags 两处核对）";
+        } catch { return null; }
+      }
+    });
+  }
+
+  // C1｜易错点前置（pre-flight hint，2026-10-10 解冻后实现；评审 v2 定稿）
+  // 依据：可预防漏召率 91.2%（回合级）、会话级 100% ⇒ 缺的不是知识，是"动作前把库拉进来"。
+  // 形态：一行 ≤80 字，只提示不阻断；关（preflightHints:false）则**提示与事件双停**（不写假触发）。
+  // 近似说明（如实）：context 行在**回合开始**渲染，此刻还不知道本回合会调用什么工具，
+  //   故用"最近失败的工具"作为**预提示**（近 30 分钟窗口 + 同工具去重）；"本回合尚未查库"这一前置
+  //   在渲染时无法判定，改为"上一个回合没有查库动作时更倾向提示"的弱化版（v1 取"总是可提示"，由去重与上限约束）。
+  const preflightState = { tool: null, at: 0 };
+  if (cfg.preflightHints !== false) {
+    ctx.systemPrompt.context({
+      name: 'akasha:preflight',
+      order: cfg.preflightOrder,
+      text: () => {
+        try {
+          if (gateState.c3Fired) return null;   // C3 优先（同回合只出一条）
+          const lib = require_(join(cfg.akashaDir, 'lib.mjs'));
+          const now = Date.now();
+          const WINDOW = 30 * 60 * 1000;
+          const recent = (recentFailures || []).filter((f) => now - Number(f.ts ?? f.at) <= WINDOW);  // 字段是 ts（见 noteFailure）
+          const map = lib.RECALL_TRAP_MAP || {};
+          // 2026-10-11 修复（用户裁定：反射要能随工程知识纠错与优化）：
+          //   **反射文本随条目走** —— 不再只认写死的表。
+          //   ① 链感知解析（id 或 id-rN 取链尾）；② 条目缺失/已退役 ⇒ **不打**（fail closed，不执行过期反射）；
+          //   ③ 优先用条目自带 `hint`（≤80 字反射文本：**改条目＝改反射**）；④ `hint_until` 过期 ⇒ 跳过；
+          //   ⑤ 内置表降级为**过渡兜底**；⑥ 都取不到 ⇒ 不打（宁缺勿滥）。
+          // 该表仅作过渡：条目补上 hint 后即成为唯一来源。
+          const FALLBACK_ACTIONS = {
+            'canon-trap-edit-context-mismatch': '先 read 原文再改、改完复核',
+            'canon-trap-read-offset-range': '先用 grep 拿真实行号再读',
+            'canon-trap-grep-exit2-path': '换浅范围/排除 node_modules 再 grep',
+            'canon-trap-unknown-tool-name': '只从本会话可见工具面选名字',
+            'canon-trap-provider-method-list': '先列方法清单再调用',
+          };
+          let canonRecs = [];
+          try { canonRecs = lib.currentRecords(lib.loadStore('canon').records); } catch { /* 读不到 ⇒ 只走兜底 */ }
+          const resolveEntry = (cid) => canonRecs.filter((r) => String(r.id) === cid || String(r.id).startsWith(cid + '-r')).pop() || null;
+          const isRetired = (rec) => !!rec && (/已退役|retired/i.test(String(rec.claim ?? '')) || String(rec.id).endsWith('-retired'));
+          const today = new Date().toISOString().slice(0, 10);
+          /** 某工具的首选反射：条目 `hint` 优先 → 兜底表；退役/过期/缺失一律跳过；取不到返回 null（fail closed）。
+           *  ⚠ 口径：**库可读时，条目是唯一来源**——该条目没有 hint 也**不**回落兜底（否则"退役/过期"会被兜底表救活，
+           *  等于过期反射照打）。兜底表只在**库读不到**时生效。 */
+          const hintForTool = (tool) => {
+            const ids = map[tool];
+            if (!ids || !ids.length) return null;
+            for (const cand of ids) {
+              if (canonRecs.length) {
+                const rec = resolveEntry(cand);
+                if (!rec) continue;                                       // 链上已无此条 ⇒ 跳过
+                if (isRetired(rec)) continue;                              // 已退役 ⇒ 不执行过期反射
+                if (rec.hint_until && String(rec.hint_until) < today) continue;  // 反射有效期已过 ⇒ 跳过
+                if (typeof rec.hint === 'string' && rec.hint.trim()) return { id: cand, act: rec.hint.trim(), hintSource: 'entry' };
+                continue;                                                  // 有条目但无 hint ⇒ 该候选作罢，不回落
+              }
+              if (FALLBACK_ACTIONS[cand]) return { id: cand, act: FALLBACK_ACTIONS[cand], hintSource: 'fallback' };
+            }
+            return null;
+          };
+          const emitPreflight = (payload) => {
+            try {                                                        // 事件：关闭时走不到这里（双停）
+              appendFileSync(join(cfg.akashaDir, 'logs', 'hooks.jsonl'),
+                JSON.stringify({ ts: new Date().toISOString(), kind: 'preflight', ...payload }) + '\n', 'utf8');
+            } catch { /* 事件失败不影响提示 */ }
+          };
+          const trim80 = (s) => (s.length <= 80 ? s : s.slice(0, 79) + '…');
+
+          // ① 失败驱动（原逻辑）：近 30 分钟内有过失败 ⇒ 给"那件工具"的反射
+          if (recent.length) {
+            const tool = String(recent[recent.length - 1].tool || '');
+            const fresh = !(preflightState.tool === tool && now - preflightState.at < WINDOW);  // 同工具 30 分钟去重
+            if (fresh && map[tool]) {
+              const h = hintForTool(tool);
+              if (h) {
+                preflightState.tool = tool; preflightState.at = now;
+                emitPreflight({ tool, entry: h.id, hintSource: h.hintSource, mode: 'failure' });
+                return trim80('[坑前提示] ' + tool + ' 前：' + h.act + ' —— 条目 ' + h.id);
+              }
+            }
+          }
+
+          // ② 首用预告（2026-10-11 新增；补"漏召"的结构缺口）：
+          //    渲染时**不知道本回合会用什么工具**，但知道**本会话还没用过哪些** ⇒ 逐个把"未用过的陷阱工具"预告一遍，
+          //    每个工具只预告一次（用过即止）= 把"事后回查"提前成"动手前预检"，不依赖历史失败。
+          if (cfg.preflightFirstUse !== false) {
+            const nextTool = Object.keys(map).find((t) => !usedTools.has(t) && !announcedTraps.has(t));
+            if (nextTool) {
+              const h = hintForTool(nextTool);
+              if (h) {
+                announcedTraps.add(nextTool);
+                emitPreflight({ tool: nextTool, entry: h.id, hintSource: h.hintSource, mode: 'first-use' });
+                return trim80('[坑前提示·首用] ' + nextTool + ' 还没用过：' + h.act + ' —— 条目 ' + h.id);
+              }
+            }
+          }
+          return null;
+        } catch { return null; }
+      }
+    });
+  }
+
+  // 极限观测行（2026-10-11，用户令）：轮次维度的机械钩子——把「该查库了」变成可见信号，不靠记性。
+  //   只在知道轮次时渲染（拿不到真值就保持静默，不伪造）。硬约束同 C1：**一行、≤80 字**。
+  if (cfg.extremeObs !== false) {
+    ctx.systemPrompt.context({
+      name: 'akasha:extreme',
+      order: (cfg.pulseOrder ?? 132) + 2,
+      text: () => {
+        try {
+          if (!obs.turn) return null;
+          const gap = obs.lastRecallTurn === null ? '(本进程尚未查库)' : '距今 ' + Math.max(0, obs.turn - obs.lastRecallTurn) + ' 轮';
+          // 口径标注（2026-10-11）：轮次/压缩/查库均为**本进程**统计——重启即归零；不标会被读成"整场会话"
+          const line = '[极限观测·本进程] 轮=' + obs.turn + ' 压缩=' + obs.compactions + ' 上次查库=' + gap;
+          return line.length <= 80 ? line : line.slice(0, 79) + '…';
+        } catch { return null; }
+      }
+    });
+  }
+
+  // 压缩补偿行（2026-10-11 用户方向："针对压缩轮次增加，逐步强行增加使用库查记忆进行补全"）。
+  //   依据（当晚实测）：① 压缩摘要只保话题、**丢约定**——四条核心约定存活率 0–21%，而**每回合注入的称呼层 100% 存活**；
+  //   ② 「丢记忆」实例（turn 220）落在**压缩后 15 轮内**（压缩在 205）。
+  //   ⇒ 分级补偿：**脆弱窗**（距上次压缩 ≤15 轮）要求"重要结论先落库"；**压缩 ≥3** 且本回合尚未查库 ⇒ 要求先查；
+  //   **压缩 ≥5** ⇒ 升级为强制；**查过即不再催**（闭环，避免噪音）。
+  const RECALL_WINDOW = 15;
+  if (cfg.compensate !== false) {
+    ctx.systemPrompt.context({
+      name: 'akasha:compensate',
+      order: (cfg.pulseOrder ?? 132) + 3,
+      text: () => {
+        try {
+          if (!obs.turn || !obs.compactions) return null;                  // 没压缩过 ⇒ 不打扰
+          const sinceComp = obs.lastCompactionTurn === null ? null : Math.max(0, obs.turn - obs.lastCompactionTurn);
+          const recalledRecently = obs.lastRecallTurn !== null && (obs.turn - obs.lastRecallTurn) <= 2;
+          const inWindow = sinceComp !== null && sinceComp <= RECALL_WINDOW;
+          if (obs.compactions >= 5 && !recalledRecently) {
+            return clip('[压缩补偿·强制] 本会话已压缩 ' + obs.compactions + ' 次：关键动作前先 akasha_lookup/brief 补全，再动手');
+          }
+          if (obs.compactions >= 3 && !recalledRecently) {
+            return clip('[压缩补偿] 已压缩 ' + obs.compactions + ' 次' + (inWindow ? '（脆弱窗 距上次 ' + sinceComp + ' 轮）' : '') + '：本回合先查库再答');
+          }
+          if (inWindow) {
+            return clip('[压缩补偿·脆弱窗] 距上次压缩 ' + sinceComp + ' 轮：重要结论先落库，动手前先查');
+          }
+          return null;
+        } catch { return null; }
+      }
+    });
+  }
+
+  // 核心约定常驻行（2026-10-11 用户裁定）：**防目标漂移**——压缩丢的是"我们怎么做事"（实测五条约定存活 0–21%），
+  //   而每回合注入的称呼层 100% 存活 ⇒ 把核心约定也做成**常驻**。**库驱动**：渲染时读 canon 的
+  //   `canon-core-conventions` 当前版本的 `line` 字段 ⇒ **改约定＝改条目**（不碰代码）；读不到 ⇒ 内置兜底（永不为空）。
+  //   行宽**破例放宽到 160 字**（其余行均为 80）：它是漂移锚，值得多占一行。
+  if (cfg.conventions !== false) {
+    const CONV_ID = 'canon-core-conventions';
+    const FALLBACK_CONVENTIONS = '库无界·装载有界｜来源态四标签｜修订链：追加不改原文｜零编造（红线）｜称呼：Master/大肥鱼';
+    const clipLong = (s) => (s.length <= 160 ? s : s.slice(0, 159) + '…');
+    ctx.systemPrompt.context({
+      name: 'akasha:conventions',
+      order: (cfg.pulseOrder ?? 132) + 4,
+      text: () => {
+        try {
+          const lib = require_(join(cfg.akashaDir, 'lib.mjs'));
+          const recs = lib.currentRecords(lib.loadStore('canon').records);
+          const rec = recs.filter((r) => String(r.id) === CONV_ID || String(r.id).startsWith(CONV_ID + '-r')).pop();
+          const text = (rec && typeof rec.line === 'string' && rec.line.trim()) ? rec.line.trim() : FALLBACK_CONVENTIONS;
+          return clipLong('[约定] ' + text);
+        } catch { return clipLong('[约定] ' + FALLBACK_CONVENTIONS); }
+      }
+    });
+  }
+
+  // ① 语义钩子 + 显式钩子（2026-10-11 用户令「开搞」；补设计稿 §2.4 五类钩子中缺的两类）
+  //   · **显式钩子**（"上次那个"）：读**本会话最近 intent 段**（会话层＝用户消息的摘要）⇒ 检测指代词 ⇒ 检索六库 ⇒ **一行**指路。
+  //     ⚠ 已知限制（如实）：数据源是**摘要**而非原话，摘要可能丢掉指代词 ⇒ **宁可漏触发不误触发**；
+  //       若要原话级，需让 hooks 侧记录 user-message 行（待办）。
+  //   · **语义钩子**（"当前处境作为查询"）：本会话近 30 分钟内有工具失败 ⇒ 用工具名检索六库 ⇒ **一行**指路。
+  //   两钩子**每回合最多出一行**，优先级 显式 > 语义；都无触发 ⇒ **静默**（不制造噪音）；可关 `recallHook:false`。
+  if (cfg.recallHook !== false) {
+    const PRONOUN = /(上次|之前|上回|那天|那个|说过|记得|当时|前面说|前面提)/;
+    const recentIntentGist = () => {
+      try {
+        const lib = require_(join(cfg.akashaDir, 'lib.mjs'));
+        const rows = lib.loadStore('session').records.filter((r) => r.kind === 'intent');
+        const last = rows[rows.length - 1];
+        return last ? String(last.gist || '') : '';
+      } catch { return ''; }
+    };
+    const clip120 = (s) => (s.length <= 120 ? s : s.slice(0, 119) + '…');
+    ctx.systemPrompt.context({
+      name: 'akasha:recall',
+      order: (cfg.pulseOrder ?? 132) + 5,
+      text: () => {
+        try {
+          const lib = require_(join(cfg.akashaDir, 'lib.mjs'));
+          // 显式钩子（指代）
+          const gist = recentIntentGist();
+          if (gist && PRONOUN.test(gist)) {
+            // 去掉**所有**指代词（2026-10-11 修：replace 无 g 标志时只替一次，残留「那个」会污染查询）
+            const q = gist.replace(new RegExp(PRONOUN.source, 'g'), ' ').replace(/\s+/g, ' ').trim().slice(0, 60) || gist.slice(0, 60);
+            const r = lib.lookupDetailed(q, { limit: 2, contextBudget: false });
+            const ids = (r.hits || []).map((h) => String(h.id)).slice(0, 2).join(' · ');
+            if (ids) return clip120('[指代检索] 像是问旧事 → 先看：' + ids);
+          }
+          // 语义钩子（近失败）
+          const f = recentFailures[recentFailures.length - 1];
+          if (f && obs.turn && Date.now() - f.ts < 30 * 60 * 1000) {
+            const r = lib.lookupDetailed(String(f.tool || ''), { limit: 2, contextBudget: false });
+            const top = (r.hits || [])[0];
+            if (top) return clip120('[处境检索] ' + f.tool + ' 近 30 分钟内失败过 → 相关条目 ' + top.id + '：' + String(top.snippet || '').slice(0, 42));
+          }
+          return null;
+        } catch { return null; }
+      }
+    });
+  }
+
   // 空闲触发（事件失败开放）。
   ctx.on('agent/status', (payload) => {
     try { if (payload?.status === 'idle') maybeSleep('idle'); } catch { /* 静默 */ }

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "@akasha-book/sleep",
-  "version": "1.5.4",
-  "repository": { "type": "git", "url": "https://github.com/Ersith/akasha-book.git", "directory": "plugins/akasha-sleep" },
-  "engines": { "node": ">=18" },
-  "license": "MIT",
+  "version": "1.7.1",
+  "engines": {
+    "node": ">=18"
+  },
   "type": "module",
-  "description": "阿卡夏之书睡眠器 v1.5：调度与注入（蒸馏逻辑归核心库 sleep.mjs，可手动 node akasha.mjs sleep）——空闲/定时触发 + 每回合条子 + 新会话唤醒条 + 库脉搏（写→可见通道）+ 回查提示（窗口内失败追一行）",
-  "exports": { ".": "./lib/index.js" },
-  "files": ["lib/index.js", "cordis.patch.yml", "README.md"],
-  "scripts": { "test": "node selftest.test.mjs" },
+  "description": "阿卡夏之书睡眠器 v1.5：调度与注入（蒸馏逻辑归核心库 akasha\\sleep.mjs，可手动 node akasha.mjs sleep）——空闲/定时触发 + 每回合条子 + 新会话唤醒条 + 库脉搏（写→可见通道）+ 回查提示（窗口内失败追一行，错误钩子注入级）",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/index.js",
+    "cordis.patch.yml",
+    "README.md"
+  ],
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
-    },
-    "compatibility": {
-      "dshReleases": {
-        "0.2.0-rc.2": "compatible",
-        "0.2.1-alpha.1": "compatible",
-        "0.2.1-alpha.2": "compatible"
-      }
     }
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }