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

package/dist/cli/backup-NUGBZ7NA.js

@@ -0,0 +1,588 @@
+(() => {
+  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 {
+  backupInspectSubCommand
+} from "./chunk-QJJWWCIC.js";
+import {
+  backupRecoverSubCommand
+} from "./chunk-2MGFDMDF.js";
+import "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import {
+  CLEO_DIR_NAME,
+  CLI_GLOBAL_BACKUP_FILES,
+  CLI_PROJECT_BACKUP_FILES,
+  CONFIG_JSON,
+  PROJECT_INFO_JSON,
+  RESTORE_CONFLICTS_MD,
+  RESTORE_IMPORTED_SUBDIR
+} from "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput,
+  humanInfo
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/backup.ts
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+
+// packages/cleo/src/cli/commands/backup-verify.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { getProjectRoot } from "@cleocode/core";
+import { runBackupVerify } from "@cleocode/core/store/backup-verify.js";
+var backupVerifySubCommand = defineCommand({
+  meta: {
+    name: "verify",
+    description: "Walk DB_INVENTORY and report per-DB freshness + integrity for each snapshot in BOTH .cleo/backups/sqlite/ (canonical) and .cleo/backups/snapshot/ (legacy). Exits non-zero on any stale/corrupt finding."
+  },
+  args: {
+    "per-db-timeout-ms": {
+      type: "string",
+      description: "Per-DB integrity-check timeout in milliseconds (default: 30000).",
+      default: "30000"
+    },
+    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 argsBag = args;
+    const rawTimeout = argsBag["per-db-timeout-ms"];
+    let perDbTimeoutMs = 3e4;
+    if (typeof rawTimeout === "string" && rawTimeout.length > 0) {
+      const parsed = Number.parseInt(rawTimeout, 10);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        cliError(
+          `Invalid --per-db-timeout-ms value: ${rawTimeout}`,
+          ExitCode.VALIDATION_ERROR,
+          {
+            name: "E_VALIDATION",
+            fix: "Provide a positive integer number of milliseconds (e.g. --per-db-timeout-ms 30000)."
+          },
+          { operation: "backup.verify" }
+        );
+        process.exitCode = ExitCode.VALIDATION_ERROR;
+        return;
+      }
+      perDbTimeoutMs = parsed;
+    }
+    let result;
+    try {
+      result = runBackupVerify({
+        projectRoot: getProjectRoot(),
+        perDbTimeoutMs
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        message,
+        ExitCode.GENERAL_ERROR,
+        { name: "E_BACKUP_VERIFY_FAILED" },
+        { operation: "backup.verify" }
+      );
+      process.exitCode = ExitCode.GENERAL_ERROR;
+      return;
+    }
+    cliOutput(result, {
+      command: "backup",
+      operation: "backup.verify"
+    });
+    if ((result.summary.corrupt > 0 || result.summary.stale > 0) && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = ExitCode.GENERAL_ERROR;
+    }
+  }
+});
+
+// packages/cleo/src/cli/commands/backup.ts
+async function promptPassphrase() {
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      "Cannot prompt for passphrase: stdin is not a TTY. Set the CLEO_BACKUP_PASSPHRASE environment variable for non-interactive use."
+    );
+  }
+  return new Promise((resolve) => {
+    process.stdout.write("Passphrase: ");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question("", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add a new backup of all CLEO data files (backup create is an alias for backup add)"
+  },
+  args: {
+    destination: {
+      type: "string",
+      description: "Backup destination directory"
+    },
+    global: {
+      type: "boolean",
+      description: "Also back up the global store (<CLEO_HOME>/cleo.db: global brain, nexus, agent registry); restore it with cleo restore backup --scope global --id <id>"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "backup",
+      {
+        type: "snapshot",
+        note: args.destination ? `destination:${args.destination}` : void 0,
+        includeGlobal: args.global === true
+      },
+      { command: "backup" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List available backups"
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Filter by backup scope: project, global, or all (default: all)",
+      default: "all"
+    }
+  },
+  async run({ args }) {
+    const scope = args.scope || "all";
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "backup",
+      {
+        type: "list",
+        scope
+      },
+      { command: "backup" }
+    );
+  }
+});
+var exportCommand = defineCommand({
+  meta: {
+    name: "export",
+    description: "Export CLEO state to a portable .cleobundle.tar.gz (scopes: project | global | all | machine)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Bundle name (used as filename stem)",
+      required: true
+    },
+    scope: {
+      type: "string",
+      description: "project | global | all | machine",
+      default: "project"
+    },
+    encrypt: {
+      type: "boolean",
+      description: "Encrypt bundle with passphrase (AES-256-GCM via scrypt); required to carry secrets"
+    },
+    out: {
+      type: "string",
+      description: "Output bundle path (default: ./<name>[.enc].cleobundle.tar.gz)"
+    }
+  },
+  async run({ args }) {
+    const scope = args.scope;
+    if (scope !== "project" && scope !== "global" && scope !== "all" && scope !== "machine") {
+      cliError(`--scope must be project, global, all or machine (got "${scope}")`, 6, {
+        name: "E_VALIDATION"
+      });
+      process.exitCode = 6;
+      return;
+    }
+    const { exportPortableBundle, PortableBundleError } = await import("@cleocode/core/store/portable-bundle.js");
+    const { getProjectRoot: getProjectRoot2 } = await import("@cleocode/core");
+    const passphrase = args.encrypt === true ? await resolvePassphrase() : void 0;
+    if (args.encrypt === true && passphrase === void 0) return;
+    const encSuffix = args.encrypt === true ? "enc." : "";
+    try {
+      const result = await exportPortableBundle({
+        scope,
+        projectRoot: scope === "project" || scope === "all" ? getProjectRoot2() : void 0,
+        outputPath: args.out ?? `./${args.name}.${encSuffix}cleobundle.tar.gz`,
+        encrypt: args.encrypt === true,
+        passphrase,
+        label: args.name
+      });
+      cliOutput(result, { command: "backup", operation: "backup.export" });
+      humanInfo(`Bundle written to ${result.bundlePath} (${result.size} bytes)`);
+      humanInfo(result.memory.notice);
+    } catch (err) {
+      reportBundleError(err, err instanceof PortableBundleError ? err : null, "E_EXPORT_FAILED");
+    }
+  }
+});
+var importCommand = defineCommand({
+  meta: {
+    name: "import",
+    description: "Import a .cleobundle.tar.gz into the current project (and/or global tier)"
+  },
+  args: {
+    bundle: {
+      type: "positional",
+      description: "Path to the .cleobundle.tar.gz file",
+      required: true
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing live data at target without aborting"
+    },
+    target: {
+      type: "string",
+      description: "Portable bundles: place a single-project bundle at this project root (paths are relocated)"
+    },
+    map: {
+      type: "string",
+      description: "Portable bundles: rewrite project paths <oldPrefix>=<newPrefix> (repeatable; longest prefix wins)"
+    },
+    "confirm-owner-store": {
+      type: "boolean",
+      description: "From inside a git worktree: allow overwriting the owning project's LIVE store (refused without it)",
+      default: false
+    }
+  },
+  async run({ args, rawArgs }) {
+    const bundlePath = args.bundle;
+    const confirmOwnerStore = args["confirm-owner-store"] === true;
+    const { detectBundleFormat } = await import("@cleocode/core/store/portable-bundle-import.js");
+    if (await detectBundleFormat(bundlePath) === "v2") {
+      await portableImport(
+        bundlePath,
+        args.target,
+        collectFlagValues(rawArgs, "map"),
+        args.force,
+        confirmOwnerStore
+      );
+      return;
+    }
+    const { getProjectRoot: getProjectRoot2, getCleoHome, getCleoVersion } = await import("@cleocode/core");
+    const { BundleError, cleanupStaging, unpackBundle } = await import("@cleocode/core/store/backup-unpack.js");
+    const { regenerateConfigJson, regenerateProjectContextJson, regenerateProjectInfoJson } = await import("@cleocode/core/store/regenerators.js");
+    const { regenerateAndCompare } = await import("@cleocode/core/store/restore-json-merge.js");
+    const { buildConflictReport, writeConflictReport } = await import("@cleocode/core/store/restore-conflict-report.js");
+    const projectRoot = getProjectRoot2();
+    const { assertOwnerStoreRewriteConfirmed } = await import("@cleocode/core/store/worktree-isolation-guard.js");
+    try {
+      assertOwnerStoreRewriteConfirmed("backup import", path.join(projectRoot, ".cleo"), {
+        cwd: process.cwd(),
+        confirmOwnerStore
+      });
+    } catch (err) {
+      reportBundleError(err, null, "E_IMPORT_FAILED");
+      return;
+    }
+    if (args.force !== true) {
+      const existing = checkForExistingData(projectRoot, getCleoHome());
+      if (existing.length > 0) {
+        process.stderr.write(
+          JSON.stringify({
+            success: false,
+            error: {
+              code: 78,
+              codeName: "E_DATA_EXISTS",
+              message: `Target has existing data: ${existing.join(", ")}. Use --force to overwrite.`
+            }
+          }) + "\n"
+        );
+        process.exitCode = 78;
+        return;
+      }
+    }
+    let passphrase;
+    if (isBundleEncrypted(bundlePath)) {
+      passphrase = process.env["CLEO_BACKUP_PASSPHRASE"];
+      if (!passphrase) {
+        try {
+          passphrase = await promptPassphrase();
+        } catch (promptErr) {
+          const msg = promptErr instanceof Error ? promptErr.message : String(promptErr);
+          process.stderr.write(
+            JSON.stringify({ success: false, error: { code: 6, message: msg } }) + "\n"
+          );
+          process.exitCode = 6;
+          return;
+        }
+      }
+    }
+    let result;
+    try {
+      result = await unpackBundle({ bundlePath, passphrase });
+    } catch (err) {
+      if (err instanceof BundleError) {
+        process.stderr.write(
+          JSON.stringify({
+            success: false,
+            error: { code: err.code, codeName: err.codeName, message: err.message }
+          }) + "\n"
+        );
+        process.exitCode = err.code;
+        return;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(JSON.stringify({ success: false, error: { code: 1, message } }) + "\n");
+      process.exitCode = 1;
+      return;
+    }
+    const { stagingDir, manifest, warnings } = result;
+    try {
+      for (const dbEntry of manifest.databases) {
+        const src = path.join(stagingDir, dbEntry.filename);
+        if (!fs.existsSync(src)) continue;
+        const dst = resolveDbTarget(projectRoot, dbEntry.name, getCleoHome());
+        fs.mkdirSync(path.dirname(dst), { recursive: true });
+        const tmpDst = `${dst}.import-tmp-${Date.now()}`;
+        fs.copyFileSync(src, tmpDst);
+        fs.renameSync(tmpDst, dst);
+        for (const sidecar of [`${dst}-wal`, `${dst}-shm`]) {
+          if (fs.existsSync(sidecar)) {
+            try {
+              fs.unlinkSync(sidecar);
+            } catch {
+            }
+          }
+        }
+      }
+      const jsonReports = [];
+      for (const jsonEntry of manifest.json) {
+        const importedPath = path.join(stagingDir, jsonEntry.filename);
+        if (!fs.existsSync(importedPath)) continue;
+        const imported = JSON.parse(fs.readFileSync(importedPath, "utf-8"));
+        const basename = path.basename(jsonEntry.filename);
+        let localGenerated;
+        if (basename === CONFIG_JSON) {
+          localGenerated = regenerateConfigJson(projectRoot).content;
+        } else if (basename === PROJECT_INFO_JSON) {
+          localGenerated = regenerateProjectInfoJson(projectRoot).content;
+        } else {
+          localGenerated = regenerateProjectContextJson(projectRoot).content;
+        }
+        const report = regenerateAndCompare({
+          filename: basename,
+          imported,
+          localGenerated
+        });
+        jsonReports.push(report);
+        const targetPath = path.join(projectRoot, CLEO_DIR_NAME, basename);
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.writeFileSync(targetPath, JSON.stringify(report.applied, null, 2), "utf-8");
+      }
+      const cleoVersion = getCleoVersion();
+      const conflictMd = buildConflictReport({
+        reports: jsonReports,
+        bundlePath,
+        sourceMachineFingerprint: manifest.backup.machineFingerprint,
+        targetMachineFingerprint: sha256OfMachineKey(getCleoHome()),
+        cleoVersion,
+        schemaWarnings: warnings.map((w) => ({
+          db: w.db,
+          bundleVersion: w.bundleVersion,
+          localVersion: w.localVersion,
+          severity: w.severity
+        }))
+      });
+      writeConflictReport(projectRoot, conflictMd);
+      const importedDir = path.join(projectRoot, CLEO_DIR_NAME, RESTORE_IMPORTED_SUBDIR);
+      fs.mkdirSync(importedDir, { recursive: true });
+      for (const jsonEntry of manifest.json) {
+        const src = path.join(stagingDir, jsonEntry.filename);
+        if (!fs.existsSync(src)) continue;
+        const dst = path.join(importedDir, jsonEntry.filename);
+        fs.mkdirSync(path.dirname(dst), { recursive: true });
+        fs.copyFileSync(src, dst);
+      }
+      const totalConflicts = jsonReports.reduce((sum, r) => sum + r.conflictCount, 0);
+      const conflictReportPath = path.join(projectRoot, CLEO_DIR_NAME, RESTORE_CONFLICTS_MD);
+      cliOutput(
+        {
+          imported: bundlePath,
+          dbsRestored: manifest.databases.length,
+          jsonReports: jsonReports.map((r) => ({
+            filename: r.filename,
+            conflicts: r.conflictCount
+          })),
+          totalConflicts,
+          conflictReportPath
+        },
+        { command: "backup", operation: "backup.import" }
+      );
+      if (totalConflicts > 0) {
+        humanInfo(
+          `Restore complete with ${totalConflicts} unresolved conflict(s). Run 'cleo restore finalize' after resolving ${conflictReportPath}`
+        );
+      } else {
+        humanInfo(`Restore complete. Review ${conflictReportPath} for details.`);
+      }
+    } catch (restoreErr) {
+      const message = restoreErr instanceof Error ? restoreErr.message : String(restoreErr);
+      process.stderr.write(
+        JSON.stringify({
+          success: false,
+          error: { code: 79, codeName: "E_RESTORE_PARTIAL", message }
+        }) + "\n"
+      );
+      process.exitCode = 79;
+    } finally {
+      cleanupStaging(stagingDir);
+    }
+  }
+});
+var backupCommand = defineCommand({
+  meta: {
+    name: "backup",
+    description: "Add backup of todo files or list available backups"
+  },
+  subCommands: {
+    add: addCommand,
+    // 'create' is an alias for 'add' (citty duplicate-key pattern)
+    create: addCommand,
+    list: listCommand,
+    export: exportCommand,
+    import: importCommand,
+    inspect: backupInspectSubCommand,
+    recover: backupRecoverSubCommand,
+    verify: backupVerifySubCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await dispatchFromCli("mutate", "admin", "backup", {}, { command: "backup" });
+  }
+});
+async function resolvePassphrase() {
+  let passphrase = process.env["CLEO_BACKUP_PASSPHRASE"];
+  if (!passphrase) {
+    try {
+      passphrase = await promptPassphrase();
+    } catch (promptErr) {
+      passphrase = void 0;
+      cliError(promptErr instanceof Error ? promptErr.message : String(promptErr), 6, {
+        name: "E_PASSPHRASE_REQUIRED"
+      });
+    }
+  }
+  if (!passphrase) {
+    if (process.exitCode === void 0) cliError("a passphrase is required", 6);
+    process.exitCode = 6;
+    return void 0;
+  }
+  return passphrase;
+}
+function collectFlagValues(rawArgs, flag) {
+  const values = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i] ?? "";
+    if (arg === `--${flag}` && i + 1 < rawArgs.length) values.push(rawArgs[++i] ?? "");
+    else if (arg.startsWith(`--${flag}=`)) values.push(arg.slice(flag.length + 3));
+  }
+  return values;
+}
+async function portableImport(bundlePath, target, mapValues, force, confirmOwnerStore) {
+  const core = await import("@cleocode/core/store/portable-bundle-import.js");
+  const { PortableBundleError } = await import("@cleocode/core/store/portable-bundle.js");
+  try {
+    const needsPass = isBundleEncrypted(bundlePath);
+    const passphrase = needsPass ? await resolvePassphrase() : void 0;
+    if (needsPass && passphrase === void 0) return;
+    const result = await core.importPortableBundle({
+      bundlePath,
+      passphrase,
+      target,
+      maps: core.parsePathMappings(mapValues),
+      force: force === true,
+      requireLossless: true,
+      registerProject: core.registerRelocatedProject,
+      // T12708: the invocation directory; core never falls back to it.
+      cwd: process.cwd(),
+      confirmOwnerStore
+    });
+    cliOutput(result, { command: "backup", operation: "backup.import" });
+  } catch (err) {
+    reportBundleError(err, err instanceof PortableBundleError ? err : null, "E_IMPORT_FAILED");
+  }
+}
+function reportBundleError(err, bundleErr, fallbackName) {
+  const exitCode = bundleErr?.exitCode ?? 1;
+  cliError(err instanceof Error ? err.message : String(err), exitCode, {
+    name: bundleErr?.code ?? fallbackName,
+    ...bundleErr?.details !== void 0 ? { details: bundleErr.details } : {}
+  });
+  process.exitCode = exitCode;
+}
+function checkForExistingData(projectRoot, cleoHome) {
+  const projectFiles = CLI_PROJECT_BACKUP_FILES;
+  const globalFiles = CLI_GLOBAL_BACKUP_FILES;
+  const found = [];
+  for (const f of projectFiles) {
+    if (fs.existsSync(path.join(projectRoot, f))) found.push(f);
+  }
+  for (const f of globalFiles) {
+    const abs = path.join(cleoHome, f);
+    if (fs.existsSync(abs)) found.push(abs);
+  }
+  return found;
+}
+function resolveDbTarget(projectRoot, name, cleoHome) {
+  if (name === "nexus" || name === "signaldock") {
+    return path.join(cleoHome, `${name}.db`);
+  }
+  return path.join(projectRoot, CLEO_DIR_NAME, `${name}.db`);
+}
+function isBundleEncrypted(bundlePath) {
+  try {
+    const header = Buffer.alloc(8);
+    const fd = fs.openSync(bundlePath, "r");
+    fs.readSync(fd, header, 0, 8, 0);
+    fs.closeSync(fd);
+    return header.toString("utf8") === "CLEOENC1";
+  } catch {
+    return false;
+  }
+}
+function sha256OfMachineKey(cleoHome) {
+  const keyPath = path.join(cleoHome, "machine-key");
+  if (!fs.existsSync(keyPath)) {
+    return "0".repeat(64);
+  }
+  return crypto.createHash("sha256").update(fs.readFileSync(keyPath)).digest("hex");
+}
+export {
+  backupCommand
+};
+//# sourceMappingURL=backup-NUGBZ7NA.js.map

