@akasha-book/session 0.2.4 → 0.3.0

package/README.md

@@ -1,12 +1,15 @@
-# @akasha-book/session（小阿卡夏）
+# @akasha-book/session（小阿卡夏）
+
+阿卡夏之书**会话层**插件 —— **自动增量索引 + 压缩事件行 + 节奏条 + 循环观测 P0（dry 干跑）**。
+核心逻辑归 `core/session.mjs` 与 `core/loop-detect.mjs`（本插件只做调度与注入；降级只留痕，不炸宿主）。
+
+- **触发**：`session/event → turn/end`（按会话去抖 `minIndexIntervalMs`，默认 30s）→ 增量索引（水位 + 指纹双幂等）；`agent/status → idle` 追平；`ctx.interval` 兜底。
+- **压缩事件行**：`session/event → compaction/end`（成功压缩）→ 先强制补索引（绕过去抖/背压）→ 观测线（带 `indexed`/`reason`）+ 节奏条点名。**只有补索引确认成功才说「已收入」**；失败时改说「可能未进会话层」并给回退（原始会话档案 / `session index`），同会话后续索引成功即改口（wave1 · B1）。
+- **循环观测 P0**：**dry 干跑——只观测、只写观测线；绝不干预**。流环＝`agent/assistant-stream` 帧按 attemptId 累积（每 480 字符对尾 8K 跑 `detectLoops`）；turn 环＝事件流缓存全文兜底；命中与帧类型探针写 `logs/hooks.jsonl`。汇总 CLI：`node akasha.mjs session loopwatch`。
+- **节奏条**：`systemPrompt.context`（`akasha:session`，order 134）——段数 / 会话数 + 回看提示；无数据静默。
+- **索引观测线**：`session-index`（added / skipped / parseFails / ms / **lagMs**＝事件循环延迟采样）/ `session-index-skip` / `session-index-error` / **`session-index-slow`**（单次索引 >1.5s 告警，含 lagMs）。
+- 配置：`akashaDir`（核心库位置）/ `sessionsRoot`（宿主会话档案目录）/ `storeFile` / `metaFile` / `log`；默认见 `lib/index.js` 的 DEFAULTS。
+- 自测：`node selftest.mjs`（桩 ctx 端到端；临时目录，不碰真实数据；需与本包 `core/` 并列）。
 
-阿卡夏之书**会话层**插件 —— **自动增量索引 + 压缩事件行 + 节奏条 + 循环观测 P0（dry 干跑）**。
-核心逻辑归 `core/session.mjs` 与 `core/loop-detect.mjs`（本插件只做调度与注入；降级只留痕，不炸宿主）。
-
-- **触发**：`session/event → turn/end`（按会话去抖 `minIndexIntervalMs`，默认 30s）→ 增量索引（水位 + 指纹双幂等）；`agent/status → idle` 追平；`ctx.interval` 兜底。
-- **压缩事件行**：`session/event → compaction/end`（成功压缩）→ 观测线 + 节奏条点名（被折叠历史的细节优先查会话层）。
-- **循环观测 P0**：**dry 干跑——只观测、只写观测线；绝不干预**。流环＝`agent/assistant-stream` 帧按 attemptId 累积（每 480 字符对尾 8K 跑 `detectLoops`）；turn 环＝事件流缓存全文兜底；命中与帧类型探针写 `logs/hooks.jsonl`。汇总 CLI：`node akasha.mjs session loopwatch`。
-- **节奏条**：`systemPrompt.context`（`akasha:session`，order 134）——段数 / 会话数 + 回看提示；无数据静默。
-- **索引观测线**：`session-index`（added / skipped / parseFails / ms / **lagMs**＝事件循环延迟采样）/ `session-index-skip` / `session-index-error` / **`session-index-slow`**（单次索引 >1.5s 告警，含 lagMs）。
-- 配置：`akashaDir`（核心库位置）/ `sessionsRoot`（宿主会话档案目录）/ `storeFile` / `metaFile` / `log`；默认见 `lib/index.js` 的 DEFAULTS。
-- 自测：`node selftest.mjs`（桩 ctx 端到端；临时目录，不碰真实数据；需与本包 `core/` 并列）。
+- **索引 worker 化（2026-10-10 · 计划队列 v0.4 项）**：宿主回调只投递（`postMessage`，µs 级返回），索引在**常驻 worker 线程**（`lib/index-worker.mjs`，插件加载即预热）串行执行、同会话排队去重；`indexSession` 以 `metaFile` 为锁对象串行化整段「读水位 → 追加 → 记账」（`core/lib.mjs` 的 `withFileLock`；**锁 meta 而非 store**——`appendSegments` 内部已持 store 锁，嵌套会死等）。退出协议：dispose → `{"type":"quit"}` → drain → 关闭（5s 兜底强杀）。降级链：`indexMode: 'worker' | 'inline'`（默认 worker；**连续** 3 次失败自动降级，任何成功回零）。
+- **观测语义（worker 化后）**：`session-index` 新增 `via`（worker/inline）与 `hostMs`（宿主投递耗时）；**`session-index-slow` 的含义变为「后台耗时 >1.5s」**——宿主卡顿请看 `hostMs` / `lagMs`。

