memory-eternal 0.8.0 → 0.9.1

package/README.en.md

@@ -37,6 +37,14 @@ dsh plugin --profile web add memory-eternal
 
 # or update directly in the profile (pnpm workspace). Use pnpm — `npm install` throws EUNSUPPORTEDPROTOCOL
 cd ~/.dsh/profiles/web && pnpm add memory-eternal@latest
+
+# right after a release, @latest can be held back by pnpm's minimum-release-age gate or a cached
+# packument (it silently stays on the old version): pin the version instead — pnpm adds it to the
+# workspace's minimumReleaseAgeExclude automatically
+cd ~/.dsh/profiles/web && pnpm add memory-eternal@0.9.0
+
+# verify the version, then restart dsh web
+node -e "console.log(require('memory-eternal/package.json').version)"
 ```
 
 After **restarting dsh web**, three things are live immediately:
@@ -169,8 +177,21 @@ Top of the config page: **🟢 A Light / 💰 B Budget / ⭐ C Premium** — cli
 
 ---
 
+## 🔔 Capture Log & Failure Alerts
+
+Auto-capture is a silent background pipeline: when it broke, the only symptom used to be "no new cards" with no visible cause. Since v0.9.0 it speaks up.
+
+- **Capture log**: Settings → Memory → Usage / Today shows the last 100 run entries: `🚀 boot` / `👂 session attached (which event API + event count)` / `✅ card created` / `➕ update appended` / `⏭ skipped (reason)` / `❌ failed (reason)`.
+- **Active alerts**: any failure turns the strip red at the top of the memory library *and* injects "auto-capture failed + reason" into the agent context, so the agent tells you in its first sentence — no need to dig through logs.
+- **Stall watchdog**: if turns start but no turn-stopping event arrives for 15 minutes (e.g. DSH renamed the event), a 10-minute sweep reports it.
+- **Self-adapting event API**: the session event API is detected automatically (`ownEvents()` → `snapshotEvents()` → `events`), so a DSH upgrade that changes the API can no longer silently break capture.
+
+---
+
 ## 🛡️ Audit Center & Recycle Bin
 
+> **Agents cannot approve on your behalf (since v0.9.1).** Whenever audit is active, the plugin injects a red line into the agent context: new cards stay `pending`, and calling the `approve`/`reject` endpoints (or any equivalent bypass) is forbidden. The decision is always yours.
+
 New cards go to the **Audit Center** (`pending`) by default and enter the main vault only after you approve them; rejected ones move to "Rejected", where you can restore or delete to the recycle bin. Cards matching an exemption (audit mode = skip all / exempt agents / exempt kinds) go straight in; recycle-bin cards are recoverable within 30 days, then auto-purged.
 
 <p align="center">
@@ -221,6 +242,22 @@ npm run build   # builds lib/client.js (DSH embed) + web/app.js (standalone web
 
 ---
 
+## 📋 Changelog
+
+| Version | Date | Highlights |
+|---|---|---|
+| **v0.9.1** | 2026-09-12 | **Performance & UX batch**: memory page loads lazily per view (opening Settings no longer drags in 250KB of cards + 890KB of graph; first paint needs ~0.5KB); graph generation **3232ms → 43ms** (bigram sets computed once + lossless mathematical-bound pruning + tag inverted index) plus a server-side cache with **fingerprint invalidation** (write/audit/delete rebuilds immediately, no stale reads); site-wide **brotli q5** (graph 877KB → **54KB**, 34% smaller than gzip; cards 246KB → 83KB → 20KB with br) and large responses compressed with both br and gzip keeping the smaller, so no response is ever worse than gzip; `/cards` gained **real pagination** (offset/limit/total + server-side title sort, globally ordered across pages) loading 100 cards first and fetching more on scroll; the "Agent cards" panel in Usage/Today filters by agent server-side (30 rows); **audit red line**: the plugin injects "never call approve/reject on the user's behalf" into the agent context; the watchdog now **reaps redundant instances on fallback ports** (a duplicate web process holding 76MB was reaped in testing) |
+| **v0.9.0** | 2026-09-12 | **Fixed silent auto-capture death (6 days without a single card)**: after a DSH upgrade the session event API moved from `events` to `ownEvents()/snapshotEvents()`; the listener read nothing, returned silently and left no trace — now it tries `ownEvents()` → `snapshotEvents()` → `events` and logs a per-session attach entry. Daily quota now counts **real writes only** (previously every "not worth saving" verdict burned quota, exhausting the 24h budget after 40 attempts); `captureCooldownMs` actually applies; a single capture input is tail-capped at 20k chars. New **capture log** panel and **active failure alerts** (red strip + agent-context injection + turn-stopping stall sweep). Removed the automatic "Daily review" digest (timer / `/todayBrief` route / UI button). |
+| **v0.8.0** | 2026-09-06 | **Full UI i18n**: follows the DSH system language live (zh/en) across cards, graph, audit center, config panel and new-card templates; SQLite EBUSY fix for the Windows test suite |
+| **v0.3.1** | 2026-09-03 | Knowledge graph loads on demand (fetch on open, unregister on close) |
+| **v0.3.0** | 2026-09-03 | **SQLite storage layer** (`node:sqlite`, zero deps) + DB-level audit guard `enforceAudit()` + `audit_log` table + automatic `.md` migration |
+| v0.2.0 | 2026-09-03 | Recall with body text (`search()` returns the `excerpt` field) |
+| v0.1.2 | 2026-09-03 | Audit guard hardening (`writeCard` defaults to `pending`, `mergeCards` goes through audit) |
+| v0.1.1 | 2026-09-03 | Recall body fix (`excerpt` field + body logic) |
+| v0.1.0 | 2026-08-31 | First release: auto capture + auto recall + graphical knowledge base + knowledge graph + audit center + recycle bin |
+
+---
+
 ## 📄 License
 
 MIT

package/README.md

@@ -37,6 +37,13 @@ dsh plugin --profile web add memory-eternal
 
 # 或直接在 profile（pnpm workspace）里更新。注意用 pnpm，npm install 会报 EUNSUPPORTEDPROTOCOL
 cd ~/.dsh/profiles/web && pnpm add memory-eternal@latest
+
+# 刚发新版时 @latest 可能被 pnpm 的最小发布年龄门槛/元数据缓存挡住（静默停在旧版）：
+# 直接指定版本号最快，pnpm 会自动把它加进 workspace 的 minimumReleaseAgeExclude
+cd ~/.dsh/profiles/web && pnpm add memory-eternal@0.9.0
+
+# 验版本（应等于上面装的号），然后重启 dsh web 生效
+node -e "console.log(require('memory-eternal/package.json').version)"
 ```
 
 **重启 dsh web** 后，三样东西立即生效：
