@remnic/core 1.0.0

package/dist/chunk-QDOSNLB4.js

@@ -0,0 +1,1048 @@
+import {
+  NamespaceStorageRouter,
+  namespaceCollectionName
+} from "./chunk-IZME7KW2.js";
+import {
+  analyzeSessionIntegrity,
+  applySessionRepair,
+  planSessionRepair
+} from "./chunk-YRMVARQP.js";
+import {
+  resolveCuratedIncludeFilesStatePath,
+  resolveNativeKnowledgeStatePath,
+  resolveOpenClawWorkspaceStatePath
+} from "./chunk-Q6FETXJA.js";
+import {
+  createEvalBaselineSnapshot,
+  getEvalHarnessStatus,
+  runEvalBaselineDeltaReport,
+  runEvalBenchmarkCiGate,
+  validateEvalBenchmarkPack
+} from "./chunk-K6WK37A6.js";
+import {
+  analyzeGraphHealth
+} from "./chunk-SCHEKPYH.js";
+import {
+  parseConfig
+} from "./chunk-ISY75RLM.js";
+import {
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-MARWOCVP.js";
+import {
+  listMemoryGovernanceRuns,
+  readMemoryGovernanceRunArtifact
+} from "./chunk-J3BT33K7.js";
+import {
+  StorageManager
+} from "./chunk-QWUUMMIK.js";
+import {
+  lintWorkspaceFiles
+} from "./chunk-DM2T26WE.js";
+import {
+  isSafeRouteNamespace
+} from "./chunk-HLXVTBF3.js";
+
+// src/operator-toolkit.ts
+import path2 from "path";
+import { constants as fsConstants } from "fs";
+import { access as access2, mkdir as mkdir2, readFile, readdir as readdir2, stat, unlink, writeFile } from "fs/promises";
+
+// src/namespaces/migrate.ts
+import path from "path";
+import { access, mkdir, readdir, rename } from "fs/promises";
+var LEGACY_NAMESPACE_CHILDREN = [
+  "facts",
+  "corrections",
+  "entities",
+  "questions",
+  "artifacts",
+  "identity",
+  "state",
+  "config",
+  "summaries",
+  "profile.md"
+];
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasAnyLegacyData(rootDir) {
+  for (const child of LEGACY_NAMESPACE_CHILDREN) {
+    if (await exists(path.join(rootDir, child))) return true;
+  }
+  return false;
+}
+async function discoverConfiguredNamespaces(config) {
+  const discovered = /* @__PURE__ */ new Set([
+    config.defaultNamespace,
+    config.sharedNamespace,
+    ...config.namespacePolicies.map((policy) => policy.name)
+  ]);
+  const namespacesDir = path.join(config.memoryDir, "namespaces");
+  try {
+    const entries = await readdir(namespacesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && isSafeRouteNamespace(entry.name)) {
+        discovered.add(entry.name);
+      }
+    }
+  } catch {
+  }
+  return [...discovered];
+}
+async function listNamespaces(options) {
+  const storageRouter = options.storageRouter ?? new NamespaceStorageRouter(options.config);
+  const namespaces = await discoverConfiguredNamespaces(options.config);
+  const items = await Promise.all(
+    namespaces.map(async (namespace) => {
+      const storage = await storageRouter.storageFor(namespace);
+      const usesLegacyRoot = namespace === options.config.defaultNamespace && storage.dir === options.config.memoryDir;
+      return {
+        namespace,
+        rootDir: storage.dir,
+        exists: await exists(storage.dir),
+        usesLegacyRoot,
+        hasMemoryData: await hasAnyLegacyData(storage.dir),
+        collection: namespaceCollectionName(options.config.qmdCollection, namespace, {
+          defaultNamespace: options.config.defaultNamespace,
+          useLegacyDefaultCollection: usesLegacyRoot
+        })
+      };
+    })
+  );
+  return items.sort((a, b) => a.namespace.localeCompare(b.namespace));
+}
+async function verifyNamespaces(options) {
+  const namespaces = await listNamespaces(options);
+  const problems = [];
+  for (const entry of namespaces) {
+    if (entry.exists && !entry.hasMemoryData) {
+      problems.push(`${entry.namespace}: root exists but contains no Engram data`);
+    }
+  }
+  return {
+    ok: problems.length === 0,
+    problems,
+    namespaces
+  };
+}
+async function runNamespaceMigration(options) {
+  if (!options.config.namespacesEnabled) {
+    throw new Error("Namespaces are disabled.");
+  }
+  const targetNamespace = options.to.trim();
+  if (!isSafeRouteNamespace(targetNamespace)) {
+    throw new Error(`Invalid namespace: ${options.to}`);
+  }
+  const targetRoot = path.join(options.config.memoryDir, "namespaces", targetNamespace);
+  const moved = [];
+  for (const child of LEGACY_NAMESPACE_CHILDREN) {
+    const from = path.join(options.config.memoryDir, child);
+    if (!await exists(from)) continue;
+    const to = path.join(targetRoot, child);
+    if (await exists(to)) {
+      throw new Error(`Target already contains ${child}: ${to}`);
+    }
+    moved.push({ from, to });
+  }
+  if (!options.dryRun && moved.length > 0) {
+    await mkdir(targetRoot, { recursive: true });
+    for (const move of moved) {
+      await rename(move.from, move.to);
+    }
+  }
+  return {
+    dryRun: options.dryRun === true,
+    fromRoot: options.config.memoryDir,
+    targetRoot,
+    moved,
+    collection: namespaceCollectionName(options.config.qmdCollection, targetNamespace, {
+      defaultNamespace: options.config.defaultNamespace,
+      useLegacyDefaultCollection: false
+    })
+  };
+}
+
+// src/operator-toolkit.ts
+function resolveConfigPath(explicitPath) {
+  if (explicitPath && explicitPath.trim().length > 0) return explicitPath.trim();
+  const configured = readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH") || readEnvVar("OPENCLAW_CONFIG_PATH");
+  if (configured && configured.trim().length > 0) return configured.trim();
+  return path2.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+}
+async function loadCliPluginConfig(configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  try {
+    const raw = JSON.parse(await readFile(resolvedPath, "utf-8"));
+    const pluginEntry = raw?.plugins && typeof raw.plugins === "object" ? raw.plugins.entries : void 0;
+    const config = pluginEntry && typeof pluginEntry === "object" ? pluginEntry["openclaw-engram"] : void 0;
+    const parsedConfig = parseConfig(
+      config && typeof config === "object" ? config.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 access2(targetPath, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathExists(targetPath) {
+  try {
+    await access2(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 access2(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,
+    path2.join(config.memoryDir, "facts"),
+    path2.join(config.memoryDir, "entities"),
+    path2.join(config.memoryDir, "state"),
+    path2.join(config.memoryDir, "questions"),
+    path2.join(config.memoryDir, "artifacts"),
+    path2.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) : path2.join(config.memoryDir, nativeKnowledgeStateDir, "curated-include-sync.json");
+  const obsidianStatePath = nativeKnowledge ? resolveNativeKnowledgeStatePath(config.memoryDir, nativeKnowledge) : path2.join(config.memoryDir, nativeKnowledgeStateDir, "obsidian-sync.json");
+  const openclawStatePath = nativeKnowledge ? resolveOpenClawWorkspaceStatePath(config.memoryDir, nativeKnowledge) : path2.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 = new StorageManager(options.orchestrator.config.memoryDir);
+  await storage.ensureDirectories();
+  await mkdir2(options.orchestrator.config.workspaceDir, { recursive: true });
+  const qmdAvailable = await options.orchestrator.qmd.probe();
+  const collectionState = options.orchestrator.config.qmdEnabled ? await options.orchestrator.qmd.ensureCollection(options.orchestrator.config.memoryDir) : "skipped";
+  const nativeKnowledgeStatus = await summarizeNativeKnowledgeStatus(options.orchestrator.config);
+  const memoryDocPath = path2.join(options.orchestrator.config.workspaceDir, "MEMORY.md");
+  const captureInstructionsMode = options.captureInstructionsMode ?? (options.installCaptureInstructions ? "install" : void 0);
+  let memoryDocExists = false;
+  try {
+    await access2(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: options.orchestrator.config.qmdEnabled,
+      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 findings = [];
+  const searchBackend = config.searchBackend ?? "qmd";
+  const workspaceBootstrapFiles = [
+    path2.join(config.workspaceDir, "IDENTITY.md"),
+    path2.join(config.workspaceDir, "MEMORY.md"),
+    path2.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" && config.queryAwareIndexingEnabled === false && config.verbatimArtifactsEnabled === false && config.rerankEnabled === false) {
+    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 (config.qmdEnabled && config.qmdDaemonEnabled === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_daemon",
+      status: "recommend",
+      setting: "qmdDaemonEnabled",
+      currentValue: config.qmdDaemonEnabled,
+      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" && config.qmdEnabled === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_search_backend_disabled",
+      status: "problem",
+      setting: "qmdEnabled",
+      currentValue: config.qmdEnabled,
+      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 (config.qmdColdTierEnabled === true && config.qmdEnabled === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_cold_tier_requires_qmd",
+      status: "problem",
+      setting: "qmdEnabled",
+      currentValue: config.qmdEnabled,
+      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 (config.qmdTierMigrationEnabled && config.qmdColdTierEnabled !== true) {
+    findings.push(buildConfigReviewFinding({
+      key: "qmd_tier_migration_requires_cold_tier",
+      status: "problem",
+      setting: "qmdColdTierEnabled",
+      currentValue: config.qmdColdTierEnabled,
+      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 (config.conversationIndexEnabled && config.conversationIndexBackend === "qmd" && config.qmdEnabled === false) {
+    findings.push(buildConfigReviewFinding({
+      key: "conversation_index_qmd_requires_qmd",
+      status: "problem",
+      setting: "qmdEnabled",
+      currentValue: config.qmdEnabled,
+      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: config.qmdEnabled,
+      qmdDaemonEnabled: config.qmdDaemonEnabled,
+      nativeKnowledgeEnabled: config.nativeKnowledge?.enabled === true,
+      fileHygieneEnabled: config.fileHygiene?.enabled === true,
+      conversationIndexEnabled: config.conversationIndexEnabled
+    },
+    summary,
+    findings
+  };
+}
+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 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 = config.qmdEnabled ? await options.orchestrator.qmd.ensureCollection(config.memoryDir) : "skipped";
+  checks.push({
+    key: "qmd",
+    status: !config.qmdEnabled ? "warn" : !qmdAvailable ? "error" : collectionState === "present" ? "ok" : collectionState === "missing" ? "error" : "warn",
+    summary: !config.qmdEnabled ? "QMD is disabled in config." : qmdAvailable ? `QMD is reachable (${collectionState}).` : "QMD is not currently reachable.",
+    remediation: !config.qmdEnabled ? "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.getConversationIndexHealth();
+  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 new StorageManager(config.memoryDir).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 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;
+  checks.push({
+    key: "access_http_auth",
+    status: !agentAccessEnabled ? "warn" : config.agentAccessHttp?.authToken ? "ok" : "error",
+    summary: !agentAccessEnabled ? "Agent access HTTP bridge is disabled." : config.agentAccessHttp?.authToken ? "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." : config.agentAccessHttp?.authToken ? 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));
+  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
+  };
+}
+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 readdir2(targetPath, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    total += await dirSize(path2.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(path2.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);
+    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.getConversationIndexHealth();
+  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: options.config.evalHarnessEnabled,
+    shadowModeEnabled: options.config.evalShadowModeEnabled,
+    baselineSnapshotsEnabled: options.config.benchmarkBaselineSnapshotsEnabled,
+    memoryRedTeamBenchEnabled: options.config.memoryRedTeamBenchEnabled
+  });
+  if (options.createSnapshot && options.snapshotId) {
+    const snapshot = await createEvalBaselineSnapshot({
+      memoryDir: options.config.memoryDir,
+      evalStoreDir: options.config.evalStoreDir,
+      baselineSnapshotsEnabled: options.config.benchmarkBaselineSnapshotsEnabled,
+      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: options.config.benchmarkDeltaReporterEnabled,
+      snapshotId: options.snapshotId
+    });
+    return {
+      schemaVersion: 1,
+      generatedAt: now.toISOString(),
+      mode: "baseline-report",
+      status,
+      baselineReport
+    };
+  }
+  if (options.validatePath) {
+    const validate = await validateEvalBenchmarkPack(options.validatePath, {
+      memoryRedTeamBenchEnabled: options.config.memoryRedTeamBenchEnabled
+    });
+    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 graphHealth = await analyzeGraphHealth(options.config.memoryDir, {
+    entityGraphEnabled: options.config.entityGraphEnabled,
+    timeGraphEnabled: options.config.timeGraphEnabled,
+    causalGraphEnabled: options.config.causalGraphEnabled,
+    includeRepairGuidance: true
+  });
+  return {
+    schemaVersion: 1,
+    generatedAt: now.toISOString(),
+    dryRun,
+    sessionCheck,
+    sessionRepairPlan,
+    sessionRepairApply,
+    graphHealth
+  };
+}
+
+export {
+  listNamespaces,
+  verifyNamespaces,
+  runNamespaceMigration,
+  runOperatorSetup,
+  runOperatorConfigReview,
+  runOperatorDoctor,
+  runOperatorInventory,
+  runBenchmarkRecall,
+  runOperatorRepair
+};
+//# sourceMappingURL=chunk-QDOSNLB4.js.map