dsh-selfnote 0.0.0-stage → 0.12.0

package/lib/profile.js

@@ -0,0 +1,70 @@
+/**
+ * 画像层（P7）
+ *
+ * 定位：**已审核记忆的聚合视图**，不是新的事实库。
+ *   - 只读 status === 'approved' 的 facts；candidate / retired 不参与
+ *   - 不产生新事实，每一句都能回指到具体 fact id
+ *   - 可重建：facts 变了就重算，画像本身从不作为事实来源
+ *   - 同一标签下多条时不擅自归纳，只取最新并标注「另有 N 条」
+ */
+
+const DEFAULT_MAX_CHARS = 80
+const DEFAULT_PIECE_MAX = 60
+
+/** facts 的时间戳只有日期（YYYY-MM-DD），比大小用字符串就够。 */
+function stamp(fact) {
+  const value = String(fact?.updated ?? fact?.created ?? '')
+  return value === '' ? '0000-00-00' : value
+}
+
+/**
+ * @param {Array<object>} facts 全部事实（内部会自己筛 approved）
+ * @param {{maxChars?: number}} options
+ * @returns {{text: string, parts: Array<{tag: string, factId: string, text: string}>, conflicts: Array<{tag: string, count: number}>, chars: number, sources: string[]}}
+ */
+export function buildProfile(facts, options = {}) {
+  const maxChars = Number(options.maxChars ?? DEFAULT_MAX_CHARS) || DEFAULT_MAX_CHARS
+  // 单句上限：画像是一句话的自我认知，不是把长决定整段落搬进来。
+  // 超过这个长度的（比如「上下文快照存哪」这种操作性决定）留在结论段，别挤掉真画像。
+  const pieceMax = Number(options.pieceMax ?? DEFAULT_PIECE_MAX) || DEFAULT_PIECE_MAX
+  /* channel === 'env' 是环境事实（机器路径、账号、坑），不是「这个人是谁」，不进画像 */
+  const approved = (Array.isArray(facts) ? facts : []).filter(
+    (fact) => fact?.status === 'approved' && (fact?.channel ?? 'rel') !== 'env',
+  )
+
+  /* 按第一个标签分组；没有标签的归到「其他」 */
+  const groups = new Map()
+  for (const fact of approved) {
+    const raw = Array.isArray(fact.tags) ? fact.tags : []
+    const tag = String(raw[0] ?? '其他').trim() || '其他'
+    const bucket = groups.get(tag) ?? []
+    bucket.push(fact)
+    groups.set(tag, bucket)
+  }
+
+  const parts = []
+  const conflicts = []
+  const ordered = [...groups.entries()].sort((a, b) => stamp(b[1][0]) < stamp(a[1][0]) ? -1 : 1)
+
+  let text = ''
+  for (const [tag, bucket] of ordered) {
+    const latest = bucket.slice().sort((a, b) => (stamp(a) < stamp(b) ? 1 : stamp(a) > stamp(b) ? -1 : 0))[0]
+    const body = String(latest.text ?? '').trim()
+    if (body === '') continue
+    if (body.length > pieceMax) continue
+    const piece = `${tag}：${body}`
+    const candidate = text === '' ? piece : `${text}；${piece}`
+    if (candidate.length > maxChars) continue
+    text = candidate
+    parts.push({ tag, factId: latest.id, text: body })
+    if (bucket.length > 1) conflicts.push({ tag, count: bucket.length - 1 })
+  }
+
+  return {
+    text,
+    parts,
+    conflicts,
+    chars: text.length,
+    sources: parts.map((part) => part.factId),
+  }
+}

package/lib/store.js

