@remnic/core 9.7.15 → 9.8.0

package/dist/{chunk-YF6FMLBT.js → chunk-EQWEIIKQ.js}

@@ -1,6 +1,8 @@
 // src/maintenance/dreams-ledger.ts
 import path from "path";
+import { createReadStream } from "fs";
 import { appendFile, lstat, mkdir, readdir, readFile } from "fs/promises";
+import { createInterface } from "readline";
 function dreamsLedgerPath(memoryDir) {
   return path.join(memoryDir, "state", "dreams-ledger.jsonl");
 }
@@ -9,38 +11,64 @@ async function appendDreamsLedgerEntry(memoryDir, entry) {
   await mkdir(path.dirname(ledgerPath), { recursive: true });
   await appendFile(ledgerPath, JSON.stringify(entry) + "\n", "utf-8");
 }
-async function readDreamsLedgerEntries(memoryDir) {
+function parseDreamsLedgerLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  let parsed;
+  try {
+    const raw = JSON.parse(trimmed);
+    if (typeof raw !== "object" || raw === null) return null;
+    parsed = raw;
+  } catch {
+    return null;
+  }
+  const phase = parsed.phase;
+  if (phase !== "lightSleep" && phase !== "rem" && phase !== "deepSleep") return null;
+  if (typeof parsed.startedAt !== "string" || typeof parsed.completedAt !== "string" || typeof parsed.durationMs !== "number" || typeof parsed.itemsProcessed !== "number") {
+    return null;
+  }
+  if ("schemaVersion" in parsed && parsed.schemaVersion !== 1) return null;
+  if ("dryRun" in parsed && typeof parsed.dryRun !== "boolean") return null;
+  if ("trigger" in parsed && parsed.trigger !== "manual" && parsed.trigger !== "scheduled") {
+    return null;
+  }
+  return {
+    schemaVersion: 1,
+    startedAt: parsed.startedAt,
+    completedAt: parsed.completedAt,
+    durationMs: parsed.durationMs,
+    phase,
+    itemsProcessed: parsed.itemsProcessed,
+    dryRun: parsed.dryRun === true,
+    trigger: parsed.trigger === "manual" ? "manual" : "scheduled",
+    notes: typeof parsed.notes === "string" ? parsed.notes : void 0
+  };
+}
+async function* streamDreamsLedgerLines(memoryDir) {
   const ledgerPath = dreamsLedgerPath(memoryDir);
-  let raw;
+  let input;
   try {
-    raw = await readFile(ledgerPath, "utf-8");
+    input = createReadStream(ledgerPath, { encoding: "utf8" });
   } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") return [];
+    if (err.code === "ENOENT") return;
     throw err;
   }
+  const rl = createInterface({ input, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) yield line;
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  } finally {
+    rl.close();
+    input.destroy();
+  }
+}
+async function readDreamsLedgerEntries(memoryDir) {
   const entries = [];
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (typeof parsed !== "object" || parsed === null) continue;
-      if (typeof parsed.phase === "string" && (parsed.phase === "lightSleep" || parsed.phase === "rem" || parsed.phase === "deepSleep") && typeof parsed.startedAt === "string" && typeof parsed.completedAt === "string" && typeof parsed.durationMs === "number" && typeof parsed.itemsProcessed === "number") {
-        entries.push({
-          schemaVersion: 1,
-          startedAt: parsed.startedAt,
-          completedAt: parsed.completedAt,
-          durationMs: parsed.durationMs,
-          phase: parsed.phase,
-          itemsProcessed: parsed.itemsProcessed,
-          dryRun: parsed.dryRun === true,
-          trigger: parsed.trigger === "manual" ? "manual" : "scheduled",
-          notes: typeof parsed.notes === "string" ? parsed.notes : void 0
-        });
-      }
-    } catch {
-    }
+  for await (const line of streamDreamsLedgerLines(memoryDir)) {
+    const entry = parseDreamsLedgerLine(line);
+    if (entry) entries.push(entry);
   }
   return entries;
 }
