@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/chunk-47JYZAMS.js

@@ -0,0 +1,30 @@
+(() => {
+  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/lib/negated-flag.ts
+function negatedFlag(args, name) {
+  if (name.startsWith("no-")) {
+    throw new Error(
+      `negatedFlag: pass the positive flag name ('${name.slice(3)}'), not '${name}'.`
+    );
+  }
+  return args[name] === false || args[`no-${name}`] === true;
+}
+
+export {
+  negatedFlag
+};
+//# sourceMappingURL=chunk-47JYZAMS.js.map

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

@@ -0,0 +1,66 @@
+(() => {
+  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-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-project-identity.ts
+import { getProjectRoot } from "@cleocode/core";
+import {
+  inspectProjectIdentity,
+  inspectProjectNameDrift,
+  resolveProjectIdentity
+} from "@cleocode/core/doctor/project-identity.js";
+var doctorProjectIdentityCommand = defineCommand({
+  meta: {
+    name: "project-identity",
+    description: "Check .cleo/project.json, its legacy .cleo/project-id mirror and the project-info.json cache (legacy / missing / conflict / invalid / untracked) plus registry-name drift, and print the exact remedy. --resolve applies it: it migrates a legacy project to .cleo/project.json (no id changes) and re-keys a conflict to the tracked id through the alias table, losing no registry rows; add --dry-run to see the plan first."
+  },
+  args: {
+    resolve: { type: "boolean", description: "Apply the remedy for the reported state" },
+    "dry-run": { type: "boolean", description: "With --resolve: print the plan, write nothing" },
+    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 projectRoot = getProjectRoot();
+    if (!args.resolve) {
+      const report = inspectProjectIdentity(projectRoot);
+      const nameDrift = await inspectProjectNameDrift(projectRoot);
+      cliOutput(
+        { ...report, nameDrift },
+        { command: "doctor", operation: "doctor.project-identity.inspect" }
+      );
+      const drifted = nameDrift.state === "drift" || nameDrift.state === "taken";
+      if ((report.state !== "ok" || drifted) && (process.exitCode === void 0 || process.exitCode === 0))
+        process.exitCode = 1;
+      return;
+    }
+    const result = await resolveProjectIdentity(projectRoot, { dryRun: !!args["dry-run"] });
+    cliOutput(result, { command: "doctor", operation: "doctor.project-identity.resolve" });
+    if (result.refused && result.before.state !== "ok" && (process.exitCode ?? 0) === 0)
+      process.exitCode = 1;
+  }
+});
+
+export {
+  doctorProjectIdentityCommand
+};
+//# sourceMappingURL=chunk-5J2VH3BC.js.map

package/dist/cli/chunk-5ZFFUFH7.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-3ZO3M37V.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-5ZFFUFH7.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-7INMKEAD.js

@@ -0,0 +1,85 @@
+(() => {
+  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-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/auth/remove.ts
+function emitLlmCredentialRemoval(outcome, command, operation) {
+  if (!outcome.ok) {
+    cliError(outcome.message, outcome.exitCode, { name: outcome.code, fix: outcome.fix });
+    process.exit(outcome.exitCode);
+  }
+  for (const path of outcome.result.cleaned) process.stderr.write(`cleaned: ${path}
+`);
+  for (const hint of outcome.result.hints) process.stderr.write(`hint: ${hint}
+`);
+  cliOutput(outcome.result, { command, operation });
+}
+var authRemoveCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Remove a credential by (provider, label) and suppress its source from future re-seeding. Dispatches to the per-source RemovalStep so claude-code (et al.) entries are handled correctly without deleting external files."
+  },
+  args: {
+    provider: {
+      type: "positional",
+      description: "Provider id (e.g. anthropic, openai, gemini)",
+      required: true
+    },
+    label: {
+      type: "positional",
+      description: "Label of the credential to remove (unique within provider)",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON envelope"
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    const provider = String(a["provider"] ?? "");
+    const label = String(a["label"] ?? "");
+    if (!provider) {
+      cliError("provider is required", 6, { name: "E_INVALID_INPUT" });
+      process.exit(6);
+    }
+    if (!label) {
+      cliError("label is required", 6, { name: "E_INVALID_INPUT" });
+      process.exit(6);
+    }
+    const { removeLlmCredential } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/credential-remove-entry.js"
+    );
+    emitLlmCredentialRemoval(
+      await removeLlmCredential(provider, label),
+      "auth-remove",
+      "auth.remove"
+    );
+  }
+});
+
+export {
+  emitLlmCredentialRemoval,
+  authRemoveCommand
+};
+//# sourceMappingURL=chunk-7INMKEAD.js.map

package/dist/cli/chunk-A2IUEIM5.js

@@ -0,0 +1,278 @@
+(() => {
+  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,
+  humanLine
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-release-readiness.ts
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+async function runCheck(name, cmd, args, cwd) {
+  const { spawnSync } = await import("node:child_process");
+  const start = Date.now();
+  const result = spawnSync(cmd, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    cwd
+  });
+  const durationMs = Date.now() - start;
+  const passed = result.status === 0;
+  return {
+    name,
+    status: passed ? "pass" : "fail",
+    exitCode: result.status,
+    durationMs,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim()
+  };
+}
+var doctorReleaseReadinessCommand = defineCommand({
+  meta: {
+    name: "release-readiness",
+    description: "Pre-flight release readiness check \u2014 lint matrix + changelog + changeset + npm OIDC + tag-trigger sanity (T10458)"
+  },
+  args: {
+    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 isHuman = args.human === true || !!process.stdout.isTTY && args.json !== true;
+    const repoRoot = resolve(process.cwd());
+    const startTotal = Date.now();
+    const checks = [];
+    const biomePath = join(repoRoot, "node_modules", ".bin", "biome");
+    const biomeAvailable = existsSync(biomePath);
+    if (biomeAvailable) {
+      checks.push(await runCheck("biome-lint", biomePath, ["ci", "."], repoRoot));
+    } else {
+      checks.push({
+        name: "biome-lint",
+        status: "skip",
+        exitCode: null,
+        durationMs: 0,
+        stdout: "",
+        stderr: "biome not found in node_modules/.bin \u2014 skipping"
+      });
+    }
+    const changesetLintScript = join(repoRoot, "scripts", "lint-changesets.mjs");
+    if (existsSync(changesetLintScript)) {
+      checks.push(await runCheck("changeset-lint", "node", [changesetLintScript], repoRoot));
+    } else {
+      checks.push({
+        name: "changeset-lint",
+        status: "skip",
+        exitCode: null,
+        durationMs: 0,
+        stdout: "",
+        stderr: "scripts/lint-changesets.mjs not found \u2014 skipping"
+      });
+    }
+    const changelogPath = join(repoRoot, "CHANGELOG.md");
+    const changelogExists = existsSync(changelogPath);
+    const changelogCheck = {
+      name: "changelog-exists",
+      status: changelogExists ? "pass" : "fail",
+      exitCode: changelogExists ? 0 : 1,
+      durationMs: 0,
+      stdout: changelogExists ? `Found ${changelogPath}` : "",
+      stderr: changelogExists ? "" : `CHANGELOG.md not found at ${changelogPath}`
+    };
+    checks.push(changelogCheck);
+    const packageJsonPath = join(repoRoot, "package.json");
+    let oidcCheck;
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(
+          await import("node:fs").then((m) => m.readFileSync(packageJsonPath, "utf8"))
+        );
+        if (pkg.private === true) {
+          oidcCheck = {
+            name: "npm-oidc-sanity",
+            status: "pass",
+            exitCode: 0,
+            durationMs: 0,
+            stdout: "root package.json is private \u2014 skipping (per-package check applies at publish time)",
+            stderr: ""
+          };
+        } else {
+          const hasPublishConfig = typeof pkg.publishConfig === "object" && pkg.publishConfig !== null;
+          const accessPublic = hasPublishConfig && pkg.publishConfig.access === "public";
+          oidcCheck = {
+            name: "npm-oidc-sanity",
+            status: accessPublic ? "pass" : "fail",
+            exitCode: accessPublic ? 0 : 1,
+            durationMs: 0,
+            stdout: accessPublic ? "package.json has publishConfig.access=public" : "",
+            stderr: accessPublic ? "" : "package.json missing publishConfig.access=public \u2014 required for npm OIDC Trusted Publishing"
+          };
+        }
+      } catch {
+        oidcCheck = {
+          name: "npm-oidc-sanity",
+          status: "fail",
+          exitCode: 1,
+          durationMs: 0,
+          stdout: "",
+          stderr: "Failed to parse package.json"
+        };
+      }
+    } else {
+      oidcCheck = {
+        name: "npm-oidc-sanity",
+        status: "fail",
+        exitCode: 1,
+        durationMs: 0,
+        stdout: "",
+        stderr: "package.json not found"
+      };
+    }
+    checks.push(oidcCheck);
+    const tagWorkflowPath = join(repoRoot, ".github", "workflows", "auto-tag-on-release-merge.yml");
+    const tagWorkflowExists = existsSync(tagWorkflowPath);
+    let tagTriggerCheck;
+    if (tagWorkflowExists) {
+      try {
+        const content = await import("node:fs").then(
+          (m) => m.readFileSync(tagWorkflowPath, "utf8")
+        );
+        const hasName = content.includes("name:");
+        const hasOnTrigger = content.includes("on:") || content.includes("pull_request:");
+        const valid = hasName && hasOnTrigger;
+        tagTriggerCheck = {
+          name: "tag-trigger-sanity",
+          status: valid ? "pass" : "fail",
+          exitCode: valid ? 0 : 1,
+          durationMs: 0,
+          stdout: valid ? `Valid workflow at ${tagWorkflowPath}` : "",
+          stderr: valid ? "" : "auto-tag-on-release-merge.yml appears malformed"
+        };
+      } catch {
+        tagTriggerCheck = {
+          name: "tag-trigger-sanity",
+          status: "fail",
+          exitCode: 1,
+          durationMs: 0,
+          stdout: "",
+          stderr: "Failed to read auto-tag-on-release-merge.yml"
+        };
+      }
+    } else {
+      tagTriggerCheck = {
+        name: "tag-trigger-sanity",
+        status: "fail",
+        exitCode: 1,
+        durationMs: 0,
+        stdout: "",
+        stderr: `.github/workflows/auto-tag-on-release-merge.yml not found`
+      };
+    }
+    checks.push(tagTriggerCheck);
+    const tsconfigPath = join(repoRoot, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      const tscPath = join(repoRoot, "node_modules", ".bin", "tsc");
+      if (existsSync(tscPath)) {
+        checks.push(await runCheck("typecheck", tscPath, ["--noEmit"], repoRoot));
+      } else {
+        checks.push({
+          name: "typecheck",
+          status: "skip",
+          exitCode: null,
+          durationMs: 0,
+          stdout: "",
+          stderr: "tsc not found in node_modules/.bin \u2014 skipping"
+        });
+      }
+    } else {
+      checks.push({
+        name: "typecheck",
+        status: "skip",
+        exitCode: null,
+        durationMs: 0,
+        stdout: "",
+        stderr: "tsconfig.json not found \u2014 skipping"
+      });
+    }
+    const fastLintScripts = [
+      { name: "contracts-dep-lint", script: "scripts/lint-contracts-dep.mjs" },
+      { name: "format-error-lint", script: "scripts/lint-format-error-misuse.mjs" },
+      { name: "json-stream-lint", script: "scripts/lint-json-stream-hygiene.mjs" }
+    ];
+    for (const lint of fastLintScripts) {
+      const scriptPath = join(repoRoot, lint.script);
+      if (existsSync(scriptPath)) {
+        checks.push(await runCheck(lint.name, "node", [scriptPath], repoRoot));
+      } else {
+        checks.push({
+          name: lint.name,
+          status: "skip",
+          exitCode: null,
+          durationMs: 0,
+          stdout: "",
+          stderr: `${lint.script} not found \u2014 skipping`
+        });
+      }
+    }
+    const passCount = checks.filter((c) => c.status === "pass").length;
+    const failCount = checks.filter((c) => c.status === "fail").length;
+    const skipCount = checks.filter((c) => c.status === "skip").length;
+    const totalDurationMs = Date.now() - startTotal;
+    const ready = failCount === 0;
+    const result = {
+      ready,
+      checks,
+      summary: {
+        pass: passCount,
+        fail: failCount,
+        skip: skipCount,
+        total: checks.length,
+        durationMs: totalDurationMs
+      }
+    };
+    if (isHuman && args.json !== true) {
+      humanLine("\nRelease Readiness Check (T10458)\n");
+      humanLine(`${"\u2500".repeat(60)}`);
+      for (const c of checks) {
+        const icon = c.status === "pass" ? "PASS" : c.status === "fail" ? "FAIL" : "SKIP";
+        humanLine(`  [${icon}] ${c.name} (${c.durationMs}ms)`);
+        if (c.status === "fail" && c.stderr) {
+          const lines = c.stderr.split("\n").slice(0, 3);
+          for (const line of lines) {
+            humanLine(`         ${line}`);
+          }
+        }
+      }
+      humanLine(`${"\u2500".repeat(60)}`);
+      humanLine(`  Result: ${passCount} passed, ${failCount} failed, ${skipCount} skipped`);
+      humanLine(`  Total time: ${totalDurationMs}ms`);
+      humanLine(`  Ready: ${ready ? "YES" : "NO"}
+`);
+    }
+    cliOutput(result, { command: "doctor", operation: "doctor.release-readiness" });
+    if (!ready) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorReleaseReadinessCommand
+};
+//# sourceMappingURL=chunk-A2IUEIM5.js.map