@akasha-book/sleep 1.6.5 → 1.7.2

package/README.md

@@ -1,6 +1,6 @@
-# @akasha-book/sleep
+# @local/akasha-sleep
 
-阿卡夏之书睡眠器 v1.5.5 —— **调度与注入**（蒸馏逻辑归核心库 `<AKASHA_DIR>/sleep.mjs`；手动触发 `node akasha.mjs sleep [--dry]` 与之共用同一水位线）。
+阿卡夏之书睡眠器 v1.5.5 —— **调度与注入**（蒸馏逻辑归核心库 `H:\Harness\akasha\sleep.mjs`；手动触发 `node akasha.mjs sleep [--dry]` 与之共用同一水位线）。
 
 - **v1.5.5（2026-10-07 复查修复）**：移除死代码 `source==='compact'` 早退（官方 `agent/created` 的 source 只有 startup/resume；压缩信号是 session 事件 `compaction/*`）；子代理守卫沿用官方 `header.origin/delegationDepth`（已核真实字段）。
 
@@ -11,7 +11,7 @@
 - **条子三（每回合·库脉搏 + 回查）**：`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 端到端（含失败→回查行）+ 写失败线 + 无核心降级；临时目录，不碰真库水位线）。
+- 自测：`node selftest.mjs`（纯函数直测 `../akasha/sleep.mjs`——含 v1.5 `renderRecallLine`；桩 ctx 端到端（含失败→回查行）+ 写失败线 + 无核心降级；临时目录，不碰真库水位线）。
 
 ## 版本与重启
 
@@ -23,7 +23,14 @@
 ## 打包 / 安装
 
 ```powershell
-cd <LOCAL_PATH>
+cd H:\Harness\dsh-akasha-sleep
 npm pack
 # 然后：plugin_manager install_bundle <tgz 绝对路径>（首次安装会 HMR 热生效；替换需重启）
 ```
+
+
+## 源与许可（Source & License）
+
+- 源仓库：https://github.com/Ersith/akasha-book
+- 本版本固定提交（pinned commit）：`5a55099586cfae4e7511ba433eaf202455d81c30`
+- 许可证：MIT（见仓库根 LICENSE）

package/cordis.patch.yml

@@ -1,12 +1,12 @@
 - insert:
     - id: akasha-sleep
-      name: '@akasha-book/sleep'
+      name: '@local/akasha-sleep'
       config:
-        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'
+        akashaDir: 'H:\Harness\akasha'
+        log: 'H:\Harness\akasha\logs\hooks.jsonl'
+        stateFile: 'H:\Harness\akasha\logs\sleep-state.json'
+        inboxFile: 'H:\Harness\akasha\logs\inbox.jsonl'
+        reportDir: 'H:\Harness\akasha\reports'
         minIntervalHours: 6
         timerCheckMs: 3600000
         contextOrder: 130

package/lib/index.js

@@ -158,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({
@@ -266,13 +297,7 @@ export function apply(ctx, config = {}) {
           const now = Date.now();
           const WINDOW = 30 * 60 * 1000;
           const recent = (recentFailures || []).filter((f) => now - Number(f.ts ?? f.at) <= WINDOW);  // 字段是 ts（见 noteFailure）
-          if (!recent.length) return null;
-          const last = recent[recent.length - 1];
-          const tool = String(last.tool || '');
           const map = lib.RECALL_TRAP_MAP || {};
-          const ids = map[tool];
-          if (!ids || !ids.length) return null;                       // 不在映射表 ⇒ 不提示
-          if (preflightState.tool === tool && now - preflightState.at < WINDOW) return null;  // 同工具 30 分钟去重
           // 2026-10-11 修复（用户裁定：反射要能随工程知识纠错与优化）：
           //   **反射文本随条目走** —— 不再只认写死的表。
           //   ① 链感知解析（id 或 id-rN 取链尾）；② 条目缺失/已退役 ⇒ **不打**（fail closed，不执行过期反射）；
@@ -291,30 +316,184 @@ export function apply(ctx, config = {}) {
           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);
-          let id = null, act = null, hintSource = 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()) { id = cand; act = rec.hint.trim(); hintSource = 'entry'; break; }
+          /** 某工具的首选反射：条目 `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);
+              }
             }
-            if (FALLBACK_ACTIONS[cand]) { id = cand; act = FALLBACK_ACTIONS[cand]; hintSource = 'fallback'; break; }
           }
-          if (!id || !act) return null;                                 // fail closed：没有现行条目/没有反射文本 ⇒ 不打
-          const line = '[坑前提示] ' + tool + ' 前：' + act + ' —— 条目 ' + id;
-          preflightState.tool = tool; preflightState.at = now;
-          try {                                                        // 事件：关闭时走不到这里（双停）
-            appendFileSync(join(cfg.akashaDir, 'logs', 'hooks.jsonl'),   // 用文件顶部已导入的 appendFileSync
-              JSON.stringify({ ts: new Date().toISOString(), kind: 'preflight', tool, entry: id, hintSource }) + '\n', 'utf8');
-          } catch { /* 事件失败不影响提示 */ }
+
+          // ② 首用预告（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,6 +1,6 @@
 {
   "name": "@akasha-book/sleep",
-  "version": "1.6.5",
+  "version": "1.7.2",
   "engines": {
     "node": ">=18"
   },
@@ -19,7 +19,18 @@
       "patch": "./cordis.patch.yml"
     }
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "@deepseek-ai/dsh": "^0.2.0-rc.2",
+    "@deepseek-ai/cordis": "^4.0.4"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ersith/akasha-book.git",
+    "directory": "dsh-akasha-sleep"
+  },
+  "scripts": {
+    "test": "node selftest.test.mjs",
+    "check": "node --check lib/index.js"
   }
-}
+}