package/dist/cli/backup-inspect-PDRXI45A.js

@@ -0,0 +1,26 @@
+(() => {
+  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 {
+  backupInspectSubCommand
+} from "./chunk-QJJWWCIC.js";
+import "./chunk-C3B7C43W.js";
+import "./chunk-PKKZPOOP.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  backupInspectSubCommand
+};
+//# sourceMappingURL=backup-inspect-PDRXI45A.js.map

package/dist/cli/backup-recover-TVKAPERB.js

@@ -0,0 +1,29 @@
+(() => {
+  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 {
+  backupRecoverBrainLeaf,
+  backupRecoverSubCommand
+} from "./chunk-2MGFDMDF.js";
+import "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import "./chunk-PKKZPOOP.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  backupRecoverBrainLeaf,
+  backupRecoverSubCommand
+};
+//# sourceMappingURL=backup-recover-TVKAPERB.js.map

package/dist/cli/blockers-ZOPCGHDW.js

@@ -0,0 +1,55 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/blockers.ts
+var blockersCommand = defineCommand({
+  meta: {
+    name: "blockers",
+    description: "Show blocked tasks and analyze blocking chains"
+  },
+  args: {
+    analyze: {
+      type: "boolean",
+      description: "Show full blocking chain analysis"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "blockers",
+      { analyze: !!args.analyze },
+      { command: "blockers" }
+    );
+  }
+});
+export {
+  blockersCommand
+};
+//# sourceMappingURL=blockers-ZOPCGHDW.js.map