dsh-anima 0.0.0-stage → 2.2.2

package/lib/injection.mjs

@@ -0,0 +1,280 @@
+// lib/injection.mjs — 会话注入消息的 source 构造（纯函数，仅依赖 node 内建）
+//
+// 为什么必须自持 kind（与某同类人设插件的行为对齐：同样自持 kind，但名字取本包自己的）：
+// 会话格式 v4 的来源准入明确拒绝共享的 `kind: 'plugin'`：
+//
+//   if (typeof value.kind !== 'string' || value.kind.length === 0 || value.kind === 'plugin')
+//     throw new SessionFormatError('format v4 message requires a producer-owned source kind')
+//
+// 也就是说不声明自持 kind 的话，注入会把**每一轮**都打成失败。
+// 本插件只在「每晚整理完成」时注入一次（低频），但仍必须走合规来源。
+
+import { randomUUID } from 'node:crypto'
+
+/** 生产者自持 kind：取 `plugin:<包名>` 形态，与 v3→v4 迁移的回落分支保持同一身份。 */
+export const INJECTION_PRODUCER_KIND = 'plugin:dsh-anima'
+
+/** 快照区块名，与 systemPrompt section 的 name 对应。 */
+export const INJECTION_SECTION_NAME = 'anima:identity'
+
+/**
+ * 构造一条**模型可见**的注入消息。
+ *
+ * 与 `createInjectionSource` 的区别：那个只造 source（供宿主自己拼消息时用），
+ * 这个直接返回可 push 进 messages 的完整 user 消息。pre-step 钩子需要后者。
+ *
+ * 三个字段都不是可选的：
+ *   - `kind` 必须自持（会话格式 v4 拒绝共享的 `plugin`，见文件头）；
+ *   - `form: 'snapshot'` 声明这是快照而非用户发言 —— 用它冒充用户会污染对话历史；
+ *   - `sections` 必须给出文本，否则宿主无法把这条消息归档回具体区块。
+ *
+ * @param {string} text 注入文本
+ * @param {string} [sectionName] 区块名，默认用质检段的
+ * @returns {object}
+ */
+export function createNoticeMessage(text, sectionName = QUALITY_SECTION_NAME) {
+  return {
+    // 与宿主 createMessage() 同构：消息必须自带稳定 id。
+    // 缺 id 的消息落库时无人校验，但加载时 assertMessageEventShape 会拒收，
+    // 后果是**整个会话打不开**（session event at seq N lacks an identified message）。
+    // 这里自持 id，不再依赖外部 pre-step 钩子事后补齐。
+    id: randomUUID(),
+    role: 'user',
+    content: [{ type: 'text', text }],
+    source: {
+      kind: INJECTION_PRODUCER_KIND,
+      form: 'snapshot',
+      sections: [{ name: sectionName, text }]
+    }
+  }
+}
+
+/**
+ * 构造注入消息的 source：自持 kind + snapshot 形态 + 命名区块。
+ * @param {string} snapshotText 注入给模型的快照文本
+ * @returns {{kind: string, form: string, sections: Array<{name:string,text:string}>}}
+ */
+export function createInjectionSource(snapshotText) {
+  return {
+    kind: INJECTION_PRODUCER_KIND,
+    form: 'snapshot',
+    sections: [{ name: INJECTION_SECTION_NAME, text: snapshotText }]
+  }
+}
+
+/**
+ * 每晚整理完成后的通知文案。
+ *
+ * **没事就说空串，调用方据此不注入。** 这条规则来自用户（m05776）：
+ * 「有需要汇报的就汇报没有就不汇报」。修改前这段文案无条件返回，
+ * 于是出现过注入「待审：0 条（整理前 0 条，自动去重/合并 0 条，超限淘汰 0 条）」
+ * 的情况 —— 一条纯粹占注意力的通知，正是这个规则要消灭的形状。
+ *
+ * 判据全在 summary 里，不含任何模型判断：
+ *   - 整理后仍有待审候选，或
+ *   - 这次真的动了数据（去重 / 超限淘汰）
+ *
+ * @param {object} summary triage() 的 summary
+ * @param {string[]} [pendingTitles] 存活候选的正文
+ * @returns {string} 无事可说时返回空串（不是空行，是 ''）
+ */
+export function triageNoticeText(summary, pendingTitles) {
+  const after = Number(summary?.pendingAfter ?? 0)
+  const removed = Number(summary?.duplicatesRemoved ?? 0) + Number(summary?.overflowRemoved ?? 0)
+  if (after <= 0 && removed <= 0) return ''
+
+  const lines = [
+    '[dsh-anima 记忆缓冲区] 每晚整理已完成。',
+    `待审：${after} 条（整理前 ${summary.pendingBefore} 条，自动去重/合并 ${summary.duplicatesRemoved} 条，超限淘汰 ${summary.overflowRemoved} 条）。`
+  ]
+  if (Array.isArray(pendingTitles) && pendingTitles.length > 0) {
+    lines.push('', '等待你裁决的候选：')
+    for (const title of pendingTitles.slice(0, 10)) lines.push(`- ${title}`)
+    if (pendingTitles.length > 10) lines.push(`- …还有 ${pendingTitles.length - 10} 条`)
+  }
+  lines.push('', '请在「设置 → 灵台」里逐条采纳或丢弃；未裁决的候选不会进入我的长期记忆。')
+  return lines.join('\n')
+}
+
+/**
+ * 巡夜汇报文案：每晚到点把「机器数得出来的事」汇总成一条。
+ *
+ * 与 triageNoticeText 的分工：那个只讲缓冲区整理，这个讲整晚的结论（缓冲区 +
+ * 体检），同一晚只该出现一条。合并由调用方做（runPatrol 里传 triage 进来）。
+ *
+ * 措辞约束（同样是防止这条提醒变成表演）：
+ *   ① 只列数字与来源，不写「我注意到你最近…」——那种话零新信息，全是编的；
+ *   ② 必须写「没报的是什么」，否则用户会以为查过的地方都没问题；
+ *   ③ 结尾给出可反查的出口（哪个命令/哪个页面能自己复算）。
+ *
+ * @param {object} input
+ * @param {{pending:number, flagged:number, removed:number}} input.facts
+ * @param {string[]} [input.pendingTitles]
+ * @param {Array<{id:string, text:string, findings:Array}>} [input.flaggedDetails]
+ * @param {object|null} [input.triage] 当晚的整理 summary（没有就传 null）
+ * @param {number} [input.checked] 体检扫过的记忆条数
+ * @returns {string}
+ */
+export function patrolNoticeText({ facts, pendingTitles = [], flaggedDetails = [], triage = null, checked = 0 }) {
+  const f = facts ?? {}
+  const lines = ['[dsh-anima 巡夜] 到点跑完，有下面这些要你看一眼。']
+
+  if (Number(f.pending) > 0) {
+    lines.push('', `待审候选：${f.pending} 条（未裁决的不会进长期记忆）`)
+    for (const title of pendingTitles.slice(0, 5)) lines.push(`- ${title}`)
+    if (pendingTitles.length > 5) lines.push(`- …还有 ${pendingTitles.length - 5} 条`)
+  }
+
+  if (Number(f.flagged) > 0) {
+    lines.push('', `记忆体检：${f.flagged} 条需要你判（扫了 ${checked} 条）`)
+    for (const item of flaggedDetails.slice(0, 5)) {
+      const first = Array.isArray(item.findings) ? item.findings[0] : null
+      lines.push(`- ${first?.detail ?? item.text}`)
+      lines.push(`  ${`/anima mark ${item.id} state=contradicted`}`)
+    }
+    if (flaggedDetails.length > 5) lines.push(`- …还有 ${flaggedDetails.length - 5} 条，看设置页「记忆体检」`)
+  }
+
+  if (Number(f.removed) > 0) {
+    lines.push('', `整理时动过 ${f.removed} 条（去重或超限淘汰），明细在设置页的整理记录里`)
+  }
+
+  if (triage && Number(triage.pendingBefore) !== Number(triage.pendingAfter) && Number(f.pending) === 0) {
+    lines.push('', `缓冲区：${triage.pendingBefore} → ${triage.pendingAfter} 条`)
+  }
+
+  // ③ 必须写清这次没说什么。只报查到的问题，会让人误以为剩下的都通过了。
+  const silent = []
+  if (Number(f.pending) === 0) silent.push('待审候选（0 条）')
+  if (Number(f.flagged) === 0) silent.push('体检问题（0 条）')
+  lines.push(
+    '',
+    `没报的：${silent.join('、') || '无'}。`,
+    '这两个数可以自己复算：设置页的记忆体检按钮，或 `GET /api/anima/memory/audit`。',
+    '「这条记忆还算不算数」不在巡夜范围内 —— 那需要理解语义，代码不判。'
+  )
+  return lines.join('\n')
+}
+
+/**
+ * 人设配置变更后的告知文案。
+ *
+ * 为什么需要单独注入一句：system prompt 的段落是每轮重新装配的，改完下一轮就已经是
+ * 新内容；但**对话历史里**仍然躺着旧设定生效期间的那条系统提示。模型看得到两套规则，
+ * 而没有任何东西告诉它哪套算数 —— 它会倾向沿用先出现的那套，于是「改了没生效」。
+ * 一句明说「刚才那套作废」比重新注入整份提示词便宜得多，也够用。
+ *
+ * 只列字段名不列新值：新值已经在下一轮的提示词里了，重复一遍只是浪费上下文。
+ *
+ * 措辞刻意不写「用户刚刚改了」：同一个函数既服务于用户在设置页的改动，也服务于
+ * 模型自己调用的 `set_assistant_persona`（工具确认关闭时它直接落盘）。把来源如实
+ * 写出来，比默认假称是用户做的更可信 —— 这条消息的作用是让模型知道自己手上的
+ * 设定来自哪里。
+ *
+ * @param {string[]} changedKeys 发生变化的配置键
+ * @param {string} [source] 变更来源的可读标注（设置页 / 命令 / 模型工具 / 本工作区覆盖）
+ * @returns {string}
+ */
+export function configChangedNoticeText(changedKeys, source = '设置页') {
+  const list = Array.isArray(changedKeys) ? changedKeys.filter(Boolean) : []
+  // 标题必须说真话：这段文案原来一律叫「助手人格设定刚有更新」，于是改一下对账档位
+  // 也会被说成人格变了。用户看到的第一句话就是错的，后面再准确也没用 —— 而且它还会
+  // 让模型以为「我这个人变了」，实际变的只是质检的判据。
+  //
+  // 分界不按「是不是提示词字段」分（两者都在提示词里），而按「改的是谁」分：
+  // memory.* / quality.* 改的是「怎么记、怎么查」，人设字段改的是「我是谁」。
+  const isPersona = (key) => !String(key).startsWith('memory.') && !String(key).startsWith('quality.')
+  const personaCount = list.filter(isPersona).length
+  const settingsCount = list.length - personaCount
+  let header
+  if (personaCount === 0) {
+    header = '[dsh-anima 配置] 提示词里的设定刚有更新'
+  } else if (settingsCount === 0) {
+    header = '[dsh-anima 人格配置] 助手人格设定刚有更新'
+  } else {
+    header = '[dsh-anima 配置] 助手人格与其它提示词设定刚有更新'
+  }
+  const lines = [
+    `${header}（来源：${source}）。`,
+    list.length > 0 ? `变更字段：${list.map(describeConfigKey).join('、')}。` : '配置有更新。',
+    personaCount > 0
+      ? '新设定立刻生效，之前那套**不再适用**；被清空的字段按「没有这项设定」处理，不要沿用旧值。'
+      : '新设定立刻生效，旧值**不再适用**，不要沿用。'
+  ]
+  return lines.join('\n')
+}
+
+/** 配置键 → 用户看得懂的名字。未收录的键原样显示（宁可露出内部名，也不要漏报变更）。 */
+const CONFIG_KEY_LABELS = {
+  enabled: '启用状态',
+  agentName: '助手名字',
+  agentRole: '角色设定',
+  addressUserAs: '对用户的称呼',
+  userOccupation: '用户职业',
+  userBio: '用户介绍',
+  style: '风格与语调',
+  headingLists: '标题与列表',
+  emoji: '表情符号',
+  tables: '表格',
+  replyLength: '回复长度',
+  language: '回复语言',
+  customInstructions: '补充指令',
+  requireToolConfirmation: '工具改动确认',
+  trailEnabled: '输入框光轨',
+  trailColor: '光轨颜色',
+  trailSpeed: '光轨速度',
+  trailWidth: '光轨粗细',
+  workspaceOverridesEnabled: '按工作区覆盖',
+  workspaceFileDir: '覆盖文件目录',
+  presets: '人设预设'
+}
+
+function describeConfigKey(key) {
+  if (typeof key !== 'string') return String(key)
+  if (CONFIG_KEY_LABELS[key]) return CONFIG_KEY_LABELS[key]
+  if (key.startsWith('memory.')) return `记忆设置（${key.slice(7)}）`
+  if (key.startsWith('quality.')) return `质检设置（${key.slice(8)}）`
+  return key
+}
+
+// ==================== 质检提醒 ====================
+
+/** 质检提醒的区块名，与 systemPrompt 的 anima:quality 段对应。 */
+export const QUALITY_SECTION_NAME = 'anima:quality'
+
+/**
+ * 把一次代码检查的结果渲染成一条「下一步要照做」的提醒。
+ *
+ * 三条措辞约束（都是为了防止这条提醒本身变成表演）：
+ *   ① 只说**机器判到了什么**，不说「我觉得你敷衍了」—— 后者是解释，前者是证据；
+ *   ② 必须把**没查的**一起列出。只报查到的问题，会让人误以为剩下的都通过了；
+ *   ③ 不给「已通过」这种话。没有 findings 时不发提醒，而不是发一句夸奖。
+ *
+ * @param {{findings:Array, uncovered:string[], checked:string[], meta:object}} result
+ * @param {number} [limit] 最多列几条，超出的只说总数
+ * @returns {string} 没有 findings 时返回 ''
+ */
+export function qualityReminderText(result, limit = 5) {
+  const findings = Array.isArray(result?.findings) ? result.findings : []
+  if (findings.length === 0) return ''
+  const shown = findings.slice(0, Math.max(1, limit))
+  const lines = [
+    '[dsh-anima 质检] 代码在你上一条回答里判到了下面这些形状。这是机器判词，不是评价：'
+  ]
+  for (const f of shown) {
+    lines.push(`- ${f.ruleId} ${f.name}：${f.detail}`)
+  }
+  if (findings.length > shown.length) {
+    lines.push(`- …还有 ${findings.length - shown.length} 条同类问题未列出`)
+  }
+  const uncovered = Array.isArray(result?.uncovered) ? result.uncovered : []
+  if (uncovered.length > 0) {
+    lines.push(
+      '',
+      `这次没查：${uncovered.join('、')}。`
+        + '别把上面这几条修掉就当「十二条全过」——没查的仍然是没查。'
+    )
+  }
+  lines.push('', '下一步：能补的补（把来源、命令、原话补上），补不了的直接说没核过。不要在回答里声明自己「已经注意了」。')
+  return lines.join('\n')
+}