@@ -65,11 +93,8 @@ async function getDreamsStatus(memoryDir, windowHours = 24, now = /* @__PURE__ *
   if (!Number.isFinite(windowStart.getTime())) {
     throw new RangeError("windowHours produces an invalid status window");
   }
-  const entries = await readDreamsLedgerEntries(memoryDir);
-  const windowEntries = entries.filter((e) => {
-    const ts = Date.parse(e.completedAt);
-    return Number.isFinite(ts) && ts >= windowStart.getTime() && ts < windowEnd.getTime();
-  });
+  const windowStartMs = windowStart.getTime();
+  const windowEndMs = windowEnd.getTime();
   const statusMap = /* @__PURE__ */ new Map();
   for (const phase of ALL_PHASES) {
     statusMap.set(phase, {
@@ -81,13 +106,17 @@ async function getDreamsStatus(memoryDir, windowHours = 24, now = /* @__PURE__ *
       lastDurationMs: null
     });
   }
-  for (const entry of windowEntries) {
+  for await (const line of streamDreamsLedgerLines(memoryDir)) {
+    const entry = parseDreamsLedgerLine(line);
+    if (!entry) continue;
+    const ts = Date.parse(entry.completedAt);
+    if (!Number.isFinite(ts) || ts < windowStartMs || ts >= windowEndMs) continue;
     const status = statusMap.get(entry.phase);
     if (!status) continue;
     status.runCount += 1;
     status.totalDurationMs += entry.durationMs;
     status.totalItemsProcessed += entry.itemsProcessed;
-    if (status.lastRunAt === null || Date.parse(entry.completedAt) > Date.parse(status.lastRunAt)) {
+    if (status.lastRunAt === null || ts > Date.parse(status.lastRunAt)) {
       status.lastRunAt = entry.completedAt;
       status.lastDurationMs = entry.durationMs;
     }
@@ -276,6 +305,7 @@ async function listMemoryFiles(memoryDir) {
 export {
   dreamsLedgerPath,
   appendDreamsLedgerEntry,
+  streamDreamsLedgerLines,
   readDreamsLedgerEntries,
   normalizeDreamsStatusWindowHours,
   getDreamsStatus,
@@ -283,4 +313,4 @@ export {
   runDreamsPhase,
   summarizeGovernanceResultForDreams
 };
-//# sourceMappingURL=chunk-YF6FMLBT.js.map
+//# sourceMappingURL=chunk-EQWEIIKQ.js.map

package/dist/chunk-EQWEIIKQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/dreams-ledger.ts"],"sourcesContent":["/**\n * dreams-ledger.ts — per-phase telemetry for the Dreams consolidation pipeline.\n *\n * Every scheduled or manual phase run appends one JSONL entry to\n *   <memoryDir>/state/dreams-ledger.jsonl\n *\n * The entry records which phase ran, how long it took, and a small\n * itemsProcessed counter so `remnic dreams status` can aggregate the last\n * 24-hour window without scanning the full memory corpus.\n *\n * This module is intentionally side-effect-free on import (no fs calls at\n * module load time) so tests can import it without touching the filesystem.\n */\n\nimport path from \"node:path\";\nimport { createReadStream, type ReadStream } from \"node:fs\";\nimport { appendFile, lstat, mkdir, readdir, readFile } from \"node:fs/promises\";\nimport { createInterface } from \"node:readline\";\n\n// ── Types ─────────────────────────────────────────────────────────────────────\n\n/** The three named phases of the Dreams consolidation pipeline. */\nexport type DreamsPhase = \"lightSleep\" | \"rem\" | \"deepSleep\";\n\n/**\n * One entry written to the dreams ledger for every phase run.\n * Older entries that predate this field simply won't have it (no backfill).\n */\nexport interface DreamsLedgerEntry {\n  /** Schema version — always 1 for entries written by this module. */\n  schemaVersion: 1;\n  /** ISO-8601 timestamp when the phase run started. */\n  startedAt: string;\n  /** ISO-8601 timestamp when the phase run completed. */\n  completedAt: string;\n  /** Wall-clock duration in milliseconds. */\n  durationMs: number;\n  /**\n   * Which Dreams phase this entry represents.\n   * - `lightSleep` — recent activity scoring + clustering\n   * - `rem`        — cross-session synthesis, supersession, consolidation\n   * - `deepSleep`  — tier migration, page-version snapshots, archive\n   */\n  phase: DreamsPhase;\n  /** How many memory items were evaluated (scored / clustered / migrated). */\n  itemsProcessed: number;\n  /** Whether this was a dry-run (no writes committed). */\n  dryRun: boolean;\n  /**\n   * How the phase was triggered.\n   * - `scheduled` — invoked by the governance cron or orchestrator maintenance pass\n   * - `manual`    — invoked via `remnic dreams run`\n   */\n  trigger: \"scheduled\" | \"manual\";\n  /** Free-form notes for debugging (optional, never required). */\n  notes?: string;\n}\n\n/** Aggregated stats for a single phase over a time window. */\nexport interface DreamsPhaseStatus {\n  phase: DreamsPhase;\n  /** Number of phase runs in the window. */\n  runCount: number;\n  /** Total wall-clock milliseconds across all runs in the window. */\n  totalDurationMs: number;\n  /** Total items processed across all runs in the window. */\n  totalItemsProcessed: number;\n  /** ISO-8601 timestamp of the most recent completed run, or null if none. */\n  lastRunAt: string | null;\n  /** Duration of the most recent run in ms, or null if none. */\n  lastDurationMs: number | null;\n}\n\n/** Shape returned by `getDreamsStatus` — the canonical telemetry response. */\nexport interface DreamsStatusResult {\n  /** ISO-8601 start of the query window (inclusive). */\n  windowStart: string;\n  /** ISO-8601 end of the query window (exclusive). */\n  windowEnd: string;\n  /** Per-phase summaries, always present for all three phases. */\n  phases: {\n    lightSleep: DreamsPhaseStatus;\n    rem: DreamsPhaseStatus;\n    deepSleep: DreamsPhaseStatus;\n  };\n}\n\n// ── Path helpers ──────────────────────────────────────────────────────────────\n\nexport function dreamsLedgerPath(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"dreams-ledger.jsonl\");\n}\n\n// ── Writer ────────────────────────────────────────────────────────────────────\n\n/**\n * Append a single entry to the dreams ledger.\n * Creates the file (and its parent directory) if needed.\n * Uses `appendFile` (O_APPEND) so concurrent callers never overwrite each other.\n */\nexport async function appendDreamsLedgerEntry(\n  memoryDir: string,\n  entry: DreamsLedgerEntry,\n): Promise<void> {\n  const ledgerPath = dreamsLedgerPath(memoryDir);\n  await mkdir(path.dirname(ledgerPath), { recursive: true });\n  await appendFile(ledgerPath, JSON.stringify(entry) + \"\\n\", \"utf-8\");\n}\n\n// ── Reader ────────────────────────────────────────────────────────────────────\n\n/**\n * Parse and validate one ledger line into a `DreamsLedgerEntry`, or `null` when\n * blank/malformed/incomplete. Shared by the streaming reader and the windowed\n * status aggregator so both apply the identical fail-open guard.\n */\nfunction parseDreamsLedgerLine(line: string): DreamsLedgerEntry | null {\n  const trimmed = line.trim();\n  if (!trimmed) return null;\n  let parsed: Record<string, unknown>;\n  try {\n    const raw = JSON.parse(trimmed);\n    if (typeof raw !== \"object\" || raw === null) return null;\n    parsed = raw as Record<string, unknown>;\n  } catch {\n    return null; // Malformed JSON — skip (fail-open).\n  }\n\n  // Required, strongly-typed fields. A row missing or mistyping any of these is\n  // not a usable telemetry entry.\n  const phase = parsed.phase;\n  if (phase !== \"lightSleep\" && phase !== \"rem\" && phase !== \"deepSleep\") return null;\n  if (\n    typeof parsed.startedAt !== \"string\" ||\n    typeof parsed.completedAt !== \"string\" ||\n    typeof parsed.durationMs !== \"number\" ||\n    typeof parsed.itemsProcessed !== \"number\"\n  ) {\n    return null;\n  }\n\n  // Optional fields: absence is tolerated (older entries predate them, no\n  // backfill), but a PRESENT value with the wrong type/value marks the row\n  // malformed and skips it — never silently coerced to a default (issue #1910).\n  if (\"schemaVersion\" in parsed && parsed.schemaVersion !== 1) return null;\n  if (\"dryRun\" in parsed && typeof parsed.dryRun !== \"boolean\") return null;\n  if (\"trigger\" in parsed && parsed.trigger !== \"manual\" && parsed.trigger !== \"scheduled\") {\n    return null;\n  }\n\n  return {\n    schemaVersion: 1,\n    startedAt: parsed.startedAt,\n    completedAt: parsed.completedAt,\n    durationMs: parsed.durationMs,\n    phase,\n    itemsProcessed: parsed.itemsProcessed,\n    dryRun: parsed.dryRun === true,\n    trigger: parsed.trigger === \"manual\" ? \"manual\" : \"scheduled\",\n    notes: typeof parsed.notes === \"string\" ? parsed.notes : undefined,\n  };\n}\n\n/**\n * Stream the dreams ledger line-by-line. The ledger is plaintext `appendFile`\n * (never encrypted), so a raw line stream is safe at any size — heap stays\n * O(1) in the file, unlike the previous whole-file `readFile` + `split`.\n * Yields nothing when the ledger does not exist yet.\n */\nexport async function* streamDreamsLedgerLines(memoryDir: string): AsyncGenerator<string> {\n  const ledgerPath = dreamsLedgerPath(memoryDir);\n  let input: ReadStream;\n  try {\n    input = createReadStream(ledgerPath, { encoding: \"utf8\" });\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return;\n    throw err;\n  }\n  const rl = createInterface({ input, crlfDelay: Infinity });\n  try {\n    for await (const line of rl) yield line;\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return;\n    throw err;\n  } finally {\n    // Close the readline interface AND destroy the underlying stream. When a\n    // consumer stops early (e.g. `getDreamsStatus` breaks out), the generator's\n    // `.return()` runs this finally; `rl.close()` alone leaves the file\n    // descriptor open, so destroy the stream to release it (issue #1910).\n    rl.close();\n    input.destroy();\n  }\n}\n\n/**\n * Parse all valid `DreamsLedgerEntry` rows from the ledger file. Thin wrapper\n * over the line stream so any caller that genuinely needs every row still\n * works; `getDreamsStatus` streams directly and filters in-window instead.\n * Malformed lines are silently skipped (resilience over strictness for\n * telemetry).\n */\nexport async function readDreamsLedgerEntries(memoryDir: string): Promise<DreamsLedgerEntry[]> {\n  const entries: DreamsLedgerEntry[] = [];\n  for await (const line of streamDreamsLedgerLines(memoryDir)) {\n    const entry = parseDreamsLedgerLine(line);\n    if (entry) entries.push(entry);\n  }\n  return entries;\n}\n\n// ── Aggregator ────────────────────────────────────────────────────────────────\n\nconst ALL_PHASES: DreamsPhase[] = [\"lightSleep\", \"rem\", \"deepSleep\"];\nconst MAX_WINDOW_HOURS = 24 * 365 * 100;\n\nexport function normalizeDreamsStatusWindowHours(value: unknown, fallback = 24): number {\n  const raw = value === undefined || value === null ? fallback : value;\n  if (\n    typeof raw !== \"number\" ||\n    !Number.isFinite(raw) ||\n    !Number.isInteger(raw) ||\n    raw < 1 ||\n    raw > MAX_WINDOW_HOURS\n  ) {\n    throw new RangeError(`windowHours must be a positive integer no greater than ${MAX_WINDOW_HOURS}`);\n  }\n  return raw;\n}\n\n/**\n * Build per-phase 24-hour summary.\n *\n * @param memoryDir   The memory directory (parent of `state/`).\n * @param windowHours How many hours to look back (default 24).\n * @param now         Reference time (default `new Date()`).\n */\nexport async function getDreamsStatus(\n  memoryDir: string,\n  windowHours = 24,\n  now: Date = new Date(),\n): Promise<DreamsStatusResult> {\n  const boundedWindowHours = normalizeDreamsStatusWindowHours(windowHours);\n  const nowMs = now.getTime();\n  if (!Number.isFinite(nowMs)) {\n    throw new RangeError(\"now must be a valid Date\");\n  }\n  const windowMs = boundedWindowHours * 60 * 60 * 1000;\n  const windowStart = new Date(nowMs - windowMs);\n  const windowEnd = now;\n  if (!Number.isFinite(windowStart.getTime())) {\n    throw new RangeError(\"windowHours produces an invalid status window\");\n  }\n\n  const windowStartMs = windowStart.getTime();\n  const windowEndMs = windowEnd.getTime();\n\n  const statusMap = new Map<DreamsPhase, DreamsPhaseStatus>();\n  for (const phase of ALL_PHASES) {\n    statusMap.set(phase, {\n      phase,\n      runCount: 0,\n      totalDurationMs: 0,\n      totalItemsProcessed: 0,\n      lastRunAt: null,\n      lastDurationMs: null,\n    });\n  }\n\n  // Stream the ledger and aggregate every in-window row inline, so heap use is\n  // O(number of phases) regardless of window or file size (issue #1910) — no\n  // per-row array and no row cap, so a large in-window window is still counted\n  // in full rather than truncated.\n  for await (const line of streamDreamsLedgerLines(memoryDir)) {\n    const entry = parseDreamsLedgerLine(line);\n    if (!entry) continue;\n    const ts = Date.parse(entry.completedAt);\n    if (!Number.isFinite(ts) || ts < windowStartMs || ts >= windowEndMs) continue;\n    const status = statusMap.get(entry.phase);\n    if (!status) continue;\n    status.runCount += 1;\n    status.totalDurationMs += entry.durationMs;\n    status.totalItemsProcessed += entry.itemsProcessed;\n    // Track the most recent run (by completedAt).\n    if (status.lastRunAt === null || ts > Date.parse(status.lastRunAt)) {\n      status.lastRunAt = entry.completedAt;\n      status.lastDurationMs = entry.durationMs;\n    }\n  }\n\n  return {\n    windowStart: windowStart.toISOString(),\n    windowEnd: windowEnd.toISOString(),\n    phases: {\n      lightSleep: statusMap.get(\"lightSleep\")!,\n      rem: statusMap.get(\"rem\")!,\n      deepSleep: statusMap.get(\"deepSleep\")!,\n    },\n  };\n}\n\n// ── Phase runner (PR 4/4: manual invocation) ─────────────────────────────────\n\nexport interface DreamsRunOptions {\n  memoryDir: string;\n  phase: DreamsPhase;\n  dryRun?: boolean;\n}\n\n/** Public result shape — identical to what HTTP, MCP, and CLI surfaces expose. */\nexport interface DreamsRunResult {\n  phase: DreamsPhase;\n  dryRun: boolean;\n  durationMs: number;\n  itemsProcessed: number;\n  notes?: string;\n}\n\n/** Internal result shape returned by `runDreamsPhase` — includes the raw ledger entry. */\nexport interface DreamsRunResultInternal extends DreamsRunResult {\n  ledgerEntry?: DreamsLedgerEntry;\n}\n\nexport async function recordDreamsPhaseRun(options: {\n  memoryDir: string;\n  phase: DreamsPhase;\n  trigger: DreamsLedgerEntry[\"trigger\"];\n  dryRun?: boolean;\n  itemsProcessed: number;\n  notes?: string;\n  startedAt?: string;\n  completedAt?: string;\n}): Promise<DreamsLedgerEntry> {\n  const startedAt = options.startedAt ?? new Date().toISOString();\n  const completedAt = options.completedAt ?? new Date().toISOString();\n  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));\n  const ledgerEntry: DreamsLedgerEntry = {\n    schemaVersion: 1,\n    startedAt,\n    completedAt,\n    durationMs: Number.isFinite(durationMs) ? durationMs : 0,\n    phase: options.phase,\n    itemsProcessed: Math.max(0, Math.floor(options.itemsProcessed)),\n    dryRun: options.dryRun === true,\n    trigger: options.trigger,\n    notes: options.notes,\n  };\n  if (!ledgerEntry.dryRun) {\n    await appendDreamsLedgerEntry(options.memoryDir, ledgerEntry);\n  }\n  return ledgerEntry;\n}\n\n/**\n * Manually invoke a single Dreams phase pass.\n *\n * For light sleep and REM: runs a lightweight scan against the observation\n * ledger and returns a count of items that would be (or were, if not dry-run)\n * processed.  The actual heavy consolidation is long-running and orchestrator-\n * bound; the manual surface delegates to existing ledger utilities and returns\n * the phase telemetry so callers get the same shape as a scheduled run.\n *\n * For deep sleep: delegates to the memory governance run (shadow mode when\n * dryRun is true, apply mode otherwise).\n */\nexport async function runDreamsPhase(\n  options: DreamsRunOptions,\n  governanceRunner?: (opts: { memoryDir: string; dryRun: boolean }) => Promise<{ scannedMemories: number; appliedActionCount: number; notes?: string }>,\n  phaseRunner?: (opts: { memoryDir: string; phase: Exclude<DreamsPhase, \"deepSleep\"> }) => Promise<{ itemsProcessed: number; notes?: string }>,\n): Promise<DreamsRunResultInternal> {\n  const { memoryDir, phase, dryRun = false } = options;\n  const startedAt = new Date().toISOString();\n\n  let itemsProcessed = 0;\n  let notes: string | undefined;\n\n  if (phase === \"lightSleep\") {\n    // Dry-run light sleep counts recent observation entries as a preview.\n    // Live runs must be backed by the orchestrator phase runner so the command\n    // never reports success without executing the phase.\n    if (!dryRun) {\n      if (!phaseRunner) {\n        throw new Error(\"light-sleep manual runs require a phase runner\");\n      }\n      const result = await phaseRunner({ memoryDir, phase });\n      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));\n      notes = result.notes ?? `scored ${itemsProcessed} memories`;\n    } else {\n      // Light sleep: count observation ledger entries from the last 24h as a\n      // proxy for \"items scored\". The live value-scoring pass runs through the\n      // phase runner above.\n      try {\n        const ledgerPath = path.join(memoryDir, \"state\", \"observation-ledger\", \"rebuilt-observations.jsonl\");\n        let raw = \"\";\n        try {\n          raw = await readFile(ledgerPath, \"utf-8\");\n        } catch {\n          // No ledger yet — zero items.\n        }\n        const lines = raw.split(\"\\n\").filter((l) => l.trim().length > 0);\n        const nowMs = Date.now();\n        const cutoff = nowMs - 24 * 60 * 60 * 1000;\n        itemsProcessed = lines.filter((line) => {\n          try {\n            const obj = JSON.parse(line) as {\n              hour?: string;\n              timestamp?: string;\n              ts?: string;\n            };\n            const timestamp = typeof obj.hour === \"string\"\n              ? obj.hour\n              : typeof obj.ts === \"string\"\n                ? obj.ts\n                : typeof obj.timestamp === \"string\"\n                  ? obj.timestamp\n                  : null;\n            if (!timestamp) return false;\n            const ms = Date.parse(timestamp);\n            return Number.isFinite(ms) && ms >= cutoff && ms < nowMs;\n          } catch {\n            return false;\n          }\n        }).length;\n        notes = `dry-run: would score ${itemsProcessed} observation entries`;\n      } catch (err) {\n        throw new Error(`light-sleep scan failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    }\n  } else if (phase === \"rem\") {\n    if (!dryRun) {\n      if (!phaseRunner) {\n        throw new Error(\"REM manual runs require a phase runner\");\n      }\n      const result = await phaseRunner({ memoryDir, phase });\n      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));\n      notes = result.notes ?? `REM pass assessed ${itemsProcessed} memories`;\n    } else {\n      // REM dry-runs estimate candidates without synthesizing or archiving.\n      try {\n        const stateFilePath = path.join(memoryDir, \"state\", \"semantic-consolidation-last-run.json\");\n        let lastRunAt: string | null = null;\n        try {\n          const stateRaw = await readFile(stateFilePath, \"utf-8\");\n          const stateData = JSON.parse(stateRaw) as { lastRunAt?: string };\n          lastRunAt = stateData.lastRunAt ?? null;\n        } catch {\n          // No state file — never run.\n        }\n        const memFiles = await listMemoryFiles(memoryDir);\n        itemsProcessed = memFiles.length;\n        notes = `dry-run: ${itemsProcessed} memories would enter REM consolidation pass${lastRunAt ? ` (last run: ${lastRunAt})` : \" (never run)\"}`;\n      } catch (err) {\n        throw new Error(`REM scan failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    }\n  } else {\n    // deep sleep\n    if (governanceRunner) {\n      try {\n        const result = await governanceRunner({ memoryDir, dryRun });\n        itemsProcessed = result.scannedMemories;\n        notes = result.notes ?? (dryRun ? `dry-run: ${result.appliedActionCount} actions proposed` : `${result.appliedActionCount} actions applied`);\n      } catch (err) {\n        throw new Error(`deep-sleep governance run failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    } else {\n      // Fallback: count memory files.\n      const memFiles = await listMemoryFiles(memoryDir);\n      itemsProcessed = memFiles.length;\n      notes = dryRun\n        ? `dry-run: ${itemsProcessed} memories eligible for deep-sleep governance`\n        : `assessed ${itemsProcessed} memories for deep-sleep governance`;\n    }\n  }\n\n  const completedAt = new Date().toISOString();\n  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));\n  let ledgerEntry: DreamsLedgerEntry | undefined;\n  try {\n    ledgerEntry = await recordDreamsPhaseRun({\n      memoryDir,\n      startedAt,\n      completedAt,\n      phase,\n      itemsProcessed,\n      dryRun,\n      trigger: \"manual\",\n      notes,\n    });\n  } catch {\n    // Telemetry is best-effort: the phase work has already completed.\n  }\n\n  return {\n    phase,\n    dryRun,\n    durationMs: ledgerEntry?.durationMs ?? durationMs,\n    itemsProcessed,\n    notes,\n    ledgerEntry,\n  };\n}\n\n// ── Shared governance result mapping ──────────────────────────────────────────\n\nexport function summarizeGovernanceResultForDreams(\n  govResult: {\n    summary?: { scannedMemories?: number };\n    proposedActions: unknown[];\n    appliedActions: unknown[];\n    reviewQueue: unknown[];\n  },\n  dryRun: boolean,\n): { scannedMemories: number; appliedActionCount: number; notes?: string } {\n  const proposedCount = govResult.proposedActions.length;\n  const appliedCount = govResult.appliedActions.length;\n  const scannedCount =\n    typeof govResult.summary?.scannedMemories === \"number\" &&\n    Number.isFinite(govResult.summary.scannedMemories)\n      ? Math.max(0, Math.floor(govResult.summary.scannedMemories))\n      : govResult.reviewQueue.length;\n  return {\n    scannedMemories: scannedCount,\n    appliedActionCount: appliedCount,\n    notes: dryRun\n      ? `shadow mode: ${proposedCount} actions proposed`\n      : `applied ${appliedCount} actions`,\n  };\n}\n\n// ── Internal helpers ──────────────────────────────────────────────────────────\n\nasync function listMemoryFiles(memoryDir: string): Promise<string[]> {\n  const out: string[] = [];\n  try {\n    const root = await lstat(memoryDir);\n    if (root.isSymbolicLink()) {\n      throw new Error(`memoryDir must not be a symlink: ${memoryDir}`);\n    }\n    if (!root.isDirectory()) return out;\n  } catch (err) {\n    if (err instanceof Error && /must not be a symlink/.test(err.message)) {\n      throw err;\n    }\n    return out;\n  }\n\n  async function walk(dir: string): Promise<void> {\n    let entries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean; isSymbolicLink(): boolean }>;\n    try {\n      entries = (await readdir(dir, { withFileTypes: true })) as typeof entries;\n    } catch {\n      return;\n    }\n    for (const entry of entries) {\n      if (entry.isSymbolicLink()) continue;\n      const full = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        // Skip state/ and archive/ subdirs.\n        if (\n          entry.name === \"state\" ||\n          entry.name === \"archive\" ||\n          entry.name === \"namespaces\" ||\n          entry.name === \".git\"\n        ) continue;\n        await walk(full);\n      } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n        out.push(full);\n      }\n    }\n  }\n\n  await walk(memoryDir);\n  return out;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-DZKHSDOM.js → chunk-ES36HTSC.js}

@@ -1,6 +1,6 @@
 import {
   scanMemoryDir
-} from "./chunk-6SXVCD7W.js";
+} from "./chunk-W7IGLX4G.js";
 import {
   isSearchAborted,
   throwIfSearchAborted
@@ -8,10 +8,10 @@ import {
 import {
   reportSearchDegradation,
   resolveEnsureCollectionArgs
-} from "./chunk-RAR2BSEM.js";
+} from "./chunk-YV32N67O.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/search/orama-backend.ts
 import path from "path";
@@ -613,4 +613,4 @@ export {
   resolveOramaCollectionDbFilePath,
   OramaBackend
 };
-//# sourceMappingURL=chunk-DZKHSDOM.js.map
+//# sourceMappingURL=chunk-ES36HTSC.js.map

package/dist/{chunk-TN7THW5U.js → chunk-ET356KSB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-O75CRYGF.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/conversation-index/faiss-adapter.ts
 import { fileURLToPath } from "url";
@@ -275,4 +275,4 @@ export {
   FaissConversationIndexAdapter,
   failOpenFaissHealth
 };
-//# sourceMappingURL=chunk-TN7THW5U.js.map
+//# sourceMappingURL=chunk-ET356KSB.js.map

package/dist/{chunk-YNDLCWXS.js → chunk-EZ25VE3G.js}

@@ -1,9 +1,9 @@
-import {
-  diffGraphSnapshots
-} from "./chunk-AUDJPF4N.js";
 import {
   graphSnapshotFromMemoryDir
 } from "./chunk-44442YCH.js";
+import {
+  diffGraphSnapshots
+} from "./chunk-AUDJPF4N.js";
 
 // src/dashboard-runtime.ts
 import { createHash, timingSafeEqual } from "crypto";
@@ -370,4 +370,4 @@ var GraphDashboardServer = class {
 export {
   GraphDashboardServer
 };
-//# sourceMappingURL=chunk-YNDLCWXS.js.map
+//# sourceMappingURL=chunk-EZ25VE3G.js.map

package/dist/{chunk-DMSDUGDM.js → chunk-F7GAIWFA.js}

@@ -1,30 +1,19 @@
 import {
   toBackupStamp
 } from "./chunk-KJTKLXTH.js";
-import {
-  commitPreparedFileAtomically
-} from "./chunk-SFQ6QNL7.js";
 import {
   loadPersistedNativeKnowledgeChunks
-} from "./chunk-MRHFJV44.js";
+} from "./chunk-2DQ2XREU.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-2AZXIZEN.js";
-import {
-  StorageManager
-} from "./chunk-K7LOWSLU.js";
+} from "./chunk-5Q7EVV4X.js";
 import {
-  MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
-  buildLifecycleEventsForMemory,
-  inferMemoryStatus,
-  sortMemoryLifecycleEvents,
-  toMemoryPathRel
-} from "./chunk-RULE4VG5.js";
+  commitPreparedFileAtomically
+} from "./chunk-R6YJI3HE.js";
 import {
-  normalizeProjectionPreview,
-  normalizeProjectionTags
-} from "./chunk-SCU65EZI.js";
+  StorageManager
+} from "./chunk-4BJQODZF.js";
 import {
   MEMORY_PROJECTION_SCHEMA_VERSION,
   getMemoryProjectionPath,
@@ -36,13 +25,24 @@ import {
   readProjectedEntityMentions,
   readProjectedGovernanceRecord,
   readProjectedNativeKnowledgeChunks
-} from "./chunk-RHOZ5LLO.js";
+} from "./chunk-347WD2LE.js";
 import {
   openBetterSqlite3
 } from "./chunk-RL6NEVXT.js";
+import {
+  MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
+  buildLifecycleEventsForMemory,
+  inferMemoryStatus,
+  sortMemoryLifecycleEvents,
+  toMemoryPathRel
+} from "./chunk-ILGC6JH6.js";
+import {
+  normalizeProjectionPreview,
+  normalizeProjectionTags
+} from "./chunk-SCU65EZI.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/maintenance/rebuild-memory-projection.ts
 import path from "path";
@@ -1023,4 +1023,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-DMSDUGDM.js.map
+//# sourceMappingURL=chunk-F7GAIWFA.js.map

package/dist/{chunk-G6XXLKC5.js → chunk-FFPJINJE.js}

@@ -1,14 +1,14 @@
-import {
-  countRecallTokenOverlap,
-  normalizeRecallTokens
-} from "./chunk-ZBJMUXZH.js";
 import {
   StorageManager
-} from "./chunk-K7LOWSLU.js";
+} from "./chunk-4BJQODZF.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
 } from "./chunk-XMMESCPD.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-ZBJMUXZH.js";
 
 // src/semantic-rule-verifier.ts
 var DEFAULT_MIN_EFFECTIVE_CONFIDENCE = 0.45;
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-G6XXLKC5.js.map
+//# sourceMappingURL=chunk-FFPJINJE.js.map