package/lib/index-worker.mjs

@@ -0,0 +1,72 @@
+// index-worker.mjs —— 小阿卡夏 v0.4 索引 worker（worker_threads 入口）。
+// 协议（宿主 → worker）：{type:'index', id, job:{akashaDir,session,file,storeFile,metaFile,trigger,full}}
+//                        {type:'quit'} / {type:'ping'}
+// 协议（worker → 宿主）：{type:'ready'} / {type:'pong'} / {type:'result', id, session, trigger, ms, ...stats|error}
+// 语义：FIFO 串行；同 session 排队去重（保留最新一条）；quit 时 drain 当前 job 后关闭。
+import { parentPort } from 'node:worker_threads';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+
+const require_ = createRequire(import.meta.url);
+let core = null;
+let coreDir = '';
+function coreOf(akashaDir) {
+  if (!core || coreDir !== akashaDir) {
+    core = require_(join(akashaDir, 'session.mjs'));
+    coreDir = akashaDir;
+  }
+  return core;
+}
+
+const queue = [];
+const queuedBySession = new Set();
+let running = false;
+let quitting = false;
+let processed = 0;
+
+function enqueue(job) {
+  if (queuedBySession.has(job.session)) {
+    // 同会话已在排队：保留最新一份（旧 job 丢弃；水位/去重保证不漏段）
+    for (let i = queue.length - 1; i >= 0; i--) if (queue[i].session === job.session) { queue.splice(i, 1); break; }
+    queuedBySession.delete(job.session);
+  }
+  queue.push(job);
+  queuedBySession.add(job.session);
+  parentPort.postMessage({ type: 'queued', id: job.id, session: job.session, depth: queue.length, running });
+  if (!running) drain();
+}
+
+function drain() {
+  running = true;
+  const job = queue.shift();
+  if (!job) {
+    running = false;
+    if (quitting) { parentPort.postMessage({ type: 'bye', processed }); parentPort.close(); }
+    return;
+  }
+  queuedBySession.delete(job.session);
+  const t0 = Date.now();
+  try {
+    const stats = coreOf(job.akashaDir).indexSession({
+      file: job.file, session: job.session,
+      storeFile: job.storeFile, metaFile: job.metaFile, full: !!job.full,
+    });
+    processed += 1;
+    parentPort.postMessage({ type: 'result', id: job.id, session: job.session, trigger: job.trigger, ms: Date.now() - t0, depth: queue.length, ...stats });
+  } catch (error) {
+    parentPort.postMessage({ type: 'result', id: job.id, session: job.session, trigger: job.trigger, ms: Date.now() - t0, depth: queue.length, error: String(error?.message ?? error).slice(0, 300) });
+  }
+  setImmediate(drain);
+}
+
+parentPort.on('message', (msg) => {
+  if (!msg || typeof msg !== 'object') return;
+  if (msg.type === 'index' && msg.job?.session) enqueue({ ...msg.job, id: msg.id });
+  else if (msg.type === 'ping') parentPort.postMessage({ type: 'pong', depth: queue.length, running });
+  else if (msg.type === 'quit') {
+    quitting = true;
+    if (!running && queue.length === 0) { parentPort.postMessage({ type: 'bye', processed }); parentPort.close(); }
+  }
+});
+
+parentPort.postMessage({ type: 'ready', pid: process.pid, node: process.version });

package/lib/index.js

