dsh-memu-memory 1.2.0 → 1.2.2

package/lib/memu.js

@@ -2,7 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
 import { dataDir, ensureDir, redactSecrets, windowsSystemEnv } from './paths.js'
-import { readCurrent, verifyEngine } from './engine.js'
+import { ENGINE_VERSION, readCurrent, verifyEngine } from './engine.js'
 import { getSettings } from './state.js'
 import { activeProfile, captureVectorGeneration, assertVectorGeneration, assertProfileVerified, assertMigrationProfile } from './vector-profile.js'
 import { embeddingWorkerManager } from './local-embedding-manager.js'
@@ -219,6 +219,6 @@ export async function forget({ db, name, timeoutMs = 60_000 } = {}) {
 
 export async function probe() {
   const current = currentEngine()
-  const verified = await verifyEngine(current.python)
+  const verified = await verifyEngine(current.python, { expectedVersion: current.version || ENGINE_VERSION })
   return { ...verified, current }
 }

package/lib/migrate.js

@@ -7,11 +7,18 @@
 // the pass exists to rewrite the files: a library nobody writes to again would otherwise
 // keep the dead `sessionId` fields on disk forever, and an auditor reading the JSON would
 // have to know about a level the code no longer has.
+//
+// The lexicon half (§2.1 of the construction spec) is the same shape: older builds
+// wrote `pending` proposals and revision drafts; the current lifecycle has only active/archived. The rewrite rule
+// lives in `lib/lexicon.js` (`migrateLegacyLexiconStatuses`); this file only finds the
+// files and runs it, one library at a time, so a single corrupt lexicon cannot take the
+// sweep — or startup — down with it.
 import fs from 'node:fs'
 import path from 'node:path'
-import { indexDir, readJson, stamp } from './paths.js'
+import { dataDir, indexDir, isSafeId, readJson, readJsonStrict, stamp } from './paths.js'
 import { listLibrariesAll, updatePrivateIndex } from './state.js'
 import { countLegacyInRaw, migrateEntryVisibility } from './visibility.js'
+import { migrateLegacyLexiconStatuses } from './lexicon.js'
 
 const DEFAULT_MIN_INTERVAL_MS = 60_000
 const lastRun = { at: 0 }
@@ -109,11 +116,85 @@ export function maybeMigrateLibraries({ minIntervalMs = DEFAULT_MIN_INTERVAL_MS,
   return migrateLibraries({ now })
 }
 
+// ── lexicon lifecycle (§2.1): pending → active/archived ─────────────────────────
+// The directory holds exactly `<libraryId>.json`; a name that does not pass `isSafeId`
+// is skipped rather than guessed at, the same path boundary `lib/lexicon.js` enforces
+// before it builds a filename.
+
+function lexiconDir() {
+  return path.join(dataDir(), 'lexicon')
+}
+
+/** Library ids that own a lexicon file. Sorted, safe names only. */
+export function scanLexiconLibraries() {
+  let names = []
+  try { names = fs.readdirSync(lexiconDir()) } catch { return [] }
+  return names
+    .filter((name) => name.endsWith('.json'))
+    .map((name) => name.slice(0, -'.json'.length))
+    .filter((id) => isSafeId(id))
+    .sort()
+}
+
+// Counted on the raw file, before any load-time interpretation, so a sweep can tell a
+// library that still needs the rewrite from one that is already migrated. `readJsonStrict`
+// (not `readJson`) on purpose: a scan must not move files, and `readJson` quarantines a
+// corrupt one as a side effect. A file that does not parse counts 0 — it cannot hold
+// statuses to migrate, and `lib/lexicon.js` already blocks writes to it until restored.
+function legacyLexiconCount(libraryId) {
+  const result = readJsonStrict(path.join(lexiconDir(), `${libraryId}.json`))
+  if (!result.ok) return 0
+  const terms = result.value?.terms
+  if (!terms || typeof terms !== 'object') return 0
+  return Object.values(terms).filter((entry) => entry && entry.status === 'pending').length
+}
+
+/** Lexicon files that still hold legacy `pending` entries. */
+export function scanLegacyLexiconLibraries() {
+  return scanLexiconLibraries()
+    .map((libraryId) => ({ libraryId, legacy: legacyLexiconCount(libraryId) }))
+    .filter((report) => report.legacy > 0)
+}
+
+/**
+ * Rewrite every lexicon that still carries `pending` entries.
+ *
+ * Per-library try/catch is the point: a single corrupt or write-protected lexicon must
+ * not stop the others, and must never abort startup (the pass runs from the cycle tick).
+ * A library with nothing to do is not written at all — `migrateLegacyLexiconStatuses`
+ * skips the write (and the revision bump) when no entry changed.
+ */
+export function migrateLexiconLibraries() {
+  const reports = []
+  for (const { libraryId, legacy } of scanLegacyLexiconLibraries()) {
+    try {
+      const result = migrateLegacyLexiconStatuses(libraryId)
+      reports.push({
+        libraryId,
+        before: legacy,
+        migrated: result.migrated,
+        ...(result.details ? { details: result.details } : {}),
+      })
+    } catch (error) {
+      reports.push({ libraryId, before: legacy, migrated: 0, error: String(error?.message || error) })
+    }
+  }
+  return reports
+}
+
 export function runVisibilityMigrationPass({ now = stamp(), log = () => {} } = {}) {
   const reports = migrateLibraries({ now })
   for (const report of reports) {
     if (report.error) log(`visibility migration failed for ${report.libraryId}: ${report.error}`)
     else if (report.migrated > 0) log(`migrated ${report.migrated} legacy memory/memories to shared in ${report.libraryId}`)
   }
-  return { reports }
+  // §2.1: legacy lexicons may still carry pending proposals/revision drafts. The rewrite is
+  // idempotent and only writes files that change, so running it on every cycle tick
+  // costs a directory read plus one JSON parse per file that still has pending entries.
+  const lexicon = migrateLexiconLibraries()
+  for (const report of lexicon) {
+    if (report.error) log(`lexicon lifecycle migration failed for ${report.libraryId}: ${report.error}`)
+    else if (report.migrated > 0) log(`migrated ${report.migrated} legacy lexicon term(s) to the active/archived lifecycle in ${report.libraryId}`)
+  }
+  return { reports, lexicon }
 }