dsh-memu-memory 1.1.2 → 1.1.3

package/lib/curator.js

@@ -1,15 +1,47 @@
 import {
-  globalDbPath, loadGlobalIndex, updateGlobalIndex, newMemoryId, getSettings, getMemoryBackend,
+  globalDbPath, loadGlobalIndex, updateGlobalIndex, newMemoryId, getSettings, effectiveVectorRoute,
 } from './state.js'
 import { commit } from './memu.js'
 import { loadPrompt } from './prompts.js'
-import { retryStoreWrite, redactSecrets } from './paths.js'
+import { retryStoreWrite, redactSecrets, warn } from './paths.js'
+import { record } from './activity-log.js'
+import { assertVectorWriteAllowed, hasActiveVectorGeneration, readVectorState, withVectorWrite } from './vector-profile.js'
 
 const MAX_SESSIONS = 10
 const MAX_TOTAL_CHARS = 90_000
 const MAX_SESSION_CHARS = 14_000
 const jobs = new Map()
 
+function managedVectorIntent() {
+  if (effectiveVectorRoute() !== 'managed-local') return false
+  try {
+    const state = readVectorState({ tolerateMissing: true }).state
+    return Boolean(state && (state.active || state.requested || state.pending))
+  } catch {
+    return true
+  }
+}
+
+// 与 memory.js 同一条口径：受管路由还没有代际时，引擎这一步按词法处理（索引照写），
+// 否则 MemU 会以 "managed local vector profile is not active" 拒绝整次提炼。
+function engineRoute() {
+  const route = effectiveVectorRoute()
+  return route === 'managed-local' && !hasActiveVectorGeneration() ? 'lexical' : route
+}
+
+async function withManagedCuratorWrite(action) {
+  if (!managedVectorIntent()) return action()
+  // Same rule as the private write path: requested-but-never-migrated has no
+  // generation to stay consistent with, so the global index + engine still get
+  // the memories. Failing here would throw away a whole curation run.
+  if (!hasActiveVectorGeneration()) {
+    warn('managed vector write degraded to index+engine: no active vector generation; run the profile switch to enable vectors')
+    record({ kind: 'vector', level: 'warn', scope: 'global', message: '向量未激活，全局提炼已降级为索引+引擎', detail: { reason: 'no active vector generation' } })
+    return action()
+  }
+  return withVectorWrite(async () => { assertVectorWriteAllowed(); return action() })
+}
+
 function textOf(blocks) {
   if (!Array.isArray(blocks)) return ''
   return blocks
@@ -259,46 +291,49 @@ export async function commitCuratorOutput(output, { job }) {
   }
 
   if (files.length === 0) {
-    if (pending.length) await retryStoreWrite(() => updateGlobalIndex(fresh => {
+    if (pending.length) await withManagedCuratorWrite(() => retryStoreWrite(() => updateGlobalIndex(fresh => {
       for (const { id, entry } of pending) fresh.entries[id] = entry
-    }))
+    })))
     return { files: [], created: 0, merged: 0, superseded: 0, pending: pending.length, skipped }
   }
 
   job.step = `committing ${files.length} global memories`
-  // In agent mode the JSON index is the store. Only the explicit remote backend
-  // needs MemU's database, so local curation stays fast and key-free.
-  if (getMemoryBackend() === 'api') {
-    await commit({
-      payload: { recall_files: files, resource: [], user: {} },
-      db: globalDbPath(),
-    })
-  }
-
-  if (job?.abort?.signal?.aborted) throw new Error('cancelled by user')
-  await retryStoreWrite(() => updateGlobalIndex(fresh => {
-    for (const { id, entry } of pending) fresh.entries[id] = entry
-    for (const { id, entry, op, targetId, previous } of updates) {
-    if (previous && JSON.stringify(fresh.entries[targetId]) !== JSON.stringify(previous)) {
-      const heldId = newMemoryId('gmem')
-      fresh.entries[heldId] = { ...entry, status: 'pending_review', conflictingWith: targetId, reviewReason: 'target changed while curator was running' }
-      continue
-    }
-    if (op === 'merge' && previous) {
-      entry.content = entry.content || previous.content
-      entry.title = entry.title || previous.title
-      entry.evidence = [...(previous.evidence || []), ...(entry.evidence || [])].slice(-40)
-    }
-    fresh.entries[id] = entry
-    if ((op === 'supersede' || op === 'merge') && targetId && fresh.entries[targetId]) {
-      fresh.entries[targetId].status = 'superseded'
-      fresh.entries[targetId].supersededBy = id
-      fresh.entries[targetId].validTo = now
-      fresh.entries[targetId].updatedAt = now
-    }
+  await withManagedCuratorWrite(async () => {
+    // Managed agent mode still commits the exact same files to the active local
+    // vector database; only pending_review entries remain index-only.
+    const route = engineRoute()
+    if (route !== 'lexical') {
+      await commit({
+        payload: { recall_files: files, resource: [], user: {} },
+        route, db: globalDbPath(),
+      })
     }
-  }))
-  return {
+
+    if (job?.abort?.signal?.aborted) throw new Error('cancelled by user')
+    await retryStoreWrite(() => updateGlobalIndex(fresh => {
+      for (const { id, entry } of pending) fresh.entries[id] = entry
+      for (const { id, entry, op, targetId, previous } of updates) {
+      if (previous && JSON.stringify(fresh.entries[targetId]) !== JSON.stringify(previous)) {
+        const heldId = newMemoryId('gmem')
+        fresh.entries[heldId] = { ...entry, status: 'pending_review', conflictingWith: targetId, reviewReason: 'target changed while curator was running' }
+        continue
+      }
+      if (op === 'merge' && previous) {
+        entry.content = entry.content || previous.content
+        entry.title = entry.title || previous.title
+        entry.evidence = [...(previous.evidence || []), ...(entry.evidence || [])].slice(-40)
+      }
+      fresh.entries[id] = entry
+      if ((op === 'supersede' || op === 'merge') && targetId && fresh.entries[targetId]) {
+        fresh.entries[targetId].status = 'superseded'
+        fresh.entries[targetId].supersededBy = id
+        fresh.entries[targetId].validTo = now
+        fresh.entries[targetId].updatedAt = now
+      }
+      }
+    }))
+  })
+  const summary = {
     files,
     created: updates.filter((u) => u.op === 'create').length,
     merged: updates.filter((u) => u.op === 'merge').length,
@@ -306,8 +341,17 @@ export async function commitCuratorOutput(output, { job }) {
     pending: pending.length,
     skipped,
   }
+  record({
+    kind: 'curate',
+    scope: 'global',
+    ok: true,
+    message: `全局提炼：新增 ${summary.created} / 合并 ${summary.merged} / 待复核 ${summary.pending}`
+      + (summary.skipped.length ? ` / 跳过 ${summary.skipped.length}` : ''),
+    detail: { ...summary, skipped: summary.skipped.slice(0, 20) },
+    refs: files.map((file) => file.name).slice(0, 20),
+  })
+  return summary
 }
-
 export function startGlobalCuration(ctx, { sessionIds, parentSessionId, model } = {}) {
   const ids = [...new Set((Array.isArray(sessionIds) ? sessionIds : []).filter((s) => typeof s === 'string' && s.trim()))]
   const jobId = `curate-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`

package/lib/cycle.js

@@ -7,6 +7,7 @@ import { expireShortTerm } from './memory.js'
 import { requestPrivateConsolidation } from './private.js'
 import { startGlobalCuration } from './curator.js'
 import { runVisibilityMigrationPass } from './migrate.js'
+import { record } from './activity-log.js'
 
 const SWEEP_MS = 5 * 60 * 1000
 // Long enough that the host has restored its session list and the agent objects
@@ -152,9 +153,11 @@ export async function runCurationPass(ctx, { now = Date.now(), log = () => {} }
   try {
     const job = await startGlobalCuration(ctx, { sessionIds: due, parentSessionId: parent, model: settings.curatorModel })
     setCycleState({ lastCurateAt: new Date(now).toISOString(), lastCurateJob: job?.id || null })
+    record({ kind: 'curate', scope: 'global', ok: true, message: `自动提炼启动：${due.length} 个会话`, detail: { sessions: due.length, jobId: job?.id || null, parent } })
     return { ran: due.length, job }
   } catch (error) {
     log(`auto curation failed: ${error?.message || error}`)
+    record({ kind: 'curate', scope: 'global', ok: false, level: 'error', message: '自动提炼失败：' + String(error?.message || error), detail: { sessions: due.length } })
     return { ran: 0, error: String(error?.message || error) }
   }
 }