@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/decide-5VPMNTSI.js

@@ -0,0 +1,419 @@
+(() => {
+  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 {
+  ReadlineWizardIO
+} from "./chunk-GZFVDR44.js";
+import "./chunk-C3B7C43W.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/decide.ts
+import {
+  DECISION_PROVIDER_KINDS,
+  DECISION_RUNGS,
+  DECISION_SITE_MODES,
+  ExitCode
+} from "@cleocode/contracts";
+import {
+  askDecideDebug,
+  clearDecideConfig,
+  configureDecide,
+  DecideCredentialsError,
+  describeDecideCredentials,
+  listDecideProfilesReport,
+  listDecisionSites,
+  parseDecisionProviderKind,
+  probeDecideProvider,
+  removeDecideProfile,
+  resetDecideBudget,
+  runDecideWizard,
+  SpendResetRefusedError,
+  useDecideProfile
+} from "@cleocode/core/decide/index.js";
+import { WizardInterruptError } from "@cleocode/core/setup";
+async function readSecretFromStdin() {
+  if (process.stdin.isTTY) return "";
+  process.stdin.setEncoding("utf-8");
+  let buf = "";
+  for await (const chunk of process.stdin) buf += chunk;
+  return buf.trim();
+}
+function failValidation(message, operation, fix) {
+  cliError(message, ExitCode.VALIDATION_ERROR, { name: "E_VALIDATION", fix }, { operation });
+  process.exitCode = ExitCode.VALIDATION_ERROR;
+}
+var CONFIG_FIX = 'printf %s "$KEY" | cleo decide config --provider layahost --key-stdin';
+var PROFILES_FIX = "cleo decide profiles";
+var ASK_FIX = 'cleo decide ask --state "<text>" --question "<yes/no question>"';
+async function runConfigWizard(op) {
+  const io = new ReadlineWizardIO(process.stdin, process.stderr);
+  try {
+    cliOutput(await runDecideWizard(io), { command: "decide-config", operation: op });
+  } catch (err) {
+    if (err instanceof WizardInterruptError) {
+      process.stderr.write("System One setup cancelled.\n");
+      process.exitCode = 130;
+      return;
+    }
+    failValidation(err instanceof Error ? err.message : "setup failed", op, CONFIG_FIX);
+  } finally {
+    io.close();
+  }
+}
+var decideConfigCommand = defineCommand({
+  meta: {
+    name: "config",
+    description: "Store a System One profile, <provider>/<name> (several per provider, each with its own key): API key, URL and model (0600 file in the CLEO home), then probe it and detect its capabilities. Each provider has a default URL (layahost https://layahost.com, jev https://api.typesafe.ai); --url overrides it. Other profiles are kept and exactly one is active. Prefer --key-stdin so the key stays out of shell history. No flags on a terminal runs the setup wizard (the key is masked); no flags without a terminal shows the active settings (key masked)."
+  },
+  args: {
+    provider: {
+      type: "string",
+      description: `Provider: ${DECISION_PROVIDER_KINDS.join("|")} (layahost: model laya-auto; jev: model from the provider listing)`
+    },
+    url: {
+      type: "string",
+      description: 'Override URL for the profile, or "default" for the provider default URL (resolved at call time)'
+    },
+    key: {
+      type: "string",
+      description: "API key. Visible in the process list (ps) and shell history; prefer --key-stdin"
+    },
+    "key-stdin": { type: "boolean", description: "Read the API key from stdin (recommended)" },
+    model: {
+      type: "string",
+      description: "Default model; omitted \u2192 the stored model, the preset (layahost: laya-auto) or the first listed (jev)"
+    },
+    profile: {
+      type: "string",
+      description: "Profile to add or update: <provider>/<name> or a name (a-z, 0-9, -); default: the active profile of that provider, else <provider>/default"
+    },
+    activate: {
+      type: "boolean",
+      description: "Make the profile active (default: only for the first profile or one already active)"
+    },
+    remove: {
+      type: "string",
+      description: "Remove this profile (<provider>/<name>); the active one needs --use"
+    },
+    use: {
+      type: "string",
+      description: "With --remove: the profile (<provider>/<name>) to activate instead"
+    },
+    clear: { type: "boolean", description: "Remove every profile (URLs, keys and models)" }
+  },
+  async run({ args }) {
+    const op = "decide.config";
+    if (args.clear === true)
+      return cliOutput(await clearDecideConfig(), { command: "decide-config", operation: op });
+    if (args.remove !== void 0) {
+      try {
+        const result = await removeDecideProfile(args.remove, args.use);
+        return cliOutput(result, { command: "decide-config", operation: "decide.config.remove" });
+      } catch (err) {
+        if (!(err instanceof DecideCredentialsError)) throw err;
+        return failValidation(err.message, op, PROFILES_FIX);
+      }
+    }
+    const provider = parseDecisionProviderKind(args.provider);
+    if (args.provider !== void 0 && provider === void 0) {
+      return failValidation(`unknown provider '${args.provider}'`, op, CONFIG_FIX);
+    }
+    const apiKey = args["key-stdin"] === true ? await readSecretFromStdin() : args.key;
+    if (args["key-stdin"] === true && !apiKey)
+      return failValidation("--key-stdin set but stdin is empty or a TTY", op, CONFIG_FIX);
+    const noSettings = provider === void 0 && args.url === void 0 && apiKey === void 0 && args.model === void 0 && args.profile === void 0 && args.activate === void 0;
+    if (noSettings && process.stdin.isTTY && process.stderr.isTTY) return runConfigWizard(op);
+    if (noSettings) {
+      return cliOutput(describeDecideCredentials(), { command: "decide-config", operation: op });
+    }
+    try {
+      const result = await configureDecide({
+        provider,
+        baseUrl: args.url,
+        apiKey,
+        model: args.model,
+        profile: args.profile,
+        ...args.activate === true ? { activate: true } : {}
+      });
+      cliOutput(result, { command: "decide-config", operation: op });
+    } catch (err) {
+      failValidation(err instanceof Error ? err.message : "invalid settings", op, CONFIG_FIX);
+    }
+  }
+});
+var decideUseCommand = defineCommand({
+  meta: {
+    name: "use",
+    description: "Switch the active System One profile (<provider>/<name>, e.g. layahost/work; a bare provider means <provider>/default): everyday decisions use it from now on. Other profiles stay stored and can still be addressed by id."
+  },
+  args: {
+    profile: {
+      type: "positional",
+      description: "Profile to activate, <provider>/<name>",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const op = "decide.use";
+    try {
+      cliOutput(await useDecideProfile(args.profile), {
+        command: "decide-profiles",
+        operation: op
+      });
+    } catch (err) {
+      if (!(err instanceof DecideCredentialsError)) throw err;
+      failValidation(err.message, op, PROFILES_FIX);
+    }
+  }
+});
+var decideProfilesCommand = defineCommand({
+  meta: {
+    name: "profiles",
+    description: "List the stored System One profiles: the active one marked, keys masked. --probe also checks each profile (GET {url}/v1/models, in parallel)."
+  },
+  args: {
+    probe: { type: "boolean", description: "Probe each profile's reachability" },
+    "timeout-ms": { type: "string", description: "Probe timeout in ms (default 3000)" }
+  },
+  async run({ args }) {
+    const timeoutMs = args["timeout-ms"] ? Number(args["timeout-ms"]) : void 0;
+    const result = await listDecideProfilesReport({ probe: args.probe === true, timeoutMs });
+    cliOutput(result, { command: "decide-profiles", operation: "decide.profiles" });
+  }
+});
+var decideStatusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Probe the decision provider (GET {url}/v1/models, short timeout): reachable, unauthorized, key_limit_reached (the key monthly limit), unconfigured or unreachable. Also reports the registered sites count, the provider capabilities and balance (GET /v1/usage, refreshed at most every 10 minutes) and month-to-date spend against decide.budget.monthlyMicros. Exits 1 unless reachable."
+  },
+  args: {
+    "timeout-ms": { type: "string", description: "Probe timeout in ms (default 3000)" }
+  },
+  async run({ args }) {
+    const timeoutMs = args["timeout-ms"] ? Number(args["timeout-ms"]) : void 0;
+    const result = await probeDecideProvider({ timeoutMs });
+    cliOutput(result, { command: "decide-status", operation: "decide.status" });
+    if (result.state !== "reachable" && (process.exitCode ?? 0) === 0) process.exitCode = 1;
+  }
+});
+var decideAskCommand = defineCommand({
+  meta: {
+    name: "ask",
+    description: "Debug: ask one yes/no question about a state through the configured provider. Shows the typed answer, source (provider or fallback), latency and cost."
+  },
+  args: {
+    state: { type: "string", description: "The state (text) to judge" },
+    question: { type: "string", description: "The yes/no question" },
+    noul: { type: "string", description: "Alias of --question" },
+    "timeout-ms": { type: "string", description: "Deadline in ms (default 10000)" },
+    profile: {
+      type: "string",
+      description: "Ask through this profile, <provider>/<name> (default: the active one)"
+    }
+  },
+  async run({ args }) {
+    const question = args.question ?? args.noul;
+    if (!args.state || !question) {
+      return failValidation(
+        "cleo decide ask needs a state and a yes/no question",
+        "decide.ask",
+        ASK_FIX
+      );
+    }
+    const timeoutMs = args["timeout-ms"] ? Number(args["timeout-ms"]) : void 0;
+    const result = await askDecideDebug({
+      state: args.state,
+      question,
+      timeoutMs,
+      ...args.profile ? { profile: args.profile } : {}
+    });
+    cliOutput(result, { command: "decide-ask", operation: "decide.ask" });
+  }
+});
+function oneOf(value, allowed) {
+  return allowed.find((a) => a === value);
+}
+var decideSitesCommand = defineCommand({
+  meta: {
+    name: "sites",
+    description: "List the System One integration decision sites: rung, ladder, fallback, owner escalation, configured and effective mode, go-live evidence and last-7-day activity. A site that uses System One is effectively off while no provider is configured."
+  },
+  args: {
+    rung: {
+      type: "string",
+      description: `Only sites with this primary rung (${DECISION_RUNGS.join("|")})`
+    },
+    mode: {
+      type: "string",
+      description: `Only sites with this effective mode (${DECISION_SITE_MODES.join("|")})`
+    },
+    id: { type: "string", description: "Only the site with this id" },
+    evidence: { type: "boolean", description: "Only sites with recorded go-live evidence" }
+  },
+  async run({ args }) {
+    const op = "decide.sites";
+    const rung = oneOf(args.rung, DECISION_RUNGS);
+    if (args.rung !== void 0 && rung === void 0) {
+      return failValidation(
+        `unknown rung '${args.rung}'`,
+        op,
+        `--rung ${DECISION_RUNGS.join("|")}`
+      );
+    }
+    const mode = oneOf(args.mode, DECISION_SITE_MODES);
+    if (args.mode !== void 0 && mode === void 0) {
+      return failValidation(
+        `unknown mode '${args.mode}'`,
+        op,
+        `--mode ${DECISION_SITE_MODES.join("|")}`
+      );
+    }
+    const result = await listDecisionSites({
+      rung,
+      mode,
+      id: args.id,
+      evidenceOnly: args.evidence === true
+    });
+    cliOutput(result, { command: "decide", operation: op });
+  }
+});
+function commaList(value) {
+  return value === void 0 ? void 0 : value.split(",").map((v) => v.trim()).filter(Boolean);
+}
+function numberFlag(value) {
+  return value === void 0 ? void 0 : Number(value);
+}
+var decideBenchCommand = defineCommand({
+  meta: {
+    name: "bench",
+    description: "System One accuracy benchmark (T12495): build a labelled dataset from this project's own history (duplicate task pairs, explicitly typed observations, superseding decisions; redacted), write a stratified spot-check sample for the owner, then compare providers against each site's heuristic with batched calls (provider cache off, 30s or longer deadline): accuracy, precision, recall, F1, false-positive rate, p50/p95 latency, cost and fallbacks, mean and spread over --runs. A hard total cap (--max-usd, default 5) is checked before every batch; the run stops cleanly at it. Each --profiles entry is a System One profile (cleo decide profiles): an id <provider>/<name> (e.g. layahost/work), or a bare provider meaning its active profile, else <provider>/default; a default URL resolves to the provider preset. A name no profile holds falls back to CLEO_DECIDE_PROFILE_<NAME>_KEY (plus _URL, _MODEL, _PROVIDER) for a one-off key. An unknown name fails listing the stored profiles (keys masked). --sample-only never contacts a provider."
+  },
+  args: {
+    profiles: {
+      type: "string",
+      description: "Comma list of profiles to compare: <provider>/<name> ids or bare providers, e.g. layahost/work,jev"
+    },
+    sites: {
+      type: "string",
+      description: "Comma list: duplicateDetection,observationType,decisionContradiction (default all)"
+    },
+    "sample-only": {
+      type: "boolean",
+      description: "Build the dataset and the spot-check sample only (offline, no spend)"
+    },
+    corrections: {
+      type: "string",
+      description: 'Owner corrections file ({"corrections":[{"id","label"}|{"id","drop":true}]}) to apply'
+    },
+    "max-usd": { type: "string", description: "Hard total spend cap in USD (default 5)" },
+    runs: { type: "string", description: "Repeated runs for mean and spread (default 1)" },
+    out: { type: "string", description: "Output directory (default .cleo/decide-bench)" },
+    "batch-size": { type: "string", description: "Rows per batch call, 1-64 (default 16)" },
+    rebuild: {
+      type: "boolean",
+      description: "Rebuild the dataset from the stores (drops corrections)"
+    },
+    seed: { type: "string", description: "Seed for negatives and the sample (default 12495)" }
+  },
+  async run({ args }) {
+    const op = "decide.bench";
+    const { DecideBenchInputError, runDecideBenchOperation } = await import("@cleocode/core/decide/bench/index.js");
+    try {
+      const result = await runDecideBenchOperation({
+        profiles: commaList(args.profiles),
+        sites: commaList(args.sites),
+        sampleOnly: args["sample-only"] === true,
+        correctionsPath: args.corrections,
+        maxUsd: numberFlag(args["max-usd"]),
+        runs: numberFlag(args.runs),
+        outDir: args.out,
+        batchSize: numberFlag(args["batch-size"]),
+        rebuild: args.rebuild === true,
+        seed: numberFlag(args.seed)
+      });
+      cliOutput(result, { command: "decide", operation: op });
+    } catch (err) {
+      if (!(err instanceof DecideBenchInputError)) throw err;
+      failValidation(err.message, op, err.fix);
+    }
+  }
+});
+var decideBudgetResetCommand = defineCommand({
+  meta: {
+    name: "reset",
+    description: "Repair a corrupt System One spend ledger (<cleoHome>/decide/spend.json): start a fresh one for this month, moving the old file aside as a receipt. Refuses a readable ledger unless --force; month-to-date spend is always kept when readable, so a reset never lifts a reached cap."
+  },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Reset a ledger that is not corrupt (keeps month-to-date spend; clears in-flight reservations and the key-limit stop)"
+    }
+  },
+  async run({ args }) {
+    const op = "decide.budget.reset";
+    try {
+      const receipt = await resetDecideBudget(void 0, { force: args.force === true });
+      cliOutput(receipt, { command: "decide", operation: op });
+    } catch (err) {
+      if (!(err instanceof SpendResetRefusedError)) throw err;
+      failValidation(err.message, op, "cleo decide status");
+    }
+  }
+});
+var decideBudgetCommand = defineCommand({
+  meta: {
+    name: "budget",
+    description: "System One monthly spend cap (decide.budget.monthlyMicros): budget reset"
+  },
+  subCommands: { reset: decideBudgetResetCommand },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+var decideCommand = defineCommand({
+  meta: {
+    name: "decide",
+    description: "System One integration (typed decisions): decide config (named provider profile + API key; wizard on a terminal), decide use (switch the active profile), decide profiles (list them), decide status (reachability probe), decide ask (one debug question), decide sites (the registered decision sites), decide bench (accuracy benchmark). Unconfigured means heuristics answer."
+  },
+  subCommands: {
+    config: decideConfigCommand,
+    use: decideUseCommand,
+    profiles: decideProfilesCommand,
+    status: decideStatusCommand,
+    ask: decideAskCommand,
+    sites: decideSitesCommand,
+    budget: decideBudgetCommand,
+    bench: decideBenchCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  decideCommand
+};
+//# sourceMappingURL=decide-5VPMNTSI.js.map

package/dist/cli/decompose-KOYEZNJL.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 "./chunk-C3B7C43W.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/decompose.ts
+var decomposeCommand = defineCommand({
+  meta: {
+    name: "decompose",
+    description: "Move a task's text acceptance criteria onto a new child so it can hold subtasks"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "ID of the task to decompose",
+      required: true
+    },
+    "child-title": {
+      type: "string",
+      description: "Title for the child that inherits the criteria (default: the parent's)"
+    },
+    "child-description": {
+      type: "string",
+      description: "Description for the child (default: the parent's)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the move without writing"
+    }
+  },
+  async run({ args }) {
+    const response = await dispatchRaw("mutate", "tasks", "decompose", {
+      taskId: args.taskId,
+      childTitle: args["child-title"],
+      childDescription: args["child-description"],
+      dryRun: args["dry-run"]
+    });
+    if (!response.success) {
+      handleRawError(response, { command: "decompose", operation: "tasks.decompose" });
+    }
+    cliOutput(response.data, {
+      command: "decompose",
+      operation: "tasks.decompose"
+    });
+  }
+});
+export {
+  decomposeCommand
+};
+//# sourceMappingURL=decompose-KOYEZNJL.js.map

package/dist/cli/decomposition-7OHUFIQN.js

@@ -0,0 +1,121 @@
+(() => {
+  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,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/decomposition.ts
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate decomposition protocol compliance for task"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to validate",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    },
+    epic: {
+      type: "string",
+      description: "Specify parent epic ID"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "protocol",
+      {
+        protocolType: "decomposition",
+        mode: "task",
+        taskId: args.taskId,
+        strict: args.strict,
+        epicId: args.epic
+      },
+      { command: "decomposition" }
+    );
+  }
+});
+var checkCommand = defineCommand({
+  meta: {
+    name: "check",
+    description: "Validate manifest entry directly"
+  },
+  args: {
+    manifestFile: {
+      type: "positional",
+      description: "Manifest file to validate",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    },
+    epic: {
+      type: "string",
+      description: "Specify parent epic ID"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "protocol",
+      {
+        protocolType: "decomposition",
+        mode: "manifest",
+        manifestFile: args.manifestFile,
+        strict: args.strict,
+        epicId: args.epic
+      },
+      { command: "decomposition" }
+    );
+  }
+});
+var decompositionCommand = defineCommand({
+  meta: {
+    name: "decomposition",
+    description: "Validate decomposition protocol compliance (alias for `cleo check protocol decomposition`)"
+  },
+  subCommands: {
+    validate: validateCommand,
+    check: checkCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  decompositionCommand
+};
+//# sourceMappingURL=decomposition-7OHUFIQN.js.map

package/dist/cli/delete-Q7YCAFY5.js

@@ -0,0 +1,68 @@
+(() => {
+  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 {
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/delete.ts
+var deleteCommand = defineCommand({
+  meta: {
+    name: "delete",
+    description: "Delete a task (soft delete to archive)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "ID of the task to delete",
+      required: true
+    },
+    force: {
+      type: "boolean",
+      description: "Force delete even with dependents or children"
+    },
+    cascade: {
+      type: "boolean",
+      description: "Delete children recursively"
+    }
+  },
+  async run({ args }) {
+    const response = await dispatchRaw("mutate", "tasks", "delete", {
+      taskId: args.taskId,
+      force: args.force,
+      cascade: args.cascade
+    });
+    if (!response.success) {
+      handleRawError(response, { command: "delete", operation: "tasks.delete" });
+    }
+    cliOutput(response.data, { command: "delete", operation: "tasks.delete" });
+  }
+});
+export {
+  deleteCommand
+};
+//# sourceMappingURL=delete-Q7YCAFY5.js.map