@cleocode/cleo 2026.10.2 → 2026.10.4

package/bin/cleo.js

@@ -65,9 +65,19 @@ import { fileURLToPath } from 'node:url';
  * Must be set before anything submits work to the pool — the pool is created
  * on first use and never resized — so it is set here, before the re-exec and
  * before the in-process import; the child inherits it through the environment.
+ *
+ * T13122: it is the CLI's tuning, not its children's. The marker names the value
+ * CLEO supplied, and the CLI removes both once its own pool exists
+ * (`src/cli/lib/cli-threadpool-env.ts`), so a test runner and each of its
+ * workers no longer start 64 pool threads apiece. An operator's own value
+ * carries no marker and is inherited as before.
  */
 const DEFAULT_UV_THREADPOOL_SIZE = '64';
-if (!process.env.UV_THREADPOOL_SIZE) process.env.UV_THREADPOOL_SIZE = DEFAULT_UV_THREADPOOL_SIZE;
+const CLI_THREADPOOL_MARKER = 'CLEO_CLI_UV_THREADPOOL_SIZE';
+if (!process.env.UV_THREADPOOL_SIZE) {
+  process.env.UV_THREADPOOL_SIZE = DEFAULT_UV_THREADPOOL_SIZE;
+  process.env[CLI_THREADPOOL_MARKER] = DEFAULT_UV_THREADPOOL_SIZE;
+}
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const cliPath = resolve(__dirname, '../dist/cli/index.js');

package/dist/cli/adapter-LVXHFBC4.js

@@ -0,0 +1,158 @@
+(() => {
+  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 {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand
+} 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/adapter.ts
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all discovered provider adapters" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.list",
+      {},
+      { command: "adapter", operation: "tools.adapter.list" }
+    );
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show details for a specific adapter" },
+  args: {
+    adapterId: {
+      type: "positional",
+      description: "Adapter ID to inspect",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.show",
+      { id: args.adapterId },
+      { command: "adapter", operation: "tools.adapter.show" }
+    );
+  }
+});
+var detectCommand = defineCommand({
+  meta: { name: "detect", description: "Detect active providers in the current environment" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.detect",
+      {},
+      { command: "adapter", operation: "tools.adapter.detect" }
+    );
+  }
+});
+var healthCommand = defineCommand({
+  meta: { name: "health", description: "Show health status for adapters" },
+  args: {
+    id: {
+      type: "string",
+      description: "Specific adapter ID (omit for all adapters)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.health",
+      { id: args.id },
+      { command: "adapter", operation: "tools.adapter.health" }
+    );
+  }
+});
+var activateCommand = defineCommand({
+  meta: { name: "activate", description: "Load and activate a provider adapter" },
+  args: {
+    adapterId: {
+      type: "positional",
+      description: "Adapter ID to activate",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "adapter.activate",
+      { id: args.adapterId },
+      { command: "adapter", operation: "tools.adapter.activate" }
+    );
+  }
+});
+var disposeCommand = defineCommand({
+  meta: { name: "dispose", description: "Dispose one or all adapters" },
+  args: {
+    id: {
+      type: "string",
+      description: "Specific adapter ID to dispose (omit to dispose all)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "adapter.dispose",
+      { id: args.id },
+      { command: "adapter", operation: "tools.adapter.dispose" }
+    );
+  }
+});
+var adapterCommand = defineCommand({
+  meta: {
+    name: "adapter",
+    description: "Provider adapter management: list, show, detect, health, activate, dispose"
+  },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    detect: detectCommand,
+    health: healthCommand,
+    activate: activateCommand,
+    dispose: disposeCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.list",
+      {},
+      { command: "adapter", operation: "tools.adapter.list" }
+    );
+  }
+});
+export {
+  adapterCommand
+};
+//# sourceMappingURL=adapter-LVXHFBC4.js.map

package/dist/cli/add-WUAV7LDT.js

