@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/doctor-S5KZ2GTN.js

@@ -0,0 +1,1138 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  formatBytes
+} from "./chunk-N24R6KWS.js";
+import "./chunk-ZIDFQJRB.js";
+import {
+  MUX_METHOD_MIN_PROTOCOL,
+  detectMux,
+  resolveSocketCandidates
+} from "./chunk-PXRCXGLK.js";
+import {
+  inspectInstalledNamingResources,
+  inspectModelOverlayNaming,
+  inspectSkillMetadataNaming,
+  inspectToolMarkerNaming,
+  inspectYaziNaming,
+  migrateNamingSettingsFile,
+  regenerateYaziNamingProfile,
+  transformNamingSettingsDocument
+} from "./chunk-NASYVWDB.js";
+import {
+  formatDoctorReport,
+  isUninitializedHome,
+  runDoctor,
+  runDoctorFleetChecks,
+  runDoctorInteropChecks,
+  runDoctorModelChecks,
+  runDoctorRuntimeChecks
+} from "./chunk-IN7DGBVS.js";
+import "./chunk-NOCSM22Y.js";
+import "./chunk-KW5HXKLJ.js";
+import "./chunk-URCXX7WJ.js";
+import {
+  describeYaziProfile,
+  inspectCurrentYaziProfile,
+  userYaziConfigDir,
+  yaziProfileDir
+} from "./chunk-U26XXPJS.js";
+import "./chunk-T2MDZES3.js";
+import {
+  resolveOnPath
+} from "./chunk-4A6YRGV4.js";
+import "./chunk-UCINIRHW.js";
+import "./chunk-GGPF6LLE.js";
+import "./chunk-3UW3KU4A.js";
+import {
+  HOST_WORKTREE_ROOT_FACTS,
+  allowedWorktreeParents,
+  gitCheckoutRoot,
+  listPreservedTaskWorktrees,
+  resolveWorktreeRoot
+} from "./chunk-BYFHHCFV.js";
+import "./chunk-TKDRT2DF.js";
+import "./chunk-LQTKDAUO.js";
+import {
+  describeValidationContract,
+  loadValidationContract
+} from "./chunk-ZU4JPCPR.js";
+import {
+  printError
+} from "./chunk-NBXFPI7U.js";
+import "./chunk-SQZHXUB3.js";
+import {
+  TraceReader
+} from "./chunk-GM4TY6VN.js";
+import "./chunk-ZARZ4POR.js";
+import "./chunk-UX2L5CUD.js";
+import "./chunk-LAR7DX5E.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-CDQ2UC6W.js";
+import "./chunk-5LP5FNNR.js";
+import "./chunk-NVPXXW2H.js";
+import "./chunk-2AF6YC7Q.js";
+import "./chunk-LAVUQX3B.js";
+import {
+  resolveMcpServers
+} from "./chunk-55RMDDFM.js";
+import "./chunk-2KUBKL63.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-DVTBERFY.js";
+import "./chunk-Z4GLJ6J4.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-2WVPJF3Z.js";
+import "./chunk-ALJWT6O6.js";
+import "./chunk-I4Y4WKZR.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL
+} from "./chunk-UZVYEF57.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-EKV4UBCM.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-LNOXCGN2.js";
+import "./chunk-BJH6WFIB.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-VYRQHORQ.js";
+import "./chunk-P4GNZPXO.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-C2CPOIH2.js";
+import "./chunk-MGLRTOCK.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-V4XJWDHR.js";
+import {
+  readSettings,
+  withSettingsLock
+} from "./chunk-56XP4FJU.js";
+import "./chunk-QZTTRSJE.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import "./chunk-O63U2I6I.js";
+import {
+  runCommandVector
+} from "./chunk-M2IPMWCN.js";
+import "./chunk-XS2QPZJE.js";
+import {
+  rawDurationMs
+} from "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import {
+  describeResolution,
+  toolStatus,
+  toolStatuses
+} from "./chunk-53OXPRI6.js";
+import {
+  findPinnedTool
+} from "./chunk-2EMLKSCX.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import {
+  resolveClioDirs
+} from "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-2VLYHHFT.js";
+import "./chunk-3JHUFKG7.js";
+import "./chunk-ZPST2KQO.js";
+import "./chunk-PS6JAWJZ.js";
+import "./chunk-FD2I4KBR.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/doctor.ts
+init_esm_shims();
+
+// src/cli/doctor-hpc.ts
+init_esm_shims();
+import { tmpdir } from "node:os";
+import path from "node:path";
+var HPC_VERSION_TIMEOUT_MS = 2e3;
+var HPC_VERSION_MAX_OUTPUT_BYTES = 4096;
+var HPC_TOOLS = [
+  { name: "cc", binaries: ["cc", "gcc"] },
+  { name: "c++", binaries: ["c++", "g++"] },
+  { name: "clang", binaries: ["clang"] },
+  { name: "gfortran", binaries: ["gfortran"] },
+  { name: "mpicc", binaries: ["mpicc"] },
+  { name: "mpicxx", binaries: ["mpicxx"] },
+  { name: "mpirun", binaries: ["mpirun"] },
+  { name: "nvcc", binaries: ["nvcc"] },
+  { name: "cmake", binaries: ["cmake"] },
+  { name: "make", binaries: ["make"] },
+  { name: "ninja", binaries: ["ninja"] },
+  { name: "meson", binaries: ["meson"] },
+  { name: "python3", binaries: ["python3"] },
+  { name: "sbatch", binaries: ["sbatch"] }
+];
+function requiredBy(contract, tool) {
+  if (contract === null) return null;
+  if (tool.name === "sbatch" && contract.runtime?.kind === "slurm") return "runtime.kind slurm needs it";
+  for (const command of contract.validators ?? []) {
+    const words = command.split(/[\s;&|()<>`"']+/).filter((word) => word.length > 0);
+    if (words.some((word) => tool.binaries.includes(path.basename(word)))) {
+      return "the validation contract names it";
+    }
+  }
+  return null;
+}
+function lines(text) {
+  return text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+async function versionLine(binary, timeoutMs) {
+  const cwd = tmpdir();
+  const result = await runCommandVector(binary, ["--version"], {
+    cwd,
+    workspaceRoot: cwd,
+    timeoutMs,
+    maxOutputBytes: HPC_VERSION_MAX_OUTPUT_BYTES
+  });
+  if (result.timedOut) return { line: `no version line (--version did not answer within ${timeoutMs}ms)` };
+  const output = lines(`${result.stdout}
+${result.stderr}`);
+  const line = output.find((entry) => /\d+\.\d+/.test(entry)) ?? output[0] ?? "no version line";
+  if (result.exitCode !== 0) return { line, fault: `--version exited ${result.exitCode ?? "on a signal"}` };
+  return { line };
+}
+async function probeTool(tool, contract, timeoutMs) {
+  const name = `toolchain ${tool.name}`;
+  const resolved = resolveOnPath(tool.binaries);
+  if (resolved.presence === "present" && resolved.binary !== void 0) {
+    const version = await versionLine(resolved.binary, timeoutMs);
+    if (version.fault !== void 0) {
+      return { ok: true, name, level: "warn", detail: `${resolved.binary}: ${version.fault}: ${version.line}` };
+    }
+    return { ok: true, name, level: "ok", detail: `${resolved.binary}: ${version.line}` };
+  }
+  const where = resolved.presence === "unknown" ? "PATH could not be read" : "not on PATH";
+  const reason = requiredBy(contract, tool);
+  if (reason !== null) return { ok: true, name, level: "warn", detail: `${where}; ${reason}` };
+  return { ok: true, name, level: "info", detail: where };
+}
+async function hpcToolchainFindings(options = {}) {
+  const loaded = loadValidationContract(options.workspaceRoot ?? process.cwd());
+  const contract = loaded.ok ? loaded.contract : null;
+  const timeoutMs = options.timeoutMs ?? HPC_VERSION_TIMEOUT_MS;
+  return Promise.all(HPC_TOOLS.map((tool) => probeTool(tool, contract, timeoutMs)));
+}
+
+// src/cli/doctor-naming.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/domains/lifecycle/naming-history.ts
+init_esm_shims();
+import { existsSync, lstatSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+var HISTORY_FILE_LIMIT = 1e4;
+var HISTORY_FILE_BYTE_LIMIT = 8 * 1024 * 1024;
+var HISTORY_SUFFIXES = [".json", ".jsonl", ".ndjson"];
+var LEGACY_EVENT_TYPES = [
+  "clio_permission_escalated",
+  "clio_permission_resolved",
+  "clio_plan_update",
+  "clio_run_outcome",
+  "clio_safety_decision",
+  "clio_skill_activation",
+  "clio_steer_received",
+  "clio_tool_activity",
+  "clio_tool_finish",
+  "clio_tool_start",
+  "clio_usage",
+  "clio_verification",
+  "clio_write_record_downgraded"
+];
+var LEGACY_HISTORY_LITERALS = [
+  ...LEGACY_EVENT_TYPES,
+  "clio.eval.",
+  '"clio-run"',
+  "clio.runReceipt.integrity",
+  "clio.gateDecision.integrity",
+  "clio.gateDecision.pending",
+  "clio.protectedArtifact.pending",
+  "clio.ask_user.interview.v1",
+  "clio.share.v1",
+  "clio-context-replay-v2",
+  "identity.clio-worker"
+];
+function countLegacyHistoryText(text) {
+  let count = 0;
+  for (const literal of LEGACY_HISTORY_LITERALS) {
+    let offset = 0;
+    for (; ; ) {
+      const found = text.indexOf(literal, offset);
+      if (found === -1) break;
+      count += 1;
+      offset = found + literal.length;
+    }
+  }
+  count += text.match(/"clio"\s*:/gu)?.length ?? 0;
+  count += text.match(/"clioVersion"\s*:/gu)?.length ?? 0;
+  count += text.match(/"clioCommit"\s*:/gu)?.length ?? 0;
+  return count;
+}
+function inspectTextTree(area, root) {
+  const result = {
+    area,
+    legacyIdentifiers: 0,
+    filesInspected: 0,
+    filesSkipped: 0,
+    error: null
+  };
+  if (!existsSync(root)) return result;
+  const pending = [root];
+  try {
+    while (pending.length > 0 && result.filesInspected + result.filesSkipped < HISTORY_FILE_LIMIT) {
+      const directory = pending.pop();
+      if (directory === void 0) break;
+      for (const entry of readdirSync(directory, { withFileTypes: true }).sort(
+        (left, right) => left.name.localeCompare(right.name)
+      )) {
+        const path2 = join(directory, entry.name);
+        if (entry.isSymbolicLink()) {
+          result.filesSkipped += 1;
+          continue;
+        }
+        if (entry.isDirectory()) {
+          pending.push(path2);
+          continue;
+        }
+        if (!entry.isFile() || !HISTORY_SUFFIXES.some((suffix) => entry.name.endsWith(suffix))) continue;
+        const stats = lstatSync(path2);
+        if (!stats.isFile() || stats.size > HISTORY_FILE_BYTE_LIMIT) {
+          result.filesSkipped += 1;
+          continue;
+        }
+        result.legacyIdentifiers += countLegacyHistoryText(readFileSync(path2, "utf8"));
+        result.filesInspected += 1;
+      }
+    }
+    if (pending.length > 0) result.filesSkipped += pending.length;
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error);
+  }
+  return result;
+}
+function inspectTrace(path2) {
+  const result = {
+    area: "trace",
+    legacyIdentifiers: 0,
+    filesInspected: 0,
+    filesSkipped: 0,
+    error: null
+  };
+  if (!existsSync(path2)) return result;
+  try {
+    if (!statSync(path2).isFile()) {
+      result.filesSkipped = 1;
+      return result;
+    }
+    const reader = new TraceReader(path2);
+    try {
+      const placeholders = LEGACY_EVENT_TYPES.map(() => "?").join(",");
+      const row = reader.db.prepare(`SELECT COUNT(*) AS count FROM events WHERE type IN (${placeholders})`).get(...LEGACY_EVENT_TYPES);
+      result.legacyIdentifiers = Number(row.count);
+      result.filesInspected = 1;
+    } finally {
+      reader.close();
+    }
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error);
+  }
+  return result;
+}
+function inspectNamingHistory(options) {
+  return [
+    inspectTrace(join(options.stateDir, "trace.sqlite")),
+    inspectTextTree("sessions", join(options.stateDir, "sessions")),
+    inspectTextTree("evals", join(options.dataDir, "evals")),
+    inspectTextTree("evidence", join(options.dataDir, "evidence")),
+    inspectTextTree("receipts", join(options.stateDir, "receipts"))
+  ];
+}
+
+// src/cli/doctor-naming.ts
+var LEGACY_ENVIRONMENT_NAMES = [
+  ["CLIO_EVAL_RUNNER_STDOUT_FILE", "CLIO_CODER_EVAL_RUNNER_STDOUT_FILE"],
+  ["CLIO_YAZI_PICK_TOKEN", "CLIO_CODER_YAZI_PICK_TOKEN"]
+];
+function namingEnvironmentFindings(yaziEnabled, environment = process.env) {
+  const present = LEGACY_ENVIRONMENT_NAMES.filter(
+    ([legacy]) => (yaziEnabled || legacy !== "CLIO_YAZI_PICK_TOKEN") && Boolean(environment[legacy]?.trim())
+  );
+  if (present.length === 0) {
+    return [{ ok: true, name: "naming environment", detail: "no legacy Clio Coder environment variables are set" }];
+  }
+  return present.map(([legacy, canonical]) => ({
+    ok: true,
+    level: "warn",
+    name: "naming environment",
+    detail: `${legacy} is deprecated; use ${canonical} (compatibility ends in v0.7.0)`
+  }));
+}
+function namingResourceFindings(options) {
+  try {
+    const resourceOptions = {
+      ...options.cwd ? { cwd: options.cwd } : {},
+      ...options.fix !== void 0 ? { fix: options.fix } : {}
+    };
+    const resources = inspectInstalledNamingResources(resourceOptions);
+    const legacyResources = resources.filter((entry) => entry.status !== "absent");
+    const rootOptions = options.cwd ? { cwd: options.cwd } : {};
+    const skillMetadata = inspectSkillMetadataNaming(rootOptions).filter((entry) => entry.legacyMetadataKey);
+    const overlays = inspectModelOverlayNaming(rootOptions).filter(
+      (entry) => entry.legacyFile || entry.legacyMetadataKeys > 0
+    );
+    if (legacyResources.length === 0 && skillMetadata.length === 0 && overlays.length === 0) {
+      return [{ ok: true, name: "naming resources", detail: "installed skills and model overlays use canonical names" }];
+    }
+    const renamed = legacyResources.filter((entry) => entry.status === "renamed").length;
+    const renamable = legacyResources.filter((entry) => entry.status === "renamable").length;
+    const conflicts = legacyResources.filter(
+      (entry) => entry.status === "modified" || entry.status === "canonical-present"
+    ).length;
+    return [
+      {
+        ok: true,
+        level: renamed > 0 && renamable === 0 && conflicts === 0 && skillMetadata.length === 0 && overlays.length === 0 ? "ok" : "warn",
+        name: "naming resources",
+        detail: [
+          `${renamed} proven skills renamed`,
+          `${renamable} proven skills await doctor --fix`,
+          `${conflicts} modified/conflicting skills left untouched`,
+          `${skillMetadata.length} legacy skill metadata keys${skillMetadata.length > 0 ? ` (rename \`clio:\` to \`clio-coder:\` in ${skillMetadata.map((entry) => entry.path).join(", ")})` : ""}`,
+          `${overlays.length} legacy model overlay files/metadata (manual migration required)`
+        ].join("; ")
+      }
+    ];
+  } catch (error) {
+    return [
+      {
+        ok: false,
+        name: "naming resources",
+        detail: `resource naming inspection failed: ${error instanceof Error ? error.message : String(error)}`
+      }
+    ];
+  }
+}
+function inspectSettingsNaming(path2) {
+  if (!existsSync2(path2)) return { path: path2, legacy: 0, conflicts: 0, error: null };
+  try {
+    const transformed = transformNamingSettingsDocument((0, import_yaml.parse)(readFileSync2(path2, "utf8")));
+    return {
+      path: path2,
+      legacy: transformed.replacements.length,
+      conflicts: transformed.conflicts.length,
+      error: null
+    };
+  } catch (error) {
+    return { path: path2, legacy: 0, conflicts: 0, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function settingsFinding(label, inspection, fixed) {
+  if (inspection.error !== null) {
+    return {
+      ok: false,
+      name: `naming ${label}`,
+      detail: `${inspection.path} could not be inspected: ${inspection.error}`
+    };
+  }
+  const count = inspection.legacy + inspection.conflicts;
+  if (count === 0) {
+    return { ok: true, name: `naming ${label}`, detail: `${inspection.path} has canonical settings identifiers` };
+  }
+  return {
+    ok: fixed,
+    level: fixed ? "ok" : "warn",
+    name: `naming ${label}`,
+    detail: fixed ? `${inspection.path}: migrated ${inspection.legacy} aliases and resolved ${inspection.conflicts} canonical collisions; backup written beside the file` : `${inspection.path}: ${inspection.legacy} legacy aliases and ${inspection.conflicts} canonical collisions (run \`clio-coder doctor --fix\`)`
+  };
+}
+function yaziNamingFinding(fix, enabled) {
+  if (!enabled) {
+    return {
+      ok: true,
+      name: "naming files profile",
+      detail: "disabled by settings"
+    };
+  }
+  const inspection = inspectYaziNaming();
+  const legacy = inspection.legacyEvents + inspection.legacyEnvironmentNames;
+  if (legacy === 0) {
+    return {
+      ok: true,
+      name: "naming files profile",
+      detail: inspection.present ? `${inspection.profileDir} uses canonical event and environment identifiers` : `${inspection.profileDir} is absent; the next managed open will generate canonical identifiers`
+    };
+  }
+  if (!fix) {
+    return {
+      ok: true,
+      level: "warn",
+      name: "naming files profile",
+      detail: `${inspection.profileDir}: ${inspection.legacyEvents} legacy events and ${inspection.legacyEnvironmentNames} legacy environment names (run \`clio-coder doctor --fix\`)`
+    };
+  }
+  const report = regenerateYaziNamingProfile();
+  return {
+    ok: report.status !== "regeneration-failed",
+    ...report.status === "regeneration-failed" ? {} : { level: "ok" },
+    name: "naming files profile",
+    detail: report.detail
+  };
+}
+function toolMarkerNamingFinding(fix) {
+  try {
+    const reports = inspectToolMarkerNaming({ fix });
+    if (reports.length === 0) {
+      return { ok: true, name: "naming tool markers", detail: "known tool versions use canonical install markers" };
+    }
+    const fixed = reports.filter((entry) => entry.status === "renamed" || entry.status === "duplicate-removed").length;
+    const fixable = reports.filter(
+      (entry) => entry.status === "renamable" || entry.status === "agreeing-duplicate"
+    ).length;
+    const manual = reports.length - fixed - fixable;
+    return {
+      ok: true,
+      level: fixed > 0 && fixable === 0 && manual === 0 ? "ok" : "warn",
+      name: "naming tool markers",
+      detail: `${fixed} validated markers fixed; ${fixable} await doctor --fix; ${manual} invalid/conflicting markers left untouched`
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      name: "naming tool markers",
+      detail: `tool marker inspection failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function immutableHistoryNamingFinding() {
+  const dirs = resolveClioDirs();
+  const counts = inspectNamingHistory({ stateDir: dirs.state, dataDir: dirs.data });
+  const errors = counts.filter((entry) => entry.error !== null);
+  if (errors.length > 0) {
+    return {
+      ok: false,
+      name: "naming immutable history",
+      detail: errors.map((entry) => `${entry.area}: ${entry.error}`).join("; ")
+    };
+  }
+  const legacy = counts.reduce((sum, entry) => sum + entry.legacyIdentifiers, 0);
+  return {
+    ok: true,
+    ...legacy > 0 ? { level: "warn" } : {},
+    name: "naming immutable history",
+    detail: `${counts.map((entry) => `${entry.area}=${entry.legacyIdentifiers}`).join("; ")} legacy identifiers; read-only retention, no rewrite`
+  };
+}
+function legacyGitRefsFinding(cwd) {
+  let refs;
+  try {
+    refs = execFileSync(
+      "git",
+      ["-C", cwd, "for-each-ref", "--format=%(refname:short)", "refs/heads/clio/task", "refs/heads/clio/compete"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }
+    ).split("\n").map((entry) => entry.trim()).filter((entry) => /^clio\/(?:task|compete)\//u.test(entry)).sort();
+  } catch {
+    refs = [];
+  }
+  if (refs.length === 0) {
+    return { ok: true, name: "naming git refs", detail: "no legacy Clio Coder task or compete refs found" };
+  }
+  const shown = refs.slice(0, 20);
+  return {
+    ok: true,
+    level: "warn",
+    name: "naming git refs",
+    detail: `${refs.length} legacy refs retained (never auto-renamed): ${shown.join(", ")}${refs.length > shown.length ? ", \u2026" : ""}`
+  };
+}
+function legacyWorktreeMarkerFinding(cwd) {
+  const root = join2(cwd, ".clio-coder", "worktrees");
+  let legacy = 0;
+  try {
+    for (const entry of readdirSync2(root, { withFileTypes: true })) {
+      const candidates = entry.isFile() ? entry.name.endsWith(".task-owner.json") ? [join2(root, entry.name)] : [] : entry.isDirectory() ? [join2(root, entry.name, ".clio-coder-compete-owner.json")] : [];
+      for (const path2 of candidates) {
+        if (!existsSync2(path2)) continue;
+        const parsed = JSON.parse(readFileSync2(path2, "utf8"));
+        if (parsed.kind === "clio-task-worktree" || parsed.kind === "clio-compete-group") legacy += 1;
+      }
+    }
+  } catch {
+  }
+  return {
+    ok: true,
+    ...legacy > 0 ? { level: "warn" } : {},
+    name: "naming worktree markers",
+    detail: legacy === 0 ? "active worktree markers use canonical identifiers" : `${legacy} active legacy worktree markers retained for cleanup compatibility; no automatic rewrite`
+  };
+}
+function namingFootprintFindings(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const userSettingsPath = join2(resolveClioDirs().config, "settings.yaml");
+  const candidates = [
+    { label: "settings user", path: userSettingsPath, lock: true },
+    { label: "settings project", path: join2(cwd, ".clio-coder", "settings.yaml"), lock: false },
+    { label: "settings local", path: join2(cwd, ".clio-coder", "settings.local.yaml"), lock: false }
+  ];
+  const findings = [];
+  for (const candidate of candidates) {
+    const before = inspectSettingsNaming(candidate.path);
+    let fixed = false;
+    if (options.fix && before.error === null && before.legacy + before.conflicts > 0) {
+      try {
+        if (candidate.lock) withSettingsLock(() => migrateNamingSettingsFile(candidate.path));
+        else migrateNamingSettingsFile(candidate.path);
+        fixed = true;
+      } catch (error) {
+        findings.push({
+          ok: false,
+          name: `naming ${candidate.label}`,
+          detail: `--fix could not migrate ${candidate.path}: ${error instanceof Error ? error.message : String(error)}`
+        });
+        continue;
+      }
+    }
+    findings.push(settingsFinding(candidate.label, before, fixed));
+  }
+  findings.push(...namingEnvironmentFindings(options.yaziEnabled ?? true));
+  findings.push(...namingResourceFindings({ ...options, cwd }));
+  findings.push(yaziNamingFinding(Boolean(options.fix), options.yaziEnabled ?? true));
+  findings.push(toolMarkerNamingFinding(Boolean(options.fix)));
+  findings.push(immutableHistoryNamingFinding());
+  findings.push(legacyGitRefsFinding(cwd));
+  findings.push(legacyWorktreeMarkerFinding(cwd));
+  return findings;
+}
+
+// src/cli/doctor-panes.ts
+init_esm_shims();
+import { accessSync, constants } from "node:fs";
+import { join as join3 } from "node:path";
+var PANE_HOST_TOOL_ID = "herdr";
+var REQUIRED_PROTOCOL = Math.max(...Object.values(MUX_METHOD_MIN_PROTOCOL));
+function journalWritabilityFinding(root = join3(resolveClioDirs().state, "runs")) {
+  try {
+    accessSync(root, constants.W_OK);
+    return { ok: true, name: "panes journal dir", detail: `${root} is writable` };
+  } catch (error) {
+    return {
+      ok: true,
+      level: "warn",
+      name: "panes journal dir",
+      detail: `${root} is absent or not writable (${error instanceof Error ? error.message : String(error)}); \`clio-coder fleet view\` will have no transcript to follow`
+    };
+  }
+}
+async function panesFindings(env = process.env) {
+  let enabled = "off";
+  let layoutRow = {
+    ok: true,
+    name: "panes layout",
+    detail: "off"
+  };
+  try {
+    const panes = readSettings().interface.panes;
+    enabled = panes.enabled;
+    if (panes.layout !== "off") {
+      layoutRow = {
+        ok: true,
+        name: "panes layout",
+        detail: `${panes.layout} at boot (workers dock ${(panes.workers.ratio * 100).toFixed(0)}%, files dock ${(panes.files.ratio * 100).toFixed(0)}%)`
+      };
+    }
+  } catch {
+  }
+  if (enabled === "off") {
+    return [
+      {
+        ok: true,
+        name: "panes mode",
+        detail: "off by choice"
+      },
+      layoutRow
+    ];
+  }
+  const { detection, client } = await detectMux({ enabled, env });
+  const snapshot = client ? await client.snapshot().catch(() => null) : null;
+  await client?.close().catch(() => void 0);
+  const candidates = detection.candidates.length > 0 ? detection.candidates : resolveSocketCandidates(env);
+  const findings = [
+    {
+      ok: true,
+      level: detection.mode === "none" ? "warn" : "ok",
+      name: "panes mode",
+      detail: `${detection.mode} (panes.enabled=${enabled}); ${detection.reason}`
+    },
+    {
+      ok: true,
+      level: detection.socketPath === null ? "warn" : "ok",
+      name: "panes socket",
+      detail: detection.socketPath === null ? `no socket answered; tried ${candidates.length > 0 ? candidates.join(", ") : "no candidates"}` : `${detection.socketPath} answered a ping`
+    }
+  ];
+  const server = detection.server;
+  findings.push({
+    ok: true,
+    level: server === null || server.protocol < REQUIRED_PROTOCOL ? "warn" : "ok",
+    name: "panes protocol",
+    detail: server === null ? `unknown; Clio's optional methods need protocol ${REQUIRED_PROTOCOL} or newer` : `server ${server.version}, protocol ${server.protocol}; Clio's optional methods need ${REQUIRED_PROTOCOL} (${server.protocol >= REQUIRED_PROTOCOL ? "satisfied" : "toasts and agent focus fall back"})`
+  });
+  const entry = findPinnedTool(PANE_HOST_TOOL_ID);
+  findings.push(
+    entry === null ? {
+      ok: true,
+      level: "warn",
+      name: "panes binary",
+      detail: `${PANE_HOST_TOOL_ID} is not in the pinned tool registry`
+    } : {
+      ok: true,
+      level: toolStatus(entry).resolution.source === "none" ? "warn" : "ok",
+      name: "panes binary",
+      detail: describeResolution(toolStatus(entry))
+    }
+  );
+  findings.push(layoutRow);
+  const legacyOwnedPanes = snapshot?.panes.filter(
+    (pane) => pane.tokens.clio_owner === "clio:mux" && pane.tokens.clio_coder_owner !== "clio-coder:mux"
+  ).length ?? 0;
+  const staleWatchTitles = snapshot?.panes.filter(
+    (pane) => (pane.title === "clio watch" || pane.label === "clio watch") && (pane.tokens.clio_coder_owner === "clio-coder:mux" || pane.tokens.clio_owner === "clio:mux")
+  ).length ?? 0;
+  findings.push({
+    ok: true,
+    level: legacyOwnedPanes > 0 || staleWatchTitles > 0 ? "warn" : "ok",
+    name: "naming panes",
+    detail: legacyOwnedPanes > 0 || staleWatchTitles > 0 ? `${legacyOwnedPanes} panes carry only the legacy clio_owner=clio:mux token; ${staleWatchTitles} owned panes retain the stale 'clio watch' title; quit/cleanup recognizes both token schemes` : "no legacy Clio Coder pane ownership tokens or watch titles found"
+  });
+  findings.push(journalWritabilityFinding());
+  return findings;
+}
+
+// src/cli/doctor-slurm.ts
+init_esm_shims();
+import { tmpdir as tmpdir2 } from "node:os";
+var PROBE_TIMEOUT_MS = 5e3;
+var PROBE_MAX_OUTPUT_BYTES = 16 * 1024;
+var GUIDE = "docs/guide/slurm.md";
+async function run(binary, args, timeoutMs) {
+  const cwd = tmpdir2();
+  const result = await runCommandVector(binary, args, {
+    cwd,
+    workspaceRoot: cwd,
+    timeoutMs,
+    maxOutputBytes: PROBE_MAX_OUTPUT_BYTES
+  });
+  return { ok: !result.timedOut && result.exitCode === 0, text: `${result.stdout}
+${result.stderr}` };
+}
+async function clioKitDetail(binary, timeoutMs) {
+  const version = await run(binary, ["--version"], timeoutMs);
+  const versionLine2 = version.ok ? version.text.split(/\r?\n/).map((line) => line.trim()).find((line) => /\d+\.\d+/.test(line)) ?? "version not reported" : "version not reported (no --version)";
+  const listing = await run(binary, ["mcp-servers"], timeoutMs);
+  const ships = listing.ok ? /^\s*-?\s*slurm\s*$/mu.test(listing.text) ? "ships the slurm server" : "does not list a slurm server" : "its server listing could not be read";
+  return `${binary}: ${versionLine2}; ${ships}`;
+}
+function isSlurmServer(server) {
+  const words = [server.command, ...server.args];
+  const at = words.indexOf("mcp-server");
+  return at !== -1 && words[at + 1] === "slurm" && /(^|\/)clio-kit$/u.test(words[at - 1] ?? server.command);
+}
+async function slurmMcpFindings(options = {}) {
+  const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;
+  const clioKit = resolveOnPath(["clio-kit"]);
+  const sbatch = resolveOnPath(["sbatch"]);
+  const squeue = resolveOnPath(["squeue"]);
+  const declared = options.untouched === true ? [] : resolveMcpServers({
+    cwd: options.workspaceRoot ?? process.cwd(),
+    configDir: options.configDir ?? resolveClioDirs().config
+  }).servers.filter(isSlurmServer);
+  const kitPresent = clioKit.presence === "present" && clioKit.binary !== void 0;
+  const schedulerPresent = sbatch.presence === "present" || squeue.presence === "present";
+  if (!kitPresent && declared.length === 0 && !schedulerPresent) {
+    return [
+      {
+        ok: true,
+        level: "info",
+        name: "slurm mcp",
+        detail: `not set up: clio-kit, sbatch, and squeue are not on PATH and no mcp.yaml declares the Slurm server; see ${GUIDE}`
+      }
+    ];
+  }
+  const findings = [];
+  findings.push(
+    kitPresent ? { ok: true, level: "ok", name: "slurm clio-kit", detail: await clioKitDetail(clioKit.binary, timeoutMs) } : { ok: true, level: "info", name: "slurm clio-kit", detail: `not on PATH; see ${GUIDE}` }
+  );
+  findings.push(
+    declared.length > 0 ? {
+      ok: true,
+      level: declared.every((server) => server.trust.status === "trusted") ? "ok" : "info",
+      name: "slurm mcp server",
+      detail: declared.map((server) => {
+        const trust = server.trust.status === "trusted" ? `trusted, action class ${server.trust.actionClass}` : `${server.trust.status}; run clio-coder mcp trust ${server.id}`;
+        return `${server.id} declared in ${server.path} (${server.scope}, ${trust})`;
+      }).join("; ")
+    } : {
+      ok: true,
+      level: "info",
+      name: "slurm mcp server",
+      detail: `no mcp.yaml entry runs clio-kit mcp-server slurm; see ${GUIDE}`
+    }
+  );
+  const clients = [
+    ["sbatch", sbatch],
+    ["squeue", squeue]
+  ];
+  findings.push({
+    ok: true,
+    level: schedulerPresent ? "ok" : "info",
+    name: "slurm scheduler",
+    detail: clients.map(([name, found]) => `${name} ${found.presence === "present" ? found.binary : "not on PATH"}`).join("; ")
+  });
+  return findings;
+}
+
+// src/cli/doctor-state-size.ts
+init_esm_shims();
+import { lstatSync as lstatSync2, readdirSync as readdirSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+function stateStorageFinding(stateDir = resolveClioDirs().state) {
+  let names;
+  try {
+    names = readdirSync3(stateDir);
+  } catch (error) {
+    return {
+      ok: false,
+      name: "state storage",
+      detail: `${stateDir} could not be measured: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  let total = 0;
+  let largest = null;
+  for (const name of names.sort()) {
+    const measured = measureEntry(join4(stateDir, name));
+    if (measured.error !== null) {
+      return { ok: false, name: "state storage", detail: measured.error };
+    }
+    total += measured.bytes;
+    if (largest === null || measured.bytes > largest.bytes) largest = { name, bytes: measured.bytes };
+  }
+  return {
+    ok: true,
+    name: "state storage",
+    detail: largest === null ? `${formatBytes(total)} (${total.toLocaleString("en-US")} bytes); largest contributor none` : `${formatBytes(total)} (${total.toLocaleString("en-US")} bytes); largest contributor ${largest.name} at ${formatBytes(largest.bytes)} (${largest.bytes.toLocaleString("en-US")} bytes)`
+  };
+}
+function measureEntry(path2) {
+  let stats;
+  try {
+    stats = lstatSync2(path2);
+  } catch (error) {
+    return {
+      bytes: 0,
+      error: `${path2} could not be inspected: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!stats.isDirectory() || stats.isSymbolicLink()) return { bytes: stats.size, error: null };
+  let names;
+  try {
+    names = readdirSync3(path2);
+  } catch (error) {
+    return { bytes: 0, error: `${path2} could not be listed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  let bytes = 0;
+  for (const name of names) {
+    const child = measureEntry(join4(path2, name));
+    if (child.error !== null) return child;
+    bytes += child.bytes;
+  }
+  return { bytes, error: null };
+}
+
+// src/cli/doctor-task-worktrees.ts
+init_esm_shims();
+function ageLabel(createdAt, now) {
+  const created = createdAt === null ? Number.NaN : Date.parse(createdAt);
+  if (!Number.isFinite(created)) return "age unknown";
+  const minutes = Math.floor(Math.max(0, rawDurationMs(created, now)) / 6e4);
+  if (minutes < 60) return `${minutes}m old`;
+  const hours = Math.floor(minutes / 60);
+  return hours < 48 ? `${hours}h old` : `${Math.floor(hours / 24)}d old`;
+}
+function describe(entry, now) {
+  return `${entry.branch} (${entry.state}, ${ageLabel(entry.createdAt, now)}, ${entry.reason}): inspect with git log ${entry.base}..${entry.branch}; drop with git worktree remove --force ${entry.path} && git branch -D ${entry.branch} && rm ${entry.claimPath}`;
+}
+function configuredRoot() {
+  try {
+    const fleet = readSettings().fleet;
+    return { setting: fleet.worktrees.root, remoteEligible: fleet.nodes.length > 0 };
+  } catch {
+    return { setting: "disk", remoteEligible: false };
+  }
+}
+function formatGiB(bytes) {
+  return bytes === null ? "free space unknown" : `${(bytes / 1024 ** 3).toFixed(1)} GiB free`;
+}
+function taskWorktreeFindings(workspaceRoot, options = {}) {
+  const root = gitCheckoutRoot(workspaceRoot);
+  if (root === null) return [];
+  const now = options.now ?? Date.now();
+  const facts = options.facts ?? HOST_WORKTREE_ROOT_FACTS;
+  const configured = options.rootSetting === void 0 ? configuredRoot() : null;
+  const setting = options.rootSetting ?? configured?.setting ?? "disk";
+  const remoteEligible = options.remoteEligible ?? configured?.remoteEligible ?? false;
+  const resolved = resolveWorktreeRoot({ setting, projectRoot: root, remoteEligible, facts });
+  const measured = resolved.base ?? root;
+  const rootFinding = {
+    ok: true,
+    level: resolved.notice === void 0 ? "ok" : "warn",
+    name: "task worktree root",
+    detail: `fleet.worktrees.root ${setting}: ${resolved.parent} (${facts.filesystemType(measured) ?? "unknown filesystem"}, ${formatGiB(facts.freeBytes(measured))})${resolved.notice === void 0 ? "" : `; ${resolved.notice}`}`
+  };
+  const preserved = listPreservedTaskWorktrees(root, allowedWorktreeParents(setting, root, facts));
+  if (preserved.length === 0) {
+    return [rootFinding, { ok: true, name: "task worktrees", detail: "none preserved" }];
+  }
+  return [
+    rootFinding,
+    ...preserved.map((entry) => ({
+      ok: true,
+      // A run keeps its worktree on purpose; a crash leaving work behind wants a look.
+      level: entry.state === "settled" ? "info" : "warn",
+      name: `task worktree ${entry.runId}`,
+      detail: describe(entry, now)
+    }))
+  ];
+}
+
+// src/cli/doctor-toolchain.ts
+init_esm_shims();
+function yaziProfileFinding(enabled) {
+  if (!enabled) {
+    return {
+      ok: true,
+      name: "files pane profile",
+      detail: "disabled by settings"
+    };
+  }
+  try {
+    const profile = inspectCurrentYaziProfile();
+    return {
+      ok: true,
+      name: "files pane profile",
+      detail: describeYaziProfile(profile),
+      level: profile.state === "current" ? "ok" : "warn"
+    };
+  } catch (error) {
+    return {
+      ok: true,
+      name: "files pane profile",
+      level: "warn",
+      detail: `${yaziProfileDir()} could not be inspected (${error instanceof Error ? error.message : String(error)}); user config ${userYaziConfigDir()} is separate and untouched`
+    };
+  }
+}
+function toolchainFindings(options = {}) {
+  const panesEnabled = options.panesEnabled ?? true;
+  const filesEnabled = options.filesEnabled ?? true;
+  const tools = toolStatuses().map((status) => ({
+    ok: true,
+    name: `external tool ${status.id}`,
+    // Active integrations share the tools-status resolution sentence. Disabled
+    // experimental integrations stay neutral and do not advertise setup work.
+    detail: status.id === "herdr" && !panesEnabled || status.id === "yazi" && !filesEnabled ? "experimental integration disabled by settings" : describeResolution(status),
+    level: status.id === "herdr" && !panesEnabled || status.id === "yazi" && !filesEnabled ? "ok" : status.resolution.source === "none" ? "warn" : "ok"
+  }));
+  return [...tools, yaziProfileFinding(filesEnabled)];
+}
+
+// src/cli/doctor-validation-contract.ts
+init_esm_shims();
+function validationContractFinding(workspaceRoot = process.cwd()) {
+  const name = "validation contract";
+  const loaded = loadValidationContract(workspaceRoot);
+  if (!loaded.ok) {
+    return { ok: false, name, detail: `invalid: ${describeValidationContract(loaded)}; rigor default stays normal` };
+  }
+  if (loaded.contract === null) {
+    if ("advisory" in loaded) {
+      return { ok: true, name, level: "warn", detail: `markdown-only: ${describeValidationContract(loaded)}` };
+    }
+    return { ok: true, name, detail: "none at the workspace root; rigor default normal" };
+  }
+  const artifacts = loaded.contract.artifacts?.length ?? 0;
+  const validators = loaded.contract.validators?.length ?? 0;
+  return {
+    ok: true,
+    name,
+    detail: `valid: ${loaded.path} (version ${loaded.contract.version}, ${artifacts} artifact(s), ${validators} validator(s)); rigor default high`
+  };
+}
+
+// src/cli/doctor.ts
+var HELP = `clio-coder doctor [--fix] [--json] [--deep [--tools-timeout <seconds>]]
+
+Diagnose Clio Coder state without creating files. On a home Clio has never
+written to, doctor says so in one row and exits 0. Use --fix to repair structure:
+missing directories, missing template files, and credential permissions.
+--fix also records the fleet preflight, which is what admits an SSH node to
+dispatch for the current project root; plain doctor only reports it.
+Settings are validated directly against the current schema.
+Pass --json to emit a machine-readable report on stdout.
+--deep adds a live tool-call probe on every configured target, which can load
+a cold local model and releases it afterwards, and a dry run of the workspace
+validation contract that resolves each validator command and reports whether
+it would run without an approval ask at the configured autonomy. The dry run
+executes nothing. --tools-timeout bounds each tool probe (default 120).
+`;
+function configuredAutonomy() {
+  try {
+    return readSettings().safety.autonomy;
+  } catch {
+    return DEFAULT_AUTONOMY_LEVEL;
+  }
+}
+async function deepFindings(untouched, workspaceRoot, deep) {
+  const { contractDryRunFindings, deepToolProbeFindings } = await import("./doctor-deep-2EJQSHIZ.js");
+  const probeOptions = deep.toolsTimeoutMs !== void 0 ? { toolsTimeoutMs: deep.toolsTimeoutMs } : {};
+  let toolRows = [];
+  if (deep.providers) {
+    toolRows = await deepToolProbeFindings(deep.providers, probeOptions);
+  } else if (!untouched) {
+    let targetCount = 0;
+    try {
+      targetCount = readSettings().targets.length;
+    } catch {
+    }
+    if (targetCount > 0) {
+      const [{ loadDomains }, { ConfigDomainModule }, { ProvidersDomainModule }] = await Promise.all([
+        import("./domain-loader-MB34FDPD.js"),
+        import("./config-XE7XYZLU.js"),
+        import("./providers-CMETPZNS.js")
+      ]);
+      const loaded = await loadDomains([ConfigDomainModule, ProvidersDomainModule]);
+      try {
+        const providers = loaded.getContract("providers");
+        if (providers) toolRows = await deepToolProbeFindings(providers, probeOptions);
+      } finally {
+        await loaded.stop();
+      }
+    }
+  }
+  const contractRows = contractDryRunFindings({ workspaceRoot, autonomy: deep.autonomy ?? configuredAutonomy() });
+  return [...toolRows, ...contractRows];
+}
+async function collectDoctorFindings(options = {}) {
+  const fix = options.fix === true;
+  const workspaceRoot = options.workspaceRoot ?? process.cwd();
+  const untouched = !fix && isUninitializedHome();
+  const findings = runDoctor({ fix });
+  let panesEnabled = false;
+  let filesEnabled = false;
+  try {
+    const panes = readSettings().interface.panes;
+    panesEnabled = panes.enabled !== "off";
+    filesEnabled = panesEnabled && panes.files.enabled;
+  } catch {
+  }
+  const storageChecks = untouched ? [] : [stateStorageFinding()];
+  const runtimeChecks = await runDoctorRuntimeChecks();
+  const modelChecks = await runDoctorModelChecks();
+  const interopChecks = untouched ? [] : await runDoctorInteropChecks();
+  const fleetChecks = untouched ? [] : await runDoctorFleetChecks(workspaceRoot, { fix });
+  const toolChecks = untouched ? [] : toolchainFindings({ panesEnabled, filesEnabled });
+  const hpcChecks = await hpcToolchainFindings({ workspaceRoot });
+  const slurmChecks = await slurmMcpFindings({ workspaceRoot, untouched });
+  const paneChecks = untouched ? [] : await panesFindings();
+  const namingChecks = namingFootprintFindings({ fix, yaziEnabled: filesEnabled });
+  const contractChecks = [validationContractFinding(workspaceRoot)];
+  const worktreeChecks = taskWorktreeFindings(workspaceRoot);
+  const deepChecks = options.deep ? await deepFindings(untouched, workspaceRoot, options.deep) : [];
+  return [
+    ...findings,
+    ...storageChecks,
+    ...runtimeChecks,
+    ...modelChecks,
+    ...interopChecks,
+    ...fleetChecks,
+    ...toolChecks,
+    ...hpcChecks,
+    ...slurmChecks,
+    ...paneChecks,
+    ...namingChecks,
+    ...contractChecks,
+    ...worktreeChecks,
+    ...deepChecks
+  ];
+}
+function doctorNotice(findings) {
+  const errors = findings.filter((f) => !f.ok).length;
+  const warnings = findings.filter((f) => f.ok && f.level === "warn").length;
+  const level = errors > 0 ? "error" : warnings > 0 ? "warn" : "success";
+  const head = `doctor: ${findings.length} checks, ${errors} error(s), ${warnings} warning(s)`;
+  return { level, text: `${head}
+${formatDoctorReport([...findings])}`, findings };
+}
+function parseDoctorArgs(args) {
+  const parsed = { fix: false, json: false, deep: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--fix") parsed.fix = true;
+    else if (arg === "--json") parsed.json = true;
+    else if (arg === "--deep") parsed.deep = true;
+    else if (arg === "--tools-timeout") {
+      const value = args[i + 1];
+      const seconds = value === void 0 ? Number.NaN : Number(value);
+      if (!Number.isFinite(seconds) || seconds <= 0)
+        throw new Error("--tools-timeout requires a positive number of seconds");
+      parsed.toolsTimeoutMs = Math.round(seconds * 1e3);
+      i += 1;
+    } else throw new Error(`unknown flag: ${arg}`);
+  }
+  if (parsed.toolsTimeoutMs !== void 0 && !parsed.deep) throw new Error("--tools-timeout requires --deep");
+  return parsed;
+}
+async function runDoctorCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  let parsed;
+  try {
+    parsed = parseDoctorArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  const { fix, json } = parsed;
+  const all = await collectDoctorFindings({
+    fix,
+    deep: parsed.deep ? parsed.toolsTimeoutMs !== void 0 ? { toolsTimeoutMs: parsed.toolsTimeoutMs } : {} : false
+  });
+  const ok = all.every((f) => f.ok);
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ ok, fix, deep: parsed.deep, findings: all }, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${formatDoctorReport(all)}
+`);
+  }
+  return ok ? 0 : 1;
+}
+export {
+  collectDoctorFindings,
+  doctorNotice,
+  runDoctorCommand
+};
+//# sourceMappingURL=doctor-S5KZ2GTN.js.map