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

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

@@ -0,0 +1,107 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-projects-registry.ts
+import {
+  applyProjectRegistryRepair,
+  inspectProjectRegistry,
+  RegistryRepairError,
+  rollbackProjectRegistryRepair
+} from "@cleocode/core/doctor/projects.js";
+import { NexusRegistryReadError } from "@cleocode/core/nexus/registry-errors.js";
+var positiveInt = (value) => {
+  const n = typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+};
+var doctorRegistryCommand = defineCommand({
+  meta: {
+    name: "projects",
+    description: "Machine-wide registry integrity: rebind moved projects by id, flag split identities, missing, temp and home/root rows, each with the exact remedy. Read-only by default; --apply writes a receipt, --rollback <receiptId> restores the prior rows."
+  },
+  args: {
+    "dry-run": { type: "boolean", description: "Report only (the default); write nothing" },
+    apply: { type: "boolean", description: "Rebind moved rows and record missing locations" },
+    rollback: { type: "string", description: "Restore the rows changed by this receipt id" },
+    roots: {
+      type: "string",
+      description: "Comma-separated extra directories to scan for .cleo/project-id"
+    },
+    "max-depth": { type: "string", description: "Scan depth below each root (default 2)" },
+    concurrency: { type: "string", description: "Filesystem reads in flight (default 16)" },
+    "timeout-ms": { type: "string", description: "Budget per filesystem probe (default 2000)" },
+    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 operation = args.rollback ? "doctor.projects.rollback" : args.apply && !args["dry-run"] ? "doctor.projects.apply" : "doctor.projects.inspect";
+    try {
+      if (typeof args.rollback === "string" && args.rollback.length > 0) {
+        const result = await rollbackProjectRegistryRepair(args.rollback);
+        cliOutput(result, { command: "doctor", operation });
+        return;
+      }
+      const opts = {
+        roots: typeof args.roots === "string" ? args.roots.split(",").map((root) => root.trim()).filter((root) => root.length > 0) : void 0,
+        maxDepth: positiveInt(args["max-depth"]),
+        concurrency: positiveInt(args.concurrency),
+        timeoutMs: positiveInt(args["timeout-ms"])
+      };
+      if (operation === "doctor.projects.apply") {
+        cliOutput(await applyProjectRegistryRepair(opts), { command: "doctor", operation });
+        return;
+      }
+      const report = await inspectProjectRegistry(opts);
+      cliOutput(report, { command: "doctor", operation });
+      if ((report.findings.some((f) => f.kind !== "other-device") || report.ambiguousAliases.length > 0) && (process.exitCode ?? 0) === 0)
+        process.exitCode = 1;
+    } catch (error) {
+      if (error instanceof NexusRegistryReadError) {
+        cliError(
+          error.message,
+          error.code,
+          { name: error.codeName, fix: error.fix, details: error.details },
+          { operation }
+        );
+        process.exitCode = error.code;
+        return;
+      }
+      const code = error instanceof RegistryRepairError ? error.code : "E_DOCTOR_PROJECTS_FAILED";
+      const exitCode = code === "E_NOT_FOUND" ? 4 : 1;
+      cliError(
+        error instanceof Error ? error.message : String(error),
+        exitCode,
+        { name: code },
+        {
+          operation
+        }
+      );
+      process.exitCode = exitCode;
+    }
+  }
+});
+
+export {
+  doctorRegistryCommand
+};
+//# sourceMappingURL=chunk-7NMKLVMI.js.map

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