@@ -1,4 +1,4 @@
-// 阿卡夏之书会话层插件 v0.2（@akasha-book/akasha-session）—— 自动增量索引 + 压缩事件行 + 节奏条 + 循环观测 P0（dry）。
+// 阿卡夏之书会话层插件 v0.2（@akasha-book/session）—— 自动增量索引 + 压缩事件行 + 节奏条 + 循环观测 P0（dry）。
 //   · 核心逻辑归 ~/.akasha/session.mjs（插件只做调度与注入；降级只留痕，不炸宿主）
 //   · 观测线（hooks.jsonl）：session-armed / session-index / session-index-skip / session-index-error / session-compact
 //     + 循环观测（P0 干跑，2026-10-07）：loop-watch / loop-watch-probe —— **只观测、绝不干预**（不 steer / 不 cancel / 不注入）
@@ -8,6 +8,7 @@ import { appendFileSync, mkdirSync, readFileSync, statSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { Worker } from 'node:worker_threads';
 
 export const inject = ['systemPrompt', 'timer'];
 
@@ -24,7 +25,9 @@ const DEFAULTS = {
   contextOrder: 134,
   loopWatch: true,
   watchMinChars: 200,
-  watchCheckEvery: 480
+  watchCheckEvery: 480,
+  indexMode: 'worker',          // 'worker'（v0.4 默认）| 'inline'（回退）
+  workerRespawnMs: 15000
 };
 
 /** 去抖判定（纯函数）。 */
@@ -37,7 +40,19 @@ export function effectiveThrottle(size, baseMs) {
   return size > 16 * 1024 * 1024 ? baseMs * 4 : baseMs;
 }
 
-/** 节奏条渲染（纯函数）：段数/会话数 + 回看提示；压缩窗口内追一行。无数据 → null（静默）。 */
+/** 压缩后补索引失败时的原因短语（给节奏条用；未知原因如实写「未确认」）。 */
+const COMPACT_FAIL_REASON = {
+  'not-found': '未找到会话档案',
+  backoff: '近期索引失败、处于背压窗口',
+  error: '索引出错',
+  'no-session': '事件缺会话 id'
+};
+
+/**
+ * 节奏条渲染（纯函数）：段数/会话数 + 回看提示；压缩窗口内追一行。无数据 → null（静默）。
+ * B1（2026-10 wave1）：只有「最近一次压缩的补索引确认成功」（compacts[i].indexed === true）才可说「已收入」；
+ * 失败 / 未确认（含旧格式条目无 indexed 字段）一律改说「可能未进会话层」并给回退路径——提示行不得替索引作伪证。
+ */
 export function renderSessionLine(state, now) {
   const sessions = state?.meta?.sessions ?? {};
   const ids = Object.keys(sessions);
@@ -51,7 +66,13 @@ export function renderSessionLine(state, now) {
     const last = compacts[compacts.length - 1];
     const s = state?.meta?.sessions?.[last?.session];
     const counts = s ? `（该会话已索引 ${Number(s.segments ?? 0)} 段 · 结论 ${Number(s.conclusions ?? 0)} 条）` : '';
-    lines.push(`⚠ 近期发生压缩（${compacts.length} 次）——本段历史已收入会话层${counts}；细节查 akasha_session_lookup`);
+    if (last?.indexed === true) {
+      lines.push(`⚠ 近期发生压缩（${compacts.length} 次）——本段历史已收入会话层${counts}；细节查 akasha_session_lookup`);
+    } else {
+      const why = COMPACT_FAIL_REASON[last?.reason] ?? '补索引未确认';
+      lines.push(`⚠ 近期发生压缩（${compacts.length} 次），但压缩后补索引未成功（${why}）——这段历史可能未进会话层；` +
+        `勿凭会话层断言「查无此事」，回看请查原始会话档案，或手动 node akasha.mjs session index <会话id>`);
+    }
   }
   return lines.join('\n');
 }
@@ -223,20 +244,118 @@ export function apply(ctx, config = {}) {
     }
   };
 
