dsh-anima 0.0.0-stage → 2.2.2

package/lib/patrol.mjs

@@ -0,0 +1,231 @@
+// lib/patrol.mjs — 巡夜：什么时候醒、醒了要不要说话
+//
+// 用户定的规则（m05776）：**有需要汇报的就汇报，没有就不汇报。**
+//
+// 这条规则的作用不是省字，是让「说了」重新有分量。一个每天到点出现、每次都说
+// 「今天没什么」的通知，两周后就会被当成背景噪音；等它真有事，用户已经不看了。
+//
+// 但它有一个必须当场堵住的洞：只报有事，等于「沉默」同时代表两件事 ——
+//   (a) 巡过了，没事
+//   (b) 巡夜那个东西根本没跑 / 坏了
+// 这正是质检钩子上花了很多功夫解决的同一个问题（checks=0 有两种相反解读）。
+// 堵法：**汇报可以不发，巡夜记录必须留。** 每次到点都写一条 meta.patrol，
+// 于是「没汇报」永远能反查成「真的没事」。
+//
+// 判据只有机器数得出来的三样，不含任何「我觉得」：
+//   ① 待审候选里出现了**新的**（不是「有没有候选」，是「有没有新的」）
+//   ② 记忆体检的 flagged 里出现了**新的**
+//   ③ 这次整理真的动了数据（去重或超限淘汰）
+//
+// 为什么用「有没有新的」而不是「数量 > 0」：如果三条候选挂了一周没人管，
+// 每天报一遍是纯噪音 —— 你早就知道了。
+//
+// 为什么用「有没有新的」而不是「集合变没变」（m06352 用户拍板改成这样）：
+// 集合变没变是**双向**的。你裁掉两条候选是好事，但集合变了 ⇒ 也会给你发一条
+// 汇报。于是「我把事情处理完了」这个动作本身会换来一条通知，形状上跟
+// 「又有人说你错了」一模一样。改判据：**增加才出声，减少只记账。**
+
+/**
+ * 计算这次巡夜的指纹。
+ *
+ * 只对**集合**做摘要，不对数量做摘要：两条旧的换成两条新的，数量没变但
+ * 指纹会变 —— 那是真的有事。反过来，三条挂了七天，指纹一模一样。
+ *
+ * 指纹本身不再直接决定「要不要说话」（那是 assessPatrol 里比较新旧集合的事），
+ * 它的用途是留痕与反查：用户拿它比对两次巡夜，就能看出中间有没有东西动过。
+ *
+ * @param {object} input
+ * @param {string[]} [input.pendingIds] 待审候选 id
+ * @param {string[]} [input.flaggedIds] 体检有问题的记忆 id
+ * @param {number} [input.removed] 本次整理动过的条数
+ * @returns {string}
+ */
+export function patrolSignature({ pendingIds = [], flaggedIds = [], removed = 0 } = {}) {
+  const norm = (list) => [...new Set((Array.isArray(list) ? list : []).map(String))].sort()
+  const pending = norm(pendingIds).join(',')
+  const flagged = norm(flaggedIds).join(',')
+  // 整理动过数据这件事本身就值得说一次；但它不是一个可以「恢复原状」的集合，
+  // 所以折成一个 0/1 位，避免同一次结果被反复重报。
+  const touched = removed > 0 ? 1 : 0
+  return `p:${pending}|f:${flagged}|t:${touched}`
+}
+
+/**
+ * 从指纹里解析出上一次的集合。
+ *
+ * 判据改成「有没有新的」之后，必须知道上次**报过什么**，而 meta 里只存了指纹。
+ * 与其加两个字段（旧介质里没有，读出来是 undefined，还得再写一套迁移），
+ * 不如从指纹本身解析回来 —— 格式是我们自己定的，解析失败有明确兜底。
+ *
+ * @param {string} signature
+ * @returns {{pending: string[], flagged: string[], touched: number, parsed: boolean}}
+ */
+export function parsePatrolSignature(signature) {
+  const empty = { pending: [], flagged: [], touched: 0, parsed: false }
+  const text = String(signature ?? '')
+  if (!text) return { ...empty, parsed: true }
+  const m = /^p:([^|]*)\|f:([^|]*)\|t:([01])$/.exec(text)
+  if (!m) return empty
+  const split = (s) => (s ? s.split(',').filter(Boolean) : [])
+  return { pending: split(m[1]), flagged: split(m[2]), touched: Number(m[3]), parsed: true }
+}
+
+/**
+ * 判断这次巡夜该不该出声。
+ *
+ * @param {object} input
+ * @param {string[]} [input.pendingIds] 待审候选 id（整理后的存活者）
+ * @param {string[]} [input.flaggedIds] 体检 flagged 的记忆 id
+ * @param {number} [input.removed] 本次整理动过的条数
+ * @param {string} [input.previousSignature] 上次巡夜留下的指纹；没跑过就传空
+ * @param {string[]} [input.previousPendingIds] 上次的待审集合（给了就不解析指纹）
+ * @param {string[]} [input.previousFlaggedIds] 上次的体检集合
+ * @returns {{shouldReport: boolean, signature: string, reasons: string[], facts: object,
+ *            added: {pending: number, flagged: number}, cleared: {pending: number, flagged: number}}}
+ */
+export function assessPatrol({
+  pendingIds = [],
+  flaggedIds = [],
+  removed = 0,
+  previousSignature = '',
+  previousPendingIds,
+  previousFlaggedIds
+} = {}) {
+  const uniq = (list) => [...new Set((Array.isArray(list) ? list : []).map(String))]
+  const pending = uniq(pendingIds)
+  const flagged = uniq(flaggedIds)
+  const signature = patrolSignature({ pendingIds, flaggedIds, removed })
+
+  let prevPending
+  let prevFlagged
+  let prevTouched = 0
+  let parseFailed = false
+  if (Array.isArray(previousPendingIds) || Array.isArray(previousFlaggedIds)) {
+    prevPending = uniq(previousPendingIds ?? [])
+    prevFlagged = uniq(previousFlaggedIds ?? [])
+  } else {
+    const parsed = parsePatrolSignature(previousSignature)
+    // 解析失败时当成「没有上次」处理：宁可多报一次，也不能因为读不懂旧记录就
+    // 把真事吞掉。吞掉的错误没人看得见，多报一次的代价只是多一句。
+    parseFailed = !parsed.parsed
+    prevPending = parsed.pending
+    prevFlagged = parsed.flagged
+    prevTouched = parsed.touched
+  }
+
+  const prevPendingSet = new Set(prevPending)
+  const prevFlaggedSet = new Set(prevFlagged)
+  const addedPending = pending.filter((id) => !prevPendingSet.has(id))
+  const addedFlagged = flagged.filter((id) => !prevFlaggedSet.has(id))
+  const clearedPending = prevPending.filter((id) => !pending.includes(id))
+  const clearedFlagged = prevFlagged.filter((id) => !flagged.includes(id))
+
+  const facts = {
+    pending: pending.length,
+    flagged: flagged.length,
+    removed: Number(removed) || 0
+  }
+  const added = { pending: addedPending.length, flagged: addedFlagged.length }
+  const cleared = { pending: clearedPending.length, flagged: clearedFlagged.length }
+
+  // 只看「增加」和「整理真的动了数据」。减少（你裁决掉了、路径修好了）不算有事：
+  // 那是你把问题解决掉的结果，不该再拿它来打扰你一次。它仍然记进 meta，
+  // 于是「上周有三条，这周没了」依然可反查 —— 只是不再发一条消息。
+  const reasons = []
+  if (addedPending.length > 0) reasons.push(`pending:${addedPending.length}`)
+  if (addedFlagged.length > 0) reasons.push(`flagged:${addedFlagged.length}`)
+  // 整理动过数据只在「上次没动过」时才说一次。否则同一个结果会每晚重报 ——
+  // 这正是 m05776「没有就不汇报」要消灭的形状。旧指纹里的 t 位就为这个存在。
+  if (facts.removed > 0 && prevTouched === 0) reasons.push(`removed:${facts.removed}`)
+
+  return {
+    shouldReport: reasons.length > 0,
+    signature,
+    reasons,
+    facts,
+    added,
+    cleared,
+    ...(parseFailed ? { parseFailed: true } : {})
+  }
+}
+
+/** 一次巡夜最多落盘几条体检明细。 */
+export const MAX_FLAGGED_ITEMS = 20
+/** 单条明细里 detail 文本的字符上限（落盘用，不是给人读的全文）。 */
+export const MAX_FLAGGED_DETAIL_CHARS = 200
+
+/**
+ * 把体检结果压成「可以安全落盘的那一份」。
+ *
+ * 为什么要压而不是原样存：`audit.flagged` 里每条都带 findings（含 evidence 里的
+ * 完整命令与路径）和建议命令，内容随记忆增长，且 store 的 metaSchema 已经把
+ * 形状钉死 —— 原样塞进去，读回时会被 zod 剥掉不认识的部分，于是「写了但读不回来」。
+ * 这正是 2026-10-24 那个 metaSchema bug 的形状，不能再犯一次。
+ *
+ * 只留三样：id（能去 `/anima mark` 那条命令）、明细首句（让人认得出是哪条）、
+ * 证据首句（证明不是瞎报）。**不留建议命令全文**：它是按 id 现算的，存下来只会过期。
+ *
+ * @param {Array<{id:string, text?:string, findings?:Array<{detail?:string, evidence?:string}>}>} flagged
+ * @returns {{items: Array<{id:string, detail:string, evidence:string, kinds:string[]}>, dropped: number}}
+ */
+export function compactFlagged(flagged) {
+  const list = Array.isArray(flagged) ? flagged : []
+  const items = []
+  for (const item of list.slice(0, MAX_FLAGGED_ITEMS)) {
+    const id = String(item?.id ?? '').trim()
+    if (!id) continue
+    const findings = Array.isArray(item?.findings) ? item.findings : []
+    const first = findings[0] ?? {}
+    const clip = (s) => {
+      const text = String(s ?? '')
+      return text.length > MAX_FLAGGED_DETAIL_CHARS
+        ? `${text.slice(0, MAX_FLAGGED_DETAIL_CHARS)}…`
+        : text
+    }
+    items.push({
+      id,
+      // detail 缺失时退回记忆正文：宁可少一句解释，也不能留一条只有 id 的孤儿明细
+      // —— 那种行在界面上等于「有 1 条有问题，但我不告诉你是什么」。
+      detail: clip(first.detail ?? item?.text ?? ''),
+      evidence: clip(first.evidence ?? ''),
+      kinds: findings.map((f) => String(f?.kind ?? '')).filter(Boolean)
+    })
+  }
+  return { items, dropped: Math.max(0, list.length - items.length) }
+}
+
+/**
+ * 算出下一次该在什么时候醒。
+ *
+ * 背景（m06351 实测）：原来的写法是「把 delay 压到 6 小时上限，然后每 6 小时
+ * 醒一次都判断今天跑过没」。后果不是跑到错的时间点就完事 —— 是**真正决定巡夜
+ * 在几点跑的，变成了「今天补跑过没有」，而不是 nightlyHour**。开机补跑一旦被
+ * 跳过（存储没就绪），第二天早上第一次醒来就会当场把巡夜跑掉。
+ *
+ * 改法：**没到目标时刻的醒来，只重新定闹钟，不跑巡夜。** 于是巡夜只可能在两个
+ * 时候跑：目标时刻本身，或者机器睡过了目标之后（那是补跑，会记 `nightly-late`）。
+ *
+ * 这个函数是纯的，所以「到底几点醒」可以被测试锁住，而不是靠读代码想象。
+ *
+ * @param {object} [input]
+ * @param {Date} [input.now] 当前时刻
+ * @param {number} [input.hour] 目标小时（0-23）
+ * @param {number} [input.maxDelayMs] 单次定时最长挂多久
+ * @returns {{delayMs: number, targetAt: number, isTarget: boolean}}
+ *   `isTarget` 为 true 表示这次醒来就是目标时刻（醒来后该跑巡夜）；
+ *   为 false 表示只是中途醒来重新定闹钟，不许跑。
+ */
+export function planNightlyWake({ now = new Date(), hour = 3, maxDelayMs = 6 * 60 * 60 * 1000 } = {}) {
+  const h = Number.isInteger(hour) && hour >= 0 && hour <= 23 ? hour : 3
+  const limit = Number(maxDelayMs) > 0 ? Number(maxDelayMs) : 6 * 60 * 60 * 1000
+  const base = now instanceof Date ? now : new Date(now)
+  const target = new Date(base.getTime())
+  target.setHours(h, 0, 0, 0)
+  if (target.getTime() <= base.getTime()) target.setDate(target.getDate() + 1)
+  const raw = target.getTime() - base.getTime()
+  return {
+    delayMs: Math.min(raw, limit),
+    targetAt: target.getTime(),
+    isTarget: raw <= limit
+  }
+}