@@ -181,6 +188,17 @@ dsh-memory watchdog [--port 7799]    # 看门狗保活 web（独立进程）
 
 ---
 
+## 🔔 自动沉淀日志 & 异常提示
+
+自动沉淀是后台静默管线：一旦坏了，以前只能表现为「卡不再增加」，看不出原因。v0.9.0 起它会自己说话。
+
+- **自动沉淀日志**：设置 → 记忆 → 用量/今日，最近 100 条运行轨迹：`🚀 启动` / `👂 会话接入（用的事件接口 + 事件数）` / `✅ 新建卡` / `➕ 追加更新` / `⏭ 跳过（原因）` / `❌ 失败（原因）`。
+- **异常主动提示**：出现失败即亮红——记忆库页面顶部红条，同时把「自动沉淀异常 + 原因」注入 Agent 上下文，Agent 会在回复第一句提醒你，不需要你自己去翻日志。
+- **停滞兜底**：有轮次开始、15 分钟收不到收尾事件（例如 DSH 改了事件名），10 分钟巡检直接报出来。
+- **接口自适应**：自动识别 DSH 会话事件接口（`ownEvents()` → `snapshotEvents()` → `events`），DSH 升级换 API 不会再静默断掉。
+
+---
+
 ## 🛡️ 审核中心 & 回收中心
 
 新卡默认进**审核中心**（`pending`），由你确认后才入主库；驳回的进「已驳回」，可恢复或删除进回收站。命中免审条件（审核模式=全部免审 / 免审智能体 / 免审类型）的新卡直接入库；回收站软删卡 30 天内可恢复，超期自动永久删除。
@@ -193,6 +211,7 @@ dsh-memory watchdog [--port 7799]    # 看门狗保活 web（独立进程）
 
 - **待审核 / 已驳回** 双页签，按类型 / 日期 / 智能体筛选，全选后一键「批准 / 驳回 / 删除进回收站」。
 - 审核规则在「记忆配置 → 自动审核配置」：`审核模式`（全部要审 / 全部免审）+ `免审智能体` + `免审类型` + `回收保留天数`。
+- **Agent 不能代你审批（v0.9.1 起）**：只要审核生效，插件就往 Agent 的上下文里注入红线——新卡只能停在「待审核」，并明确禁止调用 `approve`/`reject` 接口或任何等价方式绕过；判断权始终在你手里。
 
 ### 🥇 为什么审核系统更靠谱（对比其它记忆产品）
 
@@ -240,6 +259,8 @@ npm run build   # 构建 lib/client.js（DSH 内嵌）+ web/app.js（独立 web
 
 | 版本 | 日期 | 关键改动 |
 |---|---|---|