-  const indexNow = (sidIn, trigger, extra = {}) => {
+  // 某会话索引成功 → 该会话窗口内「补索引未确认」的压缩条目改记为已收入（档案是全量的，后补成功即真收入）。
+  const settleCompacts = (sid, trigger) => {
+    for (const c of compacts) if (c.session === sid && c.indexed !== true) { c.indexed = true; c.reason = 'recovered'; c.recoveredBy = trigger; }
+  };
+
+  // ---------- 索引 worker（v0.4）：宿主只投递任务，重活在后台线程串行跑 ----------
+  //   协议见 lib/index-worker.mjs；降级链：worker → （连续失败或 spawn 失败）→ inline 旧路径。
+  const workerUrl = new URL('./index-worker.mjs', import.meta.url);
+  let worker = null;
+  let workerFails = 0;
+  let workerMode = cfg.indexMode === 'inline' ? 'inline' : 'worker';
+  let quitting = false;
+  let respawnTimer = null;
+  let jobSeq = 0;
+  const pendingJobs = new Map(); // id -> { sid, trigger, extra, hostMs, stat }
+
+  const queueDepth = () => pendingJobs.size;
+
+  const scheduleRespawn = () => {
+    if (respawnTimer || quitting || workerMode !== 'worker') return;
+    respawnTimer = setTimeout(() => { respawnTimer = null; spawnWorker(); }, cfg.workerRespawnMs);
+    if (typeof respawnTimer.unref === 'function') respawnTimer.unref();
+  };
+
+  const onWorkerMessage = (msg) => {
+    if (!msg || typeof msg !== 'object') return;
+    if (msg.type === 'ready') { log({ kind: 'session-worker', event: 'ready', node: msg.node }); return; }
+    if (msg.type === 'queued') { log({ kind: 'session-worker', event: 'queued', session: msg.session, depth: msg.depth, running: msg.running }); return; }
+    if (msg.type === 'bye') { log({ kind: 'session-worker', event: 'bye', processed: msg.processed }); return; }
+    if (msg.type !== 'result') return;
+    const p = pendingJobs.get(msg.id);
+    pendingJobs.delete(msg.id);
+    const extra = p?.extra ?? {};
+    if (msg.error) {
+      lastFailAt.set(msg.session, Date.now());
+      log({ kind: 'session-index-error', session: msg.session, trigger: msg.trigger, message: msg.error, workerMs: msg.ms, hostMs: p?.hostMs ?? null, via: 'worker' });
+      return;
+    }
+    if (p?.stat) lastStat.set(msg.session, { size: p.stat.size, mtimeMs: p.stat.mtimeMs }); // 只记成功：失败后同档可重试
+    workerFails = 0; // 「连续失败」语义：任何一次成功都回零（2026-10-10 复查修正）
+    log({ kind: 'session-index', session: msg.session, trigger: msg.trigger, turn: extra.turn ?? null, added: msg.added, skipped: msg.skipped, parseFails: msg.parseFails, frameFails: msg.frameFails ?? 0, ms: msg.ms, hostMs: p?.hostMs ?? null, lagMs: loopLagMs, via: 'worker' });
+    if (msg.ms > 1500) log({ kind: 'session-index-slow', session: msg.session, trigger: msg.trigger, ms: msg.ms, lagMs: loopLagMs, added: msg.added, via: 'worker' });
+    settleCompacts(msg.session, msg.trigger);
+  };
+
+  function spawnWorker() {
+    if (workerMode !== 'worker' || worker || quitting) return;
+    try {
+      worker = new Worker(workerUrl);
+      worker.unref?.();
+      log({ kind: 'session-worker', event: 'spawn', pid: process.pid, pending: queueDepth() });
+      worker.on('message', (msg) => { try { onWorkerMessage(msg); } catch { /* 观测失败不拖宿主 */ } });
+      worker.on('error', (err) => {
+        log({ kind: 'session-worker-error', event: 'error', message: String(err?.message ?? err).slice(0, 300) });
+        worker = null;
+        workerFails += 1;
+        if (workerFails >= 3) { workerMode = 'inline'; log({ kind: 'session-worker', event: 'degraded-inline', fails: workerFails }); }
+        else scheduleRespawn();
+      });
+      worker.on('exit', (code) => {
+        const lost = pendingJobs.size;
+        if (lost) pendingJobs.clear();
+        log({ kind: 'session-worker', event: 'exit', code, lost, quitting });
+        worker = null;
+        if (!quitting) scheduleRespawn();
+      });
+    } catch (e) {
+      worker = null;
+      log({ kind: 'session-worker-error', event: 'spawn', message: String(e?.message ?? e).slice(0, 300) });
+    }
+  }
+  spawnWorker(); // 预热：apply 即起线程，首单不付冷启动
+
+  /** 投递一个索引任务；返回 { queued:true, hostMs } 或 { queued:false }（走 inline 回退）。 */
+  const dispatchIndex = (sid, file, trigger, extra, opts, st) => {
+    if (workerMode !== 'worker') return { queued: false };
+    spawnWorker();
+    if (!worker) return { queued: false };
+    const id = ++jobSeq;
+    const t0 = Date.now();
+    try {
+      worker.postMessage({ type: 'index', id, job: { akashaDir: cfg.akashaDir, session: sid, file, storeFile: cfg.storeFile, metaFile: cfg.metaFile, trigger, full: !!opts.full } });
+      const hostMs = Date.now() - t0;
+      pendingJobs.set(id, { sid, trigger, extra, hostMs, stat: st });
+      return { queued: true, hostMs };
+    } catch (e) {
+      workerFails += 1;
+      log({ kind: 'session-worker-error', event: 'post', message: String(e?.message ?? e).slice(0, 200) });
+      if (workerFails >= 3) { workerMode = 'inline'; log({ kind: 'session-worker', event: 'degraded-inline', fails: workerFails }); }
+      return { queued: false };
+    }
+  };
+
+  /**
+   * 返回索引结论（B1）：{ ok:true, reason:'indexed'|'unchanged' } = 档案内容已在会话层；
+   * { ok:false, reason:'no-session'|'backoff'|'not-found'|'error' } = 没收进去；
+   * { ok:null, reason:'debounced' } = 去抖跳过（不作结论）。opts.force（压缩路径）绕过去抖与失败背压。
+   */
+  const indexNow = (sidIn, trigger, extra = {}, opts = {}) => {
     const sid = String(sidIn ?? '').replace(/^session-/, ''); // 前缀归一：宿主事件常见 'session-<id>'，目录 / 记账恒用裸 id
     try {
-      if (!sid) return; // 空 id：静默跳过（正常路径不出现；见 README 降级节）
+      if (!sid) return { ok: false, reason: 'no-session' }; // 空 id：静默跳过（正常路径不出现；见 README 降级节）
       const now = Date.now();
-      if (now - (lastFailAt.get(sid) ?? 0) < FAIL_BACKOFF_MS) return; // 失败背压：窗口内静默
+      if (!opts.force && now - (lastFailAt.get(sid) ?? 0) < FAIL_BACKOFF_MS) return { ok: false, reason: 'backoff' }; // 失败背压：窗口内静默
       const file = core().resolveSessionFile(cfg.sessionsRoot, sid);
-      if (!file) { lastFailAt.set(sid, now); log({ kind: 'session-index-error', session: sid, trigger, message: '未找到会话档案' }); return; }
+      if (!file) { lastFailAt.set(sid, now); log({ kind: 'session-index-error', session: sid, trigger, message: '未找到会话档案' }); return { ok: false, reason: 'not-found' }; }
       lastFailAt.delete(sid);
       let st = null;
       try { st = statSync(file); } catch { /* stat 失败 → 走全量 */ }
-      if (!shouldIndex(lastIndexedAt.get(sid) ?? 0, now, effectiveThrottle(st?.size ?? 0, cfg.minIndexIntervalMs))) {
+      if (!opts.force && !shouldIndex(lastIndexedAt.get(sid) ?? 0, now, effectiveThrottle(st?.size ?? 0, cfg.minIndexIntervalMs))) {
         log({ kind: 'session-index-skip', session: sid, trigger, sinceMs: now - (lastIndexedAt.get(sid) ?? 0) });
-        return;
+        return { ok: null, reason: 'debounced' };
       }
       // 设计：去抖标记先置位——索引失败后 30s 内不重试（错误背压）；统一失败窗口见 lastFailAt
       lastIndexedAt.set(sid, now);
@@ -245,20 +364,30 @@ export function apply(ctx, config = {}) {
         const prev = lastStat.get(sid);
         if (prev && prev.size === st.size && prev.mtimeMs === st.mtimeMs) {
           log({ kind: 'session-index-skip', session: sid, trigger, reason: 'unchanged' });
-          return;
+          settleCompacts(sid, trigger);
+          return { ok: true, reason: 'unchanged' };
         }
       }
       const t0 = Date.now();
+      const disp = dispatchIndex(sid, file, trigger, extra, opts, st);
+      if (disp.queued) {
+        // 宿主只投递（v0.4）：结果由 worker 回传，落地线条在 onWorkerMessage
+        return { ok: null, reason: 'queued', hostMs: disp.hostMs };
+      }
+      // 回退：inline 旧路径（indexMode:'inline' / worker 不可用 / 连续失败降级）
       const r = core().indexSession({ file, session: sid, storeFile: cfg.storeFile, metaFile: cfg.metaFile });
       if (st) lastStat.set(sid, { size: st.size, mtimeMs: st.mtimeMs }); // 只记成功：失败后同档可重试
       const dur = Date.now() - t0;
-      log({ kind: 'session-index', session: sid, trigger, turn: extra.turn ?? null, added: r.added, skipped: r.skipped, parseFails: r.parseFails, frameFails: r.frameFails ?? 0, ms: dur, lagMs: loopLagMs });
-      if (dur > 1500) log({ kind: 'session-index-slow', session: sid, trigger, ms: dur, lagMs: loopLagMs, added: r.added }); // >1.5s 告警线（2026-10-07 补4）
+      log({ kind: 'session-index', session: sid, trigger, turn: extra.turn ?? null, added: r.added, skipped: r.skipped, parseFails: r.parseFails, frameFails: r.frameFails ?? 0, ms: dur, lagMs: loopLagMs, via: 'inline' });
+      if (dur > 1500) log({ kind: 'session-index-slow', session: sid, trigger, ms: dur, lagMs: loopLagMs, added: r.added, via: 'inline' }); // >1.5s 告警线（2026-10-07 补4）
+      settleCompacts(sid, trigger);
+      return { ok: true, reason: 'indexed', added: r.added };
     } catch (error) {
       const msg = String(error?.message ?? error);
       const hint = /not yet fully loaded|does not provide an export named|Cannot find module/.test(msg) ? '（疑似宿主模块代缓存——重启桌面端后恢复）' : '';
       lastFailAt.set(sid, Date.now());
       log({ kind: 'session-index-error', session: sid, trigger, message: (msg + hint).slice(0, 300) });
+      return { ok: false, reason: 'error' };
     }
   };
 
@@ -268,9 +397,13 @@ export function apply(ctx, config = {}) {
       if (event?.type === 'turn/end') indexNow(String(session?.id ?? ''), 'turn-end', { turn: event?.data?.turn ?? null });
       else if (event?.type === 'compaction/end' && event?.data?.error === void 0) {
         const sid = String(session?.id ?? '').replace(/^session-/, '');
-        compacts.push({ session: sid, ts: Date.now() });
+        // 先索引再宣称「已收入」（2026-10 复查）；B1（wave1）：宣称与否取决于索引结论——
+        // 压缩是稀有且关键的时刻，force 绕过去抖/背压强制补一次；失败如实记 indexed:false，节奏条不说「已收入」。
+        const res = indexNow(sid, 'compaction', {}, { force: true }) ?? { ok: false, reason: 'error' };
+        const indexed = res.ok === true;
+        compacts.push({ session: sid, ts: Date.now(), indexed, reason: res.reason });
         if (compacts.length > 20) compacts.splice(0, compacts.length - 20);
-        log({ kind: 'session-compact', session: sid });
+        log({ kind: 'session-compact', session: sid, indexedFirst: true, indexed, reason: res.reason });
       }
     } catch { /* 静默 */ }
   });
