@ilaomianyang/dsh-memory-graph 0.10.4 → 0.12.0

package/src/history.js

@@ -0,0 +1,467 @@
+/**
+ * History: read the sessions that ran before this plugin existed.
+ *
+ * Capture only sees turns that arrive while the host is running, so a vault
+ * installed today starts empty and the person's past is not in it. The harness
+ * keeps every closed session on disk as `session.v4.jsonl.zstd`; this module
+ * replays those files through the same turn assembler the live listener uses, so
+ * a backfilled episode and a captured one are the same kind of record.
+ *
+ * Two things make it safe to run twice:
+ *   - a turn is identified by `(session, turn)`, and turns already in the vault
+ *     are skipped, so re-running after a session grew imports only the new part;
+ *   - the timestamps come from the session file, not from now, so history lands
+ *     in the right place on the timeline instead of piling up under today.
+ */
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import zlib from 'node:zlib'
+import { Decompress } from 'fzstd'
+
+import { createTurnAssembler, projectOf } from './turns.js'
+
+const SESSION_FILE = 'session.v4.jsonl.zstd'
+/** zstd in, JSON out: a cap so one enormous session cannot pin the process. */
+export const DEFAULT_MAX_BYTES = 512 * 1024 * 1024
+/** No single event is this large; a longer line means the stream is corrupt. */
+const MAX_LINE = 4 * 1024 * 1024
+
+/**
+ * A session file is not one zstd frame: the writer appends one frame per batch,
+ * so the file is a *concatenated container*. Both decoders that matter — Node's
+ * and fzstd's — stop at a frame boundary, which is why the raw walk of these
+ * files used to yield a single header line and nothing else.
+ *
+ * Node grew a zstd codec in 22.15 / 23.8 and decodes frames with full fidelity;
+ * the pure-JS fallback below refuses some high-accuracy FSE tables that real
+ * session files here do contain ("FSE accuracy too high"). A plugin cannot choose
+ * the runtime it lands in, so both paths exist and the report names the one that
+ * ran.
+ */
+const ZSTD_MAGIC = 0xfd2fb528
+const hasNativeZstd = typeof zlib.zstdDecompressSync === 'function'
+export const decoderKind = hasNativeZstd ? 'node-zstd' : 'fzstd'
+
+export function defaultSessionsDir() {
+  const home = process.env.DSH_HOME
+  if (typeof home === 'string' && home.trim() !== '') return path.join(home.trim(), 'sessions')
+  return path.join(os.homedir(), '.dsh', 'sessions')
+}
+
+/** The profile's session store: every closed session, newest modified first. */
+export async function listSessions(dir) {
+  const out = []
+  let groups = []
+  try {
+    groups = await fsp.readdir(dir, { withFileTypes: true })
+  } catch {
+    return out
+  }
+  for (const group of groups) {
+    if (!group.isDirectory()) continue
+    const groupDir = path.join(dir, group.name)
+    let entries = []
+    try {
+      entries = await fsp.readdir(groupDir, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const file = path.join(groupDir, entry.name, SESSION_FILE)
+      try {
+        const stat = await fsp.stat(file)
+        if (!stat.isFile()) continue
+        out.push({ file, size: stat.size, mtimeMs: stat.mtimeMs, group: group.name, dirName: entry.name })
+      } catch {
+        // A session directory without a log: the turn never produced anything.
+      }
+    }
+  }
+  // Newest first: with a limit, the recent past is what a person wants back.
+  out.sort((a, b) => b.mtimeMs - a.mtimeMs)
+  return out
+}
+
+/**
+ * Cut the inflated byte stream into lines, with a ceiling on how much of one
+ * session is read at all.
+ *
+ * A session log is tens of megabytes compressed and hundreds as text, and a
+ * backfill walks a hundred of them: nothing here holds the whole plaintext.
+ */
+function lineCutter(onLine, { maxBytes = DEFAULT_MAX_BYTES } = {}) {
+  let inflated = 0
+  let pending = ''
+  let stopped = false
+  let partial = false
+  return {
+    push(chunk) {
+      if (stopped || chunk.length === 0) return
+      inflated += chunk.length
+      pending += chunk.toString('utf8')
+      let cut = pending.indexOf('\n')
+      while (cut !== -1) {
+        const line = pending.slice(0, cut)
+        pending = pending.slice(cut + 1)
+        if (line.trim() !== '') onLine(line)
+        cut = pending.indexOf('\n')
+      }
+      if (pending.length > MAX_LINE || inflated > maxBytes) {
+        stopped = true
+        pending = ''
+      }
+    },
+    end() {
+      if (!stopped && pending.trim() !== '') onLine(pending)
+      pending = ''
+    },
+    /** The caller stopped early — a byte ceiling, not a corrupt file. */
+    markPartial() {
+      partial = true
+    },
+    get stopped() {
+      return stopped
+    },
+    get truncated() {
+      return stopped || partial
+    },
+    get inflated() {
+      return inflated
+    },
+  }
+}
+
+/**
+ * Frame boundaries, without decompressing: a correctness port of the scanner the
+ * harness itself uses for these files (zstd frame header, then 3-byte block
+ * headers, then an optional 4-byte checksum). A partial trailing frame is the
+ * normal state of a session that is still being written; its start is returned
+ * so the caller can ignore it rather than call it corruption.
+ */
+export function scanFrames(buffer) {
+  const frames = []
+  let offset = 0
+  while (offset < buffer.length) {
+    const start = offset
+    const torn = () => ({ frames, tornStart: start })
+    if (buffer.length - offset < 4) return torn()
+    if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) return torn()
+    offset += 4
+    if (offset === buffer.length) return torn()
+
+    const descriptor = buffer.readUInt8(offset)
+    offset += 1
+    // Reserved bits, or a window with no content size where one is required:
+    // reason enough to stop trusting the rest of the file.
+    if ((descriptor & 0b00011000) !== 0) return torn()
+    const contentSizeFlag = descriptor >>> 6
+    const singleSegment = (descriptor & 0b00100000) !== 0
+    const checksumFlag = (descriptor & 0b00000100) !== 0
+    const dictionaryFlag = descriptor & 0b11
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag
+    const contentSizeBytes = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << contentSizeFlag
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes
+    if (buffer.length - offset < remainingHeaderBytes) return torn()
+    offset += remainingHeaderBytes
+
+    for (;;) {
+      if (buffer.length - offset < 3) return torn()
+      const blockHeader = buffer.readUIntLE(offset, 3)
+      offset += 3
+      const lastBlock = (blockHeader & 1) !== 0
+      const blockType = (blockHeader >>> 1) & 0b11
+      const blockSize = blockHeader >>> 3
+      if (blockType === 3) return torn() // reserved block type
+      const payloadBytes = blockType === 1 ? 1 : blockSize // RLE blocks carry one byte
+      if (buffer.length - offset < payloadBytes) return torn()
+      offset += payloadBytes
+      if (lastBlock) break
+    }
+
+    if (checksumFlag) {
+      if (buffer.length - offset < 4) return torn()
+      offset += 4
+    }
+    frames.push({ start, end: offset })
+  }
+  return { frames }
+}
+
+async function readBytes(file, { maxBytes = DEFAULT_MAX_BYTES } = {}) {
+  const handle = await fsp.open(file, 'r')
+  try {
+    const { size } = await handle.stat()
+    const want = Math.max(0, Math.min(size, maxBytes))
+    const buffer = Buffer.allocUnsafe(want)
+    let read = 0
+    while (read < want) {
+      const { bytesRead } = await handle.read(buffer, read, want - read, read)
+      if (bytesRead === 0) break
+      read += bytesRead
+    }
+    return { buffer: buffer.subarray(0, read), size, partial: want < size }
+  } finally {
+    await handle.close()
+  }
+}
+
+/** The reference decoder: every frame zstd can produce, one frame at a time. */
+async function readLinesNative(file, onLine, options) {
+  const cutter = lineCutter(onLine, options)
+  const { buffer, partial } = await readBytes(file, options)
+  if (partial) cutter.markPartial()
+
+  let torn = false
+  let failed = 0
+  for (const { start, end } of scanFrames(buffer).frames) {
+    let plain
+    try {
+      plain = zlib.zstdDecompressSync(buffer.subarray(start, end))
+    } catch {
+      // One frame the codec refuses (a truncated append after a crash) should
+      // cost that batch, not the session.
+      failed += 1
+      continue
+    }
+    cutter.push(plain)
+    if (cutter.stopped) break
+  }
+  torn = failed > 0
+  cutter.end()
+  if (torn && cutter.inflated === 0) throw new Error('这个会话文件里没有可解码的 zstd 帧')
+  return cutter
+}
+
+/** The fallback for a Node without a zstd codec: pure JS, most frames. */
+async function readLinesFallback(file, onLine, options) {
+  const cutter = lineCutter(onLine, options)
+  const decoder = new Decompress((chunk) => cutter.push(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)))
+  const { buffer, partial } = await readBytes(file, options)
+  if (partial) cutter.markPartial()
+  decoder.push(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength), true)
+  cutter.end()
+  return cutter
+}
+
+async function readLines(file, onLine, options) {
+  return hasNativeZstd ? readLinesNative(file, onLine, options) : readLinesFallback(file, onLine, options)
+}
+
+/** Every `(session, turn)` the vault already has, so a re-run imports nothing twice. */
+export async function existingTurns(vault) {
+  const seen = new Set()
+  let files = []
+  try {
+    files = typeof vault.episodeFiles === 'function' ? await vault.episodeFiles() : []
+  } catch {
+    return seen
+  }
+  const dir = vault.paths?.episodes
+  if (typeof dir !== 'string') return seen
+  for (const name of files) {
+    let text = ''
+    try {
+      text = await fsp.readFile(path.join(dir, name), 'utf8')
+    } catch {
+      continue
+    }
+    for (const line of text.split('\n')) {
+      if (line.trim() === '') continue
+      try {
+        const record = JSON.parse(line)
+        if (typeof record?.session === 'string') seen.add(`${record.session}#${record.turn ?? ''}`)
+      } catch {
+        // A half-written last line from a crash; the next run sees it whole.
+      }
+    }
+  }
+  return seen
+}
+
+/**
+ * One replayed session, fed a line at a time.
+ *
+ * Kept separate from the file reading so the filter, the dedupe and the
+ * timestamps can be tested on hand-written events — the part that matters is the
+ * policy, not the decompressor.
+ */
+export function createReplay({ sessionId = '', project = '', cfg, redactor, seen }) {
+  const assembler = createTurnAssembler({ cfg, redactor })
+  const episodes = []
+  let id = sessionId
+  let cwd = ''
+  let closedTurns = 0
+  let duplicates = 0
+  let malformed = 0
+
+  const keep = (episode) => {
+    const key = `${episode.session}#${episode.turn ?? ''}`
+    if (seen.has(key)) {
+      duplicates += 1
+      return
+    }
+    seen.add(key)
+    episodes.push(episode)
+  }
+
+  return {
+    feed(line) {
+      let event
+      try {
+        event = JSON.parse(line)
+      } catch {
+        malformed += 1
+        return
+      }
+      if (event?.type === 'session') {
+        if (typeof event.id === 'string' && event.id !== '') id = event.id
+        if (typeof event.cwd === 'string') cwd = event.cwd
+        return
+      }
+      if (event?.type === 'turn/end') closedTurns += 1
+      for (const episode of assembler.push({
+        sessionId: id,
+        project: projectOf({ cwd }, cfg.defaultProject),
+        event,
+      })) {
+        keep(episode)
+      }
+    },
+
+    /** A session whose last turn never closed still holds a real message. */
+    finish() {
+      for (const episode of assembler.flushAll()) keep(episode)
+      return {
+        id,
+        project: projectOf({ cwd }, cfg.defaultProject),
+        cwd,
+        closedTurns,
+        episodes,
+        duplicates,
+        malformed,
+      }
+    },
+  }
+}
+
+/** Replay one session file, then write what the vault does not have. */
+export async function importSession({ entry, cfg, vault, redactor, seen, dryRun = false, maxBytes, collect = null }) {
+  const replay = createReplay({ sessionId: entry.dirName, cfg, redactor, seen })
+  let failure = null
+  let inflated = 0
+  let truncated = false
+  try {
+    const cutter = await readLines(entry.file, (line) => replay.feed(line), { maxBytes })
+    inflated = cutter.inflated
+    truncated = cutter.truncated
+  } catch (error) {
+    // One unreadable file must not end a backfill that has hundreds of others:
+    // the report says which one failed and the run carries on.
+    failure = error?.message ?? String(error)
+  }
+
+  const report = replay.finish()
+
+  if (Array.isArray(collect)) collect.push(...report.episodes)
+  if (!dryRun) {
+    for (const episode of report.episodes) await vault.appendEpisode(episode)
+  }
+
+  return {
+    ...report,
+    episodes: report.episodes.length,
+    truncated,
+    failure,
+    inflated,
+    file: entry.file,
+    size: entry.size,
+  }
+}
+
+/**
+ * Walk the store, newest session first, and import what the vault does not have.
+ *
+ * Returns a report rather than logging: the tool formats it, the tests assert on
+ * it, and a person reads the same numbers.
+ */
+export async function runBackfill({
+  cfg,
+  vault,
+  redactor,
+  dir = defaultSessionsDir(),
+  limit = 0,
+  dryRun = false,
+  maxBytes = DEFAULT_MAX_BYTES,
+  onProgress = null,
+  collect = null,
+}) {
+  const started = Date.now()
+  const seen = await existingTurns(vault)
+  const all = await listSessions(dir)
+  const selected = limit > 0 ? all.slice(0, limit) : all
+
+  const sessions = []
+  let imported = 0
+  let duplicates = 0
+  let budget = maxBytes
+  let exhausted = false
+
+  for (const entry of selected) {
+    if (budget <= 0) {
+      exhausted = true
+      break
+    }
+    const report = await importSession({ entry, cfg, vault, redactor, seen, dryRun, maxBytes: budget, collect })
+    budget -= entry.size
+    imported += report.episodes
+    duplicates += report.duplicates
+    sessions.push(report)
+    onProgress?.(report)
+  }
+
+  // Views last, and only when something changed: `README.md` and `graph.html` are
+  // rendered from the cards, so an import that adds episodes but no cards changes
+  // nothing on either. The *reason* to do it here is that a backfill is the one
+  // operation that can add hundreds of episodes after the last render, and a stale
+  // view is indistinguishable from an empty vault when a person opens the file.
+  let refreshed = false
+  const previous = { readme: true, graph: true }
+  if (!dryRun && imported > 0) {
+    for (const [key, render] of [
+      ['readme', vault.regenerateReadme],
+      ['graph', vault.regenerateGraph],
+    ]) {
+      if (typeof render !== 'function') {
+        previous[key] = false
+        continue
+      }
+      try {
+        await render.call(vault)
+      } catch {
+        // A view that will not render must not lose the episodes that just landed.
+        previous[key] = false
+      }
+    }
+    refreshed = Object.values(previous).some(Boolean)
+  }
+
+  return {
+    dir,
+    dryRun,
+    decoder: decoderKind,
+    found: all.length,
+    scanned: sessions.length,
+    imported,
+    duplicates,
+    exhausted,
+    refreshed,
+    malformed: sessions.reduce((n, s) => n + s.malformed, 0),
+    failed: sessions.filter((s) => s.failure !== null).length,
+    ms: Date.now() - started,
+    sessions: sessions
+      .filter((s) => s.episodes > 0 || s.duplicates > 0 || s.closedTurns > 0 || s.failure !== null)
+      .sort((a, b) => b.episodes - a.episodes),
+  }
+}

