dsh-qq-digest 0.1.0 → 0.2.0

package/scripts/smoke.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * 冒烟测试：用真实子进程跑一遍 MCP 协议，验证「装进去能用」而不只是「单元测试绿」。
+ *
+ * 用法：
+ *   node scripts/smoke.mjs                 # fixture 源（零副作用）
+ *   node scripts/smoke.mjs bridge          # 真桥接（只读；不会发消息）
+ *   node scripts/smoke.mjs snowluma        # 直连 SnowLuma（需网关在线）
+ *
+ * 它只发 tools/list 与三个只读工具的调用；run_summary 在 fixture 源下用本地启发式摘要，
+ * 不消耗模型额度。
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const source = process.argv[2] || 'fixture';
+const summarizer = process.argv[3] || 'heuristic';
+
+const dataDir = mkdtempSync(join(tmpdir(), 'qq-digest-smoke-'));
+// 把本机记录的 qq-bridge 位置带进临时数据目录，否则 bridge 源会退回 ~/AI/qq-bridge 而找不到令牌
+const realBridgeRoot = join(process.env.DSH_HOME?.trim() || join(homedir(), '.dsh'), 'qq-digest', 'bridge-root.txt');
+if (existsSync(realBridgeRoot)) writeFileSync(join(dataDir, 'bridge-root.txt'), readFileSync(realBridgeRoot, 'utf8'), 'utf8');
+writeFileSync(
+  join(dataDir, 'config.json'),
+  `${JSON.stringify(
+    {
+      version: 1,
+      groups: {},
+      summarizer,
+      schedule: { enabled: false, kind: 'daily', weekdays: ['MO'], time: '09:00', timeZone: 'Asia/Shanghai' },
+    },
+    null,
+    2,
+  )}\n`,
+  'utf8',
+);
+
+const child = spawn(process.execPath, [join(root, 'src', 'run-mcp.mjs')], {
+  env: { ...process.env, QQ_DIGEST_SOURCE: source, QQ_DIGEST_DATA_DIR: dataDir },
+  stdio: ['pipe', 'pipe', 'pipe'],
+});
+
+let stdout = '';
+let stderr = '';
+child.stdout.setEncoding('utf8');
+child.stderr.setEncoding('utf8');
+child.stdout.on('data', (chunk) => {
+  stdout += chunk;
+});
+child.stderr.on('data', (chunk) => {
+  stderr += chunk;
+});
+
+const requests = [
+  { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} },
+  { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} },
+  { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'qq_digest_status', arguments: {} } },
+  { jsonrpc: '2.0', id: 4, method: 'tools/call', params: { name: 'qq_digest_list_rooms', arguments: {} } },
+  { jsonrpc: '2.0', id: 5, method: 'tools/call', params: { name: 'qq_digest_run_summary', arguments: {} } },
+  { jsonrpc: '2.0', id: 6, method: 'tools/call', params: { name: 'qq_digest_get_digest', arguments: {} } },
+];
+
+for (const request of requests) {
+  child.stdin.write(`${JSON.stringify(request)}\n`);
+  await new Promise((resolve) => setTimeout(resolve, 400));
+}
+child.stdin.end();
+
+await new Promise((resolve) => {
+  const timer = setTimeout(() => {
+    child.kill();
+    resolve();
+  }, 25_000);
+  child.on('exit', () => {
+    clearTimeout(timer);
+    resolve();
+  });
+});
+
+const responses = new Map();
+for (const line of stdout.split('\n')) {
+  const trimmed = line.trim();
+  if (trimmed === '') continue;
+  try {
+    const message = JSON.parse(trimmed);
+    if (message.id !== undefined) responses.set(message.id, message);
+  } catch {
+    // 忽略非 JSON 行
+  }
+}
+
+function text(id) {
+  const message = responses.get(id);
+  if (!message) return '(无响应)';
+  if (message.error) return `ERROR ${message.error.message}`;
+  if (message.result?.tools) return message.result.tools.map((tool) => tool.name).join(', ');
+  return String(message.result?.content?.[0]?.text ?? '').replace(/\s+/g, ' ').slice(0, 700);
+}
+
+console.log(`source = ${source} / summarizer = ${summarizer}`);
+console.log(`stderr = ${stderr.trim().split('\n').slice(0, 2).join(' | ')}`);
+console.log(`tools  = ${text(2)}`);
+console.log(`status = ${text(3)}`);
+console.log(`rooms  = ${text(4)}`);
+console.log(`run    = ${text(5)}`);
+console.log(`digest = ${text(6)}`);
+
+const all = [...responses.values()].map((message) => JSON.stringify(message)).join('\n');
+const leaks = ['PRIVATE_SENTINEL', 'private:', '男人', 'EXCLUDED_SENTINEL'].filter((needle) => all.includes(needle));
+console.log(`private 泄漏检查 = ${leaks.length === 0 ? '通过（无 private 痕迹）' : `失败：${leaks.join(',')}`}`);