@@ -0,0 +1,110 @@
+(() => {
+  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,
+  humanInfo
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-exodus-residue.ts
+import {
+  archiveStrandedResidue,
+  buildExodusPlan,
+  detectStrandedResidue
+} from "@cleocode/core/store/exodus/index.js";
+var doctorExodusResidueCommand = defineCommand({
+  meta: {
+    name: "exodus-residue",
+    description: "Detect legacy exodus source DBs still present after a cutover (stranded residue that re-arms the exodus-on-open corruption trigger). Use --fix to archive them into _archive/ (reversible move, never deletes)."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Archive stranded legacy source DBs into _archive/ (move, never delete)",
+      default: false
+    }
+  },
+  run({ args }) {
+    const fix = args.fix === true;
+    const cwd = process.cwd();
+    const plan = buildExodusPlan(cwd);
+    const stranded = detectStrandedResidue(plan.sources, cwd);
+    if (stranded.length === 0) {
+      cliOutput(
+        {
+          kind: "generic",
+          ok: true,
+          strandedCount: 0,
+          stranded: [],
+          fixed: false
+        },
+        {
+          command: "doctor exodus-residue",
+          message: "No stranded legacy exodus source DBs (clean cutover or pre-migration install)."
+        }
+      );
+      return;
+    }
+    for (const entry of stranded) {
+      humanInfo(`  STRANDED [${entry.scope}] ${entry.name} \u2192 ${entry.path}`);
+    }
+    if (!fix) {
+      cliOutput(
+        {
+          kind: "generic",
+          ok: false,
+          strandedCount: stranded.length,
+          stranded: stranded.map((s) => ({ name: s.name, path: s.path, scope: s.scope })),
+          fixed: false
+        },
+        {
+          command: "doctor exodus-residue",
+          message: `${stranded.length} stranded legacy source DB(s) found. Run \`cleo doctor exodus-residue --fix\` to archive them.`
+        }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const archived = archiveStrandedResidue(stranded, plan.sources, cwd);
+    const movedCount = archived.filter((a) => a.action === "archived").length;
+    humanInfo(`  Archived ${movedCount} stranded source DB(s) \u2192 _archive/.`);
+    cliOutput(
+      {
+        kind: "generic",
+        ok: true,
+        strandedCount: stranded.length,
+        stranded: stranded.map((s) => ({ name: s.name, path: s.path, scope: s.scope })),
+        fixed: true,
+        archived: archived.map((a) => ({
+          name: a.name,
+          action: a.action,
+          archivedTo: a.archivedTo
+        }))
+      },
+      {
+        command: "doctor exodus-residue",
+        message: `Archived ${movedCount} stranded legacy source DB(s) into _archive/.`
+      }
+    );
+  }
+});
+
+export {
+  doctorExodusResidueCommand
+};
+//# sourceMappingURL=chunk-7SINJXB6.js.map

package/dist/cli/chunk-7UARFJYS.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-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-migrations.ts
+import { inspectMigrations } from "@cleocode/core/doctor/migrations.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+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-7UARFJYS.js.map

package/dist/cli/chunk-7ZYPQV4N.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-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-legacy-backups.ts
+import { pruneLegacyBackups, scanLegacyBackups } from "@cleocode/core/doctor/legacy-backups.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+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-7ZYPQV4N.js.map

package/dist/cli/chunk-AQCYT3L4.js

@@ -0,0 +1,72 @@
+(() => {
+  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,
+  humanInfo
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-exodus.ts
+import { buildExodusHealth } from "@cleocode/core/store/exodus/index.js";
+function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+var doctorExodusCommand = defineCommand({
+  meta: {
+    name: "exodus-health",
+    description: "Read-only exodus health report: per-scope migration state, legacy DB sizes, completion markers, disk headroom, and the kill-switch \u2014 with recommended next steps."
+  },
+  run() {
+    const health = buildExodusHealth(process.cwd());
+    for (const sc of [health.project, health.global]) {
+      humanInfo(
+        `  [${sc.scope}] state=${sc.state}  consolidated=${sc.consolidatedExists ? "yes" : "no"}  marker=${sc.markerPresent ? "yes" : "no"}`
+      );
+      for (const s of sc.legacySources) {
+        humanInfo(
+          `      ${s.present ? "\u2713" : "\xB7"} ${s.name.padEnd(18)} ${s.present ? fmtBytes(s.bytes) : "-"}${s.large ? "  \u26A0 LARGE" : ""}`
+        );
+      }
+    }
+    humanInfo(
+      `  disk: ${fmtBytes(health.availableBytes)} free / ${fmtBytes(health.requiredBytes)} required \u2014 ${health.diskHeadroomOk ? "OK" : "LOW"}`
+    );
+    humanInfo(
+      `  kill-switch (CLEO_DISABLE_EXODUS_ON_OPEN): ${health.killSwitchSet ? "SET" : "off"}`
+    );
+    if (health.recommendations.length > 0) {
+      humanInfo("  recommendations:");
+      for (const r of health.recommendations) humanInfo(`    \u2022 ${r}`);
+    }
+    cliOutput(
+      { kind: "generic", ...health },
+      {
+        command: "doctor exodus",
+        message: `exodus health: project=${health.project.state}, global=${health.global.state}${health.dataParityOk ? "" : `, ${health.dataDeficits} DEFICIT(S)`}.`
+      }
+    );
+  }
+});
+
+export {
+  doctorExodusCommand
+};
+//# sourceMappingURL=chunk-AQCYT3L4.js.map

package/dist/cli/chunk-BQK6XTOH.js

@@ -0,0 +1,57 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-worktree-stores.ts
+import { scanWorktreeStores } from "@cleocode/core/doctor/worktree-stores.js";
+import { getProjectRoot, resolveStoreOwnerRoot } from "@cleocode/core/paths.js";
+var doctorWorktreeStoresCommand = defineCommand({
+  meta: {
+    name: "worktree-stores",
+    description: "List store files (.cleo/*.db, *.bak) stranded inside the project worktrees and report whether each holds rows newer than the parent store. Read-only \u2014 deletes nothing."
+  },
+  args: {
+    "skip-compare": {
+      type: "boolean",
+      description: "List files only; skip the per-table row comparison against the parent store"
+    },
+    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 = resolveStoreOwnerRoot(getProjectRoot());
+    const result = scanWorktreeStores(projectRoot, { skipCompare: args["skip-compare"] === true });
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.worktree-stores.run",
+      message: `${result.strandedFileCount} stranded store file(s) in ${result.entries.length} worktree(s); ${result.filesWithNewerRows.length} hold rows the parent store lacks.`
+    });
+    if (result.filesWithNewerRows.length > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorWorktreeStoresCommand
+};
+//# sourceMappingURL=chunk-BQK6XTOH.js.map

package/dist/cli/chunk-C3B7C43W.js

@@ -0,0 +1,16 @@
+(() => {
+  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);
+  };
+})();
+//# sourceMappingURL=chunk-C3B7C43W.js.map

package/dist/cli/chunk-CAPAGD5E.js

@@ -0,0 +1,98 @@
+(() => {
+  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,
+  humanInfo
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-repair.ts
+import { DB_INVENTORY } from "@cleocode/contracts/db-inventory.js";
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { getLogger } from "@cleocode/core/logger";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { repairMalformedDbs } from "@cleocode/core/store/repair-malformed-dbs.js";
+var doctorRepairCommand = defineCommand({
+  meta: {
+    name: "repair",
+    description: "Detect malformed CLEO databases (PRAGMA quick_check) and restore each from its freshest validated snapshot via the recovery pipeline (quarantine \u2192 restore \u2192 verify). Defaults to every present DB; use --role to narrow, --dry-run to plan without mutating."
+  },
+  args: {
+    role: {
+      type: "string",
+      description: `Repair only this DB role (one of: ${DB_INVENTORY.map((e) => e.role).join(", ")})`,
+      default: ""
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Detect + plan only \u2014 report what would be repaired without quarantining/restoring",
+      default: false
+    },
+    "confirm-owner-store": {
+      type: "boolean",
+      description: "From inside a git worktree: allow overwriting the owning project's LIVE store (refused without it)",
+      default: false
+    }
+  },
+  run({ args }) {
+    const roleArg = typeof args.role === "string" ? args.role.trim() : "";
+    const dryRun = args["dry-run"] === true;
+    if (roleArg.length > 0 && !DB_INVENTORY.some((e) => e.role === roleArg)) {
+      const validRoles = DB_INVENTORY.map((e) => e.role).join(", ");
+      cliError(
+        `Unknown DB role "${roleArg}". Valid roles: ${validRoles}.`,
+        ExitCode.VALIDATION_ERROR,
+        {
+          name: "E_VALIDATION",
+          fix: "Run `cleo doctor repair --help` for the list of valid roles."
+        },
+        { command: "doctor repair" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    const result = repairMalformedDbs({
+      projectRoot: getProjectRoot(),
+      roles: roleArg.length > 0 ? [roleArg] : void 0,
+      dryRun,
+      logger: getLogger("doctor-repair"),
+      // T12708: the invocation directory; core never falls back to it.
+      cwd: process.cwd(),
+      confirmOwnerStore: args["confirm-owner-store"] === true
+    });
+    for (const r of result.roles) {
+      if (!r.healthy) {
+        humanInfo(`  [${r.action.toUpperCase()}] ${r.role} \u2014 ${r.detail}`);
+      }
+    }
+    const verb = dryRun ? "would repair" : "repaired";
+    cliOutput(result, {
+      command: "doctor repair",
+      message: result.malformedCount === 0 ? `All ${result.roles.length} inspected DB(s) healthy \u2014 nothing to repair.` : `${result.malformedCount} malformed DB(s): ${verb} ${result.repairedCount}, ${result.failedCount} failed.`
+    });
+    if (result.failedCount > 0) {
+      process.exitCode = ExitCode.GENERAL_ERROR;
+    }
+  }
+});
+
+export {
+  doctorRepairCommand
+};
+//# sourceMappingURL=chunk-CAPAGD5E.js.map

package/dist/cli/chunk-CHGEDCKG.js

@@ -0,0 +1,77 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-ac-bindings.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { scanOrphanAcBindings } from "@cleocode/core/doctor/orphan-ac-bindings.js";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorAcBindingsCommand = defineCommand({
+  meta: {
+    name: "ac-bindings",
+    description: "Report evidence bindings whose acceptance criterion no longer exists (dangling tasks_evidence_ac_bindings rows). Read-only unless --fix is given; --fix removes them, recording each removed row in the task audit log (ac.bindings.pruned)."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Delete the orphan bindings in one transaction, after writing each row to the task audit log so binding history (alias-drift detection) is kept."
+    },
+    limit: {
+      type: "string",
+      description: "Maximum orphan rows echoed in the report (default 50; counts are exact)"
+    },
+    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 }) {
+    let limit;
+    if (typeof args.limit === "string") {
+      if (!/^\d+$/.test(args.limit.trim())) {
+        cliError(
+          `--limit must be a non-negative integer (got '${args.limit}')`,
+          ExitCode.VALIDATION_ERROR,
+          { name: "E_VALIDATION" }
+        );
+        return;
+      }
+      limit = Number.parseInt(args.limit, 10);
+    }
+    const report = await scanOrphanAcBindings(getProjectRoot(), {
+      fix: args.fix === true,
+      limit
+    });
+    cliOutput(report, {
+      command: "doctor",
+      operation: "doctor.ac-bindings.run"
+    });
+    const unresolved = report.orphanCount > report.removed;
+    if (unresolved && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorAcBindingsCommand
+};
+//# sourceMappingURL=chunk-CHGEDCKG.js.map