package/src/pageapi.js

@@ -22,14 +22,14 @@ function failure(error) {
 <style>body{font:14px/1.6 system-ui,sans-serif;margin:0;display:grid;place-items:center;height:100vh;color:#333}
 main{max-width:34rem;padding:2rem}code{background:#f4f4f5;padding:.1rem .3rem;border-radius:4px}</style>
 <main><h1>记忆图没能画出来</h1><p><code>${escaped}</code></p>
-<p>The graph could not be rendered. The vault is still on disk; nothing was written.</p></main></html>`
+<p>图谱渲染失败了，但记忆库还在磁盘上，什么都没写 · The graph could not be rendered. The vault is still on disk; nothing was written.</p></main></html>`
 }
 
 export function createPageHandler({ getVault }) {
   return async function fetch() {
     const vault = getVault()
     if (!vault || typeof vault.graphPage !== 'function') {
-      return html(failure(new Error('vault unavailable')), 500)
+      return html(failure(new Error('记忆库不可用 · vault unavailable')), 500)
     }
     try {
       return html(await vault.graphPage())

package/src/schema.js

@@ -292,6 +292,60 @@ const auto = z.object({
       .default('')
       .description('自动蒸馏记到哪个项目；空 = 最近情节的项目 · project for automatic cards; empty = the newest episode\'s project'),
   ),
+  catchUp: live(
+    z
+      .boolean()
+      .default(false)
+      .description('追平模式：只要还攒着一整批就按自己的节奏一批批蒸下去 · catch-up: keep distilling batch after batch while a full batch is still waiting'),
+  ),
+  catchUpEveryMinutes: live(
+    z
+      .number()
+      .min(1)
+      .max(1440)
+      .step(1)
+      .default(10)
+      .description('追平模式每批之间隔多少分钟 · minutes between catch-up batches'),
+  ),
+  maxBatchesPerDay: live(
+    z
+      .number()
+      .min(0)
+      .max(200)
+      .step(1)
+      .default(6)
+      .description('一天最多自动蒸几批；0 = 不限 · most automatic batches per day; 0 lifts the cap'),
+  ),
+})
+
+const update = z.object({
+  enabled: live(
+    z
+      .boolean()
+      .default(true)
+      .description('定期检查 npm 上有没有新版本（只查，不装）· check npm for a newer version (checks only, never installs)'),
+  ),
+  checkEveryHours: live(
+    z
+      .number()
+      .min(1)
+      .max(720)
+      .step(1)
+      .default(12)
+      .description('查到的结果保持多久 · hours a check result stays good for'),
+  ),
+  autoInstall: live(
+    z
+      .boolean()
+      .default(false)
+      .description('启动时发现新版本就自动装（link: 本地安装会拒绝）· install a newer version at startup; a link: install is refused'),
+  ),
+  registry: live(
+    z
+      .string()
+      .default('')
+      .description('用哪个 npm 源查版本；空 = 宿主的源，再退到 npmjs · registry to ask; empty = the harness\'s, then npmjs'),
+  ),
 })
 
 export const Config = z.object({
@@ -317,6 +371,7 @@ export const Config = z.object({
   privacy,
   extractor,
   auto,
+  update,
   retrieval,
 })
 

package/src/tools.js

@@ -1,5 +1,5 @@
 /**
- * The model-facing surface. Seven small tools, all explicit.
+ * The model-facing surface. Eight small tools, all explicit.
  *
  * Nothing here runs on its own: retrieval only happens when the agent decides
  * to ask, which keeps memory out of the context (and out of the attention
@@ -8,6 +8,7 @@
 import path from 'node:path'
 import { searchCards, timelineCards } from './search.js'
 import { distill, extractorServices, resolveRoute } from './extract.js'
+import { runBackfill, defaultSessionsDir } from './history.js'
 import { CARD_KINDS, CONFIDENCE, slugify } from './vault.js'
 
 const OUTPUT_SCHEMA = { type: 'object', additionalProperties: true }
@@ -56,6 +57,27 @@ function formatHits(hits) {
  */
 
 /** One line describing what a distill call would do right now, for memory_stats. */
+/**
+ * The version line for memory_stats.
+ *
+ * Deliberately silent about a newer version when the check has not run yet: "no
+ * news" must not read as "you are up to date", and a check is an outbound request
+ * that a person did not necessarily just make.
+ */
+function describeUpdate(getUpdate) {
+  if (typeof getUpdate !== 'function') return '版本 version: 更新检查不可用 · update check unavailable'
+  let state = null
+  try {
+    state = getUpdate()
+  } catch {
+    return '版本 version: 更新检查不可用 · update check unavailable'
+  }
+  if (state === null || typeof state !== 'object' || state.current === null) return '版本 version: 未知 · unknown'
+  const current = `版本 version: \`${state.current}\``
+  if (state.latest === null) return `${current} · 还没有检查过更新 · no update check yet`
+  if (state.latest === state.current) return `${current} · 已是最新 · latest`
+  return `${current} · 有新版本 \`${state.latest}\`（设置页可更新）· newer version available`
+}
 function describeExtractor(ctx, cfg) {
   if (!cfg.extractor.enabled) return 'extractor: off (nothing calls a model)'
   if (cfg.extractor.transport === 'http') {
@@ -72,7 +94,7 @@ function describeExtractor(ctx, cfg) {
   }
 }
 
-export function registerTools(ctx, { cfg, vault, redactor, runner = null }) {
+export function registerTools(ctx, { cfg, vault, redactor, runner = null, getUpdate = null }) {
   const disposers = []
 
   /**
@@ -524,11 +546,63 @@ export function registerTools(ctx, { cfg, vault, redactor, runner = null }) {
           describeExtractor(ctx, cfg),
           `privacy rules: ${stats.privacy.rules}`,
           `views: README.md and graph.html in the vault root (open the HTML directly, no server needed)`,
+          describeUpdate(getUpdate),
         ].join('\n')
         return { ...stats, text }
       },
     }),
   )
 
+  /* --------------------------------------------------------------- backfill */
+  disposers.push(
+    ctx.tools.register({
+      name: 'memory_backfill',
+      description:
+        '把「安装插件之前的」会话历史一次性导入记忆库。采集只在宿主运行时看得见当轮对话，所以新装的记忆库一开始是空的；这个工具回放磁盘上的历史会话文件（~/.dsh/sessions 下的 session.v4.jsonl.zstd），走的是与实时采集完全相同的过滤与脱敏逻辑，因此回填出来的情节和实时采集的是同一种记录。可重复执行：已经导入过的轮次会跳过，只补新的部分；时间戳用会话文件里的原始时间，所以历史落在时间轴的正确位置。默认只统计不写库（dryRun），确认后再真正导入。',
+      parameters: {
+        type: 'object',
+        properties: {
+          dryRun: { type: 'boolean', description: '只统计会导入多少条，不写库。默认 true。' },
+          limit: { type: 'integer', minimum: 0, description: '最多回填多少个会话，按最近修改时间优先。0 = 全部。默认 0。' },
+          sessionsDir: {
+            type: 'string',
+            description: '会话存储目录。省略则用环境变量 DSH_HOME 下的 sessions，再退到 ~/.dsh/sessions。',
+          },
+        },
+        additionalProperties: false,
+      },
+      output: { schema: OUTPUT_SCHEMA, render: (args, value) => json(args, value.text ?? value) },
+      async execute(args) {
+        const dryRun = args.dryRun !== false
+        const report = await runBackfill({
+          cfg,
+          vault,
+          redactor,
+          dir: args.sessionsDir ?? defaultSessionsDir(),
+          limit: args.limit ?? 0,
+          dryRun,
+        })
+
+        const lines = [
+          `${dryRun ? '试运行' : '已导入'}：会话目录 ${report.dir}（解码器 ${report.decoder}）`,
+          `扫描 ${report.scanned} / 共找到 ${report.found} 个会话，用时 ${(report.ms / 1000).toFixed(1)}s`,
+          `${dryRun ? '将写入' : '已写入'} ${report.imported} 条情节；已存在跳过 ${report.duplicates} 条${report.malformed > 0 ? `；坏行 ${report.malformed} 条` : ''}${report.failed > 0 ? `；读不了 ${report.failed} 个会话` : ''}`,
+        ]
+        if (report.exhausted) lines.push('达到单次读取上限，剩下的会话下次再跑即可（已导入的会自动跳过）。')
+        if (report.sessions.length > 0) {
+          lines.push('贡献最多的会话：')
+          for (const session of report.sessions.slice(0, 5)) {
+            lines.push(`  ${session.id}  ${session.project}  ${session.episodes} 条${session.duplicates > 0 ? `（跳过 ${session.duplicates}）` : ''}`)
+          }
+        }
+        if (report.imported > 0 && !dryRun) {
+          lines.push('这些情节还没有变成卡片：蒸馏一次（memory_distill 或设置页的「蒸馏一次」）才会进入检索层。')
+          if (report.refreshed === true) lines.push('README.md 和 graph.html 已经按新情节重画过一次。')
+        }
+        return { ...report, text: lines.join('\n') }
+      },
+    }),
+  )
+
   return disposers
 }