package/lib/memory-audit.mjs

@@ -0,0 +1,262 @@
+// lib/memory-audit.mjs — 记忆的机械体检
+//
+// 为什么需要这个文件：`state` 字段（current / superseded / contradicted / dropped）
+// 加进 schema 之后一直是空的，因为**没有任何代码写它**。而「哪条记忆被哪条取代了」
+// 是语义判断 —— 记忆库一旦自动做语义判断，就会生成用户没说过的话，那正是这个插件
+// 从第一天起拒绝的事（见 README「刻意不做静默自动写入」与 lib/memory.mjs 里
+// applyMemoryMeta 的注释）。
+//
+// 所以这里只做**机械能验的**那一半，并且严格区分两件事：
+//
+//   能自动的：这条记忆里写的路径还在不在、复核点过没过。这些答案来自文件系统与
+//             日历，不是来自我的判断；就算我判错了，也能拿一条命令复现。
+//   不能自动的：「这句话现在还算不算数」「新的那条有没有推翻旧的」。这需要理解语义，
+//             而理解语义就等于替用户下结论。这一半永远留给用户，代码只负责把
+//             「哪些条目值得你复核」摆出来，并附上可以直接复制的命令。
+//
+// 因此本文件的输出一律叫「体检结果」，不叫「判定」；每条建议都带 evidence，
+// 且调用方不得在没有用户动作的情况下写盘（见 index.mjs 的 /memory/audit 路由）。
+
+/** 一条记忆最多取多少个路径去探 —— 防止有人在一条记忆里塞一百个路径把磁盘打爆。 */
+export const MAX_PATHS_PER_MEMORY = 8
+
+/** Windows 盘符路径 / UNC 路径。刻意只认 Windows 形态：本插件的用户数据全在这台机器上。 */
+const WIN_PATH = /(?:[A-Za-z]:[\\/]|\\\\)[^\s，。；、）)\]】》」"'`|]+/g
+
+/** 路径里出现这些字符说明它是个占位样板，不是一个真实路径。 */
+const PLACEHOLDER = /[<>{}*?]/
+
+/** 去掉路径尾部的标点：中文标点常紧跟路径，不剥掉就永远探不到。 */
+function trimPath(raw) {
+  let s = String(raw ?? '').trim()
+  // 成对括号可能被正则一起吃进来（例如 `（D:\a\b）` 的右括号），从尾部反复剥。
+  // 尾部的分隔符 `\` `/` 也要剥：样板路径切出来的前缀会以分隔符结尾，
+  // 而 `existsSync('D:\\a\\b\\')` 与 `existsSync('D:\\a\\b')` 虽然等价，
+  // 写进报告的路径却会多一个尾巴，用户复制去手测时容易怀疑是不是自己看错了。
+  while (s.length > 0 && /[，。；：、）)\]】》」"'`,.;:!?\\/]/.test(s.slice(-1))) s = s.slice(0, -1)
+  return s
+}
+
+/**
+ * 从一条记忆里取出所有「看起来是路径」的片段。
+ *
+ * 为什么要带占位符的路径单独标出来：`D:\c\VC\Tools\MSVC\<版本号>\bin\...` 里
+ * `<版本号>` 是用户自己记得的样板，不是磁盘上真实的目录名。直接拿去探必然 false，
+ * 那会产出一条假警报 —— 而假警报比不检查更糟，它会让用户学会无视整份报告。
+ * 正确做法是探它前面的真实前缀，并把「这条是样板」如实说出来。
+ *
+ * @param {string} text
+ * @returns {{raw:string, path:string, templated:boolean}[]}
+ */
+export function extractPaths(text) {
+  return extractPathsWithStats(text).paths
+}
+
+/**
+ * extractPaths 的带统计版本。
+ *
+ * 为什么需要它：`MAX_PATHS_PER_MEMORY` 截断时，`extractPaths` 会**安静地**
+ * 少还几个路径。调用方拿到一个 8 条的结果，无法分辨「这条记忆里只有 8 个路径」
+ * 和「有 20 个，只查了前 8 个」。两种情况下体检报告长得一模一样 —— 都是
+ * 「查了、没发现问题」，而后者实际上有 12 个路径从来没被探过。
+ *
+ * 这正是「不许让没查长得像查过没事」在这份报告里的具体形态：假阴性比假阳性
+ * 更难发现，因为它什么都不显示。
+ *
+ * 保留 `extractPaths` 原来的签名（返回数组）是因为它已经被测试与调用方依赖，
+ * 改形状会牵连一串；统计另走一个函数，两者共用同一份实现。
+ *
+ * @param {string} text
+ * @returns {{paths: {raw:string, path:string, templated:boolean}[], total:number, truncated:boolean, dropped:number}}
+ *   total 是**匹配到的路径总数**（截断前），dropped = total - paths.length。
+ */
+export function extractPathsWithStats(text) {
+  const body = String(text ?? '')
+  const out = []
+  const seen = new Set()
+  let total = 0
+  for (const match of body.matchAll(WIN_PATH)) {
+    const raw = trimPath(match[0])
+    if (!raw) continue
+    const templated = PLACEHOLDER.test(raw)
+    // 样板路径只探占位符之前的那一段：`D:\c\VC\Tools\MSVC\<版本号>\...` → `D:\c\VC\Tools\MSVC`
+    const probePath = templated ? trimPath(raw.split(PLACEHOLDER)[0]) : raw
+    if (!probePath || probePath.length < 3) continue
+    // 只有盘符（`D:\`）没有信息量，探它永远是 true。
+    if (/^[A-Za-z]:[\\/]?$/.test(probePath)) continue
+    if (seen.has(probePath)) continue
+    seen.add(probePath)
+    // 先去重再计数：total 要表达的是「有多少个不同的路径值得探」，
+    // 而不是「正则匹配了多少次」—— 同一条路径在一句记忆里出现三次，
+    // 报「还有 2 个没查」是假警报。
+    total += 1
+    if (out.length >= MAX_PATHS_PER_MEMORY) continue
+    out.push({ raw, path: probePath, templated, at: match.index, end: match.index + match[0].length })
+  }
+  return {
+    paths: out,
+    total,
+    truncated: total > out.length,
+    dropped: Math.max(0, total - out.length)
+  }
+}
+
+/**
+ * 路径里带空格时，正则会在第一个空格处截断。
+ *
+ * `D:\Windows Kits` 会被截成 `D:\Windows`，而后者不存在 —— 于是产出一条
+ * 「记忆里写的路径已经不存在」的假警报。**假警报比不检查更糟**：它会让用户
+ * 学会无视整份报告，那时真警报也一起失效了。
+ *
+ * 修法不是「把空格也吃进正则」（那会把后面的中文整段吞掉），而是：
+ * 只有当**延长后的路径确实在磁盘上存在**时才采用它。延长必须由文件系统证实，
+ * 不是由我猜 —— 这样既不会误报，也不会凭空造出一个路径。
+ */
+function extendToExisting(text, candidate, endIndex, checkPath) {
+  let rest = text.slice(endIndex)
+  let current = candidate
+  for (let i = 0; i < 4; i += 1) {
+    const piece = /^[ \t][A-Za-z0-9_.\-\\/]+/.exec(rest)
+    if (!piece) return null
+    current += piece[0]
+    rest = rest.slice(piece[0].length)
+    if (checkPath(current) === true) return current
+  }
+  return null
+}
+
+/**
+ * 体检一组记忆。
+ *
+ * @param {object[]} records 全量记忆（只查 status==='adopted' 的）
+ * @param {object} options
+ * @param {(p:string)=>boolean} options.probe 路径是否存在。注入而不是直接 import fs：
+ *   这样单测可以喂一个纯函数，不必依赖这台机器上真实有什么。
+ * @param {Date} [options.now]
+ * @returns {{checked:number, flagged:object[], clean:number, note:string}}
+ */
+export function auditMemories(records, { probe, now = new Date() } = {}) {
+  const list = Array.isArray(records) ? records.filter((r) => r?.status === 'adopted') : []
+  const today = now.toISOString().slice(0, 10)
+  const checkPath = typeof probe === 'function' ? probe : () => true
+  const flagged = []
+  let clean = 0
+  // 截断统计：只要有一条记忆的路径被截断了，整份报告就必须说清「还有 N 个没查」。
+  // 不说的话，报告读起来就是「全查过了，没问题」—— 而实际上有没查的部分。
+  let truncatedRecords = 0
+  let truncatedPaths = 0
+
+  for (const record of list) {
+    const findings = []
+
+    // ① 路径存在性：答案来自磁盘，不来自我。
+    const pathScan = extractPathsWithStats(record.text)
+    if (pathScan.truncated) {
+      truncatedRecords += 1
+      truncatedPaths += pathScan.dropped
+      findings.push({
+        kind: 'paths-truncated',
+        detail: `这条记忆里有 ${pathScan.total} 个不同的路径，单条最多只查 ${MAX_PATHS_PER_MEMORY} 个，`
+          + `还有 ${pathScan.dropped} 个**没有检查**。别把这份结果当成「全部路径都在」`,
+        evidence: `extractPathsWithStats：total=${pathScan.total} checked=${pathScan.paths.length} dropped=${pathScan.dropped}`
+      })
+    }
+    for (const p of pathScan.paths) {
+      let exists = false
+      try {
+        exists = checkPath(p.path) === true
+        // 截断的路径先别急着报「不存在」：它可能只是被空格切断了
+        // （`D:\Windows Kits` → `D:\Windows`）。只有当延长后的真实路径确实存在时
+        // 才采信，这一步由文件系统证实，不是由我猜。
+        if (!exists && !p.templated) {
+          const longer = extendToExisting(record.text, p.path, p.end, checkPath)
+          if (longer) exists = true
+        }
+      } catch {
+        // 探针本身抛错（权限、非法字符）不能算「不存在」—— 那会把「我查不到」
+        // 说成「它没有了」，正是用户最烦的那种糊弄。
+        findings.push({
+          kind: 'path-unprobed',
+          detail: `探不到「${p.path}」：探测时出错，无法判断它还在不在`,
+          evidence: `probe(${JSON.stringify(p.path)}) threw`
+        })
+        continue
+      }
+      if (!exists) {
+        if (p.templated) {
+          findings.push({
+            kind: 'path-prefix-missing',
+            detail: `这条记忆里的路径样板，前缀「${p.path}」已经不存在了`,
+            evidence: `fs.existsSync(${JSON.stringify(p.path)}) === false（原样 ${p.raw}）`
+          })
+        } else {
+          findings.push({
+            kind: 'path-missing',
+            detail: `记忆里写的路径「${p.path}」现在已经不存在`,
+            evidence: `fs.existsSync(${JSON.stringify(p.path)}) === false`
+          })
+        }
+      }
+    }
+
+    // ② 复核点过期：答案来自日历，不来自我。
+    const verify = String(record.verifyAt ?? '').slice(0, 10)
+    if (/^\d{4}-\d{2}-\d{2}$/.test(verify) && verify < today) {
+      findings.push({
+        kind: 'verify-expired',
+        detail: `复核点是 ${verify}，已经过去了 —— 这条是不是还成立，只有你知道`,
+        evidence: `verifyAt=${verify} < today=${today}`
+      })
+    }
+
+    if (findings.length === 0) {
+      clean += 1
+      continue
+    }
+
+    // 建议状态：只给「事实已经不成立」的那两类。复核点过期只提示，不建议改状态 ——
+    // 「过没过期」是日历说的，「还算不算数」得用户说。
+    const hasMissing = findings.some((f) => f.kind === 'path-missing' || f.kind === 'path-prefix-missing')
+    flagged.push({
+      id: record.id,
+      text: record.text,
+      type: record.type,
+      state: record.state,
+      capturedAt: record.capturedAt,
+      verifyAt: record.verifyAt,
+      findings,
+      suggestion: hasMissing
+        ? {
+            state: 'contradicted',
+            why: '这条记忆指向的东西已经不在了；标成「有争议」后，注入时会写明它可能不成立，而不是照旧当真',
+            command: `/anima mark ${record.id} state=contradicted`
+          }
+        : {
+            state: null,
+            why: '只有复核点过期。要不要标「可能已过时」由你决定，代码不替你判',
+            command: `/anima mark ${record.id} state=contradicted`
+          }
+    })
+  }
+
+  return {
+    checked: list.length,
+    flagged,
+    clean,
+    // 截断的显式告知。放在顶层而不是只埋在 flagged 里，是因为它是**关于这份
+    // 报告本身**的事实，不是某一条记忆的问题：读者看汇总就要知道「没查全」。
+    truncated: {
+      records: truncatedRecords,
+      paths: truncatedPaths,
+      limit: MAX_PATHS_PER_MEMORY,
+      note: truncatedRecords === 0
+        ? ''
+        : `有 ${truncatedRecords} 条记忆的路径数超过单条上限 ${MAX_PATHS_PER_MEMORY}，`
+          + `合计 ${truncatedPaths} 个路径**这次没有检查**。`
+          + `「没报问题」在这些条上不等于「没有问题」。`
+    },
+    note: '这份体检只做两件机械能验的事：路径还在不在、复核点过没过。'
+      + '「这句话还算不算数」需要理解语义，代码不判 —— 那等于替用户下结论。'
+      + '所有状态都不会被自动修改，每条建议都得你自己点一次。'
+  }
+}