@@ -300,6 +433,15 @@ export function apply(ctx, config = {}) {
     } catch { /* 静默 */ }
   }
 
+  // 退出协议（v0.4）：通知 worker drain 后关闭；5s 未退则强杀。
+  ctx.effect(() => () => {
+    quitting = true;
+    try { worker?.postMessage({ type: 'quit' }); } catch { /* ignore */ }
+    const w = worker;
+    const t = setTimeout(() => { try { w?.terminate(); } catch { /* ignore */ } }, 5000);
+    if (typeof t.unref === 'function') t.unref();
+  });
+
   // 条子：每回合一行（无内容静默）。
   ctx.systemPrompt.context({
     name: 'akasha:session',

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@akasha-book/session",
-  "version": "0.2.4",
+  "version": "0.3.0",
+  "engines": { "node": ">=22.15.0" },
   "license": "MIT",
   "type": "module",
   "description": "小阿卡夏：会话层插件 —— 自动增量索引（turn/end 去抖）+ 压缩事件行 + 每回合节奏条 + 循环观测 P0（dry 干跑，只观测不干预）",
@@ -9,6 +10,7 @@
   },
   "files": [
     "lib/index.js",
+    "lib/index-worker.mjs",
     "cordis.patch.yml",
     "README.md"
   ],