dsh-line-bot 0.2.2 → 0.4.0

package/lib/host.mjs

@@ -19,6 +19,7 @@ const tiebaSyncMod = await import(withVersion('./tieba-sync.mjs'))
 const localPersonasMod = await import(withVersion('./local-personas.mjs'))
 const tiebaContextMod = await import(withVersion('./tieba-context.mjs'))
 const balanceMod = await import(withVersion('./deepseek-balance.mjs'))
+const memoryMod = await import(withVersion('./memory.mjs'))
 const utilMod = await import(withVersion('./util.mjs'))
 const { createConfigStore, publicConfig, dataDir } = configMod
 const { createPersonaClient } = personaMod
@@ -30,9 +31,10 @@ const { createTiebaSync, reloadPersonaPlugin } = tiebaSyncMod
 const { createLocalPersonas, LOCAL_PREFIX } = localPersonasMod
 const { buildTiebaContext } = tiebaContextMod
 const { createBalanceMonitor } = balanceMod
-const { chunkText, clip, inQuietWindow, jsonFail, jsonOk, maskSecret, readJsonBody } = utilMod
+const { createMemoryStore } = memoryMod
+const { chunkText, clip, inQuietWindow, jsonFail, jsonOk, maskSecret, readJsonBody, safeArray } = utilMod
 
-export const VERSION = '0.1.0'
+export const VERSION = '0.4.0'
 
 // 環境變數提供的 Cloudflare API Token（方便用 shell 注入、不用把 token 寫進設定檔）。
 // 設定檔裡的 token 優先；兩者都沒有時才用環境變數。
@@ -168,6 +170,9 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
   // ── DeepSeek 餘額 ───────────────────────────────────────────────────────
   const balance = createBalanceMonitor({ ctx, logger })
   let balanceTimer = null
+  let balanceNextAt = 0
+  const memory = createMemoryStore({ dir, logger, getConfig: () => store.get() })
+  let memoryTimer = null
 
   function balanceView() {
     const cached = balance.get()
@@ -177,9 +182,64 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
     return null
   }
 
+  function modelSelection() {
+    const cfg = store.get()
+    let fallback = null
+    try {
+      fallback = ctx.get?.('agentDefaultModel')?.currentSelection?.() || null
+    } catch {
+      fallback = null
+    }
+    const custom = Boolean(String(cfg.agent.provider || '').trim() || String(cfg.agent.model || '').trim())
+    const provider = String(cfg.agent.provider || fallback?.provider || '').trim()
+    const model = String(cfg.agent.model || fallback?.model || '').trim()
+    return {
+      provider,
+      model,
+      source: custom ? 'custom' : 'default',
+      defaultProvider: fallback?.provider || '',
+      defaultModel: fallback?.model || '',
+    }
+  }
+
+  // 只有 DeepSeek 官方帳號（deepseek-account）才查得到餘額；其他來源停用餘額相關功能。
+  function balanceApplicable() {
+    return modelSelection().provider === 'deepseek-account'
+  }
+
+  let modelCache = null
+  async function modelCatalog({ force = false } = {}) {
+    const now = Date.now()
+    if (!force && modelCache && now - modelCache.at < 60_000) return modelCache.value
+    const llm = ctx.get?.('llm')
+    if (!llm || typeof llm.listProviders !== 'function') {
+      return { providers: [], current: modelSelection(), error: '這個 profile 沒有 llm 服務，無法列出模型' }
+    }
+    const providers = []
+    try {
+      const infos = await llm.listProviders()
+      for (const info of infos || []) {
+        const entry = { id: info.id, name: info.name || info.id, models: [] }
+        try {
+          const models = await llm.listModels(info.id)
+          entry.models = (models || []).map((item) => ({ id: item.id, name: item.name || item.id }))
+        } catch (error) {
+          entry.error = errorText(error)
+        }
+        providers.push(entry)
+      }
+    } catch (error) {
+      return { providers: [], current: modelSelection(), error: errorText(error) }
+    }
+    const value = { providers, current: modelSelection(), at: now }
+    modelCache = { at: now, value }
+    return value
+  }
+
   function balanceContextText() {
     const cfg = store.get()
     if (cfg.balance.enabled === false) return ''
+    if (!balanceApplicable()) return ''
     const view = balanceView()
     if (!view) return ''
     const cached = balance.get()
@@ -193,8 +253,38 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
     return lines.join('\n')
   }
 
