dsh-qq-digest 0.1.1 → 0.2.0

package/README.md

@@ -49,6 +49,9 @@
 
 - `llm`（默认）：OpenAI 兼容接口，结构化 JSON。密钥取 `QQ_DIGEST_LLM_API_KEY` 或 `~/.dsh/.credentials.yaml` 的 `DEEPSEEK_API_KEY`。
   失败**不静默降级**，直接抛 `LLM_*` 错误码。
+  ⚠️ **知情提示**：选 `llm` 意味着被摘要的群/私聊**消息正文、昵称，以及被 @ 的 QQ 号**会发送到
+  模型服务商（默认 `api.deepseek.com`）。不能接受这一点就选 `heuristic`（纯本地规则，不出网）。
+  摘要是对**不可信输入**的加工结果：群成员可以往群名/正文里塞指令，摘要只能当数据看，不能当指令执行。
 - `heuristic`：本地关键词规则，零网络零成本，质量有上限（会漏也会误抓）。
 
 ## 配置
@@ -69,7 +72,10 @@
 
 - 不写 `groups` = 所有群都可读。
 - `groups` 里只用于**关掉**某个群或给它起名。
-- 写出 `private` / `friend` / `send` / `scope` 一类键 → 整份配置作废 → **全关**（fail-closed）。
+- `private` 是**受支持的一等键**：`{ "88880001": { "enabled": true } }` 逐条打开私聊；
+  不允许一键全开（`private.defaultEnabled=true` 在策略解析阶段即判非法 → 全关）。
+- 写出 `friend` / `send` / `reply` / `scope` / `write` 一类**危险键** → 整份配置作废 → **全关**（fail-closed）；
+  与安全无关的未知键被忽略。
 - 配置损坏同理：全关，不回退到「默认允许」。
 
 ## 落盘
@@ -82,9 +88,11 @@
 ## 验证
 
 ```bash
-npm run verify            # core 纯净性检查 + 51 个用例
-node scripts/smoke.mjs        # fixture 端到端（真实子进程走 MCP 协议）
-node scripts/smoke.mjs bridge # 真桥接只读冒烟
+npm run verify                      # core 纯净性检查 + 全部用例（当前 116）
+node scripts/smoke.mjs              # fixture 端到端（真实子进程走 MCP 协议）
+node scripts/smoke.mjs bridge       # 真桥接只读冒烟
+node scripts/host-smoke.mjs         # 宿主半：假 ctx 跑 apply()，真 req/res 打路由（含跨站/伪造 Host 用例）
+node scripts/final-check.mjs        # 发布前自检（脱敏词从 QQ_DIGEST_SENSITIVE_PATTERNS 读，不写死在仓库里）
 ```
 
 core 纯净性检查锁定：`src/core/` 不许 import `node:fs` / 子进程 / 网络，不许出现 `fetch(`、`send_*`、`/api/send`、写文件符号。
@@ -207,9 +215,18 @@ node scripts/verify-dsh.mjs      # 宿主半在线？客户端半上次启动有
 
 ## 已知限制（不美化）
 
-- **设置页的开关不是安全边界**：`/qq-digest-api` 只允许回环地址访问，但本机任何进程
-  （包括模型通过 bash 起一个 `curl`）都能 POST 改配置。开关管的是「默认不读」，
-  不是「别人改不了」。真要防，得给 API 加一次性的会话令牌，本期没做。
+- **设置页的开关不是安全边界**：`/qq-digest-api` 允许**本机进程**（包括模型通过 bash 起一个 `curl`）直接 POST 改配置。
+  它挡住的是**浏览器与网络**，不是本机同一用户下的进程。
+- 管理面已做的校验（`lib/index.js` 的 `denyUntrustedRequest`）：
+  ① 来源必须是回环（`remoteAddress`）；② `Host` 必须是回环字面量（挡 DNS rebinding）；
+  ③ `Origin` 必须是回环来源；④ `Sec-Fetch-Site: cross-site` 直接拒；
+  ⑤ 写操作必须是 `application/json` —— 这个类型跨源必预检，而本服务不返回任何 CORS 头，
+  于是 `<form>` / `text/plain` 的 CSRF 简单请求进不来。
+- 反代 / 公网隧道仍会让 `remoteAddress` 看起来是回环：**不要把本插件挂在公网隧道后面**。
+- 句柄密钥不再有源码默认值：`QQ_DIGEST_SECRET` → `<数据目录>/handle-secret`（首次启动随机生成并落盘）。
+  写不进去就拒绝启动，而不是退回弱密钥。`/state` 的 `secretSource` 会如实告诉你当前用哪一种。
+- 读取摘要会**按当前策略现算授权**：关掉某个群或关掉总开关之后，该群历史摘要立即读不到（本轮修复）。
+  拒绝列表里返回的是 `auditRef`（独立 HMAC 域），它**不能**用来读任何摘要。
 - 私聊只在 `bridge` 数据源下可用；`snowluma` 适配器只调群历史，没有私聊取数路径。
 - `bridge` 源的群名是空的（桥接不存群名）；可在 `config.json` 的 `groups.<id>.name` 里人工命名。
 - `bridge` 源每轮最多回看 **100 条**（桥接 `/api/messages` 的硬上限）。两次运行之间新增超过 100 条时，
@@ -218,6 +235,11 @@ node scripts/verify-dsh.mjs      # 宿主半在线？客户端半上次启动有
 - `snowluma` 源是 `stateless`：每轮全量重算固定窗口（默认 60 条）。原因是 OneBot 的 `message_id`
   不保证单调，拿它当水位线会静默漏读新消息。
 - 句子级启发式摘要对「谁负责」判断保守：猜不准就回退成发消息的人，不做过度推断。
-- `config.json` 里的 `schedule` 字段目前只是**描述性配置**：插件本身不注册定时任务。
-  要每天自动跑，需要另外用 DSH 的 automation 建一条定时任务去调用 `qq_digest_run_summary`。
+- `config.json` 的 `schedule` 由**宿主半自己**执行：`lib/index.js` 每 30s tick 一次，到点跑一轮
+  （启动后 5s 还会补跑一次，避免刚好在到点后才启动而整天漏跑）。
+  跨进程互斥用 `run.lock`（带心跳续租，长轮次不会被判成陈旧锁抢占）。
+- 手动「立即总结」**不会**吞掉当天的定时：去重只认 `lastTrigger === "scheduled"` 的那一次。
 - 未评估 QQ 侧 ToS 与账号风险；本插件只读本地桥接/网关接口，不额外登录。
