@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/chunk-JNZJPIPJ.js

@@ -0,0 +1,90 @@
+(() => {
+  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-legacy-backups.ts
+import { getProjectRoot } from "@cleocode/core";
+import { pruneLegacyBackups, scanLegacyBackups } from "@cleocode/core/doctor/legacy-backups.js";
+function parsePositiveInt(raw, fallback) {
+  if (raw === void 0 || raw === null) return fallback;
+  const parsed = Number.parseInt(String(raw), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+var doctorLegacyBackupsCommand = defineCommand({
+  meta: {
+    name: "legacy-backups",
+    description: "Enumerate legacy *-pre-cleo.db.bak / brain.db.PRE-DUP-FIX-* / pre-untrack / rotation-overflow artefacts and report origin + retention recommendation. Use --prune to delete 'delete'-recommended files (always dry-run unless --no-dry-run is passed)."
+  },
+  args: {
+    prune: {
+      type: "boolean",
+      description: "Remove every artefact whose recommendation is 'delete'. Defaults to --dry-run; pass --no-dry-run to physically remove."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Combine with --prune to preview deletions without touching the filesystem.",
+      default: true
+    },
+    "soft-retention-days": {
+      type: "string",
+      description: "Days under which artefacts are always kept (default 30)."
+    },
+    "hard-retention-days": {
+      type: "string",
+      description: "Days over which artefacts are eligible for prune (default 90)."
+    },
+    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 softRetentionDays = parsePositiveInt(args["soft-retention-days"], 30);
+    const hardRetentionDays = parsePositiveInt(args["hard-retention-days"], 90);
+    const projectRoot = getProjectRoot();
+    let result;
+    if (args.prune === true) {
+      const dryRun = args["dry-run"] !== false;
+      result = pruneLegacyBackups(projectRoot, {
+        softRetentionDays,
+        hardRetentionDays,
+        dryRun
+      });
+    } else {
+      result = scanLegacyBackups(projectRoot, {
+        softRetentionDays,
+        hardRetentionDays
+      });
+    }
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.legacy-backups.run"
+    });
+    if (result.errors.length > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorLegacyBackupsCommand
+};
+//# sourceMappingURL=chunk-JNZJPIPJ.js.map

package/dist/cli/chunk-KHB52JNB.js

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

package/dist/cli/chunk-KJDWWQFY.js

@@ -0,0 +1,46 @@
+(() => {
+  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-migrations.ts
+import { getProjectRoot } from "@cleocode/core";
+import { inspectMigrations } from "@cleocode/core/doctor/migrations.js";
+var doctorMigrationsCommand = defineCommand({
+  meta: {
+    name: "migrations",
+    description: "Report the migration journal of the project and global stores: row count, head, applied and pending files per lineage, hash drift, and a journal rebuilt on a store that already held its schema. Read-only."
+  },
+  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() {
+    const report = inspectMigrations(getProjectRoot());
+    cliOutput(report, { command: "doctor", operation: "doctor.migrations.run" });
+    if (report.scopes.some((s) => s.drift.length > 0)) process.exitCode = 1;
+  }
+});
+
+export {
+  doctorMigrationsCommand
+};
+//# sourceMappingURL=chunk-KJDWWQFY.js.map

package/dist/cli/chunk-LKNUA3SB.js

@@ -0,0 +1,83 @@
+(() => {
+  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/doctor-global-delivery.ts
+import {
+  auditGlobalDelivery,
+  repairGlobalDelivery
+} from "@cleocode/core/system/global-delivery.js";
+var doctorGlobalDeliveryCommand = defineCommand({
+  meta: {
+    name: "global-delivery",
+    description: "Check that ~/.cleo, the global hub reference and every harness CLEO skill install resolve. Read-only; --repair relinks them with a receipt (--dry-run to preview)."
+  },
+  args: {
+    repair: {
+      type: "boolean",
+      description: "Relink ~/.cleo to the OS data dir and every dangling or ~/.cleo-routed skill entry to the physical skills dir (verified symlink, else copy). Appends a receipt."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "With --repair: report the receipt without touching disk"
+    },
+    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 dryRun = args["dry-run"] === true;
+    let result = null;
+    if (args.repair === true) {
+      try {
+        result = await repairGlobalDelivery({ dryRun });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        cliError(
+          message,
+          1,
+          {
+            name: "E_CLEO_LINK_REPAIR_FAILED",
+            fix: "The entry that failed was restored to its previous link (~/.cleo or the skill link). The intent and failed receipts under <cleoHome>/audit list every planned entry with its previous target. On Windows enable Developer Mode or run as administrator, then re-run `cleo doctor global-delivery --repair`."
+          },
+          { operation: "doctor.global-delivery.run" }
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const audit = result?.audit ?? await auditGlobalDelivery();
+    cliOutput(
+      { ...audit, receipt: result?.receipt ?? null },
+      { command: "doctor", operation: "doctor.global-delivery.run" }
+    );
+    const refused = result?.receipt.link.action === "refused";
+    if ((refused || !audit.healthy && !dryRun) && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorGlobalDeliveryCommand
+};
+//# sourceMappingURL=chunk-LKNUA3SB.js.map

package/dist/cli/chunk-LVGIFMCV.js

@@ -0,0 +1,163 @@
+(() => {
+  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/gateway-auto-start.ts
+import { once } from "node:events";
+import { createWriteStream, existsSync, readFileSync, realpathSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import * as net from "node:net";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnWrapped } from "@cleocode/core/resources/spawn-wrapper.js";
+var GATEWAY_DEFAULT_PORT = 7777;
+var GATEWAY_DEFAULT_HOST = "127.0.0.1";
+var GATEWAY_WAIT_TIMEOUT_MS = 1e4;
+var POLL_INITIAL_DELAY_MS = 100;
+var POLL_MAX_DELAY_MS = 1e3;
+var CLEO_PACKAGE_NAME = "@cleocode/cleo";
+function shouldAutoStartGateway(config) {
+  if (config === null || config === void 0) return true;
+  const daemon = config["daemon"];
+  if (daemon === null || daemon === void 0) return true;
+  if (typeof daemon !== "object") return true;
+  const daemonObj = daemon;
+  const autoStart = daemonObj["autoStart"];
+  if (autoStart === false) return false;
+  return true;
+}
+function probePort(port, host = GATEWAY_DEFAULT_HOST) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ port, host });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+async function pollPort(port, host, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let delay = POLL_INITIAL_DELAY_MS;
+  while (Date.now() < deadline) {
+    const ok = await probePort(port, host);
+    if (ok) return true;
+    const remaining = deadline - Date.now();
+    const wait = Math.min(delay, remaining, POLL_MAX_DELAY_MS);
+    if (wait <= 0) break;
+    await new Promise((r) => setTimeout(r, wait));
+    delay = Math.min(delay * 2, POLL_MAX_DELAY_MS);
+  }
+  return probePort(port, host);
+}
+function resolveCliEntryPath(startUrl = import.meta.url) {
+  const startFile = realpathSync(fileURLToPath(startUrl));
+  let current = dirname(startFile);
+  for (let i = 0; i < 20; i++) {
+    const pkgJsonPath = join(current, "package.json");
+    if (existsSync(pkgJsonPath)) {
+      let pkgName;
+      try {
+        const raw = readFileSync(pkgJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        pkgName = typeof parsed["name"] === "string" ? parsed["name"] : void 0;
+      } catch {
+      }
+      if (pkgName === CLEO_PACKAGE_NAME) {
+        const entry = join(current, "dist", "cli", "index.js");
+        if (!existsSync(entry)) {
+          throw new Error(
+            `@cleocode/cleo package root found at ${current} but dist/cli/index.js is missing \u2014 run \`pnpm --filter @cleocode/cleo run build\` to generate it`
+          );
+        }
+        return entry;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  throw new Error(
+    `could not locate ${CLEO_PACKAGE_NAME} package root starting from ${startFile} \u2014 checked up to 20 ancestor directories`
+  );
+}
+async function spawnGatewayIfDown(opts = {}) {
+  const port = opts.port ?? GATEWAY_DEFAULT_PORT;
+  const host = opts.host ?? GATEWAY_DEFAULT_HOST;
+  const waitTimeoutMs = opts.waitTimeoutMs ?? GATEWAY_WAIT_TIMEOUT_MS;
+  if (await probePort(port, host)) {
+    return { reachable: true, spawned: false };
+  }
+  let cliEntry;
+  try {
+    cliEntry = opts.cliEntryPath ?? resolveCliEntryPath();
+  } catch (err) {
+    const reason = `gateway auto-start: cannot resolve CLI entry path \u2014 ${err instanceof Error ? err.message : String(err)}`;
+    return { reachable: false, spawned: false, reason };
+  }
+  let outFd = "ignore";
+  let errFd = "ignore";
+  try {
+    const { getCleoLogDir } = await import("@cleocode/core");
+    const logDir = getCleoLogDir();
+    await mkdir(logDir, { recursive: true });
+    const outStream = createWriteStream(join(logDir, "gateway.log"), { flags: "a" });
+    const errStream = createWriteStream(join(logDir, "gateway.err"), { flags: "a" });
+    await Promise.all([once(outStream, "open"), once(errStream, "open")]);
+    outFd = outStream;
+    errFd = errStream;
+  } catch {
+  }
+  const spawnArgs = ["daemon", "serve"];
+  if (port !== GATEWAY_DEFAULT_PORT) spawnArgs.push("--port", String(port));
+  if (host !== GATEWAY_DEFAULT_HOST) spawnArgs.push("--host", host);
+  try {
+    const { child } = spawnWrapped(
+      process.execPath,
+      [cliEntry, ...spawnArgs],
+      {
+        detached: true,
+        stdio: ["ignore", outFd, errFd],
+        env: { ...process.env, CLEO_GATEWAY_AUTO_STARTED: "1" }
+      },
+      { scopeClass: "daemon", scopeId: "gateway" }
+    );
+    child.unref();
+  } catch (err) {
+    const reason = `gateway auto-start: spawn failed \u2014 ${err instanceof Error ? err.message : String(err)}`;
+    return { reachable: false, spawned: false, reason };
+  }
+  const reachable = await pollPort(port, host, waitTimeoutMs);
+  return {
+    reachable,
+    spawned: true,
+    reason: reachable ? void 0 : "gateway did not become reachable within the timeout"
+  };
+}
+
+export {
+  GATEWAY_DEFAULT_PORT,
+  GATEWAY_DEFAULT_HOST,
+  GATEWAY_WAIT_TIMEOUT_MS,
+  shouldAutoStartGateway,
+  probePort,
+  pollPort,
+  resolveCliEntryPath,
+  spawnGatewayIfDown
+};
+//# sourceMappingURL=chunk-LVGIFMCV.js.map

package/dist/cli/chunk-LWQBJQSE.js

@@ -0,0 +1,67 @@
+(() => {
+  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-acceptance-drift.ts
+import { getProjectRoot } from "@cleocode/core";
+import {
+  scanAcceptanceDrift,
+  writeAcceptanceDriftBaseline
+} from "@cleocode/core/doctor/acceptance-drift.js";
+var doctorAcceptanceDriftCommand = defineCommand({
+  meta: {
+    name: "acceptance-drift",
+    description: "Report tasks whose acceptance criteria disagree between the JSON column and the typed rows table, separating legacy-convention rows from current-era regressions. Read-only \u2014 repairs nothing."
+  },
+  args: {
+    "update-baseline": {
+      type: "boolean",
+      description: "Accept every current drifting task, so only NEW drift fails afterwards"
+    },
+    all: {
+      type: "boolean",
+      description: "Exit non-zero for every drifting task, baselined or not"
+    },
+    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(ctx) {
+    const result = scanAcceptanceDrift(getProjectRoot());
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.acceptance-drift.run"
+    });
+    if (ctx.args["update-baseline"]) {
+      writeAcceptanceDriftBaseline(result);
+      return;
+    }
+    const failing = ctx.args.all ? result.entries.length : result.unbaselined.length;
+    if (failing > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorAcceptanceDriftCommand
+};
+//# sourceMappingURL=chunk-LWQBJQSE.js.map