package/scripts/trigger.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * 命令行手动触发一次总结（走设置页同一套 API，不是另一条路径）。
+ *
+ * 用法：node scripts/trigger.mjs [端口]
+ *
+ * 它会真的调用模型（如果 config.summarizer === 'llm'），因此会产生少量费用。
+ */
+
+const PORTS = process.argv[2] ? [Number(process.argv[2])] : [8784, 1402, 14802];
+
+let base = null;
+for (const port of PORTS) {
+  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) {
+  console.error('找不到在跑的 DSH（8784/1402/14802 都没响应 /qq-digest-api/state）');
+  process.exit(1);
+}
+
+console.log(`目标 ${base}`);
+const started = Date.now();
+const res = await fetch(`${base}/qq-digest-api/run`, {
+  method: 'POST',
+  headers: { 'content-type': 'application/json' },
+  body: JSON.stringify({ trigger: 'manual' }),
+  signal: AbortSignal.timeout(180_000),
+});
+const payload = await res.json();
+console.log(`HTTP ${res.status}，耗时 ${Math.round((Date.now() - started) / 1000)}s`);
+
+const result = payload.result ?? {};
+console.log(`状态 ${result.status}`);
+console.log(`产出 ${(result.summarized ?? []).length} 个群 / 跳过 ${(result.skipped ?? []).length} / 拒绝 ${(result.denied ?? []).length} / 失败 ${(result.errors ?? []).length}`);
+
+for (const item of result.summarized ?? []) {
+  console.log(`  ✓ ${item.roomTitle ?? item.roomHandle}：${item.messageCount} 条消息 → ${item.highlights} 条重点 / ${item.tasks} 项待办`);
+}
+for (const item of result.skipped ?? []) {
+  console.log(`  - ${item.roomHandle}：${item.reason}`);
+}
+for (const item of result.errors ?? []) {
+  console.log(`  ✗ ${item.roomHandle}：${item.code} ${item.message}`);
+}
+
+// 打印每个群最新一篇摘要的要点数量，正文留给设置页看
+const state = await (await fetch(`${base}/qq-digest-api/state`, { headers: { accept: 'application/json' } })).json();
+for (const room of state.rooms ?? []) {
+  if (!room.hasDigest) continue;
+  const digest = await (await fetch(`${base}/qq-digest-api/digest?group=${room.groupId}`, { headers: { accept: 'application/json' } })).json();
+  const d = digest.digest ?? {};
+  console.log(`\n[${room.title ?? room.groupId}] ${room.lastDigestAt}`);
+  console.log(`  ${d.overview ?? '(无概述)'}`);
+  (d.tasks ?? []).slice(0, 3).forEach((task) => console.log(`  · 待办：${task.what}${task.owner && task.owner !== '未指定' ? `（${task.owner}）` : ''}`));
+}