+- **`/state` 会明文回显群号与私聊 QQ 号**：设置页要靠它们做开关和提交，不做掩码是刻意选择
+  （入口已经用来源校验收窄到回环同源）。因此别在截图、录屏、远程协助里展示设置页。
+- 未做速率限制：`/run` 与 `run_summary` 可以被反复触发，会放大 LLM 调用费用。需要限流请在外层加。

package/install/cordis.patch.fragment.yml

@@ -6,7 +6,10 @@
       config:
         serverName: qq-digest
         transport: stdio
-        command: 'D:\Program Files\nodejs\node.exe'
+        # __NODE_EXE__ 由 install.mjs 用 process.execPath 替换。
+        # 模板里绝不能出现作者机器上的绝对路径：换台机器就会 spawn ENOENT，
+        # 表现为「MCP 工具全部消失但插件看起来装上了」。
+        command: '__NODE_EXE__'
         args:
           - '__PACKAGE_ROOT__/src/run-mcp.mjs'
         toolCallTimeoutMs: 180000

package/lib/index.js

@@ -18,7 +18,7 @@ import { join } from 'node:path';
 import { canonicalize, KIND } from '../src/core/canonical.js';
 import { roomHandle } from '../src/core/gate.js';
 import { configPath, defaultConfig, loadConfig, saveConfig } from '../src/config.js';
-import { resolveDataDir, resolveSecret, createRuntime } from '../src/runtime.js';
+import { resolveDataDir, createRuntime } from '../src/runtime.js';
 import { withRunLock } from '../src/run-lock.js';
 
 export const name = 'dsh-qq-digest';