package/lib/presets.mjs

@@ -0,0 +1,310 @@
+// lib/presets.mjs — 人设预设（纯数据 + 纯函数，无外部依赖）
+//
+// 预设 = 一组可整份套用的人设字段快照。用途：用户不必从十几个字段里逐个填，
+// 选一个预设即可得到一套自洽的语气，再在这个基础上微调。
+//
+// 设计约束：
+//   ① 预设**只覆盖它声明的字段**；套用时其余字段保持用户当前值不动。
+//      这与工作区覆盖的 field-level merge 是同一套语义，保持一致的心智模型。
+//   ② 内置预设不落盘、不可删、不可改名；用户自建预设存全局配置里。
+//   ③ 内置预设不与自建预设重名 —— 同名时内置优先（见 resolvePreset）。
+//
+// v3 起的一个定位变化：人设字段全是自由文本了，于是**预设就是模板** ——
+// 内置预设的字段值是一整段现成的话（来自 lib/wording.mjs），点一下把它填进表单，
+// 用户随后可以随意改。它不再是一组「键」，因为键在自由文本模型里没有位置：
+// 用户看不懂 'casual'，模型也读不懂。
+//
+// 这条路线的代价是内置预设的 fields 变得很长。这是刻意付的：若改成「存键 + 套用时翻译」，
+// 设置页要显示「点一下会填什么」就必须先拿到翻译结果，于是宿主得多发一份翻译表、
+// 客户端多一层同步；而用户想微调时又会发现表单里出现的和按钮上写的不是同一份东西。
+//
+// 本模块被 index.mjs（host）与 scripts/verify-core.mjs 共用。
+
+import { REPLY_LENGTH_WORDING, STYLE_WORDING, TRAIT_WORDING } from './wording.mjs'
+import { FIELD_LIMITS, isPlainObject } from './config.mjs'
+
+/** 预设可声明的字段（= 人设字段，不含记忆与工作区开关）。 */
+export const PRESET_FIELDS = [
+  'agentName', 'agentRole', 'addressUserAs', 'userOccupation', 'userBio',
+  'style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language',
+  'customInstructions'
+]
+
+/** 预设名长度上限与条数上限。 */
+export const PRESET_NAME_LIMIT = 40
+export const PRESET_COUNT_LIMIT = 50
+
+/**
+ * 内置预设。id 固定，重装/升级后仍然稳定，故可安全地写进用户配置或文档。
+ * 注意：内置预设刻意**不填** agentName（那是用户自己的助手名字）与用户背景
+ * （userOccupation/userBio 描述的是用户本人，插件不该替用户假设）。
+ *
+ * 三个特质字段（headingLists / emoji / tables）里，取「默认」档的**直接不写这个字段**
+ * —— default 档的文案就是空串，写进来也会被 applyPreset 当成「不覆盖」丢掉。
+ * 少一个键比多一个空串诚实：读源码的人一眼能看出这个预设没对它提要求。
+ */
+export const BUILTIN_PRESETS = [
+  {
+    id: 'builtin:precise',
+    name: '专业严谨',
+    description: '结论先行、逻辑清晰、用词准确，不口语化。日常技术工作与文档写作的默认档。',
+    fields: {
+      style: STYLE_WORDING.professional,
+      replyLength: REPLY_LENGTH_WORDING.normal,
+      emoji: TRAIT_WORDING.emoji.less
+    }
+  },
+  {
+    id: 'builtin:concise',
+    name: '极简主义',
+    description: '只说结论与关键理由，能省的字都省，不重复你已经知道的东西。',
+    fields: {
+      style: STYLE_WORDING.efficient,
+      replyLength: REPLY_LENGTH_WORDING.concise,
+      headingLists: TRAIT_WORDING.headingLists.less,
+      emoji: TRAIT_WORDING.emoji.less,
+      tables: TRAIT_WORDING.tables.less
+    }
+  },
+  {
+    id: 'builtin:teacher',
+    name: '教学型讲解',
+    description: '从背景讲起、层层递进、多举例，适合学新东西时用。',
+    fields: {
+      style: STYLE_WORDING.professional,
+      replyLength: REPLY_LENGTH_WORDING.detailed,
+      headingLists: TRAIT_WORDING.headingLists.more,
+      tables: TRAIT_WORDING.tables.more
+    }
+  },
+  {
+    id: 'builtin:architect',
+    name: '资深架构师',
+    description: '关注边界、失败模式与取舍，先问清约束再动手，主动指出设计里的坑。',
+    fields: {
+      style: STYLE_WORDING.professional,
+      replyLength: REPLY_LENGTH_WORDING.detailed,
+      headingLists: TRAIT_WORDING.headingLists.more,
+      emoji: TRAIT_WORDING.emoji.less,
+      tables: TRAIT_WORDING.tables.more,
+      customInstructions: [
+        '回答设计问题前先确认约束（规模、并发、可维护性要求）；',
+        '给出方案时同时说明它的失败模式与不适用条件；',
+        '发现提议里的隐藏风险要直接指出，不要为了配合而附和。'
+      ].join('\n')
+    }
+  },
+  {
+    id: 'builtin:reviewer',
+    name: '严格代码审查',
+    description: '按行审查、只讲问题不讲客套、每条都给出可执行的修法。',
+    fields: {
+      style: STYLE_WORDING.professional,
+      replyLength: REPLY_LENGTH_WORDING.detailed,
+      headingLists: TRAIT_WORDING.headingLists.more,
+      emoji: TRAIT_WORDING.emoji.less,
+      customInstructions: [
+        '审查代码时逐条列出问题，注明文件与行号；',
+        '每条问题都要给出具体的修改建议，不要只说「这里不好」；',
+        '没有问题就明确说没有问题，不要为凑数而挑刺。'
+      ].join('\n')
+    }
+  },
+  {
+    id: 'builtin:brainstorm',
+    name: '头脑风暴伙伴',
+    description: '先发散再多给几条路子，允许不成熟的点子，等你选定后再收敛。',
+    fields: {
+      style: STYLE_WORDING.casual,
+      replyLength: REPLY_LENGTH_WORDING.normal,
+      tables: TRAIT_WORDING.tables.less,
+      customInstructions: [
+        '发散阶段尽量多给几个方向，哪怕其中一些还不成熟；',
+        '每个方向写一句它的代价，方便我快速筛；',
+        '等我明确选定方向后再收敛，不要在发散阶段就替我下结论。'
+      ].join('\n')
+    }
+  }
+]
+
+const text = (v) => (typeof v === 'string' ? v.trim() : '')
+
+/**
+ * 校验一组预设字段值。
+ *
+ * v3 起全部字段都是自由文本，所以这里只剩两件事：类型、长度。
+ * 长度按 lib/config.mjs 的 FIELD_LIMITS 判 —— 预设最终要写进配置，
+ * 若这里放行一段超长文本，套用时会被 sanitizeConfig 整条拒掉，
+ * 用户看到的是「点了一下预设，报错说字段超长」，却不知道是哪个预设的锅。
+ *
+ * @returns {{fields: object, errors: Record<string,string>}}
+ */
+export function sanitizePresetFields(raw) {
+  const fields = {}
+  const errors = {}
+  if (!isPlainObject(raw)) {
+    return { fields, errors: { _: '预设字段必须是一个 JSON 对象' } }
+  }
+
+  for (const key of PRESET_FIELDS) {
+    if (!(key in raw)) continue
+    const value = raw[key]
+    if (typeof value !== 'string') {
+      errors[key] = '必须为字符串'
+      continue
+    }
+    const body = value.trim()
+    if (!body) continue // 空 = 该预设不声明这个字段
+    const limit = FIELD_LIMITS[key]
+    if (limit && body.length > limit) {
+      errors[key] = `长度超过上限 ${limit} 字符（当前 ${body.length}）`
+      continue
+    }
+    fields[key] = body
+  }
+
+  return { fields, errors }
+}
+
+/**
+ * 校验一个自建预设。
+ * @returns {{preset: object|null, errors: Record<string,string>}}
+ */
+export function sanitizeCustomPreset(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    return { preset: null, errors: { _: '预设必须是一个 JSON 对象' } }
+  }
+  const errors = {}
+  const name = text(raw.name)
+  if (!name) errors.name = '预设名不能为空'
+  else if (name.length > PRESET_NAME_LIMIT) errors.name = `预设名超过上限 ${PRESET_NAME_LIMIT} 字符`
+  else if (BUILTIN_PRESETS.some((p) => p.name === name)) errors.name = '与内置预设重名，请换一个名字'
+
+  const { fields, errors: fieldErrors } = sanitizePresetFields(raw.fields ?? {})
+  Object.assign(errors, fieldErrors)
+
+  if (Object.keys(errors).length > 0) return { preset: null, errors }
+
+  const id = text(raw.id) || `custom:${name}`
+  return {
+    preset: {
+      id,
+      name,
+      description: text(raw.description),
+      fields,
+      custom: true,
+      createdAt: text(raw.createdAt) || new Date().toISOString()
+    },
+    errors: {}
+  }
+}
+
+/**
+ * 校验自建预设列表（整表替换语义）。
+ * @returns {{presets: Array<object>, errors: Array<object>}}
+ */
+export function sanitizeCustomPresets(raw) {
+  if (!Array.isArray(raw)) return { presets: [], errors: [{ _: '预设列表必须是数组' }] }
+  if (raw.length > PRESET_COUNT_LIMIT) {
+    return { presets: [], errors: [{ _: `自建预设最多 ${PRESET_COUNT_LIMIT} 条` }] }
+  }
+  const presets = []
+  const errors = []
+  const seen = new Set()
+  for (const [index, item] of raw.entries()) {
+    const { preset, errors: itemErrors } = sanitizeCustomPreset(item)
+    if (!preset) {
+      errors.push({ index, ...itemErrors })
+      continue
+    }
+    if (seen.has(preset.name)) {
+      errors.push({ index, name: '预设名重复' })
+      continue
+    }
+    seen.add(preset.name)
+    presets.push(preset)
+  }
+  return { presets, errors }
+}
+
+/**
+ * 内置 + 自建，内置在前。
+ *
+ * 这里必须**补上 builtin 标志**：BUILTIN_PRESETS 里的六条数据本身没有这个字段
+ * （写数据时没必要自我声明），而客户端靠它决定「下拉里标内置还是自建」「要不要
+ * 给这条画删除按钮」。少补这一个布尔值，六条内置预设就会全部显示成「自建」、
+ * 每条右边多出一个删除按钮，点下去又被后端 400 挡回来（index.mjs 里
+ * `id.startsWith('builtin:')` 那段），UI 和文案直接自相矛盾。
+ * 自建侧同理补 custom: true，让两边都有明确标志，客户端不用再猜。
+ */
+export function listPresets(customPresets) {
+  const custom = Array.isArray(customPresets) ? customPresets : []
+  return [
+    ...BUILTIN_PRESETS.map((preset) => ({ ...preset, builtin: true, custom: false })),
+    ...custom.map((preset) => ({ ...preset, builtin: false, custom: true }))
+  ]
+}
+
+/** 按 id 找，找不到按 name 找；内置优先。 */
+export function resolvePreset(customPresets, key) {
+  const target = text(key)
+  if (!target) return null
+  const all = listPresets(customPresets)
+  return all.find((p) => p.id === target) ?? all.find((p) => p.name === target) ?? null
+}
+
+/**
+ * 套用预设：只覆盖预设声明的字段（空串视为「不覆盖」，与工作区覆盖同语义）。
+ * @returns {object} 可直接交给 sanitizeConfig 的补丁
+ */
+export function applyPreset(preset) {
+  if (!preset || !preset.fields) return {}
+  const patch = {}
+  for (const [key, value] of Object.entries(preset.fields)) {
+    if (!PRESET_FIELDS.includes(key)) continue
+    if (typeof value !== 'string' || !value.trim()) continue
+    patch[key] = value.trim()
+  }
+  return patch
+}
+
+/**
+ * 判断一份配置现在「正在用」哪条预设。
+ *
+ * 为什么需要：预设是**一次性套用**的 —— 点完就散成一堆字段值，配置里不再留任何
+ * 「我来自哪条预设」的痕迹。于是用户下次打开设置页，看到的是哪个名字都对不上的
+ * 一堆文字，既不知道自己刚才套过什么，也就无法判断「现在这套还算不算预设」。
+ *
+ * 判定规则（**按字段逐条比对，而不是记住一个 id**）：
+ *   - 预设声明的每个非空字段，都必须与当前值完全相等；
+ *   - 预设没声明的字段不参与比对（它本来就没动过那些字段）；
+ *   - 一条都不声明字段的预设视为「不是预设」，不参与匹配；
+ *   - 多条同时命中时取声明字段最多的那条（更具体的那条才是用户想要的），
+ *     数量相同则内置优先（列表顺序）。
+ *
+ * 这样做的代价是：用户手改一个字段后，匹配自然失效、徽标消失 —— 这是**正确的**。
+ * 记 id 的方案做不到这一点，它会一直举着一个「现在用的是 XX 预设」的牌子，
+ * 哪怕用户早就把里面的字全改光了。
+ *
+ * @param {object} config 全局配置（不是合并后的 effective —— 预设只作用于全局层）
+ * @param {Array<object>} [presets] 候选预设列表，默认内置 + 配置里的自建
+ * @returns {?object} 命中的预设，没命中返回 null
+ */
+export function findActivePreset(config, presets) {
+  const current = config && typeof config === 'object' ? config : {}
+  const candidates = Array.isArray(presets) ? presets : listPresets(current.presets)
+  let best = null
+  let bestScore = 0
+  for (const preset of candidates) {
+    const fields = applyPreset(preset)
+    const keys = Object.keys(fields)
+    if (keys.length === 0) continue
+    const matched = keys.every((key) => current[key] === fields[key])
+    if (!matched) continue
+    if (keys.length > bestScore) {
+      best = preset
+      bestScore = keys.length
+    }
+  }
+  return best
+}