package/scripts/verify-dsh.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * DSH 适配性自检：一次跑完「插件在宿主里到底活没活」的全部可观测证据。
+ *
+ * 检查项：
+ *   1) 宿主半：设置页 API 是否可达、返回什么
+ *   2) 客户端半：最近一次 web boot 有没有因为它失败（看 desktop 的 crash log）
+ *   3) MCP 行：run-mcp 进程是否在跑
+ *   4) 落盘：配置/摘要目录状态
+ *
+ * 用法：node scripts/verify-dsh.mjs [端口]
+ * 端口省略时按 8784 → 1402 → 14802 依次试。
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const PORTS = process.argv[2] ? [Number(process.argv[2])] : [8784, 1402, 14802];
+const LOG_DIR = join(homedir(), 'AppData', 'Roaming', '@deepseek-ai', 'dsh-desktop', 'logs');
+const DATA_DIR = join(process.env.DSH_HOME?.trim() || join(homedir(), '.dsh'), 'qq-digest');
+
+function ok(label, detail) {
+  console.log(`PASS  ${label}${detail ? `  ${detail}` : ''}`);
+}
+function bad(label, detail) {
+  console.log(`FAIL  ${label}${detail ? `  ${detail}` : ''}`);
+}
+
+let failures = 0;
+
+// 1) 宿主半
+let state = null;
+for (const port of PORTS) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/qq-digest-api/state`, {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(6000),
+    });
+    if (res.status === 200) {
+      state = await res.json();
+      ok('宿主半在线', `:${port} source=${state.source} 群=${state.rooms?.length ?? 0}`);
+      break;
+    }
+    console.log(`      :${port} HTTP ${res.status}`);
+  } catch {
+    console.log(`      :${port} 不可达`);
+  }
+}
+if (state === null) {
+  bad('宿主半未响应（DSH 没在跑，或行没挂上）');
+  failures += 1;
+} else {
+  if (Array.isArray(state.rooms) && state.rooms.length > 0) ok('群列表非空');
+  else bad('群列表为空（数据源不可达？）'), (failures += 1);
+  if (state.policyDegraded) bad('策略降级（配置损坏 → 全关）', state.configError), (failures += 1);
+  else ok('策略正常');
+  if (state.adapterError) bad('数据源报错', state.adapterError.message), (failures += 1);
+  else ok('数据源无报错');
+}
+
+// 2) 客户端半：看最近一次 web boot 是否因本插件失败
+try {
+  const clientFile = join(import.meta.dirname, '..', 'lib', 'client.js');
+  const fixTime = statSync(clientFile).mtimeMs;
+
+  const files = readdirSync(LOG_DIR)
+    .filter((name) => name.endsWith('-web-boot.log'))
+    .map((name) => ({ name, path: join(LOG_DIR, name), mtime: statSync(join(LOG_DIR, name)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  const newest = files[0];
+  if (!newest) {
+    console.log('SKIP  客户端半：没有 web-boot 崩溃日志可查（通常就是好事）');
+  } else if (newest.mtime < fixTime) {
+    // 修复之后还没重新加载过：既不能算通过，也不能把旧的失败算到新代码头上。
+    console.log(`SKIP  客户端半：修复后还没重新加载过（最近一次 boot ${new Date(newest.mtime).toISOString()} 早于 client.js ${new Date(fixTime).toISOString()}）`);
+  } else if (readFileSync(newest.path, 'utf8').includes('dsh-qq-digest: import failed')) {
+    bad('客户端半加载失败', `${newest.name} @ ${new Date(newest.mtime).toISOString()}`);
+    failures += 1;
+  } else {
+    ok('客户端半最近一次启动未报错', new Date(newest.mtime).toISOString());
+  }
+} catch (err) {
+  console.log(`SKIP  客户端半：读不到 desktop 日志目录（${err.code ?? err.message}）`);
+}
+
+// 3) MCP 行
+try {
+  const { execSync } = await import('node:child_process');
+  const out = execSync('tasklist /FI "IMAGENAME eq node.exe" /FO CSV', { encoding: 'utf8' });
+  ok('node 进程可枚举', `${out.split('\n').length - 2} 个（具体 run-mcp 进程见任务管理器）`);
+} catch {
+  console.log('SKIP  MCP 进程枚举失败');
+}
+
+// 4) 落盘
+const configFile = join(DATA_DIR, 'config.json');
+const digests = join(DATA_DIR, 'digests.jsonl');
+console.log(`     数据目录 ${DATA_DIR}`);
+console.log(`     config.json ${existsSync(configFile) ? '存在' : '不存在'}`);
+if (existsSync(digests)) {
+  const lines = readFileSync(digests, 'utf8').split('\n').filter(Boolean).length;
+  console.log(`     digests.jsonl ${lines} 条摘要`);
+} else {
+  console.log('     digests.jsonl 还没有（还没跑过总结）');
+}
+
+console.log(`\n${failures === 0 ? '全部通过' : `${failures} 项失败`}`);
+process.exit(failures === 0 ? 0 : 1);

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,
     };
   }