+| **v0.9.1** | 2026-09-12 | **性能与体验批次**：记忆页按视图**懒加载**（打开「设置」不再顺带拉 250KB 卡片 + 890KB 图谱，首屏只需约 0.5KB）；知识图谱生成 **3232ms → 43ms**（bigram 集合只算一次 + 数学上界剪枝无损跳过 + 标签倒排），并加**指纹精确失效**的服务端缓存（写卡/审核/删卡立即重建，无脏读）；全站 **brotli q5**（图谱 877KB → **54KB**，比 gzip 再小 34%；卡片 246KB → 83KB → br 20KB），大响应体同时压 br + gzip 取更小者，保证任何响应都不比 gzip 差；`/cards` 支持**真分页**（offset/limit/total + 服务端标题排序，跨页全局有序），首屏只拉 100 条、滚到底续拉；「用量/今日」的 Agent 卡清单改为服务端署名过滤（30 条）；**审核红线**：插件在 Agent 上下文注入「禁止调用 approve/reject 代用户审批」；watchdog **回收备用端口的多余实例**（实测清掉一个常驻 76MB 的重复 web 进程） |
+| **v0.9.0** | 2026-09-12 | **修复自动沉淀静默失效（一连 6 天不写卡）**：DSH 升级后会话事件接口由 `events` 改为 `ownEvents()/snapshotEvents()`，监听器读不到事件后静默返回、不留任何痕迹 —— 现改为三级自适应取法（`ownEvents()` → `snapshotEvents()` → `events`）+ 每会话接入留痕；日配额改为**只统计真实写卡**（此前「不值得保存」的判定也照样扣配额，40 次即耗尽 24h 配额）、`captureCooldownMs` 冷却真正生效、单次沉淀输入截尾 20000 字；新增**自动沉淀日志**面板与**异常主动提示**（页面红条 + 注入 Agent 上下文 + 轮次收尾停滞巡检）；移除「每日回顾」自动简报（定时器 / `/todayBrief` 接口 / UI 按钮） |
 | **v0.8.0** | 2026-09-06 | **全套 UI i18n**：跟随 DSH 系统语言实时切换（中/英），覆盖知识卡 / 知识图谱 / 审核中心 / 配置面板 / 新建卡模板；Windows 测试收尾 SQLite 连接 EBUSY 修复 |
 | **v0.3.1** | 2026-09-03 | 知识图谱按需加载（点击时 fetch，关闭时注销） |
 | **v0.3.0** | 2026-09-03 | **SQLite 化存储层**（`node:sqlite` 零依赖）+ 数据库层审核守卫 `enforceAudit()` + `audit_log` 审计日志 + 自动从 .md 迁移 |

package/index.js

