@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/chunk-4VASFLUW.js

@@ -0,0 +1,35 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+
+// packages/cleo/src/dispatch/registry.ts
+import {
+  deriveGatewayMatrix,
+  getActiveDomains,
+  getByDomain,
+  getByGateway,
+  getByTier,
+  getCounts,
+  getGatewayDomains,
+  OPERATIONS,
+  resolve,
+  validateRequiredParams
+} from "@cleocode/runtime/gateway/dispatch";
+
+export {
+  OPERATIONS,
+  resolve
+};
+//# sourceMappingURL=chunk-4VASFLUW.js.map

package/dist/cli/chunk-5PNI276X.js

@@ -0,0 +1,124 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/llm-cost.ts
+import { getProjectRoot } from "@cleocode/core/internal";
+import { computeCost } from "@cleocode/core/llm/usage-pricing";
+function resolveSessionId(raw) {
+  if (raw === "current") {
+    const envId = process.env["CLEO_SESSION_ID"];
+    if (envId) return envId;
+    return "current";
+  }
+  return raw;
+}
+async function loadSessionCostBreakdown(projectRoot, sessionId) {
+  const { listTokenUsage } = await import(
+    /* webpackIgnore: true */
+    "@cleocode/core/internal"
+  );
+  const result = await listTokenUsage(projectRoot, {
+    sessionId,
+    limit: 1e3
+    // Practical upper bound for a single session.
+  });
+  const entries = result.records.map(
+    (row) => {
+      const usage = {
+        inputTokens: row.inputTokens,
+        outputTokens: row.outputTokens
+      };
+      const model = row.model ?? "unknown";
+      return {
+        id: row.id,
+        provider: row.provider,
+        model: row.model,
+        usage,
+        costUsd: computeCost(usage, model),
+        createdAt: row.createdAt
+      };
+    }
+  );
+  entries.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return entries;
+}
+var costCommand = defineCommand({
+  meta: {
+    name: "cost",
+    description: 'Compute cumulative USD cost for an LLM session from recorded token_usage entries. Use "current" to resolve the active session from CLEO_SESSION_ID. Returns totalUsd=0 when no usage records exist yet (ADR-072 Wave 4b pending).'
+  },
+  args: {
+    sessionId: {
+      type: "positional",
+      description: 'Session id to query, or "current" for the active session',
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    const rawSessionId = String(a["sessionId"] ?? "");
+    if (!rawSessionId) {
+      cliError("session-id is required", 6, {
+        name: "E_VALIDATION",
+        fix: 'Provide a session id or "current": cleo llm cost <session-id>'
+      });
+      process.exit(6);
+    }
+    const sessionId = resolveSessionId(rawSessionId);
+    const projectRoot = getProjectRoot(process.cwd());
+    let breakdown;
+    try {
+      breakdown = await loadSessionCostBreakdown(projectRoot, sessionId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Failed to query token_usage: ${message}`, 1, {
+        name: "E_QUERY_FAILED",
+        fix: "Ensure tasks.db is initialized: cleo session start"
+      });
+      process.exit(1);
+    }
+    const totalUsd = breakdown.reduce((sum, entry) => sum + entry.costUsd, 0);
+    const result = {
+      sessionId,
+      totalUsd,
+      recordCount: breakdown.length,
+      breakdown
+    };
+    if (breakdown.length === 0) {
+      result.note = "No token_usage records found for this session. Live usage wiring is pending ADR-072 Wave 4b (LlmExecutor done event). Records will appear automatically once that wave ships.";
+    }
+    cliOutput(result, {
+      command: "llm-cost",
+      operation: "llm.cost"
+    });
+  }
+});
+
+export {
+  costCommand
+};
+//# sourceMappingURL=chunk-5PNI276X.js.map

package/dist/cli/chunk-6JSJNYH2.js

@@ -0,0 +1,114 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+
+// packages/cleo/src/cli/field-context.ts
+import {
+  resolveFieldExtraction
+} from "@cleocode/lafs";
+var currentContext = {
+  mvi: "minimal",
+  mviSource: "default",
+  expectsCustomMvi: false
+};
+function setFieldContext(ctx) {
+  currentContext = ctx;
+}
+function getFieldContext() {
+  return currentContext;
+}
+function resolveFieldContext(opts) {
+  const input = {
+    fieldFlag: typeof opts["field"] === "string" ? opts["field"] : void 0,
+    fieldsFlag: typeof opts["fields"] === "string" ? opts["fields"] : void 0,
+    mviFlag: typeof opts["mvi"] === "string" ? opts["mvi"] : void 0
+  };
+  return resolveFieldExtraction(input);
+}
+async function withoutOutputPointer(step) {
+  const saved = currentContext;
+  const { field: _field, ...rest } = saved;
+  currentContext = rest;
+  try {
+    return await step();
+  } finally {
+    currentContext = saved;
+  }
+}
+
+// packages/cleo/src/cli/format-context.ts
+var currentResolution = {
+  format: "json",
+  source: "default",
+  quiet: false
+};
+function setFormatContext(resolution) {
+  currentResolution = resolution;
+}
+function getFormatContext() {
+  return currentResolution;
+}
+function isJsonFormat() {
+  return currentResolution.format === "json";
+}
+function isQuiet() {
+  return currentResolution.quiet;
+}
+
+// packages/cleo/src/cli/output-context.ts
+var OUTPUT_MODES = ["envelope", "id", "table", "count", "silent"];
+var OUTPUT_MODE_ALIASES = {
+  json: "envelope"
+};
+function resolveOutputMode(value) {
+  if (isOutputMode(value)) return value;
+  return OUTPUT_MODE_ALIASES[value];
+}
+var currentMode = "envelope";
+function setOutputMode(mode) {
+  currentMode = mode;
+}
+function getOutputMode() {
+  return currentMode;
+}
+function isOutputMode(value) {
+  return OUTPUT_MODES.includes(value);
+}
+
+// packages/cleo/src/cli/summary-context.ts
+var currentSummary = false;
+function setSummaryMode(on) {
+  currentSummary = on;
+}
+function getSummaryMode() {
+  return currentSummary;
+}
+
+export {
+  setFieldContext,
+  getFieldContext,
+  resolveFieldContext,
+  withoutOutputPointer,
+  setFormatContext,
+  getFormatContext,
+  isJsonFormat,
+  isQuiet,
+  resolveOutputMode,
+  setOutputMode,
+  getOutputMode,
+  setSummaryMode,
+  getSummaryMode
+};
+//# sourceMappingURL=chunk-6JSJNYH2.js.map

package/dist/cli/chunk-6N6WGLXE.js

@@ -0,0 +1,63 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+
+// packages/cleo/src/cli/paths.ts
+import {
+  BRAIN_DB_FILENAME,
+  CLEO_DIR_NAME,
+  WORKFLOWS_SUBDIR
+} from "@cleocode/runtime/gateway/dispatch";
+var AGENTS_SUBDIR = "agents";
+var CANT_AGENTS_SUBDIR = "cant/agents";
+var TEMPLATES_SUBDIR = "templates";
+var RESTORE_IMPORTED_SUBDIR = "restore-imported";
+var TASKS_DB_FILENAME = "tasks.db";
+var CONDUIT_DB_FILENAME = "conduit.db";
+var NEXUS_DB_FILENAME = "nexus.db";
+var SIGNALDOCK_DB_FILENAME = "signaldock.db";
+var CONFIG_JSON = "config.json";
+var PROJECT_INFO_JSON = "project-info.json";
+var PROJECT_CONTEXT_JSON = "project-context.json";
+var RESTORE_CONFLICTS_MD = "restore-conflicts.md";
+var MIGRATE_MEMORY_HASHES_JSON = "migrate-memory-hashes.json";
+var CLEO_INJECTION_MD = "CLEO-INJECTION.md";
+var CLI_PROJECT_BACKUP_FILES = [
+  `${CLEO_DIR_NAME}/${TASKS_DB_FILENAME}`,
+  `${CLEO_DIR_NAME}/${BRAIN_DB_FILENAME}`,
+  `${CLEO_DIR_NAME}/${CONDUIT_DB_FILENAME}`,
+  `${CLEO_DIR_NAME}/${CONFIG_JSON}`,
+  `${CLEO_DIR_NAME}/${PROJECT_INFO_JSON}`,
+  `${CLEO_DIR_NAME}/${PROJECT_CONTEXT_JSON}`
+];
+var CLI_GLOBAL_BACKUP_FILES = [NEXUS_DB_FILENAME, SIGNALDOCK_DB_FILENAME];
+var RESTORE_DEFAULT_FILE = TASKS_DB_FILENAME;
+
+export {
+  CLEO_DIR_NAME,
+  AGENTS_SUBDIR,
+  CANT_AGENTS_SUBDIR,
+  TEMPLATES_SUBDIR,
+  RESTORE_IMPORTED_SUBDIR,
+  CONFIG_JSON,
+  PROJECT_INFO_JSON,
+  RESTORE_CONFLICTS_MD,
+  MIGRATE_MEMORY_HASHES_JSON,
+  CLEO_INJECTION_MD,
+  CLI_PROJECT_BACKUP_FILES,
+  CLI_GLOBAL_BACKUP_FILES,
+  RESTORE_DEFAULT_FILE
+};
+//# sourceMappingURL=chunk-6N6WGLXE.js.map

package/dist/cli/chunk-75UH3BLS.js

@@ -0,0 +1,210 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-db-substrate.ts
+import { dirname } from "node:path";
+import { surveyDbSubstrate, surveyFleetDbSubstrate } from "@cleocode/core/doctor/db-substrate.js";
+import { NexusRegistryReadError } from "@cleocode/core/nexus/registry-errors.js";
+import { listRegistryParentRoots } from "@cleocode/core/nexus/registry-roots.js";
+import { pushWarning } from "@cleocode/core/output";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+async function defaultFleetRoots() {
+  const roots = await listRegistryParentRoots();
+  return roots.length > 0 ? roots : [dirname(getProjectRoot())];
+}
+function reportRegistryReadError(error) {
+  cliError(
+    error.message,
+    error.code,
+    {
+      name: error.codeName,
+      fix: `Pass \`--fleet-root <dir>\` to survey without the registry. ${error.fix ?? ""}`.trim(),
+      details: error.details
+    },
+    { operation: "doctor.db-substrate.run" }
+  );
+  process.exitCode = error.code;
+}
+function pushSubstrateWarnings(result) {
+  for (const warning of result.warnings) {
+    const context = {
+      kind: warning.kind,
+      path: warning.path,
+      lastWriteMs: warning.lastWriteMs
+    };
+    if (warning.kind === "orphan-project-root") {
+      context["parentWorkspace"] = warning.parentWorkspace ?? null;
+    }
+    pushWarning({
+      code: warning.kind === "orphan-project-root" ? "W_DB_SUBSTRATE_ORPHAN_PROJECT_ROOT" : "W_DB_SUBSTRATE_NESTED_NEXUS_DUPLICATE",
+      message: warning.kind === "orphan-project-root" ? `Orphan project-root .cleo/ at ${warning.path} (T9550 regression class \u2014 review then remove)` + (warning.parentWorkspace ? ` \u2014 attributed to workspace: ${warning.parentWorkspace}` : "") : `Nested-nexus duplicate at ${warning.path} (structural duplicate of the canonical flat layout)`,
+      severity: "warn",
+      context
+    });
+  }
+  for (const projectSurvey of result.projects) {
+    for (const [role, entry] of Object.entries(projectSurvey.dbs)) {
+      if (entry.pragmaDrift === null || entry.pragmaDrift.length === 0) continue;
+      for (const drift of entry.pragmaDrift) {
+        pushWarning({
+          code: "W_DB_SUBSTRATE_PRAGMA_DRIFT",
+          message: `Pragma drift on ${role} (${entry.filePath}): expected ${drift.pragma}=${drift.expected}, actual=${drift.actual ?? "<unmeasurable>"}`,
+          severity: "warn",
+          context: {
+            role,
+            filePath: entry.filePath,
+            pragma: drift.pragma,
+            expected: drift.expected,
+            actual: drift.actual
+          }
+        });
+      }
+    }
+  }
+  for (const report of result.crossDbOrphans) {
+    if (report.skipped || report.orphanCount === 0) continue;
+    pushWarning({
+      code: `W_DB_SUBSTRATE_CROSS_DB_${report.invariant}`,
+      message: `${report.invariant}: ${report.orphanCount} orphan row${report.orphanCount === 1 ? "" : "s"} \u2014 ${report.description}. ${report.suggestedFix}`,
+      severity: "warn",
+      context: {
+        invariant: report.invariant,
+        orphanCount: report.orphanCount,
+        sample: report.sample.join(","),
+        suggestedFix: report.suggestedFix
+      }
+    });
+  }
+}
+function pushPerDbWarnings(result) {
+  for (const projectSurvey of result.projects) {
+    for (const [role, dbEntry] of Object.entries(projectSurvey.dbs)) {
+      if (dbEntry.quarantinedTo !== null) {
+        pushWarning({
+          code: "W_DB_SUBSTRATE_AUTO_QUARANTINED",
+          message: `Auto-quarantined corrupt ${role} DB at ${dbEntry.filePath} \u2192 ${dbEntry.quarantinedTo}. Recover via: cleo backup recover ${role}`,
+          severity: "warn",
+          context: {
+            role,
+            filePath: dbEntry.filePath,
+            quarantinedTo: dbEntry.quarantinedTo,
+            integrityCheckMs: dbEntry.integrityCheckMs
+          }
+        });
+      }
+      if (dbEntry.timedOut) {
+        pushWarning({
+          code: "W_DB_SUBSTRATE_INTEGRITY_TIMEOUT",
+          message: `integrity_check on ${role} DB at ${dbEntry.filePath} took ${dbEntry.integrityCheckMs}ms \u2014 slow substrate flagged for operator attention`,
+          severity: "warn",
+          context: {
+            role,
+            filePath: dbEntry.filePath,
+            integrityCheckMs: dbEntry.integrityCheckMs
+          }
+        });
+      }
+    }
+  }
+}
+var doctorDbSubstrateCommand = defineCommand({
+  meta: {
+    name: "db-substrate",
+    description: "Walk every DB in the inventory + report integrity, row counts, orphan dirs. Use --fleet for a multi-project survey under --fleet-root (default: parent dirs of registered projects)."
+  },
+  args: {
+    fleet: {
+      type: "boolean",
+      description: "Multi-project survey \u2014 walk every .cleo/-bearing subdir under --fleet-root"
+    },
+    "fleet-root": {
+      type: "string",
+      description: "Fleet root path (default: parent directories of registered projects). Only used with --fleet."
+    },
+    "integrity-timeout-ms": {
+      type: "string",
+      description: "Wall-clock budget for each PRAGMA integrity_check call (ms; default 60000; 0 disables)."
+    },
+    "no-quarantine": {
+      type: "boolean",
+      description: "Disable auto-quarantine of corrupt DBs (leaves them in place; report-only mode)."
+    },
+    "confirm-owner-store": {
+      type: "boolean",
+      description: "From inside a git worktree: allow quarantining the owning project's LIVE store (skipped without it)",
+      default: false
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const isFleet = args.fleet === true;
+    let parsedTimeoutMs;
+    if (typeof args["integrity-timeout-ms"] === "string" && args["integrity-timeout-ms"].length > 0) {
+      const n = Number.parseInt(args["integrity-timeout-ms"], 10);
+      if (Number.isFinite(n) && n >= 0) {
+        parsedTimeoutMs = n;
+      }
+    }
+    const options = {
+      ...parsedTimeoutMs !== void 0 ? { integrityCheckTimeoutMs: parsedTimeoutMs } : {},
+      autoQuarantine: !negatedFlag(args, "quarantine"),
+      // T12708: the invocation directory; the quarantine guard checks it.
+      cwd: process.cwd(),
+      confirmOwnerStore: args["confirm-owner-store"] === true
+    };
+    let fleetRoots;
+    if (isFleet) {
+      if (typeof args["fleet-root"] === "string" && args["fleet-root"].length > 0) {
+        fleetRoots = args["fleet-root"];
+      } else {
+        try {
+          fleetRoots = await defaultFleetRoots();
+        } catch (error) {
+          if (!(error instanceof NexusRegistryReadError)) throw error;
+          reportRegistryReadError(error);
+          return;
+        }
+      }
+    }
+    const result = fleetRoots !== void 0 ? surveyFleetDbSubstrate(fleetRoots, options) : surveyDbSubstrate(getProjectRoot(), options);
+    pushSubstrateWarnings(result);
+    pushPerDbWarnings(result);
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.db-substrate.run"
+    });
+    if (result.summary.corrupt > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 2;
+    }
+  }
+});
+
+export {
+  doctorDbSubstrateCommand
+};
+//# sourceMappingURL=chunk-75UH3BLS.js.map

package/dist/cli/chunk-7ACK4EIN.js

@@ -0,0 +1,92 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-split-brain.ts
+import { writeFileSync } from "node:fs";
+import {
+  importSplitBrain,
+  verifyPreexistingRows
+} from "@cleocode/core/store/split-brain-import.js";
+var doctorSplitBrainCommand = defineCommand({
+  meta: {
+    name: "split-brain",
+    description: "Import rows that exist only in a diverged copy of a store (--source) into another (--target) under new task ids, with provenance. Dry-run unless --apply; --verify-before <snapshot> proves no pre-existing target row changed."
+  },
+  args: {
+    source: {
+      type: "string",
+      description: "Store with the extra rows (opened read-only)",
+      required: true
+    },
+    target: { type: "string", description: "Store that receives them", required: true },
+    apply: { type: "boolean", description: "Write the target (default: dry run)" },
+    label: { type: "string", description: "Provenance label for the source (default: its path)" },
+    "diverged-after": {
+      type: "string",
+      description: "Override the detected divergence point (ISO 8601)"
+    },
+    receipt: { type: "string", description: "Also write the receipt JSON to this file" },
+    task: {
+      type: "string",
+      description: "Task that records provenance of imported non-task rows (required with --apply when there are any)"
+    },
+    "verify-before": {
+      type: "string",
+      description: "Pre-import snapshot of the target; verify every one of its rows is unchanged"
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const report = importSplitBrain({
+      sourcePath: String(args.source),
+      targetPath: String(args.target),
+      dryRun: !args.apply,
+      sourceLabel: args.label ? String(args.label) : void 0,
+      divergedAfter: args["diverged-after"] ? String(args["diverged-after"]) : void 0,
+      provenanceTaskId: args.task ? String(args.task) : void 0
+    });
+    const verification = args["verify-before"] ? verifyPreexistingRows(String(args["verify-before"]), String(args.target)) : void 0;
+    const changed = verification?.filter((check) => check.missingOrChanged > 0) ?? [];
+    const result = {
+      ...report,
+      ...verification && {
+        verification: {
+          tablesChecked: verification.length,
+          rowsBefore: verification.reduce((sum, check) => sum + check.before, 0),
+          rowsAfter: verification.reduce((sum, check) => sum + check.after, 0),
+          missingOrChanged: changed
+        }
+      }
+    };
+    if (args.receipt) writeFileSync(String(args.receipt), `${JSON.stringify(result, null, 2)}
+`);
+    cliOutput(result, { command: "doctor", operation: "doctor.split-brain.run" });
+    if (changed.length > 0 && (process.exitCode ?? 0) === 0) process.exitCode = 1;
+  }
+});
+
+export {
+  doctorSplitBrainCommand
+};
+//# sourceMappingURL=chunk-7ACK4EIN.js.map