dsh-memu-memory 1.1.2 → 1.1.3

package/lib/state.js

@@ -5,12 +5,20 @@ import {
   dataDir, librariesDir, indexDir, backupsDir,
   ensureDir, readJson, readFailure, readFailuresUnder, writeJson, withFileLock, assertJsonShape, warn, stamp, shortHash, libraryIdForScope, isSafeId,
 } from './paths.js'
+import {
+  activeLeases, createBackup, deleteBackupEntry, listBackupEntries,
+  pruneBackups, restoreFromBackup, withBackupLock,
+} from './backup.js'
 import { migrateIndexVisibility } from './visibility.js'
+import { memuDbFor, memuGlobalDbFor } from './vector-profile.js'
 
 const STATE_FILE = () => path.join(dataDir(), 'state.json')
 const GLOBAL_DB = () => path.join(dataDir(), 'global.sqlite3')
 const GLOBAL_INDEX = () => path.join(indexDir(), 'global.json')
 
+// Observable outcome of the last backup action; see listBackupEntries().
+let lastBackupReport = null
+
 export const DEFAULT_SETTINGS = {
   sidebarSettings: false,
   visionCaptionEnabled: true,
@@ -24,12 +32,17 @@ export const DEFAULT_SETTINGS = {
   // "too little memory", it is noise: a per-turn block sized for paragraph-long
   // prompts drowns the conversation it was meant to help. So the per-turn budgets
   // are small, and the windows that stop repetition are measured in many turns.
-  privateTopK: 3,
-  globalTopK: 2,
-  anchorTokens: 700,
-  // 640 tokens per user turn. A dense chat calls recall on almost every message,
-  // so the injected block has to stay clearly smaller than the message it serves.
-  turnTokens: 640,
+  privateTopK: 5,
+  globalTopK: 5,
+  anchorTokens: 800,
+  // 800 tokens for one recall block. A dense chat calls recall on almost every
+  // message, so the injected block has to stay clearly smaller than the message it
+  // serves. This is the recall budget, not the whole plugin-message ceiling.
+  turnTokens: 800,
+  // Whole plugin-message ceiling: anchor + recall + optional cue/texture. It must
+  // be at least the sum of the sub-budgets the user wants to allow; the default leaves
+  // room for the default anchor and recall blocks.
+  injectionTotalTokens: 2000,
   relevanceThreshold: 0.4,
   // 16 turns is a couple of minutes of group traffic. The old 8 expired inside a
   // single burst, so the same entry came back every minute or two.
@@ -90,6 +103,7 @@ export const DEFAULT_SETTINGS = {
   // agent writes and summarizes into the JSON index, with no MemU engine and no
   // embedding API. 'api' hands the work to the configured remote MemU service.
   memoryBackend: 'agent',
+  vectorSource: 'local',
   habitsInjection: true,
   // A positive age marks cleanup candidates; deletion always needs a user action.
   purgeArchivedAfterDays: 0,
@@ -110,10 +124,14 @@ function defaultState() {
 function mergeState(raw) {
   const base = defaultState()
   if (!raw || typeof raw !== 'object') return base
+  const rawSettings = raw.settings && typeof raw.settings === 'object' ? raw.settings : {}
+  const legacyVectorSource = rawSettings.vectorSource === 'api' || rawSettings.vectorSource === 'local'
+    ? rawSettings.vectorSource
+    : (rawSettings.memoryMode === 'cloud' ? 'api' : 'local')
   return {
     ...base,
     ...raw,
-    settings: { ...base.settings, ...(raw.settings || {}) },
+    settings: { ...base.settings, ...rawSettings, vectorSource: legacyVectorSource },
     libraries: raw.libraries && typeof raw.libraries === 'object' ? raw.libraries : {},
     sessions: raw.sessions && typeof raw.sessions === 'object' ? raw.sessions : {},
     workspacePolicies: raw.workspacePolicies && typeof raw.workspacePolicies === 'object' ? raw.workspacePolicies : {},
@@ -306,16 +324,27 @@ export function getMemoryBackend() {
   return loadState().settings?.memoryBackend === 'api' ? 'api' : 'agent'
 }
 
+// Single route authority for automatic memory reads and writes.
+export function effectiveVectorRoute(settings = loadState().settings) {
+  if (settings?.memoryBackend !== 'api') return 'lexical'
+  return settings?.vectorSource === 'api' ? 'remote-api' : 'managed-local'
+}
+
+export function vectorBackendEnabled(settings = loadState().settings) {
+  return effectiveVectorRoute(settings) !== 'lexical'
+}
+
 export function updateSettings(patch) {
   const clean = {}
   const ranges = {
     privateTopK: [1, 20], globalTopK: [1, 20], anchorTokens: [160, 8000], turnTokens: [80, 8000],
+    injectionTotalTokens: [160, 16000],
     relevanceThreshold: [0, 1], dedupeTurns: [0, 200], globalEveryNTurns: [0, 200], minUserChars: [0, 1000],
     mustRememberCap: [1, 100], randomCueChance: [0, 1], shortTermTtlHours: [0, 8760],
     unpinBudgetPerSession: [1, 20], unpinCooldownMinutes: [0, 1440], sleepAfterIdleMinutes: [1, 1440],
     autoCurateEveryHours: [0, 8760], autoCurateSessionLimit: [1, 10], purgeArchivedAfterDays: [0, 36500],
   }
-  const enums = { autoInject: ['smart', 'anchor-only', 'per-turn', 'off'], memoryMode: ['local', 'cloud'], memoryBackend: ['agent', 'api'], newSessionDefault: ['off', 'auto', 'global', 'both'] }
+  const enums = { autoInject: ['smart', 'anchor-only', 'per-turn', 'off'], memoryMode: ['local', 'cloud'], memoryBackend: ['agent', 'api'], vectorSource: ['local', 'api'], newSessionDefault: ['off', 'auto', 'global', 'both'] }
   for (const [key, value] of Object.entries(patch || {})) {
     if (!Object.hasOwn(DEFAULT_SETTINGS, key)) continue
     if (enums[key]) {
@@ -906,12 +935,12 @@ export function markAnniversaryShown(sessionId, memoryId, dayKey) {
 
 export function memoryDbPath(libraryId) {
   ensureDir(librariesDir())
-  return path.join(librariesDir(), `${libraryId}.sqlite3`)
+  return effectiveVectorRoute() === 'managed-local' ? memuDbFor(libraryId) : path.join(librariesDir(), `${libraryId}.sqlite3`)
 }
 
 export function globalDbPath() {
   ensureDir(dataDir())
-  return GLOBAL_DB()
+  return effectiveVectorRoute() === 'managed-local' ? memuGlobalDbFor() : GLOBAL_DB()
 }
 
 // Index files are parsed on every folder in the sidebar, and the parse (full
@@ -1144,175 +1173,94 @@ export function newMemoryId(prefix = 'mem') {
   return `${prefix}-${Date.now().toString(36)}-${crypto.randomBytes(3).toString('hex')}`
 }
 
-export function backupDatabases() {
+/**
+ * Creates a managed backup of the local memory stores (plugin state, indexes,
+ * prompts, attachments, the vector journal and every MemU database), then keeps
+ * the newest BACKUP_KEEP complete ones. Retention, staging, checksums, atomic
+ * publish and the shared lock all live in lib/backup.js so there is exactly one
+ * place that decides what a backup is and which backup may be deleted.
+ *
+ * Returns the published directory: callers (engine switch, library delete,
+ * scripts) treat the return value as a path.
+ */
+export function backupDatabases(options = {}) {
   // Pending bookkeeping changes live in memory for up to 50ms; a backup taken
   // before a flush would silently capture the previous state.
-  flushState()
-  const dest = path.join(backupsDir(), stamp().replace(/[:.]/g, '-'))
-  ensureDir(dest)
-  ensureDir(path.join(dest, 'libraries'))
-  ensureDir(path.join(dest, 'index'))
-  // The prompt manifest copy below silently no-opped without this directory —
-  // an empty catch swallowed the ENOENT and backups shipped without it.
-  ensureDir(path.join(dest, 'prompts'))
-  const copy = (from, to) => {
-    let info
-    try { info = fs.lstatSync(from) } catch (error) { if (error.code === 'ENOENT') return; throw error }
-    if (!info.isFile()) throw new Error(`backup refuses non-file: ${path.basename(from)}`)
-    fs.copyFileSync(from, to)
-  }
-  copy(STATE_FILE(), path.join(dest, 'state.json'))
-  copy(GLOBAL_DB(), path.join(dest, 'global.sqlite3'))
-  copy(GLOBAL_INDEX(), path.join(dest, 'index', 'global.json'))
-  copy(path.join(dataDir(), 'prompts', 'manifest.json'), path.join(dest, 'prompts', 'manifest.json'))
+  let report
   try {
-    for (const name of fs.readdirSync(librariesDir())) {
-      if (name.endsWith('.sqlite3') || name.endsWith('.sqlite3-wal') || name.endsWith('.sqlite3-shm')) {
-        copy(path.join(librariesDir(), name), path.join(dest, 'libraries', name))
-      }
-    }
-  } catch (error) { if (error.code !== 'ENOENT') throw error }
-  try {
-    for (const name of fs.readdirSync(indexDir())) {
-      if (name.endsWith('.json')) copy(path.join(indexDir(), name), path.join(dest, 'index', name))
-    }
-  } catch (error) { if (error.code !== 'ENOENT') throw error }
-  const copyTree = (source, target) => {
-    let names
-    try { names = fs.readdirSync(source, { withFileTypes: true }) } catch (error) { if (error.code === 'ENOENT') return; throw error }
-    ensureDir(target)
-    for (const item of names) {
-      if (item.isSymbolicLink()) throw new Error('backup refuses symbolic links')
-      if (item.isDirectory()) copyTree(path.join(source, item.name), path.join(target, item.name))
-      else copy(path.join(source, item.name), path.join(target, item.name))
-    }
-  }
-  copyTree(path.join(dataDir(), 'attachments'), path.join(dest, 'attachments'))
-  copyTree(path.join(dataDir(), 'prompts'), path.join(dest, 'prompts'))
-
-  // A backup whose integrity nobody can check is only a hope. Hash every file so
-  // a restore can refuse a truncated or half-written copy.
-  const files = {}
-  const walk = (dir, prefix = '') => {
-    let names = []
-    try { names = fs.readdirSync(dir) } catch { return }
-    for (const name of names) {
-      const full = path.join(dir, name)
-      let stat = null
-      try { stat = fs.statSync(full) } catch { continue }
-      if (stat.isDirectory()) { walk(full, `${prefix}${name}/`); continue }
-      let sha256 = null
-      try { sha256 = crypto.createHash('sha256').update(fs.readFileSync(full)).digest('hex') } catch {}
-      files[`${prefix}${name}`] = { bytes: stat.size, sha256 }
+    report = createBackup({ ...options, flushState })
+  } catch (error) {
+    // A refusal is the safety property working, not something to swallow: a
+    // database the engine could not snapshot aborts the backup, and the reason
+    // has to stay visible on the same channel the panel already reads.
+    lastBackupReport = {
+      at: stamp(),
+      action: 'create',
+      status: 'failed',
+      code: error?.code || null,
+      error: String(error?.message || error),
+      name: null,
+      dir: null,
+      files: 0,
+      bytes: 0,
+      snapshots: [],
+      pruned: [],
+      pruneFailed: [],
+      pendingCleanup: 0,
+      notice: null,
     }
+    throw error
   }
-  walk(dest)
-  const current = engineCurrentSafe()
-  writeJson(path.join(dest, 'manifest.json'), {
-    version: 1,
-    createdAt: stamp(),
-    engine: current ? { version: current.version, schemaVersion: current.schemaVersion || null } : null,
-    files,
-  })
-  return dest
+  lastBackupReport = { at: stamp(), action: 'create', ...report }
+  return report.dir
 }
 
-function engineCurrentSafe() {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(dataDir(), 'engine', 'current.json'), 'utf8'))
-  } catch {
-    return null
-  }
+/** What the last backup/restore/prune did, so the outcome stays observable. */
+export function lastBackupReportView() {
+  return lastBackupReport ? { ...lastBackupReport } : null
 }
 
+/** Newest first, including entries that failed to complete (reported, never deleted). */
 export function listBackups() {
-  let names = []
-  try { names = fs.readdirSync(backupsDir()) } catch { return [] }
-  return names
-    .map((name) => {
-      const dir = path.join(backupsDir(), name)
-      let stat = null
-      try { stat = fs.statSync(dir) } catch { return null }
-      if (!stat.isDirectory()) return null
-      const manifest = readJson(path.join(dir, 'manifest.json'), null)
-      const fileCount = manifest?.files ? Object.keys(manifest.files).length : null
-      const bytes = manifest?.files
-        ? Object.values(manifest.files).reduce((sum, f) => sum + Number(f.bytes || 0), 0)
-        : null
-      return {
-        name,
-        dir,
-        createdAt: manifest?.createdAt || stat.mtime.toISOString(),
-        engine: manifest?.engine || null,
-        files: fileCount,
-        bytes,
-        hasManifest: Boolean(manifest),
-      }
-    })
-    .filter(Boolean)
-    .sort((a, b) => String(b.name).localeCompare(String(a.name)))
+  return listBackupEntries()
 }
 
 /** Removes one backup directory. The name is validated, never used as a path. */
 export function deleteBackup(name) {
-  if (!isSafeId(name)) throw new Error('invalid backup name')
-  const dir = path.join(backupsDir(), name)
-  if (!fs.existsSync(dir)) throw new Error(`backup not found: ${name}`)
-  fs.rmSync(dir, { recursive: true, force: true })
-  return { deleted: name }
+  const result = deleteBackupEntry(name)
+  lastBackupReport = { at: stamp(), action: 'delete', ...result }
+  return { deleted: result.deleted, status: result.status }
 }
 
 /**
- * Puts a backup back. The current state is backed up first, so a restore is
- * itself reversible. Nothing is written until the target verifies, and the
- * in-memory caches are dropped so the next read sees the restored files.
+ * Applies the retention rule on demand. Creation already prunes, so this exists
+ * for the paths that must reclaim the space a protected restore target kept
+ * alive, and for callers that want the report without making a backup.
  */
-export function restoreBackup(name, { beforeRestore = null } = {}) {
-  if (!isSafeId(name)) throw new Error('invalid backup name')
-  const dir = path.join(backupsDir(), name)
-  if (!fs.existsSync(dir)) throw new Error(`backup not found: ${name}`)
-  const manifest = readJson(path.join(dir, 'manifest.json'), null)
-  if (manifest?.files) {
-    for (const [rel, info] of Object.entries(manifest.files)) {
-      const full = path.join(dir, rel)
-      if (!full.startsWith(path.resolve(dir) + path.sep) || path.isAbsolute(rel) || rel.split(/[\\/]/).includes('..')) throw new Error('invalid backup manifest path')
-      if (!fs.existsSync(full)) throw new Error(`backup is incomplete: ${rel} is missing`)
-      if (info.sha256) {
-        const actual = crypto.createHash('sha256').update(fs.readFileSync(full)).digest('hex')
-        if (actual !== info.sha256) throw new Error(`backup is corrupt: ${rel} failed its checksum`)
-      }
-    }
-  }
-  const safety = typeof beforeRestore === 'function' ? beforeRestore() : backupDatabases()
-  const copy = (from, to) => {
-    if (!fs.existsSync(from)) return
-    ensureDir(path.dirname(to))
-    fs.copyFileSync(from, to)
-  }
-  copy(path.join(dir, 'state.json'), STATE_FILE())
-  copy(path.join(dir, 'global.sqlite3'), GLOBAL_DB())
-  copy(path.join(dir, 'index', 'global.json'), GLOBAL_INDEX())
-  copy(path.join(dir, 'prompts', 'manifest.json'), path.join(dataDir(), 'prompts', 'manifest.json'))
-  for (const [sub, target] of [['index', indexDir()], ['libraries', librariesDir()]]) {
-    let names = []
-    try { names = fs.readdirSync(path.join(dir, sub)) } catch { continue }
-    for (const file of names) copy(path.join(dir, sub, file), path.join(target, file))
-  }
-  const restoreTree = (from, target) => {
-    let items
-    try { items = fs.readdirSync(from, { withFileTypes: true }) } catch (error) { if (error.code === 'ENOENT') return; throw error }
-    for (const item of items) {
-      if (item.isSymbolicLink()) throw new Error('restore refuses symbolic links')
-      if (item.isDirectory()) restoreTree(path.join(from, item.name), path.join(target, item.name))
-      else copy(path.join(from, item.name), path.join(target, item.name))
-    }
-  }
-  restoreTree(path.join(dir, 'attachments'), path.join(dataDir(), 'attachments'))
-  restoreTree(path.join(dir, 'prompts'), path.join(dataDir(), 'prompts'))
-  // The restored files are the truth now; anything cached describes the state
-  // that was just replaced.
-  clearCaches()
-  return { restored: name, safety }
+export function pruneOldBackups(options = {}) {
+  const result = pruneBackups(options)
+  lastBackupReport = { at: stamp(), action: 'prune', ...result }
+  return result
+}
+
+/** Names of backups that a running restore or migration is reading right now. */
+export function leasedBackups() {
+  return Object.keys(activeLeases())
+}
+
+/**
+ * Puts a backup back. The target is leased and its whole inventory is verified
+ * before anything is written; the live root is saved as a safety backup next;
+ * only then are files replaced. Failure leaves a recovery path: the safety
+ * backup holds the state that was replaced and retention may not delete it.
+ * A backup that predates the vector journal also retires the stale live
+ * vector-active pointer, so recall falls back to text instead of querying
+ * databases that no longer match the restored index.
+ */
+export function restoreBackup(name, { beforeRestore = null, keep = undefined } = {}) {
+  const result = restoreFromBackup(name, { beforeRestore, flushState, clearCaches, keep })
+  lastBackupReport = { at: stamp(), action: 'restore', ...result }
+  return result
 }
 
 /** Drops the in-memory mirrors so the next read comes from disk. */

package/lib/tools.js

@@ -190,7 +190,7 @@ export function registerTools(ctx) {
       mood_valence: { type: 'number', description: 'How this moment felt, -1 (bad) to 1 (good). Omit to inherit the current conversation mood.' },
       arousal: { type: 'number', description: 'How strongly it hit, 0-1.' },
       peak: { type: 'boolean', description: 'A high point or low point of the arc — peaks and endings stay easier to recall.' },
-      salient_date: { type: 'string', description: 'MM-DD for something that comes back every year (a birthday, an anniversary of an event); it resurfaces on that day each year. YYYY-MM-DD for a one-off dated commitment or appointment: it is raised the day before and on the day itself, and never again after it has passed. Use the annual form only when the day really does recur. A relative day (今天/明天/后天/today/tomorrow) must be resolved to the absolute date it points at: sending a bare MM-DD turns one appointment into a yearly reminder.' },
+      salient_date: { type: 'string', description: 'MM-DD for something that comes back every year (a birthday, an anniversary of an event); it resurfaces on that day each year. YYYY-MM-DD for a one-off dated commitment or appointment: it is raised the day before and on the day itself, and never again after it has passed. Use the annual form only when the day really does recur. A relative day (今天/明天/后天/today/tomorrow) must be resolved to the absolute date it points at: sending a bare MM-DD turns one appointment into a yearly reminder. If the content itself names a date, pass it here too: when this field is empty the plugin only falls back to a single unambiguous YYYY-MM-DD found in the text.' },
       track: { type: 'string', description: 'memory (default) or habit for an aggregated expression/sticker habit; do not write one habit per occurrence.' },
       attachments: { type: 'array', items: { type: 'object', properties: { sha256: { type: 'string', required: true } }, additionalProperties: true }, description: 'At most 8 sha256 references received in this conversation. Never supply paths or bytes. Ordinary image memories default to short_term if layer is omitted; choose long_term explicitly only when important.' },
       context: { type: 'object', properties: {
@@ -252,11 +252,14 @@ export function registerTools(ctx) {
     },
     async (args, exec) => {
       const result = await privateRecall({ exec, query: args.query, topK: args.topK })
+      // Surface a degraded semantic leg on the explicit tool path too; silently
+      // returning fewer hits would make a failed backend look like an empty library.
+      const warning = (result.errors || []).length ? `\n注意：本次召回已降级：${(result.errors || []).join('; ')}` : ''
       // Read-only: never materialize a binding/library from a recall header.
       const binding = peekBinding(exec)
       const header = `私有记忆（library=${binding?.libraryId || '?'}, domain=${domainOf(binding)}）`
-      if (!result.files?.length) return `${header}\n没有命中。`
-      return [header, ...result.files.map((f, i) => formatPrivateItem(f, i + 1, { query: args.query }))].join('\n\n')
+      if (!result.files?.length) return `${header}\n没有命中。${warning}`
+      return [header, ...result.files.map((f, i) => formatPrivateItem(f, i + 1, { query: args.query }))].join('\n\n') + warning
     },
     { isConcurrencySafe: () => true },
   ))
@@ -270,14 +273,15 @@ export function registerTools(ctx) {
       // instead of ensureSession() silently creating a placeholder library.
       if (!peekBinding(exec)?.libraryId) return '当前对话没有绑定记忆库。'
       const result = await privateList({ exec })
-      if (!result.files?.length) return `私有记忆库 ${result.libraryId} 为空。`
+      const warning = result.warning ? `\n注意：${result.warning}` : ''
+      if (!result.files?.length) return `私有记忆库 ${result.libraryId} 为空。${warning}`
       const lines = [`私有记忆库 ${result.libraryId}（${result.files.length} 条）`]
       for (const file of result.files) {
         const e = file.entry || {}
         const tag = salientTag(e)
         lines.push(`- [${file.name}] ${e.title || file.description || '(untitled)'} · ${e.layer || 'long_term'} · ${e.status || 'active'}${e.marginalized ? ' · marginalized' : ''}${tag ? ` · ${tag}` : ''}`)
       }
-      return lines.join('\n')
+      return lines.join('\n') + warning
     },
     { isConcurrencySafe: () => true },
   ))