@akasha-book/sleep 0.0.0-stage → 1.5.1

package/README.md

@@ -1,3 +1,27 @@
-# Temporary Holding Version
+# @akasha-book/sleep
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> 阿卡夏之书（Akasha Book）· 睡眠器插件
+
+阿卡夏之书睡眠器 v1.5.1 —— **调度与注入**（蒸馏逻辑归核心库 `../../core/sleep.mjs`；手动触发 `node akasha.mjs sleep [--dry]` 与之共用同一水位线）。
+
+- **触发**：`agent/status → idle`，去抖 `minIntervalHours`（默认 6）；另一路定时兜底 `ctx.interval`（默认 1h——timer 属混入服务，需 `inject:['timer']`）。跳过也留痕（`sleep-skip`）；首次激活即跑一次（`activate`）。
+- **蒸馏**：`hooks.jsonl` 增量（水位线 `processedLines`）→ 统计 + 失败备注 + 待办（审计警告 → review；工具失败 / 拦截 / agent 错误 → 孤案候选）；报告 `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 **无法进程内热更**（模块代缓存）——升级后需重启宿主载入。
+
+## 打包 / 安装（DSH 宿主）
+
+```bash
+npm pack
+# 然后：plugin_manager install_bundle <tgz 绝对路径>（新 bundle 热生效；替换已装包需重启宿主）
+```
+
+依赖：DSH 宿主（`systemPrompt` / `timer` 服务与事件面）；核心库 `../../core/sleep.mjs` + `lib.mjs`（经 `akashaDir` 动态加载）。

package/cordis.patch.yml

@@ -0,0 +1,8 @@
+- insert:
+    - id: akasha-sleep
+      name: '@akasha-book/sleep'
+      config:
+        # 路径默认 ~/.akasha（见 lib/index.js 的 DEFAULTS）；调度参数如下
+        minIntervalHours: 6
+        timerCheckMs: 3600000
+        contextOrder: 130

package/lib/index.js

@@ -0,0 +1,190 @@
+// 阿卡夏之书睡眠器 v1.5.1 —— 调度与注入（蒸馏逻辑归核心库 sleep.mjs）。
+//   · 触发：agent/status → idle（去抖 minIntervalHours）+ 定时兜底 ctx.interval（默认 1h）
+//   · 蒸馏/复核/待办/报告/水位线：核心库 sleepRun —— 手动 `node akasha.mjs sleep` 与之共用同一水位线
+//   · 条子一：systemPrompt.context（akasha:sleep）——每回合带最近一次睡眠摘要
+//   · 条子二（唤醒条）：agent/created → agent.inject 起床包摘要（不唤醒、不打断）
+//   · 条子三（库脉搏 + 回查，v1.5）：systemPrompt.context（akasha:pulse）——六库计数 + 最近写入；
+//     窗口内（默认 30 分钟）有失败时追一行「回查提示」（错误钩子的注入级动作，不拦截）
+//   · 降级：核心库不可用 → sleep-error 观测线 + 条子提示文案，不炸、不失活。
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+export const inject = ['systemPrompt', 'timer'];
+
+// 默认值：家目录下的 .akasha（可用 config 逐项覆盖）。
+const DEFAULT_AKASHA = join(homedir(), '.akasha');
+const DEFAULTS = {
+  log: join(DEFAULT_AKASHA, 'logs', 'hooks.jsonl'),
+  akashaDir: DEFAULT_AKASHA,
+  stateFile: join(DEFAULT_AKASHA, 'logs', 'sleep-state.json'),
+  inboxFile: join(DEFAULT_AKASHA, 'logs', 'inbox.jsonl'),
+  // 宿主应用模块目录（唤醒条用的 createUserMessage 从这里加载）；留空 = 唤醒条注入跳过（其余功能不受影响）。
+  appModulesDir: '',
+  minIntervalHours: 6,
+  timerCheckMs: 3600000,
+  contextOrder: 130,
+  pulseOrder: 132
+};
+
+/** 唤醒条是否值得推（有内容才说话）：无睡眠记录 / 有待办 / 审计有警告。 */
+export function isWakeNoteworthy(k) {
+  return !k.sleep || (k.inbox?.totalItems ?? 0) > 0 || (k.review?.findings ?? []).some((f) => f.level === 'warn');
+}
+
+/** 组装「唤醒条」文本（纯函数）。 */
+export function buildWakeNote(k) {
+  const lines = ['【阿卡夏·起床包】'];
+  lines.push(`库况：canon ${k.library.canon} / mirror ${k.library.mirror} / orphan ${k.library.orphan} / pricing ${k.library.pricing} / lexicon ${k.library.lexicon} / frontier ${k.library.frontier}`);
+  lines.push(k.sleep ? `睡眠：${k.sleep.lastRunAt}（${k.sleep.trigger}）待办 ${k.sleep.todo}` : '睡眠：无记录（等待首个空闲）');
+  if ((k.inbox?.totalItems ?? 0) > 0) lines.push(`待办 inbox：${k.inbox.totalItems} 条（akasha_promote 可转正）`);
+  const warns = (k.review?.findings ?? []).filter((f) => f.level === 'warn');
+  if (warns.length) lines.push(`审计：${warns.map((f) => f.code + '×' + f.count).join('，')}`);
+  lines.push('详情：akasha_kit');
+  return lines.join('\n');
+}
+
+export function apply(ctx, config = {}) {
+  const cfg = { ...DEFAULTS, ...config };
+  const require_ = createRequire(import.meta.url);
+  const reportDir = join(cfg.akashaDir, 'logs');
+  const stateFile = cfg.stateFile || join(reportDir, 'sleep-state.json');
+  const inboxFile = cfg.inboxFile || join(reportDir, 'inbox.jsonl');
+
+  const log = (record) => {
+    try {
+      mkdirSync(dirname(cfg.log), { recursive: true });
+      appendFileSync(cfg.log, JSON.stringify({ ts: new Date().toISOString(), ...record }) + '\n', 'utf8');
+    } catch { /* 静默：观测线写不了不拖垮宿主 */ }
+  };
+  const readState = () => { try { return JSON.parse(readFileSync(stateFile, 'utf8')); } catch { return {}; } };
+
+  // 核心库（蒸馏逻辑）动态加载：插件只做调度与注入；缺文件时降级留痕（不失活）。
+  const core = () => require_(join(cfg.akashaDir, 'sleep.mjs'));
+
+  const runSleep = (trigger) => {
+    try {
+      const r = core().sleepRun({ trigger, log: cfg.log, stateFile, inboxFile, reportDir });
+      if (!r.ok) { log({ kind: 'sleep-error', trigger, message: String(r.error).slice(0, 300) }); return false; }
+      log({ kind: 'sleep-done', trigger, report: r.reportFile, todo: r.todo, counters: r.state?.lastCounters, audit: r.state?.lastAudit });
+      return true;
+    } catch (error) {
+      log({ kind: 'sleep-error', trigger, message: String(error?.message ?? error).slice(0, 300) });
+      return false;
+    }
+  };
+
+  const maybeSleep = (trigger) => {
+    try {
+      const verdict = core().shouldSleep(readState(), Date.now(), cfg.minIntervalHours);
+      if (!verdict.due) { log({ kind: 'sleep-skip', trigger, sinceHours: verdict.hoursSince }); return; }
+      runSleep(trigger);
+    } catch (error) {
+      log({ kind: 'sleep-error', trigger, message: String(error?.message ?? error).slice(0, 300) });
+    }
+  };
+
+  // 唤醒条（M6b）：新会话（agent/created）自动把「起床包」摘要递进 next-step inbox（不唤醒、不打断）。
+  // 仅当有内容（无睡眠记录 / 有待办 / 审计警告）才说话；子代理与 compact 不打扰；一切异常只留痕。
+  let createUserMessage = null;
+  let llmReady = Promise.resolve();
+  let llmSkipNote = null;
+  if (cfg.appModulesDir) {
+    llmReady = import(pathToFileURL(join(cfg.appModulesDir, '@deepseek-ai', 'dsh-llm', 'lib', 'index.js')).href)
+      .then((mod) => { if (typeof mod.createUserMessage === 'function') createUserMessage = mod.createUserMessage; })
+      .catch((error) => log({ kind: 'wake-note-llm-error', message: String(error?.message ?? error).slice(0, 200) }));
+  } else {
+    // 延迟到 armed 之后留痕：不让观测线提前污染 hooks 水位线（boot 首跑的 processedLines）
+    llmSkipNote = 'appModulesDir 未配置：唤醒条注入跳过（其余功能不受影响）';
+  }
+
+  const injectWakeNote = (agent) => {
+    try {
+      if (!agent || typeof agent.inject !== 'function' || !createUserMessage) return;
+      const k = require_(join(cfg.akashaDir, 'lib.mjs')).kit();
+      if (!isWakeNoteworthy(k)) return;
+      const message = createUserMessage({
+        content: [{ type: 'text', text: buildWakeNote(k) }],
+        source: { kind: 'akasha-wake' }
+      });
+      agent.inject(message);
+      log({ kind: 'wake-note', session: String(agent.id ?? ''), todo: k.inbox?.totalItems ?? 0, auditOk: k.review?.ok ?? null });
+    } catch (error) {
+      log({ kind: 'wake-note-error', message: String(error?.message ?? error).slice(0, 200) });
+    }
+  };
+
+  ctx.on('agent/created', (payload) => {
+    try {
+      // 2026-10-07 复查：官方 agent/created 的 source 只有 startup/resume；子代理守卫沿用 header.origin / delegationDepth。
+      const agent = payload?.agent;
+      const header = agent?.session?.header;
+      if (header?.origin === 'subagent' || (header?.delegationDepth ?? 0) > 0) return;
+      if (createUserMessage) { injectWakeNote(agent); return; }
+      void llmReady.then(() => injectWakeNote(agent));
+    } catch (error) {
+      log({ kind: 'wake-note-error', message: String(error?.message ?? error).slice(0, 200) });
+    }
+  });
+
+  // 条子：每个新回合的 runtime context 自动带上最近一次睡眠摘要（渲染自核心库，失败安全）。
+  ctx.systemPrompt.context({
+    name: 'akasha:sleep',
+    order: cfg.contextOrder,
+    text: () => {
+      try { return core().renderContextLine(readState()); }
+      catch { return '阿卡夏·睡眠：核心库不可用（akasha\\sleep.mjs 缺失或损坏）。'; }
+    }
+  });
+
+  // 回查提示（v1.5，错误钩子的注入级动作）：进程内记录近期失败（工具 / agent），窗口内幂等渲染。
+  const recentFailures = [];
+  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); });
+  ctx.on('agent/error', () => noteFailure('agent'));
+
+  // 库脉搏（v1.3；v1.5 起附加回查行）：写→可见通道——并行会话 / 脚本写入库后，下一回合即可见并命名新内容。
+  ctx.systemPrompt.context({
+    name: 'akasha:pulse',
+    order: cfg.pulseOrder,
+    text: () => {
+      try {
+        const lib = require_(join(cfg.akashaDir, 'lib.mjs'));
+        const lines = [core().renderPulseLine(lib.pulse())];
+        const recall = core().renderRecallLine(recentFailures, Date.now());
+        if (recall) lines.push(recall);
+        return lines.filter(Boolean).join('\n') || null;
+      } catch { return null; }
+    }
+  });
+
+  // 空闲触发（事件失败开放）。
+  ctx.on('agent/status', (payload) => {
+    try { if (payload?.status === 'idle') maybeSleep('idle'); } catch { /* 静默 */ }
+  });
+
+  // 定时兜底：宿主长期不空闲也能按节奏睡。
+  // ⚠️ timer 是「混入服务」：访问 ctx.interval 需要 inject:['timer']，否则属性访问本身抛出
+  //    "cannot get property \"timer\" without inject"——v1.1.0 事故：整个 apply 失败、插件静默失活。
+  //    ctx.interval 返回的停止函数再挂到本插件自己的 effect 上，卸载即停。
+  if (typeof ctx.interval === 'function') {
+    try {
+      const stop = ctx.interval(() => { try { maybeSleep('timer'); } catch { /* 静默 */ } }, cfg.timerCheckMs);
+      ctx.effect(() => () => { try { stop(); } catch { /* 静默 */ } });
+    } catch { /* 静默 */ }
+  }
+
+  // 首次激活即跑一次，此后按去抖节奏。
+  const boot = readState();
+  if (!boot.lastRunAt) runSleep('activate');
+
+  log({ kind: 'sleep-armed', pid: process.pid, minIntervalHours: cfg.minIntervalHours, timerCheckMs: cfg.timerCheckMs });
+  if (llmSkipNote) log({ kind: 'wake-note-llm-skip', message: llmSkipNote });
+}

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "@akasha-book/sleep",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.5.1",
+  "license": "MIT",
+  "type": "module",
+  "description": "阿卡夏之书睡眠器 v1.5：调度与注入（蒸馏逻辑归核心库 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"
+    }
+  }
+}