@@ -0,0 +1,257 @@
+/**
+ * selfnote 的存储层：把「AI 写给自己看的叙述」落成纯文本，零依赖。
+ *
+ * 目录（默认 <DSH_HOME>/selfnote，可用 DSH_SELFNOTE_DIR 覆盖）：
+ *   notes.md              当前生效的自述，一行一条，最新的在最后
+ *   archive/YYYY-MM.md    被挤出容量的旧条目，只追加不改写
+ *
+ * 为什么用纯文本：用户能直接打开看、能 grep、能进 git；
+ * 插件崩了也不影响内容，删掉文件就是重置。
+ */
+
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { writeAtomic, writeJsonAtomic } from './atomic.js'
+
+/** 当前生效内容的上限（字符）。默认 1600 字，约 1.1k token。 */
+export const DEFAULT_MAX_CHARS = 1600
+/** 条数上限，和字符上限共同生效。 */
+export const DEFAULT_MAX_ENTRIES = 40
+/** 单条自述的硬上限，防止一次写入撑爆。 */
+export const MAX_ENTRY_CHARS = 600
+
+function dshHome() {
+  const fromEnv = typeof process.env.DSH_HOME === 'string' ? process.env.DSH_HOME.trim() : ''
+  return fromEnv.length > 0 ? fromEnv : join(homedir(), '.dsh')
+}
+
+export function selfnoteRoot() {
+  const fromEnv = typeof process.env.DSH_SELFNOTE_DIR === 'string' ? process.env.DSH_SELFNOTE_DIR.trim() : ''
+  return fromEnv.length > 0 ? fromEnv : join(dshHome(), 'selfnote')
+}
+
+export function notesPath() {
+  return join(selfnoteRoot(), 'notes.md')
+}
+
+export function archiveDir() {
+  return join(selfnoteRoot(), 'archive')
+}
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+}
+
+export function today() {
+  const now = new Date()
+  const pad = (n) => String(n).padStart(2, '0')
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`
+}
+
+/** 把 notes.md 解析成 [{ date, text }]，忽略空行与注释。 */
+export function parseNotes(raw) {
+  const out = []
+  for (const line of String(raw ?? '').split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (trimmed === '' || trimmed.startsWith('#')) continue
+    const m = trimmed.match(/^[-*]\s+(\d{4}-\d{2}-\d{2})?\s*(.*)$/)
+    if (!m) continue
+    const text = (m[2] ?? '').trim()
+    if (text === '') continue
+    out.push({ date: m[1] ?? '', text })
+  }
+  return out
+}
+
+/** 读当前生效的自述。 */
+export function readNotes() {
+  const file = notesPath()
+  if (!existsSync(file)) return []
+  return parseNotes(readFileSync(file, 'utf8'))
+}
+
+/** 渲染成注入/展示用的文本（最新在后）。 */
+export function renderNotes(entries) {
+  return entries.map((entry) => `- ${entry.date ? `${entry.date} ` : ''}${entry.text}`).join('\n')
+}
+
+/** 写回当前生效的自述（整份重写，内容不超过上限）。 */
+export function writeNotes(entries) {
+  ensureDir(selfnoteRoot())
+  const body = entries.length === 0 ? '' : `${renderNotes(entries)}\n`
+  // 原子写：notes.md 是注入来源，被截断等于每回合注入半句话
+  writeAtomic(notesPath(), body)
+}
+
+/**
+ * 按容量裁剪：从最旧的一端丢，直到同时满足条数与字符上限。
+ * 返回 { kept, overflow }，overflow 是要归档的旧条目（旧的在前）。
+ */
+export function trim(entries, { maxChars = DEFAULT_MAX_CHARS, maxEntries = DEFAULT_MAX_ENTRIES } = {}) {
+  const kept = [...entries]
+  const overflow = []
+  let total = renderNotes(kept).length
+  while (kept.length > maxEntries || (total > maxChars && kept.length > 1)) {
+    const dropped = kept.shift()
+    if (!dropped) break
+    overflow.push(dropped)
+    total = renderNotes(kept).length
+  }
+  return { kept, overflow }
+}
+
+/** 把被挤出来的条目追加到当月归档文件。 */
+export function archive(entries) {
+  if (entries.length === 0) return ''
+  ensureDir(archiveDir())
+  const month = entries[0]?.date?.slice(0, 7) || today().slice(0, 7)
+  const file = join(archiveDir(), `${month}.md`)
+  // 归档文件小（每月一个），整份读回再原子写，比 append 更能扛「写到一半被杀」
+  const head = existsSync(file) ? readFileSync(file, 'utf8') : `# 自述归档 ${month}\n\n`
+  writeAtomic(file, `${head}${renderNotes(entries)}\n`)
+  return file
+}
+
+/** 追加一条自述并裁剪归档。返回 { kept, archived, notesFile }。 */
+export function appendNote(text, limits) {
+  const clean = String(text ?? '').replace(/\s+/g, ' ').trim().slice(0, MAX_ENTRY_CHARS)
+  if (clean === '') throw new Error('自述内容不能为空')
+  const entries = readNotes()
+  entries.push({ date: today(), text: clean })
+  const { kept, overflow } = trim(entries, limits)
+  // 先归档、再改 notes.md：反过来的话，归档一抛错（磁盘满、被占用），
+  // 被挤出预算的那几条既已从 notes.md 消失、又没进归档，等于静默丢掉。
+  // 万一 notes.md 写失败，最坏是归档里有重复，还能人工删 —— 丢内容没法补。
+  const archivedFile = archive(overflow)
+  writeNotes(kept)
+  return { kept: kept.length, archived: overflow.length, archivedFile, notesFile: notesPath() }
+}
+
+/**
+ * 改一条（0 = 最旧，和 readNotes 的顺序一致）。
+ * 日期保留原样：改的是措辞，不是「今天又写了一条」。
+ * 改长了照样按容量裁剪，被挤出去的进归档 —— 和追加走同一条规则。
+ */
+export function updateNote(index, text, limits) {
+  const entries = readNotes()
+  const at = Number(index)
+  if (!Number.isInteger(at) || at < 0 || at >= entries.length) {
+    // 列表可能是几秒前拉的：给一句能照着做的话，而不是「非法参数」
+    throw new Error('没有这一条了（可能刚被改过），刷新一下再试')
+  }
+  const clean = String(text ?? '').replace(/\s+/g, ' ').trim().slice(0, MAX_ENTRY_CHARS)
+  if (clean === '') throw new Error('自述内容不能为空')
+  if (clean === entries[at].text) return { kept: entries.length, archived: 0, unchanged: true, notesFile: notesPath() }
+  entries[at] = { date: entries[at].date || today(), text: clean }
+  const { kept, overflow } = trim(entries, limits)
+  const archivedFile = archive(overflow)
+  writeNotes(kept)
+  return { kept: kept.length, archived: overflow.length, archivedFile, unchanged: false, notesFile: notesPath() }
+}
+
+/** 删一条：先归档再摘除，删掉的东西仍然找得回来（archive/YYYY-MM.md）。 */
+export function deleteNote(index) {
+  const entries = readNotes()
+  const at = Number(index)
+  if (!Number.isInteger(at) || at < 0 || at >= entries.length) {
+    throw new Error('没有这一条了（可能刚被删过），刷新一下再试')
+  }
+  const [dropped] = entries.splice(at, 1)
+  const archivedFile = archive([dropped])
+  writeNotes(entries)
+  return { kept: entries.length, removed: dropped, archivedFile, notesFile: notesPath() }
+}
+
+/** 统计：生效条数、字符数、归档文件数。 */
+export function stats() {
+  const entries = readNotes()
+  const dir = archiveDir()
+  let archiveFiles = 0
+  if (existsSync(dir)) {
+    for (const name of readdirSync(dir)) {
+      if (name.endsWith('.md')) archiveFiles += 1
+    }
+  }
+  return {
+    entries: entries.length,
+    chars: renderNotes(entries).length,
+    archiveFiles,
+    notesFile: notesPath(),
+    // 上次真正写进 notes.md 的时刻：条目里只存日期（YYYY-MM-DD），看不出「几小时前」，
+    // 所以用文件 mtime —— 它就是写入那一刻，设置页拿这个算「上次写入：N 小时前」。
+    lastWrite: lastWriteAt(),
+  }
+}
+
+function lastWriteAt() {
+  try {
+    const info = statSync(notesPath())
+    if (info.size === 0) return null
+    return info.mtime.toISOString()
+  } catch {
+    return null
+  }
+}
+
+/* ------------------------------ 配置 ------------------------------ */
+
+export function configPath() {
+  return join(selfnoteRoot(), 'config.json')
+}
+
+/** 读配置；文件不存在或坏掉都返回 {}，由调用方补默认值。 */
+export function readConfig() {
+  const file = configPath()
+  if (!existsSync(file)) return {}
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+/** 整块写入配置（保留未知字段由调用方决定）。 */
+export function writeConfig(next) {
+  ensureDir(selfnoteRoot())
+  // 原子写：config.json 被截断会让插件静默回落默认值，等于悄悄改行为
+  writeJsonAtomic(configPath(), next ?? {})
+  return configPath()
+}
+
+/* ------------------------------ 准入 token ------------------------------ */
+
+export function authTokenPath() {
+  return join(selfnoteRoot(), 'auth-token')
+}
+
+/** 读本地 token；没有或空文件都返回 ''。 */
+export function readAuthToken() {
+  try {
+    return readFileSync(authTokenPath(), 'utf8').trim()
+  } catch {
+    return ''
+  }
+}
+
+/** 写本地 token，尽量收成 600（Windows 上 chmod 基本是空操作，不报错即可）。 */
+export function writeAuthToken(value) {
+  ensureDir(selfnoteRoot())
+  const file = authTokenPath()
+  writeAtomic(file, `${String(value).trim()}\n`)
+  try {
+    chmodSync(file, 0o600)
+  } catch {
+    /* 平台不支持就算了，token 本身不是密钥材料 */
+  }
+  return file
+}
+
+/** 清空当前生效的自述：全部进归档，不丢内容。 */export function clearNotes() {
+  const entries = readNotes()
+  if (entries.length === 0) return { cleared: 0, archivedFile: '' }
+  const archivedFile = archive(entries)
+  writeNotes([])
+  return { cleared: entries.length, archivedFile }
+}

package/lib/transfer.js

@@ -0,0 +1,154 @@
+/**
+ * 迁移：把一份记忆库导出成一个 JSON，在另一台机器上导入。
+ *
+ * 两条硬规矩：
+ * 1. **不覆盖**。同 id 已存在就跳过；正文一样的也跳过（哪怕状态不同，让人自己看着办）。
+ * 2. **默认不保留状态**。导入进来的 approved 一律变回 candidate —— 采纳必须由人在这里点一次，
+ *    而不是把别人机器上的结论悄悄当成自己的。想原样搬过来，得在界面上勾「保留原状态」。
+ *
+ * 索引不导出：它记的是磁盘路径与 mtime，搬过去必然过期，导入后重建一次就行。
+ */
+
+export const BUNDLE_VERSION = 1
+export const BUNDLE_APP = 'dsh-selfnote'
+
+const CONFIG_FIELDS = [
+  'enabled',
+  'heading',
+  'maxChars',
+  'maxEntries',
+  'profileEnabled',
+  'profileOverride',
+  'profileMaxChars',
+  'halfLifeDays',
+  'noteGuide',
+]
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function textOf(value) {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+/** 导出：只挑能带走的东西，配置只挑用户可调的那几项。 */
+export function buildBundle({ notes = [], facts = [], habits = [], config = {}, now = new Date() } = {}) {
+  const safeConfig = {}
+  for (const field of CONFIG_FIELDS) {
+    if (config[field] !== undefined) safeConfig[field] = config[field]
+  }
+  return {
+    app: BUNDLE_APP,
+    v: BUNDLE_VERSION,
+    exportedAt: now.toISOString(),
+    counts: { notes: notes.length, facts: facts.length, habits: habits.length },
+    notes: notes.map((entry) => ({ date: entry.date ?? '', text: entry.text ?? '' })),
+    facts: facts.map((fact) => ({ ...fact })),
+    habits: habits.map((habit) => ({ ...habit })),
+    config: safeConfig,
+  }
+}
+
+/** 导入前的体检：结构不对就直说，别合并一半。 */
+export function validateBundle(bundle) {
+  if (!isObject(bundle)) return '不是 JSON 对象'
+  if (bundle.app !== BUNDLE_APP) return `不是本插件导出的文件（app=${String(bundle.app)}）`
+  const v = Number(bundle.v ?? 0)
+  if (!Number.isSafeInteger(v) || v < 1) return '缺少版本号'
+  if (v > BUNDLE_VERSION) return `这份文件来自更新的版本（v${v}），本机只认到 v${BUNDLE_VERSION}`
+  for (const key of ['notes', 'facts', 'habits']) {
+    if (bundle[key] !== undefined && !Array.isArray(bundle[key])) return `${key} 不是数组`
+  }
+  return null
+}
+
+/**
+ * 合并：返回「合并后的三份数据 + 账目」。
+ * 纯函数，不写盘 —— 写盘由调用方做，失败才好回滚。
+ */
+export function mergeBundle(bundle, current = {}, options = {}) {
+  const keepStatus = options.keepStatus === true
+  const notes = (current.notes ?? []).map((entry) => ({ ...entry }))
+  const facts = (current.facts ?? []).map((fact) => ({ ...fact }))
+  const habits = (current.habits ?? []).map((habit) => ({ ...habit }))
+
+  const seenNotes = new Set(notes.map((entry) => textOf(entry.text)))
+  const seenFacts = new Set(facts.map((fact) => textOf(fact.text)))
+  const factIds = new Set(facts.map((fact) => fact.id))
+  const seenHabits = new Set(habits.map((habit) => textOf(habit.text)))
+
+  const added = { notes: 0, facts: 0, habits: 0 }
+  const skipped = { notes: 0, facts: 0, habits: 0, invalid: 0 }
+  const demoted = []
+  const conflicts = []
+
+  for (const raw of bundle.facts ?? []) {
+    const text = textOf(isObject(raw) ? raw.text : '')
+    const id = textOf(isObject(raw) ? raw.id : '')
+    if (text === '' || id === '') {
+      skipped.invalid += 1
+      continue
+    }
+    if (factIds.has(id)) {
+      skipped.facts += 1
+      continue
+    }
+    if (seenFacts.has(text)) {
+      skipped.facts += 1
+      conflicts.push({ text, reason: 'same-text' })
+      continue
+    }
+    const status = textOf(raw.status) || 'candidate'
+    const fact = { ...raw, text }
+    if (!keepStatus && status !== 'candidate') {
+      fact.status = 'candidate'
+      demoted.push(id)
+    }
+    if (fact.status === 'candidate') {
+      delete fact.reviewedAt
+      delete fact.retiredAt
+    }
+    fact.importedFrom = textOf(raw.source) || 'import'
+    facts.push(fact)
+    factIds.add(id)
+    seenFacts.add(text)
+    added.facts += 1
+  }
+
+  for (const raw of bundle.notes ?? []) {
+    const text = textOf(isObject(raw) ? raw.text : '')
+    if (text === '') {
+      skipped.invalid += 1
+      continue
+    }
+    if (seenNotes.has(text)) {
+      skipped.notes += 1
+      continue
+    }
+    notes.push({ date: textOf(raw.date) || '', text })
+    seenNotes.add(text)
+    added.notes += 1
+  }
+
+  for (const raw of bundle.habits ?? []) {
+    const text = textOf(isObject(raw) ? raw.text : '')
+    if (text === '') {
+      skipped.invalid += 1
+      continue
+    }
+    if (seenHabits.has(text)) {
+      skipped.habits += 1
+      continue
+    }
+    habits.push({
+      text,
+      status: textOf(raw.status) === 'active' ? 'active' : 'retired',
+      tag: textOf(raw.tag) || '',
+    })
+    seenHabits.add(text)
+    added.habits += 1
+  }
+
+  return { notes, facts, habits, added, skipped, demoted, conflicts, keepStatus }
+}

package/lib/warm.js

@@ -0,0 +1,155 @@
+/**
+ * 温层（P3）
+ *
+ * 定位：**带指针的摘要**，介于「每回合注入的热记忆」和「按需检索的原始会话」之间。
+ *   - 一条摘要必须指回原文（sessionId + 行号）。没有指针的摘要不许写进来 ——
+ *     否则它就是一段无法核对的自述，跟幻觉没区别。
+ *   - 可以吊销（status: void），不能删除：删了就不知道「我曾经这么以为过」。
+ *   - 不进注入。只有 memory_search 命中时才浮出来，所以条数可以很多。
+ */
+
+import { existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { memoryRoot, readFacts, tokenize } from './memory.js'
+import { writeAtomic } from './atomic.js'
+
+const MAX_TEXT = 300
+const MAX_POINTERS = 8
+
+export const warmPath = () => join(memoryRoot(), 'warm.jsonl')
+
+export function readWarm() {
+  const file = warmPath()
+  if (!existsSync(file)) return []
+  const out = []
+  for (const line of readFileSync(file, 'utf8').split('\n')) {
+    if (line.trim() === '') continue
+    try {
+      const item = JSON.parse(line)
+      if (item && typeof item === 'object') out.push(item)
+    } catch {
+      // 坏行跳过：一条摘要读不出来，不该让整层都废掉
+    }
+  }
+  return out
+}
+
+function writeWarm(items) {
+  // 目录可能还不存在（第一次写温层）
+  mkdirSync(memoryRoot(), { recursive: true })
+  writeAtomic(warmPath(), items.map((item) => JSON.stringify(item)).join('\n') + (items.length > 0 ? '\n' : ''))
+}
+
+function validPointer(pointer) {
+  return (
+    pointer &&
+    typeof pointer === 'object' &&
+    String(pointer.sessionId ?? '').trim() !== '' &&
+    Number.isSafeInteger(Number(pointer.index)) &&
+    Number(pointer.index) >= 0
+  )
+}
+
+/** 写一条摘要。没指针直接拒 —— 这条规矩是温层唯一的护栏。 */
+export function writeSummary(input = {}) {
+  const text = String(input.text ?? '').trim()
+  if (text === '') return { ok: false, error: 'text 不能为空' }
+  if (text.length > MAX_TEXT) return { ok: false, error: `一条摘要最多 ${MAX_TEXT} 字，拆成两条` }
+
+  const raw = Array.isArray(input.pointers) ? input.pointers : []
+  const pointers = raw
+    .filter(validPointer)
+    .map((pointer) => ({ sessionId: String(pointer.sessionId).trim(), index: Number(pointer.index) }))
+    .slice(0, MAX_POINTERS)
+  if (pointers.length === 0) {
+    return { ok: false, error: '摘要必须带指针（sessionId + 行号）—— 核不到原文的摘要，就是一段无法证伪的自述' }
+  }
+
+  const items = readWarm()
+  const at = new Date().toISOString()
+  const item = {
+    id: 'w' + Math.random().toString(36).slice(2, 10),
+    text,
+    tags: Array.isArray(input.tags) ? input.tags.map((tag) => String(tag).trim()).filter(Boolean).slice(0, 6) : [],
+    pointers,
+    status: 'active',
+    created: at,
+  }
+  items.push(item)
+  writeWarm(items)
+  return { ok: true, item, total: items.length }
+}
+
+/** 吊销：不删，只标 void —— 以后还能查到「当时是这么以为的」。 */
+export function voidSummary(id, reason = '') {
+  const items = readWarm()
+  const item = items.find((entry) => entry.id === id)
+  if (!item) return { ok: false, error: '没有这条摘要' }
+  item.status = 'void'
+  item.voidedAt = new Date().toISOString()
+  item.voidReason = String(reason ?? '')
+  writeWarm(items)
+  return { ok: true, item }
+}
+
+function score(text, terms) {
+  const lower = String(text ?? '').toLowerCase()
+  let matched = 0
+  let total = 0
+  for (const term of terms) {
+    if (lower.includes(term)) {
+      matched += 1
+      total += 3
+    }
+  }
+  return { matched, total }
+}
+
+/**
+ * 温层检索：摘要 + 事实（含环境事实的 detail 段落）。
+ * 返回的每条都带指针，能顺着回原文核对 —— 这是它跟「让模型凭印象说」的区别。
+ */
+export function searchWarm(query, options = {}) {
+  const terms = tokenize(query)
+  if (terms.length === 0) return { mode: 'warm', total: 0, terms, hits: [] }
+  const limit = Math.max(1, Math.min(Number(options.limit ?? 8) || 8, 20))
+
+  const hits = []
+  for (const item of readWarm()) {
+    if (item.status === 'void') continue
+    const hit = score(item.text + ' ' + (item.tags ?? []).join(' '), terms)
+    if (hit.matched === 0) continue
+    hits.push({ kind: 'summary', id: item.id, text: item.text, tags: item.tags ?? [], pointers: item.pointers ?? [], matched: hit.matched, scaled: hit.total })
+  }
+
+  for (const fact of readFacts()) {
+    const hit = score(fact.text + ' ' + (fact.detail ?? '') + ' ' + (fact.tags ?? []).join(' '), terms)
+    if (hit.matched === 0) continue
+    hits.push({
+      kind: 'fact',
+      id: fact.id,
+      text: fact.text,
+      detail: fact.detail ?? '',
+      status: fact.status,
+      channel: fact.channel ?? 'rel',
+      pointers: fact.citation ? [{ sessionId: fact.citation.sessionId, index: fact.citation.index }] : [],
+      matched: hit.matched,
+      scaled: hit.total,
+    })
+  }
+
+  // 全词命中优先，其次分数
+  hits.sort((a, b) => b.matched - a.matched || b.scaled - a.scaled)
+  return { mode: 'warm', total: hits.length, terms, hits: hits.slice(0, limit) }
+}
+
+export function warmStats() {
+  const items = readWarm()
+  return {
+    total: items.length,
+    active: items.filter((item) => item.status !== 'void').length,
+    voided: items.filter((item) => item.status === 'void').length,
+    withPointers: items.filter((item) => Array.isArray(item.pointers) && item.pointers.length > 0).length,
+  }
+}