-  function agentContextText() {
-    return [tiebaContextText(), balanceContextText()].filter(Boolean).join('\n\n')
+  function memoryRulesText() {
+    if (store.get().memory?.enabled === false) return ''
+    return [
+      '【個人記憶】你有一份自己的記憶（每位使用者分開）。',
+      '對話中若出現你覺得重要、之後還會用到的資訊（喜好、近況、承諾、重要事件），馬上用 line_memory_add 記下來，不用等對方交代。',
+      '一次只記一件事；如果同時有兩三件重要的事，就分開呼叫兩三次，不要合併成一段。',
+      '有期限的事（考試、旅行、短期的狀況）請填 ttlDays，到期會自動刪掉；一次性閒聊不要記。',
+      '使用者要你忘掉某件事時，用 line_memory_forget 刪掉；想確認自己記了什麼就用 line_memory_list。',
+      '很重要：只有真的呼叫了工具才算記住。沒呼叫就不要說「記好了」；使用者明確要你記住時，先呼叫工具再回覆。',
+      '不要記密碼、token、證件號等敏感資料，也不要在回覆裡提到這些工具或「記憶系統」。',
+    ].join('\n')
+  }
+
+  function memoryContextText(userId) {
+    if (!userId) return ''
+    const rules = memoryRulesText()
+    const remembered = memory.formatForContext(userId)
+    return [rules, remembered].filter(Boolean).join('\n\n')
+  }
+
+  function memoryToolsFor(userId) {
+    if (!userId || store.get().memory?.enabled === false) return []
+    try {
+      return memory.toolsFor(userId)
+    } catch (error) {
+      logger.warn('準備記憶工具失敗：' + errorText(error))
+      return []
+    }
+  }
+
+  function agentContextText(userId) {
+    return [tiebaContextText(), balanceContextText(), memoryContextText(userId)].filter(Boolean).join('\n\n')
   }
 
   async function refreshBalance() {
@@ -204,6 +294,7 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
   async function maybeAskForTopUp({ dryRun = true, force = false } = {}) {
     const cfg = store.get()
     if (cfg.balance.enabled === false || cfg.balance.ask === false) return { skipped: 'disabled' }
+    if (!balanceApplicable()) return { skipped: 'provider-not-deepseek', provider: modelSelection().provider }
     const view = balanceView()
     if (!view) {
       const cached = balance.get()
@@ -219,7 +310,8 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
     if (!force && lastAskAt && Date.now() - lastAskAt < cooldownMs) return { skipped: 'cooldown', lastAskAt }
     if (!force && inQuietWindow(Date.now(), cfg.nudge.quietStart, cfg.nudge.quietEnd)) return { skipped: 'quiet-hours' }
     const candidates = Object.entries(state.users || {}).filter(([, user]) => user?.sessionId)
-    const preferred = (cfg.nudge.targetUserIds || []).find((id) => candidates.some(([key]) => key === id))
+    const targetIds = safeArray(cfg.balance?.targetUserIds).length ? safeArray(cfg.balance?.targetUserIds) : safeArray(cfg.nudge?.targetUserIds)
+    const preferred = targetIds.find((id) => candidates.some(([key]) => key === id))
     const picked = preferred ? candidates.find(([key]) => key === preferred) : [...candidates].sort((a, b) => (a[1].lastAt || 0) - (b[1].lastAt || 0))[0]
     if (!picked) return { skipped: 'no-user' }
     const [userId, user] = picked
@@ -251,14 +343,25 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
 
   function startBalanceWatch() {
     stopBalanceWatch()
-    const check = () => {
+    const runCheck = () => {
+      balanceNextAt = Date.now() + 30 * 60_000
+      if (!balanceApplicable()) return
       refreshBalance()
-        .then(() => maybeAskForTopUp({ dryRun: false }))
+        .then((cache) => {
+          if (!cache || cache.status !== 'ready') return null
+          return maybeAskForTopUp({ dryRun: false })
+        })
+        .then((result) => {
+          if (!result || !result.skipped) return
+          if (['enough', 'disabled', 'provider-not-deepseek'].includes(result.skipped)) return
+          logger.info('餘額檢查：這次不提醒（' + result.skipped + '）')
+        })
         .catch((error) => logger.warn('餘額檢查失敗：' + errorText(error)))
     }
-    const initial = setTimeout(check, 8_000)
+    const initial = setTimeout(runCheck, 8_000)
+    balanceNextAt = Date.now() + 8_000
     initial.unref?.()
-    balanceTimer = setInterval(check, 30 * 60_000)
+    balanceTimer = setInterval(runCheck, 30 * 60_000)
     balanceTimer.unref?.()
   }
 
@@ -267,6 +370,95 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
       clearInterval(balanceTimer)
       balanceTimer = null
     }
+    balanceNextAt = 0
+  }
+
+  // ── 個人記憶：清理與每日整理 ────────────────────────────────────────────
+  function pruneMemories() {
+    try {
+      const out = memory.prune()
+      if (out.removed > 0) logger.info('個人記憶：清理 ' + out.removed + ' 筆到期項目')
+      return out
+    } catch (error) {
+      logger.warn('清理個人記憶失敗：' + errorText(error))
+      return { removed: 0, error: errorText(error) }
+    }
+  }
+
+  async function reviewMemories({ userId = '' } = {}) {
+    const cfg = store.get()
+    if (cfg.memory?.enabled === false) return { skipped: 'disabled' }
+    const state = store.getState()
+    const targets = userId
+      ? [[userId, state.users?.[userId]]]
+      : Object.entries(state.users || {})
+    const reviewed = []
+    for (const [id, user] of targets) {
+      if (!user?.sessionId) continue
+      const entries = memory.list(id)
+      if (entries.length === 0) continue
+      const selection = cfg.persona.enforce ? user.personaId || cfg.persona.id : ''
+      const applied = await applyPersonaSelection(selection, user.sessionId)
+      const lines = entries.map((entry) => {
+        const created = new Date(entry.createdAt).toISOString().slice(0, 10)
+        const until = entry.expiresAt ? '，' + new Date(entry.expiresAt).toISOString().slice(0, 10) + ' 失效' : ''
+        return '- ' + entry.id + ' [' + entry.kind + '] ' + entry.text + '（' + created + until + '）'
+      })
+      const promptText = [
+        '（這是系統提供的背景整理，不是主人說的話）請你檢查自己對這位使用者的記憶。',
+        '目前的記憶：',
+        ...lines,
+        '把已經過期、一次事件已結束、或明顯不再成立的，用 line_memory_forget 刪掉；其餘保留。',
+        '不要輸出給主人看的訊息，只呼叫工具，最後回一個 OK。',
+      ].join('\n')
+      try {
+        await runner.turn({
+          sessionId: user.sessionId,
+          text: promptText,
+          persona: applied.persona,
+          personaText: applied.personaText,
+          personaClient: persona(),
+          contextText: '',
+          tools: memoryToolsFor(id),
+          cwd: ensureUserWorkspace(id) || undefined,
+        })
+        reviewed.push({ userId: id, entries: entries.length })
+      } catch (error) {
+        logger.warn('整理 ' + id + ' 的記憶失敗：' + errorText(error))
+      }
+    }
+    store.updateState((current) => ({ ...current, memory: { ...(current.memory || {}), lastReviewAt: Date.now() } }))
+    logger.info('個人記憶：整理完成，檢查 ' + reviewed.length + ' 位使用者')
+    return { reviewed: reviewed.length, users: reviewed }
+  }
+
+  function maybeDailyMemoryReview() {
+    const cfg = store.get()
+    if (cfg.memory?.enabled === false || cfg.memory?.reviewDaily === false) return
+    const hour = Number(cfg.memory?.reviewHour)
+    const wantedHour = Number.isFinite(hour) ? Math.max(0, Math.min(23, Math.round(hour))) : 4
+    const now = new Date()
+    if (now.getHours() !== wantedHour) return
+    const lastReviewAt = Number(store.getState().memory?.lastReviewAt) || 0
+    if (lastReviewAt && now.getTime() - lastReviewAt < 20 * 3600_000) return
+    reviewMemories().catch((error) => logger.warn('每日記憶整理失敗：' + errorText(error)))
+  }
+
+  function startMemoryWatch() {
+    stopMemoryWatch()
+    pruneMemories()
+    memoryTimer = setInterval(() => {
+      pruneMemories()
+      maybeDailyMemoryReview()
+    }, 10 * 60_000)
+    memoryTimer.unref?.()
+  }
+
+  function stopMemoryWatch() {
+    if (memoryTimer) {
+      clearInterval(memoryTimer)
+      memoryTimer = null
+    }
   }
 
   // ── LINE 憑證 ────────────────────────────────────────────────────────────
@@ -684,7 +876,8 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
         persona: applied.persona,
         personaText: applied.personaText,
         personaClient: persona(),
-        contextText: agentContextText(),
+        contextText: agentContextText(userId),
+        tools: memoryToolsFor(userId),
         cwd: ensureUserWorkspace(userId) || cfg.agent.cwd || undefined,
       })
       let replyText = String(result?.text || '').trim()
@@ -759,7 +952,8 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
         persona: applied.persona,
         personaText: applied.personaText,
         personaClient: persona(),
-        contextText: agentContextText(),
+        contextText: agentContextText(owner?.[0]),
+        tools: memoryToolsFor(owner?.[0]),
         cwd: owner ? ensureUserWorkspace(owner[0]) : undefined,
       })
     },