@@ -34,11 +34,12 @@ export function apply(ctx) {
   mkdirSync(dataDir, { recursive: true });
 
   const stateFile = join(dataDir, 'schedule-state.json');
-  const secret = resolveSecret();
 
   let runtime = null;
   const getRuntime = () => {
-    if (runtime === null) runtime = createRuntime({ dataDir, secret });
+    // createRuntime 自己解析密钥（env → <dataDir>/handle-secret → 首次生成），
+    // 与 MCP 半走同一份实现，保证两边算出的句柄一致。
+    if (runtime === null) runtime = createRuntime({ dataDir });
     return runtime;
   };
 
@@ -52,6 +53,7 @@ export function apply(ctx) {
   // ── 状态 ────────────────────────────────────────────────────────────────
 
   async function buildState() {
+    const secret = getRuntime().secret;
     const loaded = loadConfig(configPath(dataDir));
     const config = loaded.config;
     const scheduleState = readScheduleState(stateFile);
@@ -113,6 +115,8 @@ export function apply(ctx) {
       privateRooms,
       configError: loaded.error,
       policyDegraded: Boolean(loaded.policy?.degraded),
+      // 密钥来源如实上报（env / generated / file / explicit）。值本身永不下发。
+      secretSource: getRuntime().secretSource,
       summarizer: config.summarizer,
       schedule: config.schedule,
       scheduleState,
@@ -129,7 +133,11 @@ export function apply(ctx) {
   // ── 配置写入 ─────────────────────────────────────────────────────────────
 
   function saveFromUi(body) {
-    const current = loadConfig(configPath(dataDir)).config;
+    const loaded = loadConfig(configPath(dataDir));
+    // 配置文件本身坏了时 loadConfig 会回退成默认值；拿这个默认值当 current 再保存，
+    // 会把用户原有的 groups 静默清空。宁可明确拒绝，让人先修好文件。
+    if (loaded.error) throw badRequest(`CONFIG_UNREADABLE:${loaded.error}`);
+    const current = loaded.config;
 
     const groups = {};
     const inputGroups = body?.groups ?? {};
@@ -205,7 +213,7 @@ export function apply(ctx) {
   // ── 路由 ────────────────────────────────────────────────────────────────
 
   function handler(req, res) {
-    if (denyNonLoopback(req, res)) return;
+    if (denyUntrustedRequest(req, res)) return;
 
     let url;
     try {
@@ -249,9 +257,19 @@ export function apply(ctx) {
           if (!canonical.ok || canonical.kind !== KIND.GROUP) {
             return sendJson(res, 400, { ok: false, error: 'ONLY_GROUPS' });
           }
-          const handle = roomHandle(secret, canonical.canonicalId);
-          const entry = getRuntime().store.latest(handle);
-          return sendJson(res, 200, { ok: true, groupId: canonical.groupId, digest: entry?.digest ?? null, createdAt: entry?.createdAt ?? null });
+          // 与 MCP 工具走同一条读取路径：读取也要按当前策略复核，
+          // 否则「关掉这个群」只影响下一轮取数，历史摘要照样读得到。
+          const handle = roomHandle(getRuntime().secret, canonical.canonicalId);
+          const out = await getRuntime().service.getDigest(handle);
+          const entry = out.status === 'OK' ? out.entry : null;
+          return sendJson(res, 200, {
+            ok: true,
+            groupId: canonical.groupId,
+            status: out.status,
+            ...(out.reason ? { reason: out.reason } : {}),
+            digest: entry?.digest ?? null,
+            createdAt: entry?.createdAt ?? null,
+          });
         }
 
         return sendJson(res, 404, { ok: false, error: 'NOT_FOUND' });
@@ -279,10 +297,7 @@ export function apply(ctx) {
       if (!isDue(schedule, now)) return;
 
       const state = readScheduleState(stateFile);
-      if (state.lastRunAt) {
-        const last = nowIn(schedule.timeZone, new Date(state.lastRunAt));
-        if (last.dateKey === now.dateKey) return; // 今天已经跑过
-      }
+      if (alreadyRanToday(state, schedule, now)) return;
 
       const result = await runOnce('scheduled');
       ctx.logger?.info?.(`[qq-digest] 定时总结 ${now.dateKey} ${now.hhmm} → ${result.status}`);
@@ -381,7 +396,8 @@ function nowIn(timeZone, at = new Date()) {
   return {
     dateKey: `${year}-${month}-${day}`,
     hhmm: `${hour}:${minute}`,
-    weekday: index >= 0 ? WEEKDAY_CODES[index] : 'MO',
+    // 解析不出来就是 null，不再默默当成周一：fail-open 会让「每周一」的任务在错误的星期跑。
+    weekday: index >= 0 ? WEEKDAY_CODES[index] : null,
   };
 }
 
@@ -401,9 +417,22 @@ function normalizeSchedule(raw) {
   };
 }
 
+/**
+ * 今天是否已经「由定时任务」跑过。
+ *
+ * 只认 lastTrigger === 'scheduled'：手动跑也会写 lastRunAt，若把它当成定时已完成，
+ * 用户在 08:59 手点一次「立即总结」，09:00 的定时就会被静默吞掉 —— 而且没有任何提示。
+ */
+function alreadyRanToday(state, schedule, now) {
+  if (state?.lastTrigger !== 'scheduled' || !state.lastRunAt) return false;
+  const last = nowIn(schedule.timeZone, new Date(state.lastRunAt));
+  return last.dateKey === now.dateKey;
+}
+
 function isDue(schedule, now) {
   if (now.hhmm !== schedule.time) return false;
   if (schedule.kind === 'daily') return true;
+  if (!now.weekday) return false; // 周几不可判定 → 不跑，而不是猜一个
   return Array.isArray(schedule.weekdays) && schedule.weekdays.includes(now.weekday);
 }
 
@@ -412,10 +441,11 @@ function readScheduleState(file) {
     const parsed = JSON.parse(readFileSync(file, 'utf8'));
     return {
       lastRunAt: typeof parsed?.lastRunAt === 'string' ? parsed.lastRunAt : null,
+      lastTrigger: typeof parsed?.lastTrigger === 'string' ? parsed.lastTrigger : null,
       lastStatus: typeof parsed?.lastStatus === 'string' ? parsed.lastStatus : null,
     };
   } catch {
-    return { lastRunAt: null, lastStatus: null };
+    return { lastRunAt: null, lastTrigger: null, lastStatus: null };
   }
 }
 
@@ -429,14 +459,64 @@ function writeScheduleState(file, { lastRunAt, trigger, status }) {
   }
 }
 
-function denyNonLoopback(req, res) {
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1', '[::1]']);
+
+/**
+ * 管理面入口校验。
+ *
+ * 只判 remoteAddress 是不够的，有三种真实场景会绕过去：
+ *  1) DNS rebinding：攻击者的域名解析到 127.0.0.1，浏览器会把请求发到本机，remoteAddress 就是回环；
+ *  2) 任意网页的跨站请求：浏览器发出的简单请求（form / text-plain）不需要预检，服务端不校验就照做；
+ *  3) 反向代理 / 公网隧道：转进来的请求 remoteAddress 通常也是 127.0.0.1。
+ *
+ * 因此这里同时校验 Host、Origin、Sec-Fetch-Site，并要求写操作必须是 application/json
+ * （该类型跨源必预检，而本服务不返回任何 CORS 头，预检不可能通过）。
+ */
+function denyUntrustedRequest(req, res) {
   const address = String(req.socket?.remoteAddress ?? '');
   const loopback = address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1';
-  if (loopback) return false;
-  sendJson(res, 403, { ok: false, error: 'LOCAL_ONLY' });
+  if (!loopback) return reject(res, 403, 'LOCAL_ONLY');
+
+  if (!hostIsLoopback(req.headers?.host)) return reject(res, 403, 'BAD_HOST');
+  if (!originIsLoopback(req.headers?.origin)) return reject(res, 403, 'BAD_ORIGIN');
+
+  const site = String(req.headers?.['sec-fetch-site'] ?? '').toLowerCase();
+  if (site === 'cross-site') return reject(res, 403, 'CROSS_SITE');
+
+  const method = String(req.method ?? 'GET').toUpperCase();
+  if (method === 'POST') {
+    const type = String(req.headers?.['content-type'] ?? '').toLowerCase();
+    if (!type.startsWith('application/json')) return reject(res, 415, 'JSON_REQUIRED');
+  }
+
+  return false;
+}
+
+function reject(res, status, error) {
+  sendJson(res, status, { ok: false, error });
   return true;
 }
 
+function hostIsLoopback(header) {
+  if (typeof header !== 'string' || header.trim() === '') return false;
+  let value = header.trim().toLowerCase();
+  // IPv6 形如 [::1]:1875，先剥掉端口
+  if (value.startsWith('[')) value = value.slice(0, value.indexOf(']') + 1);
+  else value = value.split(':')[0];
+  return LOOPBACK_HOSTS.has(value);
+}
+
+function originIsLoopback(header) {
+  // 没有 Origin 说明不是跨源浏览器请求（同源导航、curl、脚本），交给 Host 校验兜住。
+  if (typeof header !== 'string' || header.trim() === '') return true;
+  try {
+    const url = new URL(header.trim());
+    return LOOPBACK_HOSTS.has(url.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
 function readJson(req) {
   return new Promise((resolve, reject) => {
     let size = 0;
@@ -475,5 +555,13 @@ function sendJson(res, status, payload) {
   res.end(body);
 }
 
-/** 仅供单元测试：时区换算与到期判定是定时逻辑里最容易错的部分。 */
-export const __test = { nowIn, isDue, normalizeSchedule };
+/** 仅供单元测试：时区换算、到期判定与管理面来源校验是最容易出错的三块。 */
+export const __test = {
+  nowIn,
+  isDue,
+  alreadyRanToday,
+  normalizeSchedule,
+  readScheduleState,
+  writeScheduleState,
+  denyUntrustedRequest,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-qq-digest",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "只读的 DSH QQ 摘要插件：群聊默认全开、私聊默认全关且只能逐条打开；MCP 四个只读工具 + 设置页（选群/起名/定时/立即总结），零发送能力",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,8 @@
     "mcp"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=20",
+    "dsh": ">=0.2.0-0 <0.3.0"
   },
   "main": "lib/index.js",
   "exports": {

package/scripts/final-check.mjs

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * 发布前/后的全量自检：仓库、脱敏、测试、npm、GitHub、DSH 运行态，一次跑完。
+ *
+ * 用法：node scripts/final-check.mjs
+ */
+
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+let failures = 0;
+const ok = (label, detail) => console.log(`PASS  ${label}${detail ? `  ${detail}` : ''}`);
+const bad = (label, detail) => { console.log(`FAIL  ${label}${detail ? `  ${detail}` : ''}`); failures += 1; };
+const info = (label, detail) => console.log(`INFO  ${label}${detail ? `  ${detail}` : ''}`);
+
+function run(cmd, args, options = {}) {
+  try {
+    return {
+      ok: true,
+      out: execFileSync(cmd, args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], ...options }).trim(),
+    };
+  } catch (err) {
+    return { ok: false, out: String(err.stdout ?? '').trim(), err: String(err.stderr ?? err.message).trim() };
+  }
+}
+
+// ── 1. 仓库 ──────────────────────────────────────────────────────────────
+const log = run('git', ['log', '--oneline']);
+if (log.ok && log.out) {
+  const commits = log.out.split('\n');
+  ok('git 提交', `${commits.length} 个：${commits[0]}`);
+} else bad('git 提交读不到');
+
+const status = run('git', ['status', '--porcelain']);
+if (status.ok) {
+  if (status.out === '') ok('工作区干净');
+  else bad('工作区有未提交改动', status.out.split('\n').slice(0, 3).join(' | '));
+}
+
+const tracked = run('git', ['ls-files']);
+const fileCount = tracked.ok ? tracked.out.split('\n').filter(Boolean).length : 0;
+info('跟踪文件', `${fileCount} 个`);
+
+const remote = run('git', ['remote', '-v']);
+info('remote', remote.ok && remote.out ? remote.out.split('\n')[0] : '(未配置)');
+
+// ── 2. 脱敏 ──────────────────────────────────────────────────────────────
+// 敏感词**不能写在这个文件里**：本文件随 npm 包一起发布（package.json files 含 scripts），
+// 把真实 QQ 号/群号写进来，等于用「检查泄漏的脚本」本身泄漏一遍，而且它还会命中自己，
+// 于是永远报 4 项 FAIL。现在改为外部注入：
+//   QQ_DIGEST_SENSITIVE_PATTERNS="123456,88888888" node scripts/final-check.mjs
+const PATTERNS = String(process.env.QQ_DIGEST_SENSITIVE_PATTERNS ?? '')
+  .split(',')
+  .map((value) => value.trim())
+  .filter((value) => value !== '');
+
+// 排除检查器自身：否则只要配了词，就必然命中这个文件。
+const GREP_EXCLUDE = [':(exclude)scripts/final-check.mjs'];
+
+let leak = 0;
+if (PATTERNS.length === 0) {
+  info('脱敏', '未设置 QQ_DIGEST_SENSITIVE_PATTERNS，已跳过（仓库内不得残留个人标识）');
+} else {
+  for (const pattern of PATTERNS) {
+    const hit = run('git', ['grep', '-n', pattern, '--', '.', ...GREP_EXCLUDE]);
+    if (hit.ok && hit.out !== '') {
+      bad(`仓库里仍有 ${pattern}`, hit.out.split('\n').slice(0, 2).join(' | '));
+      leak += 1;
+    }
+  }
+  if (leak === 0) ok('仓库内无个人标识（QQ/群号/用户名）');
+}
+
+const bridgePath = join(root, 'src', 'adapters', 'bridge.js');
+const bridgeSrc = run('node', ['-e', `process.stdout.write(require('node:fs').readFileSync(${JSON.stringify(bridgePath)},'utf8'))`]);
+if (bridgeSrc.ok && /resolveBridgePaths/.test(bridgeSrc.out)) ok('桥接路径可解析（无硬编码目录）');
+else bad('bridge.js 仍在硬编码路径');
+
+// ── 3. 测试 ──────────────────────────────────────────────────────────────
+const tests = run('node', ['--test']);
+const summary = (tests.out.match(/# tests (\d+)/) ?? tests.out.match(/ℹ tests (\d+)/) ?? [])[1];
+const failed = (tests.out.match(/# fail (\d+)/) ?? tests.out.match(/ℹ fail (\d+)/) ?? [])[1];
+if (tests.ok && failed === '0') ok('单元/集成测试', `${summary} 用例全过`);
+else bad('测试失败', `fail=${failed ?? '?'}`);
+
+const purity = run('node', ['scripts/check-core-purity.mjs']);
+if (purity.ok) ok('core 纯净性', purity.out.split('\n')[0].slice(0, 60));
+else bad('core 纯净性检查失败', purity.out);
+
+const smoke = run('node', ['scripts/host-smoke.mjs']);
+const smokeLine = (smoke.out.match(/(\d+)\/(\d+) 通过/) ?? []).slice(1).join('/');
+if (smoke.ok && smokeLine && smokeLine.split('/')[0] === smokeLine.split('/')[1]) ok('宿主冒烟', `${smokeLine} 通过`);
+else bad('宿主冒烟失败', smokeLine || smoke.out.slice(-200));
+
+// ── 4. npm ──────────────────────────────────────────────────────────────
+const whoami = run('npm', ['whoami'], { shell: true });
+info('npm 登录', whoami.ok ? whoami.out : '(未登录)');
+
+try {
+  const res = await fetch('https://registry.npmjs.org/dsh-qq-digest', { signal: AbortSignal.timeout(15000) });
+  if (res.status === 404) {
+    info('npm 包', '尚未创建');
+  } else {
+    const meta = await res.json();
+    const versions = Object.keys(meta.versions ?? {});
+    const latest = meta['dist-tags']?.latest;
+    info('npm 版本', versions.join(', ') || '(无)');
+    info('npm latest', String(latest));
+    info('npm maintainer', (meta.maintainers ?? []).map((m) => `${m.name}<${m.email}>`).join(', ') || '(无)');
+
+    if (versions.some((v) => v !== '0.0.0-stage')) {
+      ok('npm 已有正式版本', versions.filter((v) => v !== '0.0.0-stage').join(', '));
+    } else {
+      bad('npm 只有占位版 0.0.0-stage —— 暂存版本仍未批准', String(latest));
+    }
+  }
+} catch (err) {
+  bad('npm registry 查询失败', String(err.message));
+}
+
+// ── 5. GitHub ───────────────────────────────────────────────────────────
+const lsRemote = run('git', ['ls-remote', 'origin'], {
+  env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+  timeout: 20000,
+});
+if (lsRemote.ok && lsRemote.out !== '') {
+  const heads = lsRemote.out.split('\n').filter((line) => line.includes('refs/heads/'));
+  ok('GitHub 仓库可达', heads.length ? heads.map((h) => h.split('refs/heads/')[1]).join(',') : '(空仓库)');
+} else if (lsRemote.ok) {
+  info('GitHub 仓库', '存在但为空，可以直接 push');
+} else {
+  bad('GitHub 仓库不可达', lsRemote.err.split('\n').slice(0, 2).join(' '));
+}
+
+/**
+ * 猜不出端口就等于误报。这里从 DSH 自己留下的痕迹里取：
+ *  1) QQ_DIGEST_PORT（显式）
+ *  2) ~/.dsh/dsh-process.json 里记录的端口
+ *  3) 几个历史默认端口兜底
+ */
+function detectDshPorts() {
+  const ports = new Set([8784, 1402, 14802]);
+  try {
+    const home = process.env.DSH_HOME && process.env.DSH_HOME.trim() !== ''
+      ? process.env.DSH_HOME.trim()
+      : join(homedir(), '.dsh');
+    const parsed = JSON.parse(readFileSync(join(home, 'dsh-process.json'), 'utf8'));
+    for (const value of [parsed?.port, parsed?.webPort, parsed?.web?.port]) {
+      if (Number.isInteger(value) && value > 0) ports.add(value);
+    }
+  } catch {
+    // 没有就只试兜底端口
+  }
+  return [...ports];
+}
+
+// ── 6. DSH 运行态 ───────────────────────────────────────────────────────
+// DSH 的 Web 端口每次重启都可能变（同一台机器实测过 4845 / 1875 / 4260），
+// 因此优先用显式指定，其次才试历史端口，最后直接问 DSH 的进程信息。
+const explicitPort = process.env.QQ_DIGEST_PORT
+  || (process.argv.find((arg) => arg.startsWith('--port=')) ?? '').split('=')[1]
+  || '';
+const candidatePorts = [
+  ...(explicitPort === '' ? [] : [Number(explicitPort)]),
+  ...detectDshPorts(),
+];
+let base = null;
+for (const port of candidatePorts) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/qq-digest-api/state`, {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (res.status === 200) { base = `http://127.0.0.1:${port}`; break; }
+  } catch { /* 下一个端口 */ }
+}
+
+if (base === null) {
+  bad('DSH 里插件没在跑', `试过端口：${candidatePorts.join(', ') || '(无)'}；可用 QQ_DIGEST_PORT=<端口> 指定`);
+} else {
+  const state = await (await fetch(`${base}/qq-digest-api/state`, { headers: { accept: 'application/json' } })).json();
+  ok('宿主半在线', base);
+  if (typeof state.groupsEnabled === 'boolean') ok('群聊总开关在位', String(state.groupsEnabled));
+  else bad('宿主半是旧版本（缺 groupsEnabled）—— 需要重启 DSH');
+  if (Array.isArray(state.privateRooms)) {
+    ok('私聊列表中', `${state.privateRooms.length} 条，打开 ${state.privateRooms.filter((r) => r.enabled).length} 条`);
+  } else bad('宿主半是旧版本（缺 privateRooms）');
+  info('群数', String((state.rooms ?? []).length));
+  info('客户端心跳', state.clientBoot ? (state.clientBoot.mountedAt ? '已注册设置页' : `未注册（${state.clientBoot.lastError ?? state.clientBoot.lastPhase}）`) : '(旧版宿主无此字段)');
+}
+
+console.log(`\n${failures === 0 ? '全部通过' : `${failures} 项失败`}`);
+process.exit(failures === 0 ? 0 : 1);

package/scripts/host-smoke.mjs

@@ -47,12 +47,19 @@ if (captured.kind !== 'prefix' || captured.path !== '/qq-digest-api') {
   process.exit(1);
 }
 
-function request(handler, { method = 'GET', url, body }) {
+function request(handler, { method = 'GET', url, body, headers = {}, remoteAddress = '127.0.0.1' }) {
   return new Promise((resolve, reject) => {
     const req = new Readable({ read() {} });
     req.method = method;
     req.url = url;
-    req.socket = { remoteAddress: '127.0.0.1' };
+    // 真实请求一定带 Host；写操作还带 content-type。
+    // 宿主半现在会校验 Host / Origin / Sec-Fetch-Site，所以这里要把「正常浏览器」的形状补齐。
+    req.headers = {
+      host: '127.0.0.1:4845',
+      ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+      ...headers,
+    };
+    req.socket = { remoteAddress };
     if (body !== undefined) req.push(JSON.stringify(body));
     req.push(null);
 
@@ -175,6 +182,48 @@ const uniqueSave = await request(captured.handler, {
 });
 check('名字互不相同 → 200', uniqueSave.status === 200, uniqueSave.status);
 
+
+// ── 管理面来源校验（跨站 / rebinding / 隧道 / CSRF）──────────────────────
+// 这些用例锁住的是「只判 remoteAddress 不够」这件事本身：
+// 每一条的攻击前提都能让 remoteAddress 看起来是回环。
+const evilOrigin = await request(captured.handler, {
+  method: 'POST',
+  url: '/qq-digest-api/config',
+  body: { groupsEnabled: false },
+  headers: { origin: 'https://evil.example' },
+});
+check('跨站 Origin → 403', evilOrigin.status === 403 && evilOrigin.json.error === 'BAD_ORIGIN', `${evilOrigin.status} ${JSON.stringify(evilOrigin.json)}`);
+
+const evilHost = await request(captured.handler, { url: '/qq-digest-api/state', headers: { host: 'evil.example:4845' } });
+check('伪造 Host（DNS rebinding）→ 403', evilHost.status === 403 && evilHost.json.error === 'BAD_HOST', `${evilHost.status} ${JSON.stringify(evilHost.json)}`);
+
+const crossSite = await request(captured.handler, {
+  method: 'POST',
+  url: '/qq-digest-api/run',
+  body: {},
+  headers: { 'sec-fetch-site': 'cross-site' },
+});
+check('Sec-Fetch-Site: cross-site → 403', crossSite.status === 403 && crossSite.json.error === 'CROSS_SITE', `${crossSite.status} ${JSON.stringify(crossSite.json)}`);
+
+const textPlain = await request(captured.handler, {
+  method: 'POST',
+  url: '/qq-digest-api/config',
+  body: { groupsEnabled: true },
+  headers: { 'content-type': 'text/plain', origin: 'https://evil.example' },
+});
+check('text/plain 简单请求（CSRF）→ 被来源校验挡住', textPlain.status === 403 || textPlain.status === 415, `${textPlain.status} ${JSON.stringify(textPlain.json)}`);
+
+const sameOriginNoBody = await request(captured.handler, {
+  method: 'POST',
+  url: '/qq-digest-api/client-boot',
+  body: { phase: 'factory' },
+  headers: { origin: 'http://127.0.0.1:4845' },
+});
+check('同源 Origin + application/json → 放行', sameOriginNoBody.status === 200, `${sameOriginNoBody.status} ${JSON.stringify(sameOriginNoBody.json)}`);
+
+const nonLoopback = await request(captured.handler, { url: '/qq-digest-api/state', remoteAddress: '192.168.1.10' });
+check('非回环来源 → 403 LOCAL_ONLY', nonLoopback.status === 403 && nonLoopback.json.error === 'LOCAL_ONLY', `${nonLoopback.status} ${JSON.stringify(nonLoopback.json)}`);
+
 for (const result of results) {
   console.log(`${result.ok ? 'PASS' : 'FAIL'}  ${result.name}${result.detail === undefined ? '' : `  (${result.detail})`}`);
 }

package/scripts/install.mjs

@@ -68,7 +68,12 @@ if (!existsSync(patchFile)) {
 }
 
 const fragment = readFileSync(join(root, 'install', 'cordis.patch.fragment.yml'), 'utf8');
-const block = fragment.replace(/__PACKAGE_ROOT__/g, root.replace(/\\/g, '/')).trimEnd();
+const block = fragment
+  .replace(/__PACKAGE_ROOT__/g, root.replace(/\\/g, '/'))
+  // node 可执行文件必须取当前这台机器上的真实路径：写死任何一台机器的路径，
+  // 换机安装都会 spawn ENOENT，而症状是「工具全部消失、插件却像是装好了」。
+  .replace(/__NODE_EXE__/g, process.execPath.replace(/\\/g, '/'))
+  .trimEnd();
 
 const current = readFileSync(patchFile, 'utf8');
 

package/src/core/gate.js

@@ -26,10 +26,23 @@ export const REASON = Object.freeze({
   GROUP_DISABLED: 'GROUP_DISABLED',
 });
 
+/** 读取句柄：拿到它意味着「当前策略放行这个房间」。 */
 export function roomHandle(secret, canonicalId) {
   return createHmac('sha256', secret).update(`room:${canonicalId}`).digest('hex').slice(0, 16);
 }
 
+/**
+ * 审计引用：与读取句柄**必须不同域**。
+ *
+ * 拒绝分支也要能回一个稳定的、可对账但不泄漏标识的引用；但如果直接复用 roomHandle，
+ * 拒绝就等于把「读取凭据」发给了被拒绝的一方 —— 模型可以从 denied[] 里取到被拒绝房间的
+ * 句柄，再去读该房间的历史摘要，撤销语义直接失效。
+ * 因此审计引用走 `audit:` 域，它**不能**用来读任何东西。
+ */
+export function auditRefFor(secret, canonicalId) {
+  return createHmac('sha256', secret).update(`audit:${canonicalId}`).digest('hex').slice(0, 16);
+}
+
 export function createGate({ secret }) {
   if (typeof secret !== 'string' || secret.length < 16) {
     throw new Error('GATE_SECRET_TOO_SHORT');
@@ -47,7 +60,8 @@ export function createGate({ secret }) {
     }
 
     const { canonicalId, kind } = canon;
-    const auditRef = roomHandle(secret, canonicalId);
+    // 审计引用与读取句柄分属两个 HMAC 域：拒绝时只发放 auditRef，它读不了任何东西。
+    const auditRef = auditRefFor(secret, canonicalId);
 
     // 交叉校验：声明形态必须与数据源给出的权威类型一致，不一致即拒。
     if (authoritativeKind !== undefined && authoritativeKind !== null && authoritativeKind !== kind) {
@@ -68,7 +82,7 @@ export function createGate({ secret }) {
     return Object.freeze({
       verdict: VERDICT.ALLOW,
       kind,
-      roomHandle: auditRef,
+      roomHandle: roomHandle(secret, canonicalId),
       auditRef,
     });
   };

package/src/mcp-server.js

@@ -17,15 +17,28 @@
  */
 
 import { createInterface } from 'node:readline';
+import { readFileSync } from 'node:fs';
 
 import { createRuntime } from './runtime.js';
 import { withRunLock } from './run-lock.js';
 import { createToolHandlers } from './tools.js';
 import { TOOLS } from './core/toolSurface.js';
 
+/** 版本只有一个真相源：package.json。硬编码会漂（serverInfo 与包版本打对不上）。 */
+function readPackageVersion() {
+  try {
+    const parsed = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    return typeof parsed?.version === 'string' ? parsed.version : '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+const VERSION = readPackageVersion();
+
 const runtime = createRuntime();
 process.stderr.write(
-  `[qq-digest] source=${runtime.source} data=${runtime.dataDir} llmKey=${runtime.llm.apiKeySource}\n`,
+  `[qq-digest] source=${runtime.source} data=${runtime.dataDir} llmKey=${runtime.llm.apiKeySource} secretSource=${runtime.secretSource}\n`,
 );
 
 // run_summary 走跨进程锁；拿不到锁如实返回 ALREADY_RUNNING，而不是重复跑一轮。
@@ -63,7 +76,7 @@ rl.on('line', async (line) => {
         result: {
           protocolVersion: '2024-11-05',
           capabilities: { tools: {} },
-          serverInfo: { name: 'qq-digest', version: '0.2.0' },
+          serverInfo: { name: 'qq-digest', version: VERSION },
         },
       });
       return;

package/src/run-lock.js

@@ -8,10 +8,17 @@
  * 超过 lease 时限视为陈旧锁并抢占，避免进程崩溃后永久卡死。
  */
 
-import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 const DEFAULT_LEASE_MS = 10 * 60_000;
+/**
+ * 心跳间隔。租期只有 10 分钟，而一轮最坏可能跑几个小时
+ * （200 个房间上限 × LLM 单次 60s 超时 + 桥接 15s），所以必须续租：
+ * 否则「还在跑」的锁会被下一个触发者判成陈旧锁抢占，两轮并发写水位线，
+ * 表现为重复摘要与水位线互相覆盖 —— 也就是锁存在的唯一理由失效。
+ */
+const DEFAULT_HEARTBEAT_MS = 60_000;
 
 export function lockPath(dir) {
   return join(dir, 'run.lock');
@@ -22,18 +29,43 @@ export function lockPath(dir) {
  * @param {{ leaseMs?: number, now?: () => number }} [options]
  */
 export function acquireRunLock(dir, options = {}) {
-  const { leaseMs = DEFAULT_LEASE_MS, now = () => Date.now() } = options;
+  const {
+    leaseMs = DEFAULT_LEASE_MS,
+    heartbeatMs = DEFAULT_HEARTBEAT_MS,
+    now = () => Date.now(),
+  } = options;
   const path = lockPath(dir);
   const owner = { pid: process.pid, at: now() };
 
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
       mkdirSync(path);
-      writeFileSync(join(path, 'owner.json'), `${JSON.stringify(owner)}\n`, 'utf8');
+      const ownerFile = join(path, 'owner.json');
+      writeFileSync(ownerFile, `${JSON.stringify(owner)}\n`, 'utf8');
+
+      // 续租：age 判定看的是**目录** mtime，所以心跳除了刷新 owner.json 还要 touch 目录本身。
+      let timer = null;
+      if (heartbeatMs > 0) {
+        const period = Math.max(1_000, Math.min(heartbeatMs, Math.floor(leaseMs / 2)));
+        timer = setInterval(() => {
+          try {
+            const beat = { pid: process.pid, at: now() };
+            writeFileSync(ownerFile, `${JSON.stringify(beat)}\n`, 'utf8');
+            const at = new Date();
+            utimesSync(path, at, at);
+          } catch {
+            // 心跳失败不该让整轮失败：下一轮最多被判成陈旧锁，行为与没有心跳时相同。
+          }
+        }, period);
+        timer.unref?.();
+      }
+
       return {
         ok: true,
         path,
+        owner,
         release() {
+          if (timer) clearInterval(timer);
           try {
             rmSync(path, { recursive: true, force: true });
           } catch {

package/src/runtime.js

@@ -8,7 +8,8 @@
  *   DSH_HOME 空白视为未设置，绝不退回 cwd（否则换个目录启动就多一份空数据）。
  */
 
-import { readFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 
@@ -20,11 +21,11 @@ import { configPath, loadConfig } from './config.js';
 import { createSummarizerFromConfig } from './summarizer-factory.js';
 import { createService } from './service.js';
 import { resolveLlmConfig } from './llm-config.mjs';
-
-export const DEFAULT_SECRET = 'qq-digest-local-dev-secret-0123456789';
-
 import { resolveBridgePaths } from './bridge-paths.js';
 
+export const HANDLE_SECRET_FILE = 'handle-secret';
+export const MIN_SECRET_LENGTH = 16;
+
 export function resolveDshHome(env = process.env) {
   const fromEnv = env.DSH_HOME;
   if (typeof fromEnv === 'string' && fromEnv.trim() !== '') return resolve(fromEnv.trim());
@@ -37,9 +38,48 @@ export function resolveDataDir(env = process.env) {
   return join(resolveDshHome(env), 'qq-digest');
 }
 
-export function resolveSecret(env = process.env) {
-  const value = env.QQ_DIGEST_SECRET;
-  return typeof value === 'string' && value.length >= 16 ? value : DEFAULT_SECRET;
+export function secretPath(dataDir) {
+  return join(dataDir, HANDLE_SECRET_FILE);
+}
+
+/**
+ * 解析句柄 HMAC 密钥，并如实说明来源。
+ *
+ * 为什么不再有「默认常量」：常量写死在源码里，等于句柄可离线计算 ——
+ * 知道群号/QQ 号的人就能算出 handle 去定向读摘要，不透明句柄这层保护归零。
+ *
+ * 优先级：QQ_DIGEST_SECRET（>=16 字符）→ <dataDir>/handle-secret → 首次启动随机生成并落盘。
+ * 必须落盘：只存内存会让每次重启都换密钥，水位线（按句柄作键）全部作废，等于每次重启全量重跑。
+ */
+export function resolveSecretInfo(env = process.env, dataDir = resolveDataDir(env)) {
+  const fromEnv = env.QQ_DIGEST_SECRET;
+  if (typeof fromEnv === 'string' && fromEnv.trim().length >= MIN_SECRET_LENGTH) {
+    return { secret: fromEnv.trim(), source: 'env' };
+  }
+
+  const file = secretPath(dataDir);
+  try {
+    const existing = readFileSync(file, 'utf8').trim();
+    if (existing.length >= MIN_SECRET_LENGTH) return { secret: existing, source: 'file' };
+  } catch {
+    // 文件不存在 → 下面生成
+  }
+
+  const generated = randomBytes(32).toString('hex');
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(file, `${generated}\n`, { encoding: 'utf8', mode: 0o600 });
+  } catch (err) {
+    // 写不进去就拒绝启动：宁可工具不可用，也不要用一个「一看就知道」的密钥继续跑。
+    const failure = new Error(`HANDLE_SECRET_UNWRITABLE:${file}:${err?.message ?? err}`);
+    failure.code = 'HANDLE_SECRET_UNWRITABLE';
+    throw failure;
+  }
+  return { secret: generated, source: 'generated' };
+}
+
+export function resolveSecret(env = process.env, dataDir = resolveDataDir(env)) {
+  return resolveSecretInfo(env, dataDir).secret;
 }
 
 export function readBridgeToken(tokenFile) {
@@ -93,10 +133,14 @@ export function createRuntime(options = {}) {
 
   const store = options.store ?? createFileStore({ dir: dataDir });
   const watermark = options.watermark ?? createFileWatermark({ dir: dataDir });
+  const secretInfo = options.secret
+    ? { secret: options.secret, source: 'explicit' }
+    : resolveSecretInfo(env, dataDir);
 
   const service = createService({
     adapter,
-    secret: options.secret ?? resolveSecret(env),
+    secret: secretInfo.secret,
+    secretSource: secretInfo.source,
     store,
     watermark,
     getPolicy: () => readConfig().policy,
@@ -112,5 +156,17 @@ export function createRuntime(options = {}) {
     summarize: (input) => createSummarizerFromConfig(readConfig().config, { llm })(input),
   });
 
-  return { dataDir, source, adapter, llm, store, watermark, readConfig, configPath: configPath(dataDir), service };
+  return {
+    dataDir,
+    source,
+    adapter,
+    llm,
+    store,
+    watermark,
+    readConfig,
+    configPath: configPath(dataDir),
+    service,
+    secret: secretInfo.secret,
+    secretSource: secretInfo.source,
+  };
 }

package/src/service.js

@@ -40,6 +40,8 @@ export function createService(options = {}) {
     getPolicy: externalPolicyProvider,
     // 桥接不提供群名，允许外部按 rawId 补一个显示名（只用于展示，不参与裁决）。
     titleProvider = null,
+    // 密钥来源：env | generated | file | unknown。只用于如实上报，绝不外传值。
+    secretSource = 'unknown',
   } = options;
 
   if (!adapter) throw new Error('SERVICE_MISSING_ADAPTER');
@@ -142,16 +144,62 @@ export function createService(options = {}) {
   }
 
   function getDigest(handle) {
-    if (handle !== undefined && handle !== null && handle !== '') {
-      if (typeof handle !== 'string' || !/^[0-9a-f]{16}$/.test(handle)) {
-        return { status: 'REJECTED', reason: 'INVALID_HANDLE' };
-      }
+    return readDigest(handle);
+  }
+
+  /**
+   * 读取已落盘摘要。
+   *
+   * 关键约束：**读取也必须过闸门**。
+   * 句柄是不透明令牌，但它只证明「签发时策略放行过这个房间」，不证明「现在仍然放行」。
+   * 因此每次读取都先按当前策略对数据源现算一遍允许集，再与存储求交 ——
+   * 关掉某个群 / 关掉总开关之后，历史摘要立即读不到（撤销语义成立）。
+   *
+   * 数据源不可用时不允许「先读再说」：无法确认当前允许谁，就一律拒绝。
+   */
+  async function readDigest(handle) {
+    const hasHandle = handle !== undefined && handle !== null && handle !== '';
+    if (hasHandle && (typeof handle !== 'string' || !/^[0-9a-f]{16}$/.test(handle))) {
+      return { status: 'REJECTED', reason: 'INVALID_HANDLE' };
+    }
+
+    const allowed = await currentAllowedHandles();
+    if (!allowed.ok) {
+      return {
+        status: 'DENIED',
+        reason: 'SOURCE_UNAVAILABLE',
+        detail: allowed.error?.code ?? null,
+      };
+    }
+
+    if (hasHandle) {
+      // 不在允许集里，与「没有摘要」返回同一个结果：不告诉调用方它是否存在。
+      if (!allowed.handles.has(handle)) return { status: 'NOT_FOUND' };
       const entry = store.latest(handle);
       return entry ? { status: 'OK', entry } : { status: 'NOT_FOUND' };
     }
 
     const rows = typeof store.latestPerRoom === 'function' ? store.latestPerRoom() : dedupeLatest(store.all());
-    return { status: 'OK', count: rows.length, items: rows };
+    const visible = rows.filter((row) => allowed.handles.has(row.roomHandle));
+    return { status: 'OK', count: visible.length, items: visible };
+  }
+
+  /** 按当前策略现算「此刻允许读」的句柄集合。数据源失败时返回 ok:false。 */
+  async function currentAllowedHandles() {
+    const policy = resolvePolicy();
+    let rooms;
+    try {
+      rooms = await adapter.listRooms();
+    } catch (err) {
+      return { ok: false, error: { code: err?.code ?? 'ADAPTER_ERROR', message: String(err?.message ?? err) } };
+    }
+
+    const handles = new Set();
+    for (const room of rooms) {
+      const decision = gate({ policy, rawId: room.rawId, authoritativeKind: room.authoritativeKind });
+      if (decision.verdict === 'ALLOW') handles.add(decision.roomHandle);
+    }
+    return { ok: true, handles, policy };
   }
 
   async function status() {
@@ -173,8 +221,10 @@ export function createService(options = {}) {
       adapterError,
       digestCount: store.all().length,
       lastRun,
-      // 句柄密钥只报「是否设置」，绝不报值。
-      secretConfigured: typeof secret === 'string' && secret.length >= 16,
+      // 句柄密钥只报「是否设置」与「来源」，绝不报值。
+      // 注意：源码里不再有默认常量，因此 secretConfigured 不会再出现「恒真」的假保证。
+      secretConfigured: typeof secret === 'string' && secret.length >= 16 && secretSource !== 'default',
+      secretSource,
     };
   }
 

package/src/store-file.js

@@ -7,7 +7,7 @@
  * 损坏行启动时跳过并计数，不因为一行坏掉就丢整份历史。
  */
 
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { RECORD_FIELDS, fail } from './core/store.js';
@@ -23,26 +23,87 @@ export function createFileStore({ dir, now = () => new Date().toISOString() } =
   const entries = [];
   let skippedLines = 0;
   let allowed = new Set();
+  let stamp = null;
 
-  if (existsSync(file)) {
-    const text = readFileSync(file, 'utf8');
-    for (const line of text.split('\n')) {
-      const trimmed = line.trim();
-      if (trimmed === '') continue;
-      try {
-        const parsed = JSON.parse(trimmed);
-        if (parsed && typeof parsed.roomHandle === 'string') entries.push(parsed);
-        else skippedLines += 1;
-      } catch {
-        skippedLines += 1;
+  function currentStamp() {
+    try {
+      const stat = statSync(file);
+      return `${stat.mtimeMs}:${stat.size}`;
+    } catch {
+      return 'missing';
+    }
+  }
+
+  /** 载入时按落盘白名单重建：文件可能被别的进程改过，原样塞进内存等于绕过白名单。 */
+  function rebuildRecord(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    if (typeof raw.roomHandle !== 'string' || !/^[0-9a-f]{16}$/.test(raw.roomHandle)) return null;
+
+    const p = raw.provenance;
+    if (!p || typeof p.seqFrom !== 'number' || typeof p.seqTo !== 'number') return null;
+
+    const draft = {
+      roomHandle: raw.roomHandle,
+      roomTitle: typeof raw.roomTitle === 'string' ? raw.roomTitle.slice(0, 60) : null,
+      digest: sanitizeDigest(raw.digest),
+      provenance: {
+        roomHandle: raw.roomHandle,
+        seqFrom: p.seqFrom,
+        seqTo: p.seqTo,
+        ...(typeof p.messageCount === 'number' ? { messageCount: p.messageCount } : {}),
+      },
+      trigger: raw.trigger === 'scheduled' ? 'scheduled' : 'manual',
+      createdAt: typeof raw.createdAt === 'string' ? raw.createdAt : now(),
+    };
+
+    return Object.freeze(
+      Object.fromEntries(RECORD_FIELDS.filter((key) => key in draft).map((key) => [key, draft[key]])),
+    );
+  }
+
+  function loadFromDisk() {
+    entries.length = 0;
+    skippedLines = 0;
+    try {
+      const text = readFileSync(file, 'utf8');
+      for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '') continue;
+        try {
+          const rebuilt = rebuildRecord(JSON.parse(trimmed));
+          if (rebuilt) entries.push(rebuilt);
+          else skippedLines += 1;
+        } catch {
+          skippedLines += 1;
+        }
       }
+    } catch {
+      // 文件不存在 = 空表
     }
+    stamp = currentStamp();
+  }
+
+  /**
+   * 跨进程可见性：MCP 子进程写入的摘要，宿主进程（设置页）也必须看得到。
+   * 用 mtime+size 判断有没有变化，变了就整体重载 —— 比 tail 增量简单，
+   * 也不会因为读到半行而把一条合法记录判成损坏。
+   */
+  function refresh() {
+    if (currentStamp() !== stamp) loadFromDisk();
   }
 
+  loadFromDisk();
+
   return {
     dir,
     file,
-    skippedLines,
+
+    get skippedLines() {
+      refresh();
+      return skippedLines;
+    },
+
+    refresh,
 
     bindAllowed(handles) {
       allowed = new Set(Array.isArray(handles) ? handles : []);
@@ -78,14 +139,18 @@ export function createFileStore({ dir, now = () => new Date().toISOString() } =
 
       appendFileSync(file, `${JSON.stringify(stored)}\n`, 'utf8');
       entries.push(stored);
+      // 自己刚写过：记下新的 stamp，避免下一次读取又整体重载一遍。
+      stamp = currentStamp();
       return stored;
     },
 
     all() {
+      refresh();
       return entries.slice();
     },
 
     latest(roomHandle) {
+      refresh();
       for (let index = entries.length - 1; index >= 0; index -= 1) {
         if (entries[index].roomHandle === roomHandle) return entries[index];
       }
@@ -93,12 +158,14 @@ export function createFileStore({ dir, now = () => new Date().toISOString() } =
     },
 
     latestPerRoom() {
+      refresh();
       const map = new Map();
       for (const entry of entries) map.set(entry.roomHandle, entry);
       return [...map.values()];
     },
 
     dump() {
+      refresh();
       return JSON.stringify(entries);
     },
   };