@@ -0,0 +1,443 @@
+(() => {
+  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 {
+  collectMutateInput
+} from "./chunk-QA6T2LQ5.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchRaw,
+  handleRawError,
+  maybeEmitDescribe
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput,
+  humanInfo,
+  humanWarn
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/add.ts
+import { ExitCode, TASK_SEVERITIES } from "@cleocode/contracts";
+import {
+  getProjectRoot,
+  INPUT_CONTRACTS,
+  inferTaskAddParams,
+  validateOperationInput
+} from "@cleocode/core";
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: `Create a new task (requires active session)
+For 2+ tasks at once: cleo add-batch --file tasks.json (single transaction, atomic rollback)`
+  },
+  args: {
+    /**
+     * Schema-first input — supersedes all flag-based args when present.
+     *
+     * Accepts a JSON object that matches `INPUT_CONTRACTS['tasks.add']`.
+     * When provided, the command short-circuits the flag-mapping path
+     * entirely and goes straight to validate→dispatch.
+     *
+     * @task T9917
+     */
+    params: {
+      type: "string",
+      description: 'Inline JSON object matching INPUT_CONTRACTS["tasks.add"] (T9917). Overrides positional + flags.'
+    },
+    /**
+     * Schema-first input from a JSON file. Same semantics as --params.
+     *
+     * @task T9917
+     */
+    "params-file": {
+      type: "string",
+      description: 'Path to JSON file matching INPUT_CONTRACTS["tasks.add"] (T9917).'
+    },
+    title: {
+      type: "positional",
+      description: "Task title (3\u2013500 characters)",
+      required: false
+    },
+    status: {
+      type: "string",
+      alias: "s",
+      description: "Task status (pending | active | blocked | done)"
+    },
+    priority: {
+      type: "string",
+      alias: "p",
+      description: "Task priority (low | medium | high | critical)"
+    },
+    type: {
+      type: "string",
+      alias: "t",
+      description: "Task type (epic | task | subtask)"
+    },
+    parent: {
+      type: "string",
+      description: 'Parent task ID (makes this task a subtask). Pass "none" to suppress focus-task inference \u2014 the task will still require a valid parent per hierarchy policy (T11293).'
+    },
+    "parent-id": {
+      type: "string",
+      description: 'Alias for --parent. Pass "none" to suppress focus-task inference (T11293).'
+    },
+    size: {
+      type: "string",
+      description: "Scope size estimate (small | medium | large)"
+    },
+    phase: {
+      type: "string",
+      alias: "P",
+      description: "Phase slug to assign the task to"
+    },
+    description: {
+      type: "string",
+      alias: "d",
+      description: "Detailed task description (must differ meaningfully from title)"
+    },
+    desc: {
+      type: "string",
+      description: "Task description (alias for --description)"
+    },
+    labels: {
+      type: "string",
+      alias: "l",
+      description: 'Comma-separated labels (lowercase alphanumeric + hyphens + periods only, e.g. "track-b,wave.1") (gh-392)'
+    },
+    files: {
+      type: "string",
+      description: "Comma-separated file paths"
+    },
+    "files-infer": {
+      type: "boolean",
+      description: "Infer touched files from task title and description using GitNexus"
+    },
+    acceptance: {
+      type: "string",
+      description: 'Pipe-separated acceptance criteria (e.g. "AC1|AC2|AC3")'
+    },
+    depends: {
+      type: "string",
+      alias: "D",
+      description: "Comma-separated dependency task IDs"
+    },
+    notes: {
+      type: "string",
+      description: "Initial note entry for the task"
+    },
+    note: {
+      type: "string",
+      description: "Alias for --notes"
+    },
+    position: {
+      type: "string",
+      description: "Position within sibling group"
+    },
+    "parent-search": {
+      type: "string",
+      description: "Resolve parent by title substring instead of exact ID (T090)"
+    },
+    "add-phase": {
+      type: "boolean",
+      description: "Create new phase if it does not exist"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be created without making changes"
+    },
+    /**
+     * Task kind axis — intent of work.
+     * Values: work | research | experiment | bug | spike | release
+     * @task T944
+     * @task T9072
+     */
+    kind: {
+      type: "string",
+      description: "Task kind / intent axis (work|research|experiment|bug|spike|release) \u2014 orthogonal to --type (T944)"
+    },
+    /**
+     * Task scope axis — granularity of work.
+     * Values: project | feature | unit
+     * @task T944
+     */
+    scope: {
+      type: "string",
+      description: "Task scope / granularity axis (project|feature|unit) \u2014 orthogonal to --type (T944)"
+    },
+    /**
+     * Severity level for any task kind (not just bug).
+     * Values: P0 | P1 | P2 | P3
+     * Orthogonal to --priority — does NOT auto-map priority.
+     * Appends a signed attestation to .cleo/audit/severity-attestation.jsonl (T9071/T9073).
+     * @task T944
+     * @task T9073
+     */
+    severity: {
+      type: "string",
+      description: "Severity level (P0|P1|P2|P3) \u2014 valid for any --kind (T9073). Orthogonal to priority. Appends signed attestation."
+    },
+    /**
+     * Bypass the E_DUPLICATE_TASK_LIKELY rejection guard.
+     *
+     * When passed, `cleo add` proceeds even if BRAIN similarity scoring
+     * determines the task is very likely a duplicate (score >= 0.92).
+     * The bypass is audited to `.cleo/audit/duplicate-bypass.jsonl`.
+     *
+     * @task T1633
+     */
+    "force-duplicate": {
+      type: "boolean",
+      description: "Bypass BRAIN duplicate-task rejection (audited to .cleo/audit/duplicate-bypass.jsonl) (T1633)"
+    },
+    /**
+     * Resolve the PM-Core V2 design-point 3 guard in-line rather than failing.
+     *
+     * Without it, filing the first subtask under a task that carries its own
+     * text ACs costs three commands: add (rejected), decompose, add again.
+     *
+     * @task T12298
+     */
+    "auto-decompose": {
+      type: "boolean",
+      description: "Move the parent's text acceptance criteria to a new first subtask if they would block this add (T12298)"
+    },
+    /**
+     * Waiver for the critical-priority dependency declaration requirement.
+     *
+     * Critical-priority tasks without declared dependencies silently break
+     * wave-order spawning when downstream work assumes they are load-bearing.
+     * Provide a justification string to waive the `--depends` requirement.
+     * The waiver is stored in the task creation audit log in the mutation transaction.
+     *
+     * @task T1856
+     * @epic T1855
+     */
+    "depends-waiver": {
+      type: "string",
+      description: "Non-empty justification for creating a critical-priority task without --depends (T1856). Recorded verbatim in the transactional task creation audit log; rejected for non-critical creation."
+    },
+    /**
+     * Related tasks — semantic relationships (non-dependency).
+     * Comma-separated task IDs with optional type suffix (e.g. "T001:blocks,T002:related").
+     * Default type is 'related'.
+     */
+    relates: {
+      type: "string",
+      description: 'Comma-separated related task IDs with optional type suffix (e.g. "T001:blocks,T002")'
+    }
+  },
+  async run({ args, cmd }) {
+    if (maybeEmitDescribe("mutate", "tasks", "add", { command: "add" })) return;
+    const paramsArg = args.params;
+    const paramsFileArg = args["params-file"];
+    if (paramsArg !== void 0 || paramsFileArg !== void 0) {
+      const collectArgs = {};
+      if (paramsArg !== void 0) collectArgs.params = paramsArg;
+      if (paramsFileArg !== void 0) collectArgs.file = paramsFileArg;
+      let raw;
+      try {
+        raw = await collectMutateInput(
+          collectArgs,
+          process.stdin
+        );
+      } catch (err) {
+        cliError(
+          err.message,
+          ExitCode.VALIDATION_ERROR,
+          {
+            name: "E_VALIDATION_FAILED",
+            fix: "Verify the JSON syntax of your --params / --params-file input"
+          },
+          { operation: "tasks.add" }
+        );
+        process.exit(ExitCode.VALIDATION_ERROR);
+        return;
+      }
+      const contract = INPUT_CONTRACTS["tasks.add"];
+      if (!contract) {
+        cliError(
+          "tasks.add contract missing from INPUT_CONTRACTS registry",
+          ExitCode.GENERAL_ERROR,
+          { name: "E_INTERNAL", fix: "This is a CLI bug \u2014 file an issue" },
+          { operation: "tasks.add" }
+        );
+        process.exit(ExitCode.GENERAL_ERROR);
+        return;
+      }
+      const validation = validateOperationInput(contract, raw);
+      if (!validation.ok) {
+        cliError(
+          "tasks.add failed: validation",
+          ExitCode.VALIDATION_ERROR,
+          {
+            name: "E_VALIDATION_FAILED",
+            fix: validation.errors[0]?.fix ?? "Inspect errors[] and correct the input",
+            details: { errors: validation.errors }
+          },
+          { operation: "tasks.add" }
+        );
+        process.exit(ExitCode.VALIDATION_ERROR);
+        return;
+      }
+      const validatedPayload = raw;
+      const response2 = await dispatchRaw("mutate", "tasks", "add", validatedPayload);
+      if (!response2.success) {
+        handleRawError(response2, { command: "add", operation: "tasks.add" });
+      }
+      const data2 = response2.data;
+      const dataWarnings2 = data2?.warnings;
+      if (dataWarnings2?.length) {
+        for (const w of dataWarnings2) {
+          humanWarn(`\u26A0 ${w}`);
+        }
+      }
+      cliOutput(data2, { command: "add", operation: "tasks.add" });
+      return;
+    }
+    if (!args.title) {
+      await showUsage(cmd);
+      return;
+    }
+    if (args.severity !== void 0 && !TASK_SEVERITIES.includes(args.severity)) {
+      const valid = TASK_SEVERITIES.join(", ");
+      cliError(
+        `severity must be one of: ${valid} \u2014 got '${args.severity}'`,
+        6,
+        {
+          name: "E_INVALID_SEVERITY_VALUE",
+          fix: `Pass --severity with one of: ${valid}`
+        },
+        { operation: "tasks.add" }
+      );
+      process.exit(6);
+      return;
+    }
+    const params = { title: args.title };
+    if (args.status !== void 0) params["status"] = args.status;
+    if (args.priority !== void 0) params["priority"] = args.priority;
+    if (args.type !== void 0) params["type"] = args.type;
+    const parentArg = args.parent;
+    const parentIdArg = args["parent-id"];
+    const resolvedParent = parentArg ?? parentIdArg;
+    if (resolvedParent !== void 0 && resolvedParent !== "none") {
+      params["parent"] = resolvedParent;
+    }
+    if (args.size !== void 0) params["size"] = args.size;
+    if (args.phase !== void 0) params["phase"] = args.phase;
+    if (args["add-phase"] !== void 0) params["addPhase"] = args["add-phase"];
+    if (args.description !== void 0) {
+      params["description"] = args.description;
+    } else if (args.desc !== void 0) {
+      params["description"] = args.desc;
+    }
+    if (args.labels) params["labels"] = args.labels.split(",").map((s) => s.trim());
+    if (args.depends) params["depends"] = args.depends.split(",").map((s) => s.trim());
+    if (args.relates) {
+      params["relates"] = args.relates.split(",").map((s) => {
+        const [taskId, relType = "related"] = s.trim().split(":");
+        return { taskId: taskId.trim(), type: relType.trim() };
+      });
+    }
+    if (args.notes !== void 0) params["notes"] = args.notes;
+    if (args.note !== void 0) params["notes"] = params["notes"] ?? args.note;
+    if (args.position !== void 0)
+      params["position"] = Number.parseInt(args.position, 10);
+    if (args["dry-run"] !== void 0) params["dryRun"] = args["dry-run"];
+    if (args["parent-search"] !== void 0) params["parentSearch"] = args["parent-search"];
+    if (args.kind !== void 0) params["kind"] = args.kind;
+    if (args.scope !== void 0) params["scope"] = args.scope;
+    if (args.severity !== void 0) params["severity"] = args.severity;
+    if (args["force-duplicate"] !== void 0) params["forceDuplicate"] = args["force-duplicate"];
+    if (args["auto-decompose"] !== void 0) params["autoDecompose"] = args["auto-decompose"];
+    if (args["depends-waiver"] !== void 0) params["dependsWaiver"] = args["depends-waiver"];
+    const parentSentinel = resolvedParent === "none" ? "none" : void 0;
+    const parentRawForInference = params["parent"] ?? parentSentinel;
+    const inferred = await inferTaskAddParams(getProjectRoot(), {
+      title: args.title,
+      description: args.description ?? args.desc,
+      filesInfer: args["files-infer"],
+      filesRaw: args.files,
+      acceptanceRaw: args.acceptance,
+      parentRaw: parentRawForInference,
+      type: params["type"]
+    });
+    if (inferred.filesInferWarning) {
+      humanWarn(
+        "\u26A0 No files inferred by GitNexus. Use --files to specify files explicitly, or leave empty for atomicity check at spawn time."
+      );
+    }
+    if (inferred.files) params["files"] = inferred.files;
+    if (inferred.acceptance) params["acceptance"] = inferred.acceptance;
+    if (inferred.inferredParent) {
+      params["parent"] = inferred.inferredParent;
+      params["parentSource"] = "session-inference";
+      humanInfo(
+        `[cleo add] ${inferred.parentInference?.note ?? `inferred --parent from current task: ${inferred.inferredParent}`}`
+      );
+    }
+    if (inferred.parentInference && inferred.parentInference.outcome !== "applied") {
+      if (inferred.parentInference.outcome !== "no-current-task") {
+        humanWarn(`\u26A0 [cleo add] ${inferred.parentInference.note}`);
+      }
+    }
+    const parentInferenceMeta = inferred.parentInference;
+    const response = await dispatchRaw("mutate", "tasks", "add", params);
+    if (!response.success) {
+      handleRawError(response, { command: "add", operation: "tasks.add" });
+    }
+    const data = response.data;
+    const dataWarnings = data?.warnings;
+    if (dataWarnings?.length) {
+      for (const w of dataWarnings) {
+        humanWarn(`\u26A0 ${w}`);
+      }
+    }
+    const inferenceExtensions = parentInferenceMeta && parentInferenceMeta.outcome !== "no-current-task" ? { parentInference: parentInferenceMeta } : void 0;
+    if (data?.duplicate) {
+      cliOutput(data, {
+        command: "add",
+        message: "Task with identical title was created recently",
+        operation: "tasks.add",
+        ...inferenceExtensions ? { extensions: inferenceExtensions } : {}
+      });
+    } else if (data?.dryRun) {
+      cliOutput(data, {
+        command: "add",
+        message: "Dry run - no changes made",
+        operation: "tasks.add",
+        ...inferenceExtensions ? { extensions: inferenceExtensions } : {}
+      });
+    } else {
+      cliOutput(data, {
+        command: "add",
+        operation: "tasks.add",
+        ...inferenceExtensions ? { extensions: inferenceExtensions } : {}
+      });
+    }
+  }
+});
+export {
+  addCommand
+};
+//# sourceMappingURL=add-WUAV7LDT.js.map