@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/doctor-ZGPEGHIP.js

@@ -0,0 +1,772 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  MUX_METHOD_MIN_PROTOCOL,
+  detectMux,
+  resolveSocketCandidates
+} from "./chunk-K6BF4U2H.js";
+import "./chunk-HRQMFLJP.js";
+import {
+  formatDoctorReport,
+  isUninitializedHome,
+  runDoctor,
+  runDoctorFleetChecks,
+  runDoctorInteropChecks,
+  runDoctorModelChecks,
+  runDoctorRuntimeChecks
+} from "./chunk-OJTRZGR3.js";
+import {
+  inspectInstalledNamingResources,
+  inspectModelOverlayNaming,
+  inspectSkillMetadataNaming,
+  inspectToolMarkerNaming,
+  inspectYaziNaming,
+  migrateNamingSettingsFile,
+  regenerateYaziNamingProfile,
+  transformNamingSettingsDocument
+} from "./chunk-QTFGO774.js";
+import {
+  describeYaziProfile,
+  inspectCurrentYaziProfile,
+  userYaziConfigDir,
+  yaziProfileDir
+} from "./chunk-J5LZHVIT.js";
+import "./chunk-D4CJV46V.js";
+import {
+  TraceReader
+} from "./chunk-ZAZB4JMW.js";
+import "./chunk-LCGCVYZ4.js";
+import "./chunk-3DPEIQKN.js";
+import "./chunk-HUAS7ITX.js";
+import "./chunk-NDDGJUXD.js";
+import "./chunk-FEFIFZTL.js";
+import "./chunk-SUW5DORT.js";
+import {
+  describeResolution,
+  toolStatus,
+  toolStatuses
+} from "./chunk-QSNYB6ZV.js";
+import {
+  findPinnedTool
+} from "./chunk-QDC3K2U3.js";
+import "./chunk-FSP7CMNU.js";
+import "./chunk-4BJ5BYCE.js";
+import "./chunk-K6BSR66V.js";
+import "./chunk-XPLRXC72.js";
+import "./chunk-NEKRRTYW.js";
+import "./chunk-BDPT6GTK.js";
+import "./chunk-7PWAODYW.js";
+import "./chunk-ZW55JB7N.js";
+import {
+  printError
+} from "./chunk-VPKWYKEY.js";
+import "./chunk-5TSRNF4G.js";
+import "./chunk-72GZI5EV.js";
+import "./chunk-MQXIVJ35.js";
+import "./chunk-R346GLFC.js";
+import "./chunk-BTK3SSSK.js";
+import "./chunk-IHXBNWMM.js";
+import {
+  readSettings,
+  withSettingsLock
+} from "./chunk-EIMVLWB3.js";
+import "./chunk-D7E7WCDF.js";
+import "./chunk-HJWWJ6IL.js";
+import "./chunk-JIEGK6UF.js";
+import "./chunk-EBY63B7G.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-IWHMRKLL.js";
+import "./chunk-BWW4HLO4.js";
+import "./chunk-LL4KHSZI.js";
+import "./chunk-NLFAQR7Z.js";
+import "./chunk-WNP7O5WZ.js";
+import "./chunk-336NSSKI.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-NUGM5KR6.js";
+import "./chunk-YXLYO42X.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/doctor.ts
+init_esm_shims();
+
+// 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 path = join(directory, entry.name);
+        if (entry.isSymbolicLink()) {
+          result.filesSkipped += 1;
+          continue;
+        }
+        if (entry.isDirectory()) {
+          pending.push(path);
+          continue;
+        }
+        if (!entry.isFile() || !HISTORY_SUFFIXES.some((suffix) => entry.name.endsWith(suffix))) continue;
+        const stats = lstatSync(path);
+        if (!stats.isFile() || stats.size > HISTORY_FILE_BYTE_LIMIT) {
+          result.filesSkipped += 1;
+          continue;
+        }
+        result.legacyIdentifiers += countLegacyHistoryText(readFileSync(path, "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(path) {
+  const result = {
+    area: "trace",
+    legacyIdentifiers: 0,
+    filesInspected: 0,
+    filesSkipped: 0,
+    error: null
+  };
+  if (!existsSync(path)) return result;
+  try {
+    if (!statSync(path).isFile()) {
+      result.filesSkipped = 1;
+      return result;
+    }
+    const reader = new TraceReader(path);
+    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`,
+          `${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(path) {
+  if (!existsSync2(path)) return { path, legacy: 0, conflicts: 0, error: null };
+  try {
+    const transformed = transformNamingSettingsDocument((0, import_yaml.parse)(readFileSync2(path, "utf8")));
+    return {
+      path,
+      legacy: transformed.replacements.length,
+      conflicts: transformed.conflicts.length,
+      error: null
+    };
+  } catch (error) {
+    return { path, 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 yazi profile",
+      detail: "disabled by settings"
+    };
+  }
+  const inspection = inspectYaziNaming();
+  const legacy = inspection.legacyEvents + inspection.legacyEnvironmentNames;
+  if (legacy === 0) {
+    return {
+      ok: true,
+      name: "naming yazi 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 yazi 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 yazi 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 path of candidates) {
+        if (!existsSync2(path)) continue;
+        const parsed = JSON.parse(readFileSync2(path, "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-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(path) {
+  let stats;
+  try {
+    stats = lstatSync2(path);
+  } catch (error) {
+    return {
+      bytes: 0,
+      error: `${path} 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(path);
+  } catch (error) {
+    return { bytes: 0, error: `${path} could not be listed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  let bytes = 0;
+  for (const name of names) {
+    const child = measureEntry(join4(path, name));
+    if (child.error !== null) return child;
+    bytes += child.bytes;
+  }
+  return { bytes, error: null };
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KiB", "MiB", "GiB", "TiB"];
+  let value = bytes;
+  let unit = -1;
+  do {
+    value /= 1024;
+    unit += 1;
+  } while (value >= 1024 && unit < units.length - 1);
+  return `${value.toFixed(value >= 10 ? 1 : 2)} ${units[unit]}`;
+}
+
+// src/cli/doctor-toolchain.ts
+init_esm_shims();
+function yaziProfileFinding(enabled) {
+  if (!enabled) {
+    return {
+      ok: true,
+      name: "yazi managed profile",
+      detail: "disabled by settings"
+    };
+  }
+  try {
+    const profile = inspectCurrentYaziProfile();
+    return {
+      ok: true,
+      name: "yazi managed profile",
+      detail: describeYaziProfile(profile),
+      level: profile.state === "current" ? "ok" : "warn"
+    };
+  } catch (error) {
+    return {
+      ok: true,
+      name: "yazi managed 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.ts
+var HELP = `clio-coder doctor [--fix] [--json]
+
+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.
+Settings are validated directly against the current schema.
+Pass --json to emit a machine-readable report on stdout.
+`;
+async function runDoctorCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const fix = args.includes("--fix");
+  const json = args.includes("--json");
+  const unknown = args.find((arg) => arg !== "--fix" && arg !== "--json");
+  if (unknown) {
+    printError(`unknown flag: ${unknown}`);
+    process.stderr.write(HELP);
+    return 2;
+  }
+  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();
+  const toolChecks = untouched ? [] : toolchainFindings({ panesEnabled, filesEnabled });
+  const paneChecks = untouched ? [] : await panesFindings();
+  const namingChecks = namingFootprintFindings({ fix, yaziEnabled: filesEnabled });
+  const all = [
+    ...findings,
+    ...storageChecks,
+    ...runtimeChecks,
+    ...modelChecks,
+    ...interopChecks,
+    ...fleetChecks,
+    ...toolChecks,
+    ...paneChecks,
+    ...namingChecks
+  ];
+  const ok = all.every((f) => f.ok);
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ ok, fix, findings: all }, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${formatDoctorReport(all)}
+`);
+  }
+  return ok ? 0 : 1;
+}
+export {
+  runDoctorCommand
+};
+//# sourceMappingURL=doctor-ZGPEGHIP.js.map