@@ -848,6 +1042,7 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
     nudge.start()
     tiebaSync.start()
     startBalanceWatch()
+    startMemoryWatch()
     store.updateState((state) => ({ ...state, lastStartAt: Date.now() }))
     if (cfg.line.channelId && cfg.line.channelSecret) refreshBotInfo().catch(() => {})
     return buildStatus()
@@ -856,6 +1051,7 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
   async function stopAll() {
     stopWebhookGuard()
     stopBalanceWatch()
+    stopMemoryWatch()
     nudge.stop()
     tiebaSync.stop()
     await tunnel.stop({ silent: true }).catch(() => {})
@@ -922,20 +1118,35 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
       persona: personaSummary,
       agent: {
         ...runner.stats(),
+        ...modelSelection(),
         timeoutMs: cfg.agent.timeoutMs,
         lastFinishedAt: runner.stats().lastFinishedAt,
       },
       nudge: { ...nudge.stats(), config: cfg.nudge },
       balance: {
         ...balance.get(),
+        applicable: balanceApplicable(),
+        provider: modelSelection().provider,
         enabled: cfg.balance.enabled !== false,
         ask: cfg.balance.ask !== false,
         threshold: Number(cfg.balance.threshold) || 0,
         cooldownHours: Number(cfg.balance.cooldownHours) || 12,
         lastAskAt: Number(state.balance?.lastAskAt) || 0,
+        nextCheckAt: balanceNextAt,
+        targetUserIds: safeArray(cfg.balance?.targetUserIds),
         lastAskText: state.balance?.lastAskText || '',
         low: Boolean(balanceView() && Number(cfg.balance.threshold) > 0 && balanceView().value.total < Number(cfg.balance.threshold)),
       },
+      memory: {
+        ...memory.stats(),
+        enabled: cfg.memory?.enabled !== false,
+        reviewDaily: cfg.memory?.reviewDaily !== false,
+        reviewHour: Number(cfg.memory?.reviewHour) || 0,
+        maxPerUser: Number(cfg.memory?.maxPerUser) || 120,
+        injectMaxEntries: Number(cfg.memory?.injectMaxEntries) || 20,
+        injectMaxChars: Number(cfg.memory?.injectMaxChars) || 2000,
+        lastReviewAt: Number(state.memory?.lastReviewAt) || 0,
+      },
       sync: { ...tiebaSync.stats(), config: cfg.sync },
       users,
       logs: logger.lines(),
@@ -1092,10 +1303,44 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
         personaCache.at = 0
         return created
       }