@@ -25,10 +25,10 @@ const PACKAGE_ROOT = path.resolve(path.dirname(__filename))
 const versionRef = (() => { try { const p = JSON.parse(readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8')); return p.version } catch { return '' } })()
 import z from '@deepseek-ai/schemastery'
 import { defineTool } from '@deepseek-ai/dsh-tools'
-import { ensureVault, search, generateDailyBrief } from './lib/vault.js'
+import { ensureVault, search } from './lib/vault.js'
 import { migrateFromMarkdown, setAuditConfig, backupDb } from './lib/db.js'
-import { summarizeTurn, extractLastTurn, sliceNewEvents, resolveRoute, captureCard, captureUpdate, pickNeighbors } from './lib/capture.js'
-import { createApi, json } from './lib/api.js'
+import { summarizeTurn, extractLastTurn, sliceNewEvents, sessionEvents, sessionEventApi, createCaptureHealth, resolveRoute, captureCard, captureUpdate, pickNeighbors } from './lib/capture.js'
+import { createApi, json, encodeBody } from './lib/api.js'
 
 export const name = 'memory-eternal'
 export const inject = ['systemPrompt', 'settings']
@@ -152,22 +152,65 @@ export function apply(ctx, config) {
   const pending = new Map() // sessionId -> merged events array
   let captureQueue = Promise.resolve()
 
-  const scheduleCapture = (agent, events, lastSeq) => {
+  // -- 自动沉淀日志：最近 200 条「监听/判定/写入」事件（内存环形缓冲，不落盘）。
+  // 自动沉淀是后台静默管线，出错或空转时页面上完全看不出来；这里留一条可读的
+  // 运行轨迹，供「用量/今日」页的「自动沉淀日志」面板直接排查。
+  const captureLog = []
+  const CAPTURE_LOG_MAX = 200
+  // 健康状态：fail → 亮红（systemPrompt 段 + 页面横幅都会提示）；真写卡成功 → 复原。
+  const health = createCaptureHealth()
+  let refreshPrompt = null // 由 systemPrompt effect 赋值；健康状态翻转时重渲染提示段
+  const touchPrompt = () => {
+    if (typeof refreshPrompt !== 'function') return
+    try { refreshPrompt(settings.get()) } catch { /* 提示段刷新失败不影响沉淀 */ }
+  }
+  const logCapture = (sessionId, action, reason, extra = {}) => {
+    captureLog.push({ time: Date.now(), sessionId: String(sessionId || 'unknown').slice(0, 40), action, reason, ...extra })
+    if (captureLog.length > CAPTURE_LOG_MAX) captureLog.splice(0, captureLog.length - CAPTURE_LOG_MAX)
+    if (action === 'fail') { health.fail(reason); touchPrompt() }
+    else if (action === 'created' || action === 'appended') { health.succeed(); touchPrompt() }
+  }
+  const preview = (text) => String(text || '').replace(/\s+/g, ' ').trim().slice(0, 60)
+  // 单次沉淀送进 LLM 的对话上限（字符）：够覆盖一轮长对话，又不会把整段历史塞进去。
+  const CAPTURE_TEXT_MAX = 20000
+  // 启动留痕：面板里看不到这条 = host 半边没加载（而不是「没东西可沉淀」）。
+  {
+    const c = settings.get() ?? {}
+    logCapture('system', 'boot', `记忆核心 v${versionRef || '?'} 已加载：自动沉淀 ${c.enabled !== false && c.autoCapture !== false ? '开' : '关'} · 库 ${vaultDir()}`)
+  }
+  const lastCaptureAt = new Map() // sessionId -> 上次实际发起蒸馏的时间戳
+
+  const scheduleCapture = (agent, events) => {
     const cfg = settings.get() ?? {}
-    if (!cfg.enabled || !cfg.autoCapture) return
     const sessionId = agent?.session?.id ?? agent?.id ?? 'unknown'
-    const newEvents = sliceNewEvents(events, lastSeq)
-    if (newEvents.length === 0) return
+    if (!cfg.enabled || !cfg.autoCapture) return
+    if (!Array.isArray(events) || events.length === 0) {
+      logCapture(sessionId, 'listen', '读不到会话事件：agent.session 无 events/snapshotEvents（DSH 版本不匹配）')
+      return
+    }
     const existing = pending.get(sessionId)
+    // 连续轮次合并：把新事件接到待处理队列尾，一次 LLM 调用处理。
     if (existing) {
-      // 连续轮次合并：把新事件接到待处理队列尾，一次 LLM 调用处理。
-      pending.set(sessionId, [...existing, ...newEvents])
+      existing.events.push(...events)
       return
     }
-    pending.set(sessionId, newEvents)
-    captureQueue = captureQueue.then(() => runCapture(agent, pending.get(sessionId) ?? newEvents))
+    const job = { events }
+    pending.set(sessionId, job)
+    captureQueue = captureQueue.then(() => runCapture(agent, job))
   }
 
+  // 日配额：滚动 24h 内的「实际写卡」计数。只在真的写卡/追加后记一笔——
+  // 之前是「每发起一次判定就记一笔」，模型回 {save:false} 也照样扣配额，
+  // 40 次低价值判定就能把配额耗光、之后 24h 全部静默不再沉淀。
+  const lastDayStamps = []
+  const countWrite = () => { lastDayStamps.push(Date.now()) }
+  const quotaUsed = () => {
+    const dayStart = Date.now() - 86400000
+    while (lastDayStamps.length && lastDayStamps[0] < dayStart) lastDayStamps.shift()
+    return lastDayStamps.length
+  }
+  const underDailyQuota = (max) => quotaUsed() < (max ?? 60)
+
   // 自动审核：根据配置决定新卡 status（免审→approved，否则 pending）
   const resolveAuditStatus = (cfg, kind, submittedBy) => {
     if (cfg.auditMode === 'none') return 'approved'
@@ -178,19 +221,39 @@ export function apply(ctx, config) {
     return 'pending'
   }
 
-  const runCapture = async (agent, events) => {
+  const runCapture = async (agent, job) => {
+    const sessionId = agent?.session?.id ?? agent?.id ?? 'unknown'
+    const events = Array.isArray(job?.events) ? job.events : []
     try {
       const cfg = settings.get() ?? {}
       if (!cfg.enabled || !cfg.autoCapture) return
       const llm = ctx.get('llm')
-      const text = extractLastTurn(events)
-      if (text.length < (cfg.captureMinChars ?? 200)) return
-      // 日配额：防止一次大扫荡烧光 token。
-      if (!(await underDailyQuota(cfg.maxCardsPerDay))) return
+      // 水位从 0 开始的那一轮（重启后同一会话的第一轮）会把整段历史切进来——
+      // 只取尾部，避免一次超大 LLM 调用（超上下文/超时）。
+      const raw = extractLastTurn(events)
+      const text = raw.length > CAPTURE_TEXT_MAX ? raw.slice(-CAPTURE_TEXT_MAX) : raw
+      logCapture(sessionId, 'listen', `会话事件 ${events.length} 条 → 有效对话 ${text.length} 字${raw.length > text.length ? '（超长已截尾）' : ''}`, { preview: preview(text) })
+      if (text.length < (cfg.captureMinChars ?? 200)) {
+        logCapture(sessionId, 'skip', `内容太短：${text.length} < ${cfg.captureMinChars ?? 200} 字（调小「捕获最小长度」可放宽）`)
+        return
+      }
+      // 会话冷却：同一会话频繁收尾时避免每轮都烧一次 LLM。
+      const cooldown = Number(cfg.captureCooldownMs) || 0
+      const lastAt = lastCaptureAt.get(sessionId) ?? 0
+      if (cooldown > 0 && Date.now() - lastAt < cooldown) {
+        logCapture(sessionId, 'skip', `冷却中：距上次沉淀 ${Math.round((Date.now() - lastAt) / 1000)}s < ${Math.round(cooldown / 1000)}s`)
+        return
+      }
+      // 日配额：防止一次大扫荡烧光 token（只统计真正写卡/追加的次数）。
+      if (!underDailyQuota(cfg.maxCardsPerDay)) {
+        logCapture(sessionId, 'skip', `日配额已满（24h 已写 ${quotaUsed()} 张 / 上限 ${cfg.maxCardsPerDay ?? 60}）`)
+        return
+      }
+      lastCaptureAt.set(sessionId, Date.now())
       // 成本控制：distillEnabled=false 时不调 LLM，直接存原文卡（零蒸馏成本）
       const source = DSH_AGENT
       if (cfg.distillEnabled === false || !llm) {
-        await captureCard(vaultDir(), {
+        const out = await captureCard(vaultDir(), {
           kind: 'content',
           title: text.replace(/\s+/g, ' ').slice(0, 40) || '未命名记录',
           tags: ['raw'],
@@ -201,19 +264,25 @@ export function apply(ctx, config) {
           severity: 'info',
           reason: 'AI 自动沉淀（原文卡）',
         }, { threshold: cfg.dedupThreshold })
+        if (out.ok) { countWrite(); logCapture(sessionId, 'created', '原文卡（蒸馏已关闭）', { path: out.path ?? out.rel, kind: 'content' }) }
+        else if (out.duplicate) { countWrite(); logCapture(sessionId, 'appended', '与已有卡重复 → 追加更新记录', { path: out.duplicate.path }) }
+        else logCapture(sessionId, 'fail', `写卡失败：${out.reason || '未知原因'}`)
         return
       }
       const route = await resolveRoute(llm)
-      if (!route) return
+      if (!route) { logCapture(sessionId, 'fail', '取不到模型路由（llm.listProviders 为空）'); return }
       // 语义去重近邻：把已有卡片索引喂给模型，让模型决定新建 vs 追加。
       // 成本控制：dedupByLLM=false 时跳过喂 LLM 的近邻采样（纯词法去重兜底）。
       const draft = { title: '', body: text.slice(0, 400) }
       const neighbors = cfg.dedupByLLM === false ? [] : await pickNeighbors(vaultDir(), draft, 8)
       const result = await summarizeTurn(llm, route, text, { signal: AbortSignal.timeout(45000), existing: neighbors, maxTokens: cfg.captureMaxTokens ?? 900 })
-      if (!result || result.save !== true) return
+      if (!result) { logCapture(sessionId, 'skip', '模型无输出或 JSON 解析失败', { model: route.model }); return }
+      if (result.save !== true) { logCapture(sessionId, 'skip', '模型判定不值得保存', { model: route.model }); return }
       if (result.append_to) {
         // 模型判定属于已有卡 → 追加更新记录，不新建（boujoy 语义）。
         await captureUpdate(vaultDir(), result.append_to, result.update, { threshold: cfg.dedupThreshold })
+        countWrite()
+        logCapture(sessionId, 'appended', '模型判定属于已有卡 → 追加更新', { path: result.append_to, model: route.model })
         return
       }
       const card = {
@@ -228,38 +297,70 @@ export function apply(ctx, config) {
         reason: 'AI 自动沉淀（蒸馏卡）',
       }
       const out = await captureCard(vaultDir(), card, { threshold: cfg.dedupThreshold })
-      if (!out.ok && out.duplicate) {
+      if (out.ok) {
+        countWrite()
+        logCapture(sessionId, 'created', `新卡：${card.title}（${card.status === 'approved' ? '已入库' : '待审核'}）`, { path: out.path ?? out.rel, kind: card.kind, model: route.model })
+        return
+      }
+      if (out.duplicate) {
         // 词法兜底：高度相似 → 追加更新记录而不是再建一张重复卡。
         await captureUpdate(vaultDir(), out.duplicate.path, `${result.title}：${result.body.slice(0, 400)}`, {
           threshold: cfg.dedupThreshold,
         })
+        countWrite()
+        logCapture(sessionId, 'appended', '词法去重命中 → 追加更新记录', { path: out.duplicate.path, model: route.model })
+        return
       }
+      logCapture(sessionId, 'fail', `写卡失败：${out.reason || '未知原因'}`)
     } catch (error) {
+      logCapture(sessionId, 'fail', `异常：${error?.message || error}`)
       console.error('[memory-eternal] capture failed:', error)
     } finally {
-      const sessionId = agent?.session?.id ?? agent?.id ?? 'unknown'
-      pending.delete(sessionId)
+      // 运行期间若又累积了新事件，保留队列给下一轮 run 处理，避免丢事件。
+      if (pending.get(sessionId) === job) pending.delete(sessionId)
     }
   }
 
-  const lastDayStamps = []
-  const underDailyQuota = async (max) => {
-    const now = Date.now()
-    const dayStart = now - 86400000
-    while (lastDayStamps.length && lastDayStamps[0] < dayStart) lastDayStamps.shift()
-    if (lastDayStamps.length >= (max ?? 60)) return false
-    lastDayStamps.push(now)
-    return true
-  }
-
-  const lastSeqs = new Map() // sessionId -> last processed seq
+  const lastSeqs = new Map() // sessionId -> 已处理到的 seq 水位
+  const lastTouched = new Map() // sessionId -> 上次监听时间（用于清理，避免 Map 无界增长）
+  // 轮次计数：inbox/claimed 每轮必发（不依赖 turn-stopping），两个计数器对不上
+  // 就说明收尾事件没到——这是「监听器整个没被调用」这类静默死亡的兜底探测。
+  let turnsStarted = 0
+  let turnsStopped = 0
+  let lastClaimAt = 0
+  ctx.on('agent/inbox/claimed', () => { turnsStarted += 1; lastClaimAt = Date.now() })
   ctx.on('agent/turn-stopping', ({ agent }) => {
-    const events = agent?.session?.events
-    if (!Array.isArray(events)) return
+    turnsStopped += 1
     const sessionId = agent?.session?.id ?? agent?.id ?? 'unknown'
-    const lastSeq = lastSeqs.get(sessionId) ?? 0
-    scheduleCapture(agent, events, lastSeq)
-    lastSeqs.set(sessionId, events.length ? events[events.length - 1].seq : lastSeq)
+    try {
+      const api = sessionEventApi(agent?.session)
+      const first = !lastTouched.has(sessionId)
+      const all = sessionEvents(agent?.session)
+      // 水位默认 -1：新会话「已处理到」的位置在第一条事件之前，seq 0 不该被跳过。
+      const lastSeq = lastSeqs.get(sessionId) ?? -1
+      const fresh = sliceNewEvents(all, lastSeq)
+      if (all.length) lastSeqs.set(sessionId, Math.max(lastSeq, all[all.length - 1].seq ?? lastSeq))
+      // 每个会话第一次收尾留一条接入记录：接口名 + 事件数 + 新增数。
+      // 这样「面板一条都没有」只会意味着监听器没跑，而不是看不出所以然。
+      if (first) {
+        logCapture(sessionId, api ? 'listen' : 'fail', api
+          ? `会话接入：事件接口 ${api}，事件 ${all.length} 条，新增 ${fresh.length} 条`
+          : '会话对象没有事件接口（events/ownEvents/snapshotEvents 都不认识）——DSH 改了接口，需要适配')
+      }
+      lastTouched.set(sessionId, Date.now())
+      if (fresh.length) scheduleCapture(agent, fresh)
+      // 1 天没动静的会话水位清理掉（长跑进程里会话数会一直涨）。
+      if (lastTouched.size > 200) {
+        const cut = Date.now() - 86400000
+        for (const [id, t] of lastTouched) {
+          if (t < cut) { lastTouched.delete(id); lastSeqs.delete(id); lastCaptureAt.delete(id) }
+        }
+      }
+    } catch (error) {
+      // 监听器里抛异常等于管线静默死亡（页面只表现为「一直不写卡」）——记进日志。
+      logCapture(sessionId, 'fail', `监听异常：${error?.message || error}`)
+      console.error('[memory-eternal] turn-stopping listener failed:', error)
+    }
   })
 
   // -- 2. 自动召回：systemPrompt 分段 + memory_recall 工具 -----------------
@@ -279,16 +380,31 @@ export function apply(ctx, config) {
         '2. 当任务需要项目背景、历史决策、之前讨论过的方案或领域知识时，先调用 memory_recall 检索相关卡片，再作答。',
         '3. 若检索结果为空，就诚实说明当前记忆库没有相关内容，不要编造。',
         '4. 知识卡存储在 SQLite 数据库中（memory-eternal.db），**禁止**用文件工具直接读写 vault 目录下的任何文件。沉淀记忆必须通过 memory_recall 工具或 /memory-eternal/api/write API。',
+        '5. 若下方出现「自动沉淀异常」，必须在本次回复的第一句用中文转述该异常并提醒用户处理，不要自行猜测或尝试修复。',
+        // 审核红线（主上 2026-09-12 强制要求）：只在审核真正生效时注入。
+        ...((cfg.auditMode ?? 'all') === 'none' ? [] : [
+          '6. **审核红线（强制）**：写卡一律停在 pending，由用户在「审核中心」审批。**禁止**调用 /memory-eternal/api/audit/approve 或 /audit/reject 代替用户审批，也不得用任何等价方式绕过审核；用户说「记录一下 / 增加记忆」不等于允许免审入库。需要立刻可用时，写卡后明确告知用户「已进审核中心，待批准」。',
+        ]),
+      ].join('\n')
+      // 异常提示：沉淀管线坏了，靠这一句把消息送到用户面前（不依赖用户去翻页面）。
+      const h = health.snapshot()
+      const alert = h.ok ? '' : [
+        '',
+        '⚠ 自动沉淀异常（记忆核心 memory-eternal）——' + h.reason,
+        '（发生时间：' + new Date(h.since).toLocaleString() + '。请在回复第一句提醒用户：自动沉淀异常 + 上述原因；'
+          + '并可提示用户打开 设置→记忆→用量/今日 查看「自动沉淀日志」；若原因是接口/版本不匹配，需更新 memory-eternal 插件。）',
       ].join('\n')
       disposeSection = ctx.systemPrompt.section({
         name: 'memory-eternal: auto-recall',
         order: 600,
-        text,
+        text: text + alert,
       })
     }
+    refreshPrompt = refresh
     refresh(settings.get())
     const unwatch = settings.watch(refresh)
     return () => {
+      if (refreshPrompt === refresh) refreshPrompt = null
       if (typeof unwatch === 'function') unwatch()
       if (disposeSection) disposeSection()
     }
@@ -333,16 +449,14 @@ export function apply(ctx, config) {
     }))
   }
 
-  // 每日回顾：每 30 分钟检查一次，跨天就生成当日简报文件（幂等，凌晨/首日各一次）。
-  let lastBriefDate = ''
-  const briefTimer = setInterval(() => {
-    const d = new Date()
-    const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
-    if (lastBriefDate === date) return
-    lastBriefDate = date
-    generateDailyBrief(vaultDir()).catch(() => {})
-  }, 30 * 60 * 1000)
-  ctx.effect(() => () => clearInterval(briefTimer), 'memory-eternal: daily brief timer')
+  // 沉淀停滞探测：有轮次开始、却迟迟没有收尾（>15 分钟），说明 turn-stopping 没到。
+  const stallTimer = setInterval(() => {
+    if (turnsStarted > turnsStopped && lastClaimAt && Date.now() - lastClaimAt > 15 * 60 * 1000) {
+      // 经 logCapture 统一走「记日志 + 置异常 + 刷提示段」一条路
+      logCapture('system', 'fail', `轮次收尾事件未触发（agent/turn-stopping 没到）：已开始 ${turnsStarted} / 已收尾 ${turnsStopped}——DSH 可能改了事件名或作用域`)
+    }
+  }, 10 * 60 * 1000)
+  ctx.effect(() => () => clearInterval(stallTimer), 'memory-eternal: capture stall watch')
 
   // 回收站清理：每 30 分钟永久删除超过保留期（默认 30 天）的软删卡。
   const purgeTimer = setInterval(() => {
@@ -376,6 +490,9 @@ export function apply(ctx, config) {
   if (webServer !== undefined) {
     const handleApi = createApi({
       vaultDir, vaultRoots, getSettings: settings.get,
+      // 自动沉淀运行轨迹 + 健康状态：供「用量/今日」页排查「为什么没写卡」，异常时页面顶部亮红。
+      getCaptureLog: () => captureLog.slice().reverse(),
+      getCaptureHealth: () => health.snapshot(),
       getDshInfo: () => ({
         name: 'deepseek-harness',
         label: 'DeepSeek Harness（当前宿主）',
@@ -487,8 +604,13 @@ export function apply(ctx, config) {
             const webRoot = path.join(PACKAGE_ROOT, 'web')
             if (pathname.endsWith('app.js')) {
               const buf = await readFile(path.join(webRoot, 'app.js'))
-              res.writeHead(200, { 'Content-Type': 'application/javascript; charset=utf-8', 'Cache-Control': 'no-store' })
-              return res.end(buf)
+              // client bundle 270KB，每次打开配置页都要重下 —— 支持 gzip 的客户端走压缩
+              const headers = { 'Content-Type': 'application/javascript; charset=utf-8', 'Cache-Control': 'no-store', 'Vary': 'Accept-Encoding' }
+              const { body: out, encoding } = encodeBody(res, buf)
+              if (encoding) headers['Content-Encoding'] = encoding
+              headers['Content-Length'] = out.length
+              res.writeHead(200, headers)
+              return res.end(out)
             }
             const buf = await readFile(path.join(webRoot, 'index.html'))
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' })

package/lib/api.js

@@ -9,8 +9,10 @@
 // - vaultDir()  → 当前激活 vault 根目录（string）
 // - vaultRoots() → [{ name, root }] 全部 profile 根（跨库聚合用）
 // - getSettings() → 插件设置对象（/budget /compress 读取；可选，缺省 {}）
+// - getCaptureLog() → 自动沉淀运行轨迹（DSH host 注入；独立 web server 无此数据）
 
-import { listCards, readCard, search, searchAll, graph, graphAll, overview, exportCards, deleteCard, writeCard, parseCard, stats, optimizeCandidates, optimizeApply, addFeedback, dailyBrief, dailyCounts, mergeCards, ensureVault, auditQueue, recycleList, purgeExpired, setCardStatus, restoreCard } from './vault.js'
+import { gzipSync, brotliCompressSync, constants as zlibConstants } from 'node:zlib'
+import { listCards, countCards, readCard, search, searchAll, graph, graphAll, overview, exportCards, deleteCard, writeCard, parseCard, stats, optimizeCandidates, optimizeApply, addFeedback, dailyCounts, mergeCards, ensureVault, auditQueue, recycleList, purgeExpired, setCardStatus, restoreCard } from './vault.js'
 import { compressExcerpt } from './capture.js'
 import { getSetupStatus, runSetup, mcpAgentAction } from './setup.js'
 import { backupDb } from './db.js'
@@ -23,6 +25,9 @@ export function createApi(deps = {}) {
   const getSettings = deps.getSettings ?? (() => ({}))
   // DSH 宿主信息（独立 web server 无 DSH 环境时为 null）。head DSH 状态行用。
   const getDshInfo = deps.getDshInfo ?? (() => null)
+  // 自动沉淀运行轨迹（最新在前）+ 健康状态（异常时 UI 顶部亮红）。
+  const getCaptureLog = deps.getCaptureLog ?? (() => null)
+  const getCaptureHealth = deps.getCaptureHealth ?? (() => null)
 
   return async function handleApi(req, res) {
     const vaultRoot = vaultDir()
@@ -40,17 +45,25 @@ export function createApi(deps = {}) {
         const kind = query.get('kind') || ''
         const q = query.get('q') || ''
         const status = (query.get('status') || 'approved').toLowerCase()
-        const limit = Math.min(Number(query.get('limit')) || 200, 500)
+        // 真分页：offset/limit + total（客户端据此判断还有没有下一页）
+        const limit = Math.min(Math.max(Number(query.get('limit')) || 200, 1), 500)
+        const offset = Math.max(Number(query.get('offset')) || 0, 0)
+        const sort = query.get('sort') === 'title' ? 'title' : 'recent'
+        const agent = query.get('agent') || '' // 服务端署名过滤（如 agent=deepseek-harness）
         // all = 全部（含 pending/rejected，排除回收站）；默认/approved = 已审核。
         const want = status === 'all' ? ['approved', 'pending', 'rejected'] : status === 'pending' || status === 'rejected' ? [status] : ['approved']
-        let cards = await listCards(vaultRoot, { status: want })
-        if (kind) cards = cards.filter((c) => c.kind === kind)
         if (q.trim()) {
-          const hits = await search(vaultRoot, q, { limit: 200 })
+          // 检索是相关性排序：先把命中集合取齐，再在内存里分页（保证 total 与顺序一致）
+          const hits = await search(vaultRoot, q, { limit: 500 })
           const hitPaths = new Set(hits.map((h) => h.path))
-          cards = cards.filter((c) => hitPaths.has(c.path))
+          let cards = (await listCards(vaultRoot, { status: want, kind, agent })).filter((c) => hitPaths.has(c.path))
+          const total = cards.length
+          json(res, 200, { ok: true, cards: cards.slice(offset, offset + limit), total, offset, limit })
+          return
         }
-        json(res, 200, { ok: true, cards: cards.slice(0, limit) })
+        const total = await countCards(vaultRoot, { status: want, kind, agent })
+        const cards = await listCards(vaultRoot, { status: want, kind, agent, limit, offset, sort })
+        json(res, 200, { ok: true, cards, total, offset, limit })
         return
       }
       case '/card': {
@@ -80,10 +93,11 @@ export function createApi(deps = {}) {
         json(res, 200, { ok: true, ...g })
         return
       }
-      case '/todayBrief': {
-        await ensureVault(vaultRoot)
-        const s = await stats(vaultRoot)
-        json(res, 200, { ok: true, today: s.today, brief: dailyBrief(s.todayCards) })
+      case '/capture-log': {
+        // 最近 100 条自动沉淀运行轨迹（监听 → 判定 → 写入/跳过原因）+ 健康状态。
+        const log = getCaptureLog()
+        if (!log) return json(res, 200, { ok: true, available: false, entries: [], health: null })
+        json(res, 200, { ok: true, available: true, health: getCaptureHealth(), entries: log.slice(0, 100) })
         return
       }
       case '/export': {
@@ -312,12 +326,69 @@ export function createApi(deps = {}) {
 
 export function json(res, status, body) {
   const payload = JSON.stringify(body)
-  res.writeHead(status, {
+  const headers = {
     'Content-Type': 'application/json; charset=utf-8',
-    'Content-Length': Buffer.byteLength(payload),
     'Cache-Control': 'no-store',
-  })
-  res.end(payload)
+    'Vary': 'Accept-Encoding',
+  }
+  const { body: out, encoding } = encodeBody(res, Buffer.from(payload, 'utf8'))
+  if (encoding) headers['Content-Encoding'] = encoding
+  headers['Content-Length'] = out.length
+  res.writeHead(status, headers)
+  res.end(out)
+}
+
+/** 请求方的 Accept-Encoding（`res.req` 由 Node 的 http server 挂上；取不到当不支持）。 */
+export function acceptEncoding(res) {
+  try {
+    const req = res && (res.req || res.__meReq)
+    return String((req && req.headers && req.headers['accept-encoding']) || '').toLowerCase()
+  } catch { return '' }
+}
+
+/** 请求方是否接受 gzip。 */
+export function acceptsGzip(res) {
+  return acceptEncoding(res).includes('gzip')
+}
+
+/**
+ * 协商压缩大响应体：
+ * - 支持 brotli 就优先 br（质量 4 = 在线压缩的速度/体积平衡点，比 gzip 再小约 30%）
+ * - 否则退 gzip
+ * - 都不支持、体积太小、或压完反而更大 → 明文
+ */
+export function encodeBody(res, buf) {
+  if (buf.length <= 2048) return { body: buf, encoding: '' }
+  const ae = acceptEncoding(res)
+  const wantBr = /(^|[,\s])br($|[,\s;])/.test(ae)
+  const wantGzip = ae.includes('gzip')
+  // 大响应体同时压 br + gzip 取更小的那个：br q5 在图谱这种高重复 JSON 上比 gzip 小 35%，
+  // 但在高熵的 JS/小 JSON 上偶尔略大 —— 取小者保证永不劣化（成本仅几毫秒）。
+  if (buf.length >= 16 * 1024) {
+    let br = null
+    if (wantBr) {
+      try { br = brotliCompressSync(buf, { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 5, [zlibConstants.BROTLI_PARAM_SIZE_HINT]: buf.length } }) } catch { br = null }
+    }
+    let gz = null
+    if (wantGzip) { try { gz = gzipSync(buf) } catch { gz = null } }
+    const best = [br && { body: br, encoding: 'br' }, gz && { body: gz, encoding: 'gzip' }]
+      .filter(Boolean)
+      .filter((x) => x.body.length < buf.length)
+      .sort((a, b) => a.body.length - b.body.length)[0]
+    if (best) return best
+    return { body: buf, encoding: '' }
+  }
+  if (wantBr) {
+    try {
+      const out = brotliCompressSync(buf, { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 5, [zlibConstants.BROTLI_PARAM_SIZE_HINT]: buf.length } })
+      if (out.length < buf.length) return { body: out, encoding: 'br' }
+    } catch { /* 落到 gzip */ }
+  }
+  if (wantGzip) {
+    const out = gzipSync(buf)
+    if (out.length < buf.length) return { body: out, encoding: 'gzip' }
+  }
+  return { body: buf, encoding: '' }
 }
 
 /** 读请求体（POST body），返回解析后的 JSON 对象或空。 */