@remnic/core 9.69.56 → 9.69.57

package/dist/chunk-B7SSU55V.js

@@ -0,0 +1,1686 @@
+import {
+  planNamespaceMaintenance,
+  readNamespaceMaintenanceLastRanStatuses,
+  readNamespaceMaintenanceStatuses,
+  runNamespaceMaintenancePlan
+} from "./chunk-AULKCNZW.js";
+import {
+  analyzeSessionIntegrity,
+  applySessionRepair,
+  planSessionRepair
+} from "./chunk-KFY3SGN7.js";
+import {
+  resolvePluginEntry
+} from "./chunk-CMTINOFS.js";
+import {
+  summarizeCorpusAndReplica
+} from "./chunk-2JQZSQXI.js";
+import {
+  readJudgeVerdictStats
+} from "./chunk-OZKOPQCM.js";
+import {
+  createEvalBaselineSnapshot,
+  getEvalHarnessStatus,
+  runEvalBaselineDeltaReport,
+  runEvalBenchmarkCiGate,
+  validateEvalBenchmarkPack
+} from "./chunk-4IHBN6WU.js";
+import {
+  resolveCuratedIncludeFilesStatePath,
+  resolveNativeKnowledgeStatePath,
+  resolveOpenClawWorkspaceStatePath
+} from "./chunk-2DQ2XREU.js";
+import {
+  runConsolidationProvenanceCheck
+} from "./chunk-2SGLMP2E.js";
+import {
+  reportBufferSurpriseDistribution
+} from "./chunk-YBPYIAA5.js";
+import {
+  parseConfig
+} from "./chunk-M5IJP3YW.js";
+import {
+  readAggregateExtractionWatermark
+} from "./chunk-FSXD6Y4H.js";
+import {
+  listMemoryGovernanceRuns,
+  readMemoryGovernanceRunArtifact
+} from "./chunk-ZIEZJMFW.js";
+import {
+  listNamespaces
+} from "./chunk-S3JPD4N7.js";
+import {
+  analyzeGraphHealth
+} from "./chunk-GWK7FEUL.js";
+import {
+  summarizeExtractionLiveness
+} from "./chunk-3SG4FGDV.js";
+import {
+  StorageManager
+} from "./chunk-S2OBXHMN.js";
+import {
+  lintWorkspaceFiles
+} from "./chunk-DM2T26WE.js";
+import {
+  probeProjectionHealth
+} from "./chunk-AL3UYZ5N.js";
+import {
+  resolveAccessSetupCapabilities,
+  resolveCapabilities,
+  resolveConversationContextCapabilities,
+  resolveEvalCapabilities,
+  resolveGraphConstructionCapabilities,
+  resolveIndexingCapabilities,
+  resolveNamespaceCapabilities,
+  resolvePresentationCapabilities,
+  resolveQmdCapabilities
+} from "./chunk-JUOZ62Y7.js";
+import {
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-P2QRMMVQ.js";
+
+// src/operator-toolkit.ts
+import path from "path";
+import { constants as fsConstants } from "fs";
+import { access, mkdir, readFile, readdir, stat, unlink, writeFile } from "fs/promises";
+
+// src/maintenance/namespace-maintenance-fanout.ts
+var NAMESPACE_MAINTENANCE_JOBS = [
+  "qmd",
+  "pattern-reinforcement",
+  "contradiction-scan",
+  "semantic-consolidation",
+  "governance",
+  "lifecycle",
+  "graph-decay",
+  "fact-archival",
+  "tier-migration"
+];
+async function runNamespaceMaintenanceFanout(options) {
+  if (options.enabled === false) {
+    return {
+      jobName: options.jobName,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ran: 0,
+      skipped: 0,
+      failed: 0,
+      statuses: []
+    };
+  }
+  const plan = await planNamespaceMaintenance(options.config, {
+    jobName: options.jobName,
+    catalog: options.catalog
+  });
+  return runNamespaceMaintenancePlan(
+    options.config,
+    plan,
+    async (candidate) => {
+      return options.runner({
+        config: options.config,
+        candidate,
+        resolveStorage: options.resolveStorage
+      });
+    },
+    options.catalog
+  );
+}
+async function summarizeNamespaceMaintenanceHealth(config) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const statuses = await readNamespaceMaintenanceStatuses(config);
+  const lastRanStatuses = await readNamespaceMaintenanceLastRanStatuses(config);
+  const lastRanByJobNs = /* @__PURE__ */ new Map();
+  for (const lr of lastRanStatuses) {
+    lastRanByJobNs.set(`${lr.jobName}\0${lr.namespace}`, lr);
+  }
+  const byJob = /* @__PURE__ */ new Map();
+  for (const status of statuses) {
+    const bucket = byJob.get(status.jobName);
+    if (bucket) {
+      bucket.push(status);
+    } else {
+      byJob.set(status.jobName, [status]);
+    }
+  }
+  const knownJobs = new Set(NAMESPACE_MAINTENANCE_JOBS);
+  for (const jobName of byJob.keys()) {
+    knownJobs.add(jobName);
+  }
+  const jobs = [];
+  let totalRan = 0;
+  let totalSkipped = 0;
+  let totalFailed = 0;
+  for (const jobName of [...knownJobs].sort()) {
+    const jobStatuses = byJob.get(jobName) ?? [];
+    const ran = jobStatuses.filter((s) => s.state === "ran").length;
+    const skipped = jobStatuses.filter((s) => s.state === "skipped").length;
+    const failed = jobStatuses.filter((s) => s.state === "failed").length;
+    const candidates = [];
+    for (const st of jobStatuses) {
+      if (typeof st.completedAt === "string") candidates.push(st.completedAt);
+      const lr = lastRanByJobNs.get(`${jobName}\0${st.namespace}`);
+      if (lr && typeof lr.completedAt === "string") candidates.push(lr.completedAt);
+    }
+    const lastRunAt = candidates.sort().at(-1) ?? null;
+    totalRan += ran;
+    totalSkipped += skipped;
+    totalFailed += failed;
+    jobs.push({
+      jobName,
+      ran,
+      skipped,
+      failed,
+      lastRunAt,
+      namespaces: jobStatuses
+    });
+  }
+  return {
+    generatedAt,
+    fanoutEnabled: resolveConversationContextCapabilities(config).maintenanceNamespaceFanout !== false,
+    namespacesEnabled: resolveNamespaceCapabilities(config).namespaces,
+    maxNamespacesPerCycle: config.maintenanceMaxNamespacesPerCycle,
+    jobs,
+    totalRan,
+    totalSkipped,
+    totalFailed
+  };
+}
+function formatNamespaceMaintenanceHealthText(summary) {
+  const lines = [
+    "=== Namespace Maintenance ===",
+    "",
+    `  fanout:        ${summary.fanoutEnabled ? "enabled" : "disabled"}`,
+    `  namespaces:    ${summary.namespacesEnabled ? "enabled" : "disabled"}`,
+    `  max/cycle:     ${summary.maxNamespacesPerCycle}`,
+    `  total ran:     ${summary.totalRan}`,
+    `  total skipped: ${summary.totalSkipped}`,
+    `  total failed:  ${summary.totalFailed}`,
+    ""
+  ];
+  if (summary.totalRan === 0 && summary.totalSkipped === 0 && summary.totalFailed === 0) {
+    lines.push("  (no maintenance status recorded yet)");
+    return lines.join("\n");
+  }
+  lines.push("  Per-job breakdown:");
+  for (const job of summary.jobs) {
+    const parts = [
+      `ran=${job.ran}`,
+      `skipped=${job.skipped}`,
+      `failed=${job.failed}`
+    ];
+    if (job.lastRunAt) {
+      parts.push(`last=${job.lastRunAt}`);
+    }
+    lines.push(`    ${job.jobName}: ${parts.join(", ")}`);
+    const failedNs = job.namespaces.filter((n) => n.state === "failed");
+    for (const ns of failedNs) {
+      const detail = ns.error ? `: ${ns.error}` : "";
+      lines.push(`      ! ${ns.namespace} failed (reason=${ns.reason ?? "unknown"})${detail}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/operator-toolkit.ts
+var OPENCLAW_REMNIC_PLUGIN_IDS = ["openclaw-remnic", "openclaw-engram"];
+function getOpenClawPluginEntries(raw) {
+  const plugins = raw["plugins"] && typeof raw["plugins"] === "object" && !Array.isArray(raw["plugins"]) ? raw["plugins"] : void 0;
+  const entries = plugins && plugins["entries"] && typeof plugins["entries"] === "object" && !Array.isArray(plugins["entries"]) ? plugins["entries"] : void 0;
+  return entries;
+}
+function getOpenClawMemorySlotId(raw) {
+  const plugins = raw["plugins"] && typeof raw["plugins"] === "object" && !Array.isArray(raw["plugins"]) ? raw["plugins"] : void 0;
+  const slots = plugins && plugins["slots"] && typeof plugins["slots"] === "object" && !Array.isArray(plugins["slots"]) ? plugins["slots"] : void 0;
+  const slotId = slots?.["memory"];
+  return typeof slotId === "string" ? slotId : void 0;
+}
+function resolveOpenClawRemnicPluginEntry(raw) {
+  return resolvePluginEntry(raw, {
+    candidateIds: OPENCLAW_REMNIC_PLUGIN_IDS,
+    getEntries: getOpenClawPluginEntries,
+    getSlotId: getOpenClawMemorySlotId
+  });
+}
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function formatUnknownError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function resolveConfigPath(explicitPath) {
+  if (explicitPath && explicitPath.trim().length > 0) return explicitPath.trim();
+  const configured = readEnvVar("OPENCLAW_CONFIG_PATH") || readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH");
+  if (configured && configured.trim().length > 0) return configured.trim();
+  return path.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+}
+async function loadCliPluginConfig(configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  try {
+    const raw = JSON.parse(await readFile(resolvedPath, "utf-8"));
+    const entry = resolveOpenClawRemnicPluginEntry(raw);
+    const parsedConfig = parseConfig(
+      entry && typeof entry === "object" ? entry["config"] ?? {} : {}
+    );
+    return {
+      found: true,
+      path: resolvedPath,
+      parsed: true,
+      memoryDir: parsedConfig.memoryDir,
+      workspaceDir: parsedConfig.workspaceDir
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      found: !/ENOENT/i.test(message),
+      path: resolvedPath,
+      parsed: false,
+      error: message
+    };
+  }
+}
+async function isWritable(targetPath) {
+  try {
+    await access(targetPath, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathExists(targetPath) {
+  try {
+    await access(targetPath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatConfigValue(value) {
+  if (value === void 0 || value === null) return "(unset)";
+  if (typeof value === "string") return value.length > 0 ? value : "(unset)";
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+async function gatherDirectoryStatus(paths) {
+  return Promise.all(paths.map(async (targetPath) => {
+    try {
+      await access(targetPath, fsConstants.F_OK);
+      return {
+        path: targetPath,
+        exists: true,
+        writable: await isWritable(targetPath)
+      };
+    } catch {
+      return {
+        path: targetPath,
+        exists: false,
+        writable: false
+      };
+    }
+  }));
+}
+function getSetupPaths(config) {
+  return [
+    config.memoryDir,
+    config.workspaceDir,
+    path.join(config.memoryDir, "facts"),
+    path.join(config.memoryDir, "entities"),
+    path.join(config.memoryDir, "state"),
+    path.join(config.memoryDir, "questions"),
+    path.join(config.memoryDir, "artifacts"),
+    path.join(config.memoryDir, "config")
+  ];
+}
+async function readJsonIfExists(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function summarizeNativeKnowledgeStatus(config) {
+  const nativeKnowledge = config.nativeKnowledge;
+  const nativeKnowledgeStateDir = nativeKnowledge?.stateDir ?? "state/native-knowledge";
+  const curatedStatePath = nativeKnowledge ? resolveCuratedIncludeFilesStatePath(config.memoryDir, nativeKnowledge) : path.join(config.memoryDir, nativeKnowledgeStateDir, "curated-include-sync.json");
+  const obsidianStatePath = nativeKnowledge ? resolveNativeKnowledgeStatePath(config.memoryDir, nativeKnowledge) : path.join(config.memoryDir, nativeKnowledgeStateDir, "obsidian-sync.json");
+  const openclawStatePath = nativeKnowledge ? resolveOpenClawWorkspaceStatePath(config.memoryDir, nativeKnowledge) : path.join(config.memoryDir, nativeKnowledgeStateDir, "openclaw-workspace-sync.json");
+  const [curatedRaw, obsidianRaw, openclawRaw] = await Promise.all([
+    readJsonIfExists(curatedStatePath),
+    readJsonIfExists(obsidianStatePath),
+    readJsonIfExists(openclawStatePath)
+  ]);
+  const curatedFiles = curatedRaw && typeof curatedRaw === "object" && curatedRaw !== null && "files" in curatedRaw && typeof curatedRaw.files === "object" && curatedRaw.files !== null ? curatedRaw : null;
+  let curatedActiveChunkCount = 0;
+  let curatedDeletedFileCount = 0;
+  for (const file of Object.values(curatedFiles?.files ?? {})) {
+    if (file.deleted) {
+      curatedDeletedFileCount += 1;
+      continue;
+    }
+    curatedActiveChunkCount += Array.isArray(file.chunks) ? file.chunks.length : 0;
+  }
+  const obsidianVaults = obsidianRaw && typeof obsidianRaw === "object" && obsidianRaw !== null && "vaults" in obsidianRaw && typeof obsidianRaw.vaults === "object" && obsidianRaw.vaults !== null ? obsidianRaw : null;
+  let obsidianActiveChunkCount = 0;
+  let obsidianDeletedNoteCount = 0;
+  for (const vault of Object.values(obsidianVaults?.vaults ?? {})) {
+    for (const note of Object.values(vault.notes ?? {})) {
+      if (note.deleted) {
+        obsidianDeletedNoteCount += 1;
+        continue;
+      }
+      obsidianActiveChunkCount += Array.isArray(note.chunks) ? note.chunks.length : 0;
+    }
+  }
+  const openclawFiles = openclawRaw && typeof openclawRaw === "object" && openclawRaw !== null && "files" in openclawRaw && typeof openclawRaw.files === "object" && openclawRaw.files !== null ? openclawRaw : null;
+  let openclawActiveChunkCount = 0;
+  let openclawDeletedFileCount = 0;
+  for (const file of Object.values(openclawFiles?.files ?? {})) {
+    if (file.deleted) {
+      openclawDeletedFileCount += 1;
+      continue;
+    }
+    openclawActiveChunkCount += Array.isArray(file.chunks) ? file.chunks.length : 0;
+  }
+  return {
+    enabled: nativeKnowledge?.enabled === true,
+    includeFiles: nativeKnowledge?.includeFiles ?? [],
+    curatedIncludeSync: {
+      statePath: curatedStatePath,
+      exists: curatedFiles !== null,
+      updatedAt: typeof curatedFiles?.updatedAt === "string" ? curatedFiles.updatedAt : null,
+      fileCount: Object.keys(curatedFiles?.files ?? {}).length,
+      activeChunkCount: curatedActiveChunkCount,
+      deletedFileCount: curatedDeletedFileCount
+    },
+    openclawWorkspaceAdapterEnabled: nativeKnowledge?.openclawWorkspace?.enabled === true,
+    obsidianVaultAdapterEnabled: (nativeKnowledge?.obsidianVaults?.length ?? 0) > 0,
+    obsidianSync: {
+      statePath: obsidianStatePath,
+      exists: obsidianVaults !== null,
+      updatedAt: typeof obsidianVaults?.updatedAt === "string" ? obsidianVaults.updatedAt : null,
+      vaultCount: Object.keys(obsidianVaults?.vaults ?? {}).length,
+      activeChunkCount: obsidianActiveChunkCount,
+      deletedNoteCount: obsidianDeletedNoteCount
+    },
+    openclawWorkspaceSync: {
+      statePath: openclawStatePath,
+      exists: openclawFiles !== null,
+      updatedAt: typeof openclawFiles?.updatedAt === "string" ? openclawFiles.updatedAt : null,
+      fileCount: Object.keys(openclawFiles?.files ?? {}).length,
+      activeChunkCount: openclawActiveChunkCount,
+      deletedFileCount: openclawDeletedFileCount
+    }
+  };
+}
+var CAPTURE_INSTRUCTIONS_START = "<!-- BEGIN ENGRAM EXPLICIT CAPTURE INSTRUCTIONS -->";
+var CAPTURE_INSTRUCTIONS_END = "<!-- END ENGRAM EXPLICIT CAPTURE INSTRUCTIONS -->";
+function buildCaptureInstructions() {
+  return [
+    CAPTURE_INSTRUCTIONS_START,
+    "# Memory",
+    "",
+    "Use this file for explicit memory capture notes when Engram runs in explicit or hybrid mode.",
+    "",
+    "## Suggested format",
+    "",
+    "- Write durable facts, decisions, commitments, or corrections.",
+    "- Keep entries concise and specific.",
+    "- Avoid secrets, tokens, and private credentials.",
+    "",
+    "## Example",
+    "",
+    "- Decision: recall benchmark packs live under `state/evals/benchmarks/`.",
+    "- Commitment: rerun `openclaw engram doctor --json` after changing retrieval settings.",
+    "",
+    CAPTURE_INSTRUCTIONS_END
+  ].join("\n");
+}
+function upsertManagedCaptureInstructions(existing, snippet) {
+  if (!existing || existing.trim().length === 0) {
+    return { content: `${snippet}
+`, updated: false, installed: true };
+  }
+  if (existing.includes(CAPTURE_INSTRUCTIONS_START) && existing.includes(CAPTURE_INSTRUCTIONS_END)) {
+    const next = existing.replace(
+      new RegExp(`${CAPTURE_INSTRUCTIONS_START}[\\s\\S]*?${CAPTURE_INSTRUCTIONS_END}`),
+      snippet
+    );
+    return { content: next.endsWith("\n") ? next : `${next}
+`, updated: next !== existing, installed: false };
+  }
+  const trimmed = existing.trimEnd();
+  return {
+    content: `${trimmed}
+
+${snippet}
+`,
+    updated: false,
+    installed: true
+  };
+}
+function removeManagedCaptureInstructions(existing) {
+  if (!existing.includes(CAPTURE_INSTRUCTIONS_START) || !existing.includes(CAPTURE_INSTRUCTIONS_END)) {
+    return { content: existing, removed: false };
+  }
+  const stripped = existing.replace(new RegExp(`\\n*${CAPTURE_INSTRUCTIONS_START}[\\s\\S]*?${CAPTURE_INSTRUCTIONS_END}\\n*`), "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    content: stripped.length > 0 ? `${stripped}
+` : "",
+    removed: true
+  };
+}
+async function runOperatorSetup(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const configStatus = await loadCliPluginConfig(options.configPath);
+  const storage = options.orchestrator.storage;
+  await storage.ensureDirectories();
+  await mkdir(options.orchestrator.config.workspaceDir, { recursive: true });
+  const qmdAvailable = await options.orchestrator.qmd.probe();
+  const collectionState = resolveQmdCapabilities(options.orchestrator.config).qmd ? await options.orchestrator.qmd.ensureCollection(
+    options.orchestrator.config.memoryDir,
+    options.orchestrator.config.qmdCollection
+  ) : "skipped";
+  const nativeKnowledgeStatus = await summarizeNativeKnowledgeStatus(options.orchestrator.config);
+  const memoryDocPath = path.join(options.orchestrator.config.workspaceDir, "MEMORY.md");
+  const captureInstructionsMode = options.captureInstructionsMode ?? (options.installCaptureInstructions ? "install" : void 0);
+  let memoryDocExists = false;
+  try {
+    await access(memoryDocPath, fsConstants.F_OK);
+    memoryDocExists = true;
+  } catch {
+    memoryDocExists = false;
+  }
+  let memoryDocInstalled = false;
+  let memoryDocUpdated = false;
+  let memoryDocRemoved = false;
+  const explicitCaptureEnabled = options.orchestrator.config.captureMode === "explicit" || options.orchestrator.config.captureMode === "hybrid";
+  const captureInstructionsPreview = captureInstructionsMode ? buildCaptureInstructions() : null;
+  if (captureInstructionsMode) {
+    if (captureInstructionsMode === "preview") {
+    } else if (captureInstructionsMode === "install") {
+      const existing = memoryDocExists ? await readFile(memoryDocPath, "utf-8") : null;
+      const next = upsertManagedCaptureInstructions(existing, captureInstructionsPreview ?? "");
+      if (!existing || next.content !== existing) {
+        await writeFile(memoryDocPath, next.content, "utf-8");
+      }
+      memoryDocExists = true;
+      memoryDocInstalled = next.installed;
+      memoryDocUpdated = next.updated;
+    } else if (captureInstructionsMode === "remove" && memoryDocExists) {
+      const existing = await readFile(memoryDocPath, "utf-8");
+      const next = removeManagedCaptureInstructions(existing);
+      if (next.removed) {
+        if (next.content.length === 0) {
+          await unlink(memoryDocPath);
+          memoryDocExists = false;
+        } else {
+          await writeFile(memoryDocPath, next.content, "utf-8");
+          memoryDocExists = true;
+        }
+        memoryDocRemoved = true;
+      }
+    }
+  }
+  const directories = await gatherDirectoryStatus(getSetupPaths(options.orchestrator.config));
+  const nextSteps = [
+    `Run \`openclaw engram doctor${options.installCaptureInstructions ? "" : " --json"}\` to verify runtime health.`,
+    "Run `openclaw engram inventory --json` to capture a baseline footprint.",
+    "If QMD is enabled and the collection is missing, add the collection to `~/.config/qmd/index.yml` and run `qmd update && qmd embed`."
+  ];
+  if (explicitCaptureEnabled && !memoryDocExists) {
+    nextSteps.push("Run `openclaw engram setup --preview-capture-instructions` to review the managed explicit-capture snippet, then `--install-capture-instructions` to write it.");
+  }
+  return {
+    schemaVersion: 1,
+    generatedAt: now.toISOString(),
+    config: configStatus,
+    memoryDir: options.orchestrator.config.memoryDir,
+    workspaceDir: options.orchestrator.config.workspaceDir,
+    directories,
+    qmd: {
+      enabled: resolveQmdCapabilities(options.orchestrator.config).qmd,
+      available: qmdAvailable,
+      collectionState,
+      debugStatus: options.orchestrator.qmd.debugStatus()
+    },
+    nativeKnowledge: nativeKnowledgeStatus,
+    explicitCapture: {
+      captureMode: options.orchestrator.config.captureMode,
+      enabled: explicitCaptureEnabled,
+      memoryDocPath,
+      memoryDocExists,
+      memoryDocInstalled,
+      memoryDocUpdated,
+      memoryDocRemoved,
+      preview: captureInstructionsMode === "preview" ? captureInstructionsPreview : null
+    },
+    nextSteps,
+    verificationCommands: [
+      "openclaw engram doctor --json",
+      "openclaw engram inventory --json",
+      "openclaw engram benchmark recall --json"
+    ]
+  };
+}
+function summarizeHygieneWarnings(warnings, hygiene) {
+  if (!hygiene?.enabled || hygiene.lintEnabled !== true) {
+    return {
+      key: "file_hygiene",
+      status: "warn",
+      summary: "File hygiene linting is disabled; bootstrap file truncation warnings are not active.",
+      remediation: "Enable `fileHygiene.enabled` and `fileHygiene.lintEnabled` if large workspace bootstrap files are common.",
+      details: {
+        enabled: hygiene?.enabled === true,
+        lintEnabled: hygiene?.lintEnabled === true
+      }
+    };
+  }
+  if (warnings.length > 0) {
+    return {
+      key: "file_hygiene",
+      status: "warn",
+      summary: `${warnings.length} bootstrap file(s) are near or above the configured budget.`,
+      remediation: "Archive/split the listed files or adjust `fileHygiene` budgets.",
+      details: { warnings }
+    };
+  }
+  return {
+    key: "file_hygiene",
+    status: "ok",
+    summary: "Bootstrap file hygiene is within budget.",
+    details: {
+      enabled: true,
+      lintPaths: hygiene.lintPaths,
+      budgetBytes: hygiene.lintBudgetBytes
+    }
+  };
+}
+function buildConfigReviewFinding(input) {
+  return {
+    key: input.key,
+    status: input.status,
+    setting: input.setting,
+    currentValue: formatConfigValue(input.currentValue),
+    defaultValue: formatConfigValue(input.defaultValue),
+    recommendedValue: formatConfigValue(input.recommendedValue),
+    summary: input.summary,
+    rationale: input.rationale
+  };
+}
+async function runOperatorConfigReview(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const configStatus = await loadCliPluginConfig(options.configPath);
+  return buildOperatorConfigReviewReport({
+    now,
+    configStatus,
+    config: options.orchestrator.config
+  });
+}
+async function buildOperatorConfigReviewReport(input) {
+  const { now, configStatus, config } = input;
+  const caps = resolveCapabilities(config);
+  const findings = [];
+  const searchBackend = config.searchBackend ?? "qmd";
+  const workspaceBootstrapFiles = [
+    path.join(config.workspaceDir, "IDENTITY.md"),
+    path.join(config.workspaceDir, "MEMORY.md"),
+    path.join(config.workspaceDir, "USER.md")
+  ];
+  const workspaceBootstrapExists = (await Promise.all(workspaceBootstrapFiles.map(pathExists))).some(Boolean);
+  if (config.memoryOsPreset !== "conservative" && config.memoryOsPreset !== "balanced" && config.memoryOsPreset !== "research-max" && config.memoryOsPreset !== "local-llm-heavy" && resolveIndexingCapabilities(config).queryAwareIndexing === false && resolvePresentationCapabilities(config).verbatimArtifacts === false && !caps.rerank) {
+    findings.push(buildConfigReviewFinding({
+      key: "balanced_preset",
+      status: "recommend",
+      setting: "memoryOsPreset",
+      currentValue: config.memoryOsPreset,
+      defaultValue: "(unset)",
+      recommendedValue: "balanced",
+      summary: "Adopt the balanced preset as the baseline configuration profile.",
+      rationale: "The balanced preset enables the recommended indexing, reranking, and artifact defaults without turning on the higher-churn graph and learning loops."
+    }));
+  }
+  if (resolveQmdCapabilities(config).qmd && resolveQmdCapabilities(config).qmdDaemon === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_daemon",
+      status: "recommend",
+      setting: "qmdDaemonEnabled",
+      currentValue: resolveQmdCapabilities(config).qmdDaemon,
+      defaultValue: true,
+      recommendedValue: true,
+      summary: "Enable the QMD daemon path when QMD powers recall.",
+      rationale: "The daemon path reduces recall/search contention by preferring the MCP transport instead of repeated subprocess calls when QMD is available."
+    }));
+  }
+  if (workspaceBootstrapExists && config.nativeKnowledge?.enabled !== true) {
+    findings.push(buildConfigReviewFinding({
+      key: "native_knowledge_enabled",
+      status: "recommend",
+      setting: "nativeKnowledge.enabled",
+      currentValue: config.nativeKnowledge?.enabled,
+      defaultValue: false,
+      recommendedValue: true,
+      summary: "Enable native knowledge recall for workspace bootstrap documents.",
+      rationale: "When files like IDENTITY.md or MEMORY.md already exist, native knowledge recall can chunk and inject them directly instead of relying only on extracted memories."
+    }));
+  }
+  if (workspaceBootstrapExists && config.fileHygiene?.enabled !== true) {
+    findings.push(buildConfigReviewFinding({
+      key: "file_hygiene_enabled",
+      status: "recommend",
+      setting: "fileHygiene.enabled",
+      currentValue: config.fileHygiene?.enabled,
+      defaultValue: false,
+      recommendedValue: true,
+      summary: "Enable file hygiene to avoid silent workspace-file truncation.",
+      rationale: "OpenClaw bootstrap files can grow quietly; file hygiene warns before oversized files are truncated during prompt bootstrap."
+    }));
+  }
+  if (searchBackend === "qmd" && resolveQmdCapabilities(config).qmd === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_search_backend_disabled",
+      status: "problem",
+      setting: "qmdEnabled",
+      currentValue: resolveQmdCapabilities(config).qmd,
+      defaultValue: true,
+      recommendedValue: true,
+      summary: "QMD search is selected but QMD is disabled.",
+      rationale: "When searchBackend resolves to qmd while qmdEnabled is false, Engram falls back to the noop backend and disables the primary search path."
+    }));
+  }
+  if (resolveQmdCapabilities(config).qmdColdTier === true && resolveQmdCapabilities(config).qmd === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_cold_tier_requires_qmd",
+      status: "problem",
+      setting: "qmdEnabled",
+      currentValue: resolveQmdCapabilities(config).qmd,
+      defaultValue: true,
+      recommendedValue: true,
+      summary: "Cold-tier QMD recall is enabled while QMD itself is disabled.",
+      rationale: "The cold tier depends on the same QMD runtime as the hot tier, so turning QMD off leaves the extra tiering path unusable."
+    }));
+  }
+  if (resolveQmdCapabilities(config).qmdTierMigration && resolveQmdCapabilities(config).qmdColdTier !== true) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_tier_migration_requires_cold_tier",
+      status: "problem",
+      setting: "qmdColdTierEnabled",
+      currentValue: resolveQmdCapabilities(config).qmdColdTier,
+      defaultValue: false,
+      recommendedValue: true,
+      summary: "Hot/cold tier migration is enabled without the cold tier itself.",
+      rationale: "Tier migration depends on the cold-tier collection and recall path, so enabling migration while the cold tier is off leaves the feature in a contradictory state."
+    }));
+  }
+  if (resolveIndexingCapabilities(config).conversationIndex && config.conversationIndexBackend === "qmd" && resolveQmdCapabilities(config).qmd === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "conversation_index_qmd_requires_qmd",
+      status: "problem",
+      setting: "qmdEnabled",
+      currentValue: resolveQmdCapabilities(config).qmd,
+      defaultValue: true,
+      recommendedValue: true,
+      summary: "The conversation index is configured for QMD while QMD is disabled.",
+      rationale: "A QMD-backed conversation index cannot rebuild or serve queries when the underlying QMD runtime is disabled."
+    }));
+  }
+  const summary = findings.reduce(
+    (acc, finding) => {
+      acc[finding.status] += 1;
+      return acc;
+    },
+    { recommend: 0, problem: 0 }
+  );
+  return {
+    schemaVersion: 1,
+    generatedAt: now.toISOString(),
+    ok: configStatus.parsed && summary.problem === 0,
+    config: configStatus,
+    profile: {
+      memoryOsPreset: config.memoryOsPreset,
+      searchBackend,
+      qmdEnabled: resolveQmdCapabilities(config).qmd,
+      qmdDaemonEnabled: resolveQmdCapabilities(config).qmdDaemon,
+      nativeKnowledgeEnabled: config.nativeKnowledge?.enabled === true,
+      fileHygieneEnabled: config.fileHygiene?.enabled === true,
+      conversationIndexEnabled: resolveIndexingCapabilities(config).conversationIndex
+    },
+    summary,
+    findings
+  };
+}
+function summarizeProvenanceCoverage(memories) {
+  const counts = { verified: 0, unverified: 0, none: 0 };
+  for (const mem of memories) {
+    const tag = mem.frontmatter.provenance ?? "none";
+    if (tag === "verified") counts.verified += 1;
+    else if (tag === "unverified") counts.unverified += 1;
+    else counts.none += 1;
+  }
+  return { counts, total: memories.length };
+}
+function summarizeProjectionHealth(config) {
+  const probe = probeProjectionHealth(config.memoryDir);
+  if (probe.state === "absent") {
+    return {
+      key: "memory_projection",
+      status: "ok",
+      summary: "Memory projection index not built yet (normal until first maintenance run).",
+      details: { state: probe.state }
+    };
+  }
+  if (probe.state === "openable") {
+    return {
+      key: "memory_projection",
+      status: "ok",
+      summary: "Memory projection index opens cleanly.",
+      details: { state: probe.state }
+    };
+  }
+  if (probe.state === "present-but-invalid") {
+    const schemaDetailSuffix = probe.detail ? ` (${probe.detail})` : "";
+    return {
+      key: "memory_projection",
+      status: "error",
+      summary: `Memory projection index exists but its schema is missing or unreadable${schemaDetailSuffix}; memory browse is falling back to full-corpus scans.`,
+      remediation: "Rebuild the projection with `remnic rebuild-memory-projection --write`.",
+      details: { state: probe.state, detail: probe.detail }
+    };
+  }
+  const nativeSuffix = probe.nativeBindingMismatch ? " Native binding appears built for the wrong Node.js ABI." : "";
+  const detailSuffix = probe.detail ? ` (${probe.detail})` : "";
+  return {
+    key: "memory_projection",
+    status: "error",
+    summary: `Memory projection index exists but could not be opened${detailSuffix}.${nativeSuffix}`,
+    remediation: probe.nativeBindingMismatch ? "Rebuild the better-sqlite3 native binding for this Node.js (`node scripts/ensure-better-sqlite3.mjs` or `pnpm rebuild better-sqlite3`), then restart." : "Rebuild the projection with `remnic rebuild-memory-projection --write`; check file permissions and integrity.",
+    details: {
+      state: probe.state,
+      detail: probe.detail,
+      nativeBindingMismatch: probe.nativeBindingMismatch
+    }
+  };
+}
+async function runOperatorDoctor(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const configStatus = await loadCliPluginConfig(options.configPath);
+  const checks = [];
+  const config = options.orchestrator.config;
+  const storage = options.orchestrator.storage;
+  const configReview = await buildOperatorConfigReviewReport({
+    now,
+    configStatus,
+    config
+  });
+  const nativeKnowledgeStatus = await summarizeNativeKnowledgeStatus(config);
+  const setupPaths = await gatherDirectoryStatus(getSetupPaths(config));
+  const missingPaths = setupPaths.filter((entry) => !entry.exists).map((entry) => entry.path);
+  checks.push({
+    key: "config",
+    status: configStatus.parsed ? "ok" : options.configPath ? "error" : "warn",
+    summary: configStatus.parsed ? "OpenClaw config loaded and Engram config parsed successfully." : "Config file could not be parsed.",
+    remediation: configStatus.parsed ? void 0 : "Fix the config file or set OPENCLAW_ENGRAM_CONFIG_PATH/OPENCLAW_CONFIG_PATH.",
+    details: configStatus
+  });
+  checks.push({
+    key: "memory_dir",
+    status: missingPaths.length === 0 ? "ok" : "warn",
+    summary: missingPaths.length === 0 ? "Expected Engram directories exist." : `${missingPaths.length} expected directory path(s) are missing.`,
+    remediation: missingPaths.length === 0 ? void 0 : "Run `openclaw engram setup` to create missing directories.",
+    details: { directories: setupPaths }
+  });
+  checks.push({
+    key: "config_review",
+    status: configReview.summary.problem > 0 ? "error" : configReview.summary.recommend > 0 ? "warn" : "ok",
+    summary: configReview.summary.problem > 0 ? `${configReview.summary.problem} configuration problem(s) detected.` : configReview.summary.recommend > 0 ? `No configuration problems detected; ${configReview.summary.recommend} optional recommendation(s) are available.` : "No configuration problems detected.",
+    remediation: configReview.summary.problem > 0 || configReview.summary.recommend > 0 ? "Run `openclaw engram config-review` to inspect and fix the flagged configuration combinations." : void 0,
+    details: configReview
+  });
+  const qmdAvailable = await options.orchestrator.qmd.probe();
+  const collectionState = resolveQmdCapabilities(config).qmd ? await options.orchestrator.qmd.ensureCollection(config.memoryDir, config.qmdCollection) : "skipped";
+  checks.push({
+    key: "qmd",
+    status: !resolveQmdCapabilities(config).qmd ? "warn" : !qmdAvailable ? "error" : collectionState === "present" ? "ok" : collectionState === "missing" ? "error" : "warn",
+    summary: !resolveQmdCapabilities(config).qmd ? "QMD is disabled in config." : qmdAvailable ? `QMD is reachable (${collectionState}).` : "QMD is not currently reachable.",
+    remediation: !resolveQmdCapabilities(config).qmd ? "Enable `qmdEnabled` if you expect hybrid search." : !qmdAvailable ? "Ensure the `qmd` binary is installed and on PATH, or set `qmdPath`." : collectionState === "missing" ? "Add the configured collection to `~/.config/qmd/index.yml`." : collectionState === "present" ? void 0 : "Re-run `openclaw engram setup` after restoring QMD access.",
+    details: {
+      available: qmdAvailable,
+      collectionState,
+      debugStatus: options.orchestrator.qmd.debugStatus()
+    }
+  });
+  const conversationIndex = await options.orchestrator.conversationIndexCoordinator.getHealth();
+  checks.push({
+    key: "conversation_index",
+    status: conversationIndex.status === "ok" ? "ok" : conversationIndex.enabled ? "error" : "warn",
+    summary: conversationIndex.enabled ? `Conversation index backend is ${conversationIndex.status}.` : "Conversation index is disabled.",
+    remediation: conversationIndex.enabled && conversationIndex.status !== "ok" ? "Run `openclaw engram rebuild-index` to refresh the conversation index artifacts." : void 0,
+    details: conversationIndex
+  });
+  const meta = await storage.loadMeta();
+  checks.push({
+    key: "maintenance",
+    status: meta.lastExtractionAt || meta.lastConsolidationAt ? "ok" : "warn",
+    summary: meta.lastExtractionAt || meta.lastConsolidationAt ? "Extraction/consolidation metadata is present." : "No extraction or consolidation metadata found yet.",
+    remediation: meta.lastExtractionAt || meta.lastConsolidationAt ? void 0 : "Run a normal agent turn or `openclaw engram consolidate` after seeding memory.",
+    details: meta
+  });
+  const retryEntries = meta.extractionRetryState ?? [];
+  const authConfigFailures = retryEntries.filter((entry) => entry.lastFailureClass === "auth_config");
+  const nowMs = Date.now();
+  const parkedFingerprints = retryEntries.filter((entry) => {
+    const eligibleAt = Date.parse(entry.nextEligibleAt);
+    return Number.isFinite(eligibleAt) && eligibleAt > nowMs;
+  });
+  const providerRetryableParked = parkedFingerprints.filter(
+    (entry) => entry.lastFailureClass === "provider_retryable"
+  );
+  const breakerLikelyOpen = providerRetryableParked.length >= Math.max(1, config.extractionBreakerFailureThreshold);
+  const resilienceStatus = authConfigFailures.length > 0 ? "error" : parkedFingerprints.length > 0 ? "warn" : "ok";
+  checks.push({
+    key: "extraction-resilience",
+    status: resilienceStatus,
+    summary: resilienceStatus === "error" ? `Extraction provider has ${authConfigFailures.length} auth/config failure(s); the circuit breaker opens immediately and extraction is suspended.` : resilienceStatus === "warn" ? `${parkedFingerprints.length} extraction fingerprint(s) in backoff after transient provider failures${breakerLikelyOpen ? "; the provider circuit breaker is likely OPEN in the daemon (non-forced extraction is suspended until it half-opens)" : ""}.` : "No extraction provider failures are currently parked.",
+    remediation: resilienceStatus === "error" ? 'Check the extraction LLM gateway/model configuration (a 401/403 or "no models configured" was seen). Extraction resumes automatically once the provider is reachable.' : resilienceStatus === "warn" ? "Transient provider failures (e.g. 429/5xx). Backoff clears automatically as the provider recovers; no action needed unless it persists." : void 0,
+    details: {
+      backoffFingerprintCount: retryEntries.length,
+      authConfigFailureCount: authConfigFailures.length,
+      parkedFingerprintCount: parkedFingerprints.length,
+      providerRetryableParkedCount: providerRetryableParked.length,
+      breakerLikelyOpen
+    }
+  });
+  checks.push(summarizeProjectionHealth(config));
+  let provenanceCoverage = {
+    counts: { verified: 0, unverified: 0, none: 0 },
+    total: 0
+  };
+  let provenanceReadOk = true;
+  let provenancePartialTiers = [];
+  try {
+    const [hot, archived, cold] = await Promise.allSettled([
+      storage.readAllMemories(),
+      storage.readArchivedMemories(),
+      storage.readAllColdMemories()
+    ]);
+    const all = [];
+    if (hot.status === "fulfilled") all.push(...hot.value);
+    else provenancePartialTiers.push("hot");
+    if (archived.status === "fulfilled") all.push(...archived.value);
+    else provenancePartialTiers.push("archived");
+    if (cold.status === "fulfilled") all.push(...cold.value);
+    else provenancePartialTiers.push("cold");
+    provenanceCoverage = summarizeProvenanceCoverage(all);
+  } catch {
+    provenanceReadOk = false;
+  }
+  const pc = provenanceCoverage.counts;
+  const totalProvenance = provenanceCoverage.total;
+  const provenanceCovered = pc.verified + pc.unverified;
+  const partialSuffix = provenancePartialTiers.length > 0 ? ` (partial: ${provenancePartialTiers.join("/")} tier unreadable)` : "";
+  checks.push({
+    key: "provenance_coverage",
+    status: !provenanceReadOk || provenancePartialTiers.length > 0 ? "warn" : totalProvenance === 0 ? "warn" : provenanceCovered === 0 ? "warn" : "ok",
+    summary: !provenanceReadOk ? "Could not read memories for provenance coverage." : totalProvenance === 0 ? "No memories found yet \u2014 provenance coverage is empty." : `Provenance coverage: ${pc.verified} verified, ${pc.unverified} unverified, ${pc.none} none (${totalProvenance} total).${partialSuffix}`,
+    remediation: !provenanceReadOk ? void 0 : provenancePartialTiers.length > 0 ? `Some tiers could not be read (${provenancePartialTiers.join(", ")}). Check storage health and re-run.` : provenanceCovered === 0 && totalProvenance > 0 ? "New extractions will carry source spans. Existing legacy memories remain `none` until re-extracted." : void 0,
+    details: { provenanceCounts: pc, total: totalProvenance, partialTiers: provenancePartialTiers.length > 0 ? provenancePartialTiers : void 0 }
+  });
+  const syncedChunkCount = nativeKnowledgeStatus.curatedIncludeSync.activeChunkCount + nativeKnowledgeStatus.obsidianSync.activeChunkCount + nativeKnowledgeStatus.openclawWorkspaceSync.activeChunkCount;
+  const hasSyncState = nativeKnowledgeStatus.curatedIncludeSync.exists || nativeKnowledgeStatus.obsidianSync.exists || nativeKnowledgeStatus.openclawWorkspaceSync.exists;
+  checks.push({
+    key: "native_knowledge",
+    status: !nativeKnowledgeStatus.enabled ? "warn" : hasSyncState ? "ok" : "warn",
+    summary: !nativeKnowledgeStatus.enabled ? "Native knowledge sync is disabled." : hasSyncState ? `Native knowledge sync state is present (${syncedChunkCount} active chunks).` : "Native knowledge sync is enabled but no sync state has been written yet.",
+    remediation: !nativeKnowledgeStatus.enabled ? "Enable `nativeKnowledge.enabled` if curated workspace recall should participate in retrieval." : hasSyncState ? void 0 : "Run a recall, sync, or setup flow that touches native knowledge sources, then rerun `openclaw engram doctor --json`.",
+    details: nativeKnowledgeStatus
+  });
+  const agentAccessEnabled = config.agentAccessHttp?.enabled === true;
+  const rawAuthToken = config.agentAccessHttp?.authToken;
+  const authTokenConfigured = typeof rawAuthToken === "string" && rawAuthToken.length > 0 || rawAuthToken !== null && typeof rawAuthToken === "object" && typeof rawAuthToken.source === "string";
+  checks.push({
+    key: "access_http_auth",
+    status: !agentAccessEnabled ? "warn" : authTokenConfigured ? "ok" : "error",
+    summary: !agentAccessEnabled ? "Agent access HTTP bridge is disabled." : authTokenConfigured ? "Agent access HTTP bridge has an auth token configured." : "Agent access HTTP bridge is enabled without an auth token.",
+    remediation: !agentAccessEnabled ? "Ignore unless you plan to enable the HTTP bridge." : authTokenConfigured ? void 0 : "Set `agentAccessHttp.authToken` before exposing the bridge."
+  });
+  const warnings = config.fileHygiene?.lintEnabled ? await lintWorkspaceFiles({
+    workspaceDir: config.workspaceDir,
+    paths: config.fileHygiene.lintPaths,
+    budgetBytes: config.fileHygiene.lintBudgetBytes,
+    warnRatio: config.fileHygiene.lintWarnRatio
+  }) : [];
+  checks.push(summarizeHygieneWarnings(warnings, config.fileHygiene));
+  checks.push(await summarizeMemoryWorthLegacyCounters(storage));
+  checks.push(
+    await summarizeBufferSurpriseDistribution(storage, config)
+  );
+  checks.push(await summarizeConsolidationProvenance(storage, config));
+  checks.push(await summarizeGraphEdgeDecayStatus(config));
+  checks.push(await summarizeTierDistribution(options.orchestrator.storage));
+  checks.push(await summarizeDreamsPhases(config, storage, meta));
+  const extractionWatermark = await readAggregateExtractionWatermark({ config, rootStorage: storage, rootMeta: meta, storageForNamespace: (ns, rootDir) => options.orchestrator.getStorage?.(ns) ?? new StorageManager(rootDir) });
+  checks.push(await summarizeExtractionLiveness(config, extractionWatermark, options.orchestrator.buffer));
+  checks.push(...await summarizeCorpusAndReplica(config, (d) => new StorageManager(d), options.resolveSecretRef));
+  checks.push(summarizeSecurityMitigations(config));
+  checks.push(await summarizeObservationThroughput(config.memoryDir));
+  const namespaceMaintenanceHealth = await summarizeNamespaceMaintenanceHealth(config);
+  checks.push({
+    key: "namespace_maintenance",
+    status: namespaceMaintenanceHealth.totalFailed > 0 ? "warn" : "ok",
+    summary: namespaceMaintenanceHealth.totalRan === 0 && namespaceMaintenanceHealth.totalFailed === 0 ? "No namespace maintenance recorded yet (expected for a fresh install)." : `${namespaceMaintenanceHealth.totalRan} namespace maintenance run(s)` + (namespaceMaintenanceHealth.totalFailed > 0 ? `, ${namespaceMaintenanceHealth.totalFailed} failure(s) across ${namespaceMaintenanceHealth.jobs.filter((j) => j.failed > 0).length} job(s)` : "") + ".",
+    remediation: namespaceMaintenanceHealth.totalFailed > 0 ? "Run `remnic namespaces maintenance` for per-namespace details." : void 0,
+    details: namespaceMaintenanceHealth
+  });
+  checks.push(await summarizeTombstoneStatus(options.orchestrator.storage));
+  const summary = checks.reduce(
+    (acc, check) => {
+      acc[check.status] += 1;
+      return acc;
+    },
+    { ok: 0, warn: 0, error: 0 }
+  );
+  return {
+    schemaVersion: 1,
+    generatedAt: now.toISOString(),
+    ok: summary.error === 0,
+    summary,
+    config: configStatus,
+    checks
+  };
+}
+var MEMORY_WORTH_ELIGIBLE_CATEGORIES = /* @__PURE__ */ new Set(["fact", "procedure"]);
+async function summarizeMemoryWorthLegacyCounters(storage) {
+  let legacy = 0;
+  let instrumented = 0;
+  let ineligible = 0;
+  try {
+    const memories = await storage.readAllMemories();
+    for (const memory of memories) {
+      if (!MEMORY_WORTH_ELIGIBLE_CATEGORIES.has(memory.frontmatter.category)) {
+        ineligible += 1;
+        continue;
+      }
+      const { mw_success, mw_fail } = memory.frontmatter;
+      if (mw_success === void 0 && mw_fail === void 0) {
+        legacy += 1;
+      } else {
+        instrumented += 1;
+      }
+    }
+  } catch (err) {
+    return {
+      key: "memory_worth_legacy",
+      status: "warn",
+      summary: "Could not enumerate memories to count Memory Worth instrumentation.",
+      remediation: "Retry `remnic doctor` after ensuring the memory directory is readable.",
+      details: { error: String(err) }
+    };
+  }
+  const total = legacy + instrumented;
+  return {
+    key: "memory_worth_legacy",
+    status: "ok",
+    summary: total === 0 ? "No Memory Worth\u2013eligible memories on disk yet \u2014 counters will populate as facts are extracted." : `${legacy} of ${total} eligible memories have no Memory Worth counters yet (${instrumented} instrumented).`,
+    details: { legacy, instrumented, total, ineligible }
+  };
+}
+async function summarizeBufferSurpriseDistribution(storage, config) {
+  const storageWithLedger = storage;
+  if (typeof storageWithLedger.readBufferSurpriseEvents !== "function") {
+    return {
+      key: "buffer_surprise_distribution",
+      status: "ok",
+      summary: "Buffer-surprise telemetry reader unavailable in this build.",
+      details: { available: false }
+    };
+  }
+  try {
+    const dist = await reportBufferSurpriseDistribution(
+      async (opts) => storageWithLedger.readBufferSurpriseEvents({ limit: opts.limit }),
+      { limit: 200 }
+    );
+    if (dist.count === 0) {
+      return {
+        key: "buffer_surprise_distribution",
+        status: "ok",
+        summary: resolvePresentationCapabilities(config).bufferSurpriseTrigger ? "Surprise trigger is enabled but no telemetry has been recorded yet." : "Surprise trigger is disabled; no telemetry expected.",
+        details: {
+          enabled: resolvePresentationCapabilities(config).bufferSurpriseTrigger,
+          distribution: dist
+        }
+      };
+    }
+    const pct = (value) => (value * 100).toFixed(1);
+    return {
+      key: "buffer_surprise_distribution",
+      status: "ok",
+      summary: `Recent surprise: mean=${dist.mean.toFixed(3)}, median=${dist.median.toFixed(3)}, p90=${dist.p90.toFixed(3)}, triggered=${pct(dist.triggeredRate)}% over ${dist.count} turns (threshold=${dist.currentThreshold ?? config.bufferSurpriseThreshold}).`,
+      details: {
+        enabled: resolvePresentationCapabilities(config).bufferSurpriseTrigger,
+        distribution: dist
+      }
+    };
+  } catch (err) {
+    return {
+      key: "buffer_surprise_distribution",
+      status: "warn",
+      summary: "Could not read buffer-surprise telemetry ledger.",
+      remediation: "Retry `remnic doctor` after ensuring the memory state directory is readable.",
+      details: { error: String(err) }
+    };
+  }
+}
+async function summarizeGraphEdgeDecayStatus(config) {
+  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-ROSUPDX3.js");
+  const { graphEdgeDecayEnabled } = config;
+  const enabled = graphEdgeDecayEnabled === true;
+  if (!enabled) {
+    return {
+      key: "graph_edge_decay",
+      status: "ok",
+      summary: "Graph-edge decay maintenance is disabled (graphEdgeDecayEnabled = false).",
+      remediation: "Set graphEdgeDecayEnabled = true to opt into the periodic decay job (issue #681).",
+      details: { enabled: false }
+    };
+  }
+  const status = await readGraphEdgeDecayStatus(config.memoryDir);
+  if (!status) {
+    return {
+      key: "graph_edge_decay",
+      status: "warn",
+      summary: "Graph-edge decay is enabled but has not run yet (no status file present).",
+      remediation: "Trigger the cron, run `engram.graph_edge_decay_run` via MCP, or wait for the scheduled cadence to fire.",
+      details: { enabled: true, lastRun: null, cadenceMs: config.graphEdgeDecayCadenceMs }
+    };
+  }
+  return {
+    key: "graph_edge_decay",
+    status: "ok",
+    summary: `Graph-edge decay last ran at ${status.ranAt} (${status.edgesDecayed}/${status.edgesTotal} edges decayed, ${status.edgesBelowVisibilityThreshold} below visibility threshold).`,
+    details: {
+      enabled: true,
+      lastRun: status.ranAt,
+      durationMs: status.durationMs,
+      edgesTotal: status.edgesTotal,
+      edgesDecayed: status.edgesDecayed,
+      edgesBelowVisibilityThreshold: status.edgesBelowVisibilityThreshold,
+      topDecayedEntities: status.topDecayedEntities,
+      cadenceMs: config.graphEdgeDecayCadenceMs
+    }
+  };
+}
+async function summarizeTierDistribution(storage) {
+  try {
+    const { summarizeTiers } = await import("./tier-stats-VK5PCO2L.js");
+    const summary = await summarizeTiers(storage);
+    const storageDir = storage.dir ?? "";
+    const journalPath = storageDir.length > 0 ? path.join(storageDir, "state", "tier-migration-journal.jsonl") : null;
+    let recentMigrations = 0;
+    const demotionReasons = {};
+    const sevenDaysAgoMs = Date.now() - 7 * 864e5;
+    if (journalPath) {
+      try {
+        const { readFile: readFile2 } = await import("fs/promises");
+        const raw = await readFile2(journalPath, "utf-8");
+        for (const line of raw.split("\n")) {
+          const trimmed = line.trim();
+          if (trimmed.length === 0) continue;
+          try {
+            const entry = JSON.parse(trimmed);
+            const tsMs = entry.ts ? Date.parse(entry.ts) : NaN;
+            if (Number.isFinite(tsMs) && tsMs >= sevenDaysAgoMs && entry.changed === true) {
+              recentMigrations += 1;
+              if (entry.fromTier === "hot" && entry.toTier === "cold" && typeof entry.reason === "string") {
+                const reason = entry.reason;
+                demotionReasons[reason] = (demotionReasons[reason] ?? 0) + 1;
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    const topDemotionReasons = Object.entries(demotionReasons).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 5).map(([reason, count]) => ({ reason, count }));
+    const statusParts = Object.entries(summary.byStatus).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 6).map(([s, n]) => `${s}: ${n}`).join(", ");
+    return {
+      key: "tier_distribution",
+      status: "ok",
+      summary: `Tier distribution: hot=${summary.byTier.hot}, cold=${summary.byTier.cold}` + (summary.forgottenCount > 0 ? `, forgotten=${summary.forgottenCount}` : "") + `. Total: ${summary.total}.` + (recentMigrations > 0 ? ` Recent migrations (7d): ${recentMigrations}.` : ""),
+      details: {
+        total: summary.total,
+        byTier: summary.byTier,
+        byStatus: summary.byStatus,
+        forgottenCount: summary.forgottenCount,
+        statusSummary: statusParts,
+        recentMigrations,
+        topDemotionReasons
+      }
+    };
+  } catch (err) {
+    return {
+      key: "tier_distribution",
+      status: "ok",
+      summary: "Tier distribution unavailable \u2014 could not enumerate memories.",
+      details: { error: String(err) }
+    };
+  }
+}
+async function summarizeDreamsPhases(config, storage = new StorageManager(config.memoryDir), loadedMeta) {
+  const phases = config.dreamsPhases;
+  const meta = loadedMeta ?? await storage.loadMeta();
+  let deepSleepLastRun = null;
+  let deepSleepLastRunWarning = null;
+  try {
+    const runsDir = path.join(config.memoryDir, "state", "memory-governance", "runs");
+    const runIds = (await readdir(runsDir)).sort().reverse();
+    if (runIds.length > 0) {
+      const latestRunId = runIds[0];
+      const manifestPath = path.join(
+        runsDir,
+        latestRunId,
+        "manifest.json"
+      );
+      const raw = await readFile(manifestPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.createdAt === "string" && parsed.createdAt.length > 0) {
+        deepSleepLastRun = parsed.createdAt;
+      }
+    }
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      deepSleepLastRunWarning = `Could not read latest governance run manifest: ${formatUnknownError(error)}`;
+    }
+  }
+  const phaseLines = [
+    `lightSleep: enabled=${phases.lightSleep.enabled}, cadenceMs=${phases.lightSleep.cadenceMs}, promoteHeat=${phases.lightSleep.promoteHeatThreshold}, staleDecay=${phases.lightSleep.staleDecayThreshold}, archiveDecay=${phases.lightSleep.archiveDecayThreshold}, filterStale=${phases.lightSleep.filterStaleEnabled}, lastRun=${meta.lastExtractionAt ?? "never"}`,
+    `rem: enabled=${phases.rem.enabled}, cadenceMs=${phases.rem.cadenceMs}, similarity=${phases.rem.similarityThreshold}, minCluster=${phases.rem.minClusterSize}, maxPerRun=${phases.rem.maxPerRun}, minIntervalMs=${phases.rem.minIntervalMs}, lastRun=${meta.lastConsolidationAt ?? "never"}`,
+    `deepSleep: enabled=${phases.deepSleep.enabled}, cadenceMs=${phases.deepSleep.cadenceMs}, versioning=${phases.deepSleep.versioningEnabled}, versioningMaxPerPage=${phases.deepSleep.versioningMaxPerPage}, lastRun=${deepSleepLastRun ?? "never"}`
+  ];
+  return {
+    key: "dreams_phases",
+    status: deepSleepLastRunWarning ? "warn" : "ok",
+    summary: `Dreams pipeline phases: ${phaseLines.join("; ")}${deepSleepLastRunWarning ? `; ${deepSleepLastRunWarning}` : ""}`,
+    remediation: deepSleepLastRunWarning ? "Inspect state/memory-governance/runs and repair or remove unreadable governance run artifacts." : void 0,
+    details: {
+      lightSleep: {
+        enabled: phases.lightSleep.enabled,
+        cadenceMs: phases.lightSleep.cadenceMs,
+        promoteHeatThreshold: phases.lightSleep.promoteHeatThreshold,
+        staleDecayThreshold: phases.lightSleep.staleDecayThreshold,
+        archiveDecayThreshold: phases.lightSleep.archiveDecayThreshold,
+        filterStaleEnabled: phases.lightSleep.filterStaleEnabled,
+        lastRun: meta.lastExtractionAt ?? null
+      },
+      rem: {
+        enabled: phases.rem.enabled,
+        cadenceMs: phases.rem.cadenceMs,
+        similarityThreshold: phases.rem.similarityThreshold,
+        minClusterSize: phases.rem.minClusterSize,
+        maxPerRun: phases.rem.maxPerRun,
+        minIntervalMs: phases.rem.minIntervalMs,
+        lastRun: meta.lastConsolidationAt ?? null
+      },
+      deepSleep: {
+        enabled: phases.deepSleep.enabled,
+        cadenceMs: phases.deepSleep.cadenceMs,
+        versioningEnabled: phases.deepSleep.versioningEnabled,
+        versioningMaxPerPage: phases.deepSleep.versioningMaxPerPage,
+        lastRun: deepSleepLastRun,
+        warning: deepSleepLastRunWarning
+      }
+    }
+  };
+}
+function summarizeSecurityMitigations(config) {
+  const accessCaps = resolveAccessSetupCapabilities(config);
+  const budgetEnabled = accessCaps.recallCrossNamespaceBudget;
+  const anomalyEnabled = accessCaps.recallAuditAnomalyDetection;
+  if (!budgetEnabled && !anomalyEnabled) {
+    return {
+      key: "security_mitigations",
+      status: "warn",
+      summary: "Memory-extraction mitigations are disabled (cross-namespace budget and anomaly detection off).",
+      remediation: "Enable recallCrossNamespaceBudgetEnabled and/or recallAuditAnomalyDetectionEnabled for production deployments. See docs/security/memory-extraction-threat-model.md.",
+      details: {
+        budgetEnabled: false,
+        anomalyDetectionEnabled: false
+      }
+    };
+  }
+  const details = {
+    budgetEnabled,
+    anomalyDetectionEnabled: anomalyEnabled
+  };
+  if (budgetEnabled) {
+    details.budgetConfig = {
+      windowMs: config.recallCrossNamespaceBudgetWindowMs,
+      softLimit: config.recallCrossNamespaceBudgetSoftLimit,
+      hardLimit: config.recallCrossNamespaceBudgetHardLimit
+    };
+  }
+  if (anomalyEnabled) {
+    details.anomalyConfig = {
+      windowMs: config.recallAuditAnomalyWindowMs,
+      repeatQueryLimit: config.recallAuditAnomalyRepeatQueryLimit,
+      namespaceWalkLimit: config.recallAuditAnomalyNamespaceWalkLimit,
+      highCardinalityLimit: config.recallAuditAnomalyHighCardinalityLimit,
+      rapidFireLimit: config.recallAuditAnomalyRapidFireLimit
+    };
+  }
+  return {
+    key: "security_mitigations",
+    status: "ok",
+    summary: `Memory-extraction mitigation config enabled: ${budgetEnabled ? "budget" : ""}${budgetEnabled && anomalyEnabled ? ", " : ""}${anomalyEnabled ? "anomaly detection" : ""}.`,
+    details: { ...details, configOnly: true }
+  };
+}
+async function summarizeObservationThroughput(memoryDir) {
+  try {
+    const stats = await readJudgeVerdictStats(memoryDir);
+    if (stats.total === 0) {
+      return {
+        key: "observations",
+        status: "ok",
+        summary: "No observations recorded yet (extraction-judge telemetry ledger is empty or missing).",
+        details: { total: 0, accept: 0, reject: 0, defer: 0, lastObservedAt: null }
+      };
+    }
+    const acceptPct = (stats.accept / stats.total * 100).toFixed(1);
+    const rejectPct = (stats.reject / stats.total * 100).toFixed(1);
+    const deferPct = (stats.defer / stats.total * 100).toFixed(1);
+    return {
+      key: "observations",
+      status: "ok",
+      summary: `${stats.total} observations recorded: accept=${acceptPct}%, reject=${rejectPct}%, defer=${deferPct}%. Last observed: ${stats.lastTs ?? "unknown"}.`,
+      details: {
+        total: stats.total,
+        accept: stats.accept,
+        reject: stats.reject,
+        defer: stats.defer,
+        deferCapTriggered: stats.deferCapTriggered,
+        deferRate: stats.deferRate,
+        meanElapsedMs: stats.meanElapsedMs,
+        firstObservedAt: stats.firstTs ?? null,
+        lastObservedAt: stats.lastTs ?? null
+      }
+    };
+  } catch (err) {
+    return {
+      key: "observations",
+      status: "warn",
+      summary: "Could not read observation telemetry ledger.",
+      remediation: "Retry `remnic doctor` after ensuring the memory state directory is readable.",
+      details: { error: String(err) }
+    };
+  }
+}
+async function summarizeTombstoneStatus(storage) {
+  try {
+    const stats = await storage.getTombstoneStats();
+    if (stats === null) {
+      return {
+        key: "tombstones",
+        status: "ok",
+        summary: "Tombstone non-resurrection invariant is disabled (tombstonesEnabled=false).",
+        details: { enabled: false }
+      };
+    }
+    const corrupted = stats.corruptedLines > 0;
+    const parts = [
+      `${stats.count} active tombstone(s)`,
+      ...stats.revoked > 0 ? [`${stats.revoked} revoked`] : []
+    ];
+    if (stats.lastAppendAt) {
+      parts.push(`last append ${stats.lastAppendAt}`);
+    }
+    if (corrupted) {
+      parts.push(`${stats.corruptedLines} corrupted line(s) skipped`);
+    }
+    return {
+      key: "tombstones",
+      status: corrupted ? "warn" : "ok",
+      summary: `Tombstone invariant enabled. ${parts.join(", ")}. ` + (corrupted ? "Run `remnic doctor --rebuild-tombstones` to repair the log." : "Re-observation of retired facts is blocked at the storage chokepoint."),
+      remediation: corrupted ? "Rebuild the tombstone log from retired memories on disk." : void 0,
+      details: {
+        enabled: true,
+        count: stats.count,
+        revoked: stats.revoked,
+        lastAppendAt: stats.lastAppendAt,
+        corruptedLines: stats.corruptedLines,
+        loaded: stats.loaded
+      }
+    };
+  } catch (err) {
+    return {
+      key: "tombstones",
+      status: "warn",
+      summary: "Could not read tombstone store stats.",
+      remediation: "Ensure the memory state directory is readable and rerun `remnic doctor`.",
+      details: { error: String(err) }
+    };
+  }
+}
+async function summarizeConsolidationProvenance(storage, config) {
+  let report;
+  try {
+    report = await runConsolidationProvenanceCheck({
+      storage,
+      memoryDir: config.memoryDir,
+      // Honor the configured sidecar directory (PR #634 review): when an
+      // operator overrides `versioningSidecarDir`, the default `.versions`
+      // would point at the wrong location and every entry would report as
+      // missing.  Undefined falls back to the helper's default.
+      sidecarDir: config.versioningSidecarDir
+    });
+  } catch (err) {
+    return {
+      key: "consolidation_provenance",
+      status: "warn",
+      summary: "Could not run consolidation-provenance integrity check.",
+      remediation: "Ensure the memory directory is readable and rerun `remnic doctor`.",
+      details: { error: String(err) }
+    };
+  }
+  if (report.issues.length === 0) {
+    return {
+      key: "consolidation_provenance",
+      status: "ok",
+      summary: report.withProvenance === 0 ? "No consolidation-provenance memories on disk yet." : `${report.withProvenance} consolidation-provenance memories verified (no broken references).`,
+      details: report
+    };
+  }
+  return {
+    key: "consolidation_provenance",
+    status: "warn",
+    summary: `${report.issues.length} consolidation-provenance integrity issue(s) detected across ${report.withProvenance} memories with provenance frontmatter.`,
+    remediation: "Broken pointers are informational. Inspect flagged memories, and if they should resolve, re-snapshot via a consolidation pass or accept pruning.",
+    details: report
+  };
+}
+function getMemoryAgeBand(memory, now) {
+  const created = Date.parse(memory.frontmatter.created ?? "");
+  if (!Number.isFinite(created)) return "unknown";
+  const ageDays = Math.max(0, Math.floor((now.getTime() - created) / 864e5));
+  if (ageDays < 7) return "0_6d";
+  if (ageDays < 30) return "7_29d";
+  if (ageDays < 90) return "30_89d";
+  return "90d_plus";
+}
+async function dirSize(targetPath) {
+  try {
+    const info = await stat(targetPath);
+    if (info.isFile()) return info.size;
+    if (!info.isDirectory()) return 0;
+  } catch {
+    return 0;
+  }
+  let total = 0;
+  let entries;
+  try {
+    entries = await readdir(targetPath, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    total += await dirSize(path.join(targetPath, entry.name));
+  }
+  return total;
+}
+async function summarizeStorageFootprint(memoryDir) {
+  const topLevel = [
+    "facts",
+    "entities",
+    "questions",
+    "corrections",
+    "artifacts",
+    "state",
+    "identity",
+    "namespaces",
+    "summaries",
+    "profile.md"
+  ];
+  const byTopLevel = {};
+  let bytes = 0;
+  for (const name of topLevel) {
+    const size = await dirSize(path.join(memoryDir, name));
+    if (size > 0) {
+      byTopLevel[name] = size;
+      bytes += size;
+    }
+  }
+  return { bytes, byTopLevel };
+}
+async function runOperatorInventory(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const config = options.orchestrator.config;
+  const namespaceEntries = await listNamespaces({ config });
+  const uniqueRootEntries = /* @__PURE__ */ new Map();
+  for (const entry of namespaceEntries) {
+    if (!uniqueRootEntries.has(entry.rootDir)) {
+      uniqueRootEntries.set(entry.rootDir, { namespace: entry.namespace, rootDir: entry.rootDir });
+    }
+  }
+  const categories = {};
+  const statuses = {};
+  const ageBands = {
+    "0_6d": 0,
+    "7_29d": 0,
+    "30_89d": 0,
+    "90d_plus": 0,
+    unknown: 0
+  };
+  const namespaces = [];
+  let totalMemories = 0;
+  let totalEntities = 0;
+  let archived = 0;
+  let pendingReview = 0;
+  let quarantined = 0;
+  let rejected = 0;
+  for (const entry of uniqueRootEntries.values()) {
+    const storage = new StorageManager(entry.rootDir, void 0, false);
+    const memories = await storage.readAllMemories();
+    const entities = await storage.readAllEntityFiles();
+    namespaces.push({
+      namespace: entry.namespace,
+      memoryCount: memories.length,
+      entityCount: entities.length
+    });
+    totalMemories += memories.length;
+    totalEntities += entities.length;
+    for (const memory of memories) {
+      const category = memory.frontmatter.category;
+      categories[category] = (categories[category] ?? 0) + 1;
+      const status = memory.frontmatter.status ?? "active";
+      statuses[status] = (statuses[status] ?? 0) + 1;
+      ageBands[getMemoryAgeBand(memory, now)] += 1;
+      if (status === "archived") archived += 1;
+      if (status === "pending_review") pendingReview += 1;
+      if (status === "quarantined") quarantined += 1;
+      if (status === "rejected") rejected += 1;
+    }
+  }
+  const defaultStorage = new StorageManager(config.memoryDir);
+  const profile = await defaultStorage.readProfile();
+  const footprint = await summarizeStorageFootprint(config.memoryDir);
+  const reviewRunId = (await listMemoryGovernanceRuns(config.memoryDir))[0];
+  let reviewQueue = 0;
+  if (reviewRunId) {
+    try {
+      reviewQueue = (await readMemoryGovernanceRunArtifact(config.memoryDir, reviewRunId)).reviewQueue.length;
+    } catch {
+      reviewQueue = 0;
+    }
+  }
+  const conversationIndex = await options.orchestrator.conversationIndexCoordinator.getHealth();
+  const nativeKnowledgeStatus = await summarizeNativeKnowledgeStatus(config);
+  return {
+    schemaVersion: 1,
+    generatedAt: now.toISOString(),
+    memoryDir: config.memoryDir,
+    totals: {
+      memories: totalMemories,
+      entities: totalEntities,
+      namespaces: namespaceEntries.length,
+      reviewQueue,
+      storageBytes: footprint.bytes
+    },
+    categories,
+    statuses,
+    namespaces,
+    ageBands,
+    profile: {
+      exists: profile.length > 0,
+      chars: profile.length,
+      lines: profile.length > 0 ? profile.split("\n").length : 0
+    },
+    storageFootprint: footprint,
+    archivePressure: {
+      archived,
+      pendingReview,
+      quarantined,
+      rejected
+    },
+    conversationIndex: {
+      enabled: conversationIndex.enabled,
+      backend: conversationIndex.backend,
+      status: conversationIndex.status,
+      chunkDocCount: conversationIndex.chunkDocCount,
+      lastUpdateAt: conversationIndex.lastUpdateAt
+    },
+    nativeKnowledge: {
+      enabled: nativeKnowledgeStatus.enabled,
+      curatedIncludeSync: nativeKnowledgeStatus.curatedIncludeSync,
+      obsidianSync: nativeKnowledgeStatus.obsidianSync,
+      openclawWorkspaceSync: nativeKnowledgeStatus.openclawWorkspaceSync
+    }
+  };
+}
+async function runBenchmarkRecall(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const status = await getEvalHarnessStatus({
+    memoryDir: options.config.memoryDir,
+    evalStoreDir: options.config.evalStoreDir,
+    enabled: resolveEvalCapabilities(options.config).evalHarness,
+    shadowModeEnabled: resolveEvalCapabilities(options.config).evalShadowMode,
+    baselineSnapshotsEnabled: resolveEvalCapabilities(options.config).benchmarkBaselineSnapshots,
+    memoryRedTeamBenchEnabled: resolveEvalCapabilities(options.config).memoryRedTeamBench
+  });
+  if (options.createSnapshot && options.snapshotId) {
+    const snapshot = await createEvalBaselineSnapshot({
+      memoryDir: options.config.memoryDir,
+      evalStoreDir: options.config.evalStoreDir,
+      baselineSnapshotsEnabled: resolveEvalCapabilities(options.config).benchmarkBaselineSnapshots,
+      snapshotId: options.snapshotId,
+      notes: options.snapshotNotes,
+      gitRef: options.gitRef,
+      createdAt: options.createdAt
+    });
+    return {
+      schemaVersion: 1,
+      generatedAt: now.toISOString(),
+      mode: "snapshot",
+      status,
+      snapshot: {
+        targetPath: snapshot.targetPath,
+        snapshotId: snapshot.snapshot.snapshotId
+      }
+    };
+  }
+  if (options.baseEvalStoreDir && options.candidateEvalStoreDir) {
+    const ciGate = await runEvalBenchmarkCiGate({
+      baseEvalStoreDir: options.baseEvalStoreDir,
+      candidateEvalStoreDir: options.candidateEvalStoreDir
+    });
+    return {
+      schemaVersion: 1,
+      generatedAt: now.toISOString(),
+      mode: "ci-gate",
+      status,
+      ciGate
+    };
+  }
+  if (options.snapshotId) {
+    const baselineReport = await runEvalBaselineDeltaReport({
+      memoryDir: options.config.memoryDir,
+      evalStoreDir: options.config.evalStoreDir,
+      benchmarkDeltaReporterEnabled: resolveEvalCapabilities(options.config).benchmarkDeltaReporter,
+      snapshotId: options.snapshotId
+    });
+    return {
+      schemaVersion: 1,
+      generatedAt: now.toISOString(),
+      mode: "baseline-report",
+      status,
+      baselineReport
+    };
+  }
+  if (options.validatePath) {
+    const validate = await validateEvalBenchmarkPack(options.validatePath, {
+      memoryRedTeamBenchEnabled: resolveEvalCapabilities(options.config).memoryRedTeamBench
+    });
+    return {
+      schemaVersion: 1,
+      generatedAt: now.toISOString(),
+      mode: "validate",
+      status,
+      validate
+    };
+  }
+  return {
+    schemaVersion: 1,
+    generatedAt: now.toISOString(),
+    mode: "status",
+    status
+  };
+}
+async function runOperatorRepair(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const dryRun = options.dryRun === true || options.apply !== true;
+  const sessionCheck = await analyzeSessionIntegrity({ memoryDir: options.config.memoryDir });
+  const sessionRepairPlan = planSessionRepair({
+    report: sessionCheck,
+    dryRun,
+    allowSessionFileRepair: options.allowSessionFileRepair,
+    sessionFilesDir: options.sessionFilesDir
+  });
+  const sessionRepairApply = await applySessionRepair({
+    plan: sessionRepairPlan
+  });
+  const graphCaps = resolveGraphConstructionCapabilities(options.config);
+  const graphHealth = await analyzeGraphHealth(options.config.memoryDir, {
+    entityGraphEnabled: graphCaps.entityGraph,
+    timeGraphEnabled: graphCaps.timeGraph,
+    causalGraphEnabled: graphCaps.causalGraph,
+    includeRepairGuidance: true
+  });
+  return {
+    schemaVersion: 1,
+    generatedAt: now.toISOString(),
+    dryRun,
+    sessionCheck,
+    sessionRepairPlan,
+    sessionRepairApply,
+    graphHealth
+  };
+}
+
+export {
+  runNamespaceMaintenanceFanout,
+  summarizeNamespaceMaintenanceHealth,
+  formatNamespaceMaintenanceHealthText,
+  runOperatorSetup,
+  runOperatorConfigReview,
+  summarizeProvenanceCoverage,
+  summarizeProjectionHealth,
+  runOperatorDoctor,
+  summarizeMemoryWorthLegacyCounters,
+  summarizeBufferSurpriseDistribution,
+  summarizeTierDistribution,
+  summarizeDreamsPhases,
+  summarizeObservationThroughput,
+  summarizeTombstoneStatus,
+  summarizeConsolidationProvenance,
+  runOperatorInventory,
+  runBenchmarkRecall,
+  runOperatorRepair
+};
+//# sourceMappingURL=chunk-B7SSU55V.js.map