+      case 'model-catalog':
+        return modelCatalog({ force: payload.force === true })
       case 'balance-refresh':
+        if (!balanceApplicable()) return { skipped: 'provider-not-deepseek', provider: modelSelection().provider }
         return refreshBalance()
       case 'balance-ask':
         return maybeAskForTopUp({ dryRun: payload.dryRun !== false, force: payload.force === true })
+      case 'memory-list': {
+        const only = String(payload.userId || '').trim()
+        const state = store.getState()
+        const rows = Object.entries(state.users || {})
+          .filter(([userId]) => !only || userId === only)
+          .map(([userId, user]) => ({
+            userId,
+            displayName: user?.displayName || '',
+            entries: memory.list(userId).map((entry) => ({
+              ...entry,
+              createdText: new Date(entry.createdAt).toISOString(),
+              expiresText: entry.expiresAt ? new Date(entry.expiresAt).toISOString() : '',
+            })),
+          }))
+          .filter((row) => row.entries.length > 0)
+        return { users: rows, total: rows.reduce((sum, row) => sum + row.entries.length, 0) }
+      }
+      case 'memory-add': {
+        const userId = String(payload.userId || '').trim()
+        if (!userId) throw new Error('缺少 userId')
+        return memory.add(userId, payload)
+      }
+      case 'memory-delete': {
+        const userId = String(payload.userId || '').trim()
+        if (!userId) throw new Error('缺少 userId')
+        return memory.forget(userId, { ids: payload.id ? [payload.id] : payload.ids })
+      }
+      case 'memory-prune':
+        return pruneMemories()
+      case 'memory-review':
+        return reviewMemories({ userId: String(payload.userId || '').trim() })
       case 'nudge-test':
         return nudge.tick({ force: true })
       case 'agent-test': {
@@ -1103,6 +1348,9 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
         const sessionId = String(payload.sessionId || `session-line-selftest-${Date.now()}`)
         const cwd = String(payload.cwd || '').trim() || undefined
         const selection = String(payload.personaId || '').trim() || (cfg.persona.enforce ? cfg.persona.id : '')
+        const testUserId = String(payload.userId || '').trim()
+          || Object.entries(store.getState().users || {}).find(([, item]) => item.sessionId === sessionId)?.[0]
+          || ''
         const applied = await applyPersonaSelection(selection, sessionId)
         const result = await runner.turn({
           sessionId,
@@ -1110,7 +1358,8 @@ export async function create({ ctx, config: pluginConfig, logger: upstream }) {
           persona: applied.persona,
           personaText: applied.personaText,
           personaClient: persona(),
-          contextText: agentContextText(),
+          contextText: agentContextText(testUserId),
+          tools: memoryToolsFor(testUserId),
           cwd,
         })
         return { text: result.text, reason: result.reason, sessionId, cwd: cwd || '', persona: selection, personaSource: applied.source }

package/lib/memory.mjs

@@ -0,0 +1,209 @@
+// 每位 LINE 使用者各自的「個人記憶」：agent 覺得重要就自己寫進來，
+// 有保存期限的到期後由背景清理；也可以被要求翻出來看或忘掉。
+import fs from 'node:fs'
+import path from 'node:path'
+import { randomBytes } from 'node:crypto'
+import { readJsonSafe, writeJsonAtomic, nowIso } from './util.mjs'
+import { defineTool } from './toolkit.mjs'
+
+const KINDS = ['fact', 'event', 'preference', 'inside']
+const MAX_TEXT = 600
+const DAY = 24 * 60 * 60 * 1000
+
+function emptyStore() {
+  return { version: 1, users: {}, lastPruneAt: 0 }
+}
+
+function normalizeEntry(input) {
+  const text = String(input?.text || '').trim().slice(0, MAX_TEXT)
+  if (!text) throw new Error('記憶內容不能是空的')
+  const kind = KINDS.includes(input?.kind) ? input.kind : 'fact'
+  let importance = Number(input?.importance)
+  if (!Number.isFinite(importance)) importance = 3
+  importance = Math.max(1, Math.min(5, Math.round(importance)))
+  let expiresAt = 0
+  const ttlDays = Number(input?.ttlDays)
+  if (Number.isFinite(ttlDays) && ttlDays > 0) {
+    expiresAt = Date.now() + Math.min(ttlDays, 3650) * DAY
+  }
+  return {
+    id: 'm_' + randomBytes(4).toString('hex'),
+    text,
+    kind,
+    importance,
+    source: input?.source === 'user' ? 'user' : 'agent',
+    createdAt: Date.now(),
+    expiresAt,
+  }
+}
+
+export function createMemoryStore({ dir, logger, getConfig }) {
+  const file = path.join(dir, 'memories.json')
+  let store = readJsonSafe(file, emptyStore())
+  if (!store || typeof store !== 'object') store = emptyStore()
+  if (!store.users || typeof store.users !== 'object') store.users = {}
+  if (!store.version) store.version = 1
+
+  function save() {
+    writeJsonAtomic(file, store, 0o600)
+  }
+
+  function cfg() {
+    return getConfig()?.memory || {}
+  }
+
+  function bucket(userId) {
+    const key = String(userId || '')
+    if (!key) throw new Error('缺少使用者 ID')
+    if (!store.users[key]) store.users[key] = { entries: [], updatedAt: 0 }
+    if (!Array.isArray(store.users[key].entries)) store.users[key].entries = []
+    return store.users[key]
+  }
+
+  function activeEntries(userId) {
+    const now = Date.now()
+    return bucket(userId).entries
+      .filter((entry) => !entry.expiresAt || entry.expiresAt > now)
+      .sort((a, b) => b.createdAt - a.createdAt)
+  }
+
+  function list(userId) {
+    return activeEntries(userId).map((entry) => ({ ...entry }))
+  }
+
+  function add(userId, input) {
+    const entry = normalizeEntry(input)
+    const target = bucket(userId)
+    target.entries.push(entry)
+    target.updatedAt = Date.now()
+    const max = Math.max(10, Math.min(Number(cfg().maxPerUser) || 120, 500))
+    if (target.entries.length > max) {
+      target.entries.sort((a, b) => a.createdAt - b.createdAt)
+      target.entries.splice(0, target.entries.length - max)
+    }
+    save()
+    logger?.info?.(`個人記憶：幫 ${userId} 記下「${entry.text.slice(0, 40)}」`)
+    return { ...entry }
+  }
+
+  function forget(userId, { ids, query, expired } = {}) {
+    const target = bucket(userId)
+    const now = Date.now()
+    const wanted = new Set(Array.isArray(ids) ? ids.map(String) : [])
+    const needle = String(query || '').trim().toLowerCase()
+    const removed = []
+    target.entries = target.entries.filter((entry) => {
+      const hit = (wanted.size > 0 && wanted.has(entry.id))
+        || (expired === true && entry.expiresAt && entry.expiresAt <= now)
+        || (needle && String(entry.text || '').toLowerCase().includes(needle))
+      if (hit) removed.push(entry.id)
+      return !hit
+    })
+    if (removed.length > 0) {
+      target.updatedAt = Date.now()
+      save()
+      logger?.info?.(`個人記憶：從 ${userId} 刪掉 ${removed.length} 筆`)
+    }
+    return { removed: removed.length, ids: removed }
+  }
+
+  function prune() {
+    const now = Date.now()
+    let removed = 0
+    for (const [userId, target] of Object.entries(store.users)) {
+      const entries = Array.isArray(target?.entries) ? target.entries : []
+      const kept = entries.filter((entry) => !entry.expiresAt || entry.expiresAt > now)
+      removed += entries.length - kept.length
+      if (kept.length !== entries.length) {
+        target.entries = kept
+        target.updatedAt = now
+      }
+      if (kept.length === 0 && Object.keys(target).length <= 2) delete store.users[userId]
+    }
+    if (removed > 0 || !store.lastPruneAt) {
+      store.lastPruneAt = now
+      save()
+    }
+    return { removed, at: now }
+  }
+
+  function stats() {
+    const now = Date.now()
+    let total = 0
+    let expired = 0
+    const users = []
+    for (const [userId, target] of Object.entries(store.users)) {
+      const entries = Array.isArray(target?.entries) ? target.entries : []
+      const live = entries.filter((entry) => !entry.expiresAt || entry.expiresAt > now)
+      expired += entries.length - live.length
+      total += live.length
+      if (live.length > 0) users.push({ userId, count: live.length, lastAt: target.updatedAt || 0 })
+    }
+    return { file, total, expired, users, lastPruneAt: store.lastPruneAt || 0 }
+  }
+
+  function formatForContext(userId) {
+    const conf = cfg()
+    if (conf.enabled === false || !userId) return ''
+    const entries = activeEntries(userId)
+    if (entries.length === 0) return ''
+    const maxEntries = Math.max(1, Math.min(Number(conf.injectMaxEntries) || 20, 80))
+    const maxChars = Math.max(200, Math.min(Number(conf.injectMaxChars) || 2000, 8000))
+    const lines = []
+    let used = 0
+    for (const entry of entries.slice(0, maxEntries)) {
+      const stamp = new Date(entry.createdAt).toISOString().slice(0, 10)
+      const until = entry.expiresAt ? `，${new Date(entry.expiresAt).toISOString().slice(0, 10)} 失效` : ''
+      const line = `- [${entry.kind}] ${entry.text}（${stamp}${until}）`
+      if (used + line.length > maxChars) break
+      lines.push(line)
+      used += line.length
+    }
+    if (lines.length === 0) return ''
+    return [
+      '【你記得的關於這位使用者的事】',
+      '（這些是你自己寫下的記憶；可自然引用，但不必逐條複述。若發現過期或不再成立，可用 line_memory_forget 刪掉。）',
+      ...lines,
+    ].join('\n')
+  }
+
+  function toolsFor(userId) {
+    return [
+      defineTool({
+        name: 'line_memory_add',
+        description: '把關於這位使用者的重要事情寫進你的個人記憶。只記長期有用、之後還會影響對話的內容；'
+          + '一次性或純閒聊不要記。有期限的（例如「下週考試」「這個月在減肥」）請填 ttlDays，到期會自動刪掉。'
+          + '不要記密碼、token、身分證號等敏感資料。',
+        parameters: {
+          text: { type: 'string', description: '要記住的事，一句到兩句，寫成你自己看得懂的描述', required: true },
+          kind: { type: 'string', enum: KINDS, description: 'fact=事實、event=事件、preference=喜好、inside=你們之間的默契' },
+          importance: { type: 'number', description: '1~5，越高越重要（預設 3）' },
+          ttlDays: { type: 'number', description: '幾天後失效；不填或 0 表示長期保留' },
+        },
+        execute: async (args) => {
+          const entry = add(userId, args || {})
+          return { saved: true, id: entry.id, kind: entry.kind, expiresAt: entry.expiresAt || null }
+        },
+      }),
+      defineTool({
+        name: 'line_memory_forget',
+        description: '刪掉你的個人記憶：用 ids 指定，或給 query 刪掉內容包含這段字的記憶；'
+          + '給 expired:true 則清掉所有已到期的。使用者要求「忘掉」時就用這個。',
+        parameters: {
+          ids: { type: 'array', items: { type: 'string' }, description: '要刪的記憶 id' },
+          query: { type: 'string', description: '刪掉內容包含這個字串的記憶' },
+          expired: { type: 'boolean', description: '清掉所有已到期的記憶' },
+        },
+        execute: async (args) => forget(userId, args || {}),
+      }),
+      defineTool({
+        name: 'line_memory_list',
+        description: '列出你目前對這位使用者記得的內容（含 id 與到期日），想確認或整理時使用。',
+        parameters: {},
+        execute: async () => ({ count: activeEntries(userId).length, entries: activeEntries(userId) }),
+      }),
+    ]
+  }
+
+  return { file, list, add, forget, prune, stats, formatForContext, toolsFor }
+}

package/lib/tieba-sync.mjs

@@ -70,6 +70,11 @@ export function buildSection(tieba, date = new Date()) {
   return `${lines.join('\n')}\n\n`
 }
 
+// 只比較內容：標題裡的時間戳每次都會變，不能拿它判斷「語氣有變化」。
+function sansStamp(text) {
+  return String(text).replace(/(##\s*貼吧學來的口氣（自動同步 )[^）]*(）)/, '$1…$2')
+}
+
 function findSection(text) {
   const heading = /^##\s*貼吧學來的口氣[^\n]*$/m.exec(text)
   if (!heading) return null
@@ -174,7 +179,7 @@ export function createTiebaSync({ ctx, store, logger }) {
       const oldText = String(target.text || '')
       let nextText = applySection(oldText, buildSection(tieba))
       if (cfg.syncTraits !== false) nextText = applyTraits(nextText, tieba.traits)
-      const changed = nextText !== oldText
+      const changed = sansStamp(nextText) !== sansStamp(oldText)
       const stateSync = store.getState().sync || {}
       if (!changed && stateSync.version === tieba.version) {
         return { skipped: 'unchanged', version: tieba.version, targetId }
@@ -195,17 +200,9 @@ export function createTiebaSync({ ctx, store, logger }) {
         }
         writeJsonAtomic(dafeiyuStorePath(), next)
         logger.info(`已把刷貼吧學到的語氣寫回人設「${target.name || targetId}」（版本 ${tieba.version}）`)
-        if (cfg.reloadPersona !== false) {
-          try {
-            reload = await reloadPersonaPlugin(ctx)
-            if (!reload.ok) logger.warn(`重載大肥魚外掛失敗：${reload.error}`)
-          } catch (error) {
-            reload = { ok: false, error: String(error?.message || error) }
-            logger.warn(`重載大肥魚外掛失敗：${reload.error}`)
-          }
-        }
       }
 
+      // 先記帳再重載：重載要幾百毫秒，中途若插件重啟，新實例讀到的 state 才不會還停在舊的 at 而立刻再跑一次。
       store.updateState((state) => ({
         ...state,
         sync: {
@@ -215,10 +212,21 @@ export function createTiebaSync({ ctx, store, logger }) {
           samples: tieba.samples.length,
           changed,
           backupPath,
-          reloadOk: reload ? Boolean(reload.ok) : null,
+          reloadOk: null,
           error: '',
         },
       }))
+
+      if (changed && cfg.reloadPersona !== false) {
+        try {
+          reload = await reloadPersonaPlugin(ctx)
+          if (!reload.ok) logger.warn(`重載大肥魚外掛失敗：${reload.error}`)
+        } catch (error) {
+          reload = { ok: false, error: String(error?.message || error) }
+          logger.warn(`重載大肥魚外掛失敗：${reload.error}`)
+        }
+        store.updateState((state) => ({ ...state, sync: { ...(state.sync || {}), reloadOk: Boolean(reload?.ok) } }))
+      }
       return {
         at,
         version: tieba.version,