@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/init-IHEJDQWU.js

@@ -0,0 +1,40 @@
+(() => {
+  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 {
+  FIRST_RUN_LOGIN_NEXT_STEP,
+  getGitignoreTemplate,
+  getWorkflowTemplatesDir,
+  initCommand,
+  isCredentialPoolEmpty,
+  maybeNudgeFirstRunLogin
+} from "./chunk-OPTEQKBB.js";
+import "./chunk-J3ZFM3UQ.js";
+import "./chunk-GZFVDR44.js";
+import "./chunk-ULN4OKQQ.js";
+import "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import "./chunk-PKKZPOOP.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  FIRST_RUN_LOGIN_NEXT_STEP,
+  getGitignoreTemplate,
+  getWorkflowTemplatesDir,
+  initCommand,
+  isCredentialPoolEmpty,
+  maybeNudgeFirstRunLogin
+};
+//# sourceMappingURL=init-IHEJDQWU.js.map

package/dist/cli/inject-LSRVWNCP.js

@@ -0,0 +1,82 @@
+(() => {
+  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 {
+  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/inject.ts
+var injectCommand = defineCommand({
+  meta: { name: "inject", description: "Prepare tasks for external system injection" },
+  args: {
+    "max-tasks": {
+      type: "string",
+      description: "Maximum tasks to inject",
+      default: "8"
+    },
+    "focused-only": {
+      type: "boolean",
+      description: "Only inject the focused task",
+      default: false
+    },
+    phase: {
+      type: "string",
+      description: "Filter tasks to specific phase"
+    },
+    output: {
+      type: "string",
+      description: "Write to file instead of stdout"
+    },
+    "save-state": {
+      type: "boolean",
+      description: "Save session state for extraction",
+      default: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview without writing",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "inject.generate",
+      {
+        maxTasks: Number.parseInt(args["max-tasks"], 10),
+        focusedOnly: args["focused-only"],
+        phase: args.phase,
+        output: args.output,
+        saveState: args["save-state"],
+        dryRun: args["dry-run"]
+      },
+      { command: "inject" }
+    );
+  }
+});
+export {
+  injectCommand
+};
+//# sourceMappingURL=inject-LSRVWNCP.js.map

package/dist/cli/install-global-4AZUCH6U.js

@@ -0,0 +1,95 @@
+(() => {
+  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,
+  humanLine
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/install-global.ts
+import { bootstrapGlobalCleo } from "@cleocode/core/internal";
+function renderBootstrapHuman(ctx, dryRun) {
+  if (dryRun) {
+    humanLine("Dry-run mode \u2014 no changes will be made.\n");
+  }
+  if (ctx.created.length > 0) {
+    humanLine(`${dryRun ? "Would create/update" : "Created/updated"}:`);
+    for (const item of ctx.created) {
+      humanLine(`  + ${item}`);
+    }
+    humanLine("");
+  } else {
+    humanLine("No changes needed \u2014 everything is already up to date.\n");
+  }
+  if (ctx.warnings.length > 0) {
+    humanLine("Warnings:");
+    for (const w of ctx.warnings) {
+      humanLine(`  ! ${w}`);
+    }
+    humanLine("");
+  }
+}
+var installGlobalCommand = defineCommand({
+  meta: {
+    name: "install-global",
+    description: "Run the global bootstrap manually (install templates, ~/.cleo symlink, agents, skills). Same as npm postinstall."
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without applying them"
+    },
+    // Global output format flags — read directly from args (no optsWithGlobals in citty)
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    },
+    human: {
+      type: "boolean",
+      description: "Force human-readable output"
+    },
+    quiet: {
+      type: "boolean",
+      description: "Suppress non-essential output"
+    }
+  },
+  async run({ args }) {
+    const dryRun = args["dry-run"] === true;
+    const isHuman = args.human === true || !!process.stdout.isTTY && args.json !== true;
+    const ctx = await bootstrapGlobalCleo({ dryRun });
+    if (isHuman && args.quiet !== true) {
+      renderBootstrapHuman(ctx, dryRun);
+    }
+    cliOutput(
+      {
+        dryRun,
+        created: ctx.created,
+        warnings: ctx.warnings
+      },
+      {
+        command: "install-global",
+        message: dryRun ? `Dry-run complete \u2014 ${ctx.created.length} action(s) would be applied` : `Bootstrap complete \u2014 ${ctx.created.length} action(s) applied, ${ctx.warnings.length} warning(s)`
+      }
+    );
+  }
+});
+export {
+  installGlobalCommand
+};
+//# sourceMappingURL=install-global-4AZUCH6U.js.map

package/dist/cli/intelligence-2OSFOGD2.js

@@ -0,0 +1,181 @@
+(() => {
+  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/intelligence.ts
+var predictCommand = defineCommand({
+  meta: {
+    name: "predict",
+    description: "Calculate risk score for a task, or predict validation outcome for a stage"
+  },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to assess",
+      required: true
+    },
+    stage: {
+      type: "string",
+      description: "Lifecycle stage for validation outcome prediction"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "predict",
+      { taskId: args.task, stage: args.stage },
+      { command: "intelligence", operation: "intelligence.predict" }
+    );
+  }
+});
+var suggestCommand = defineCommand({
+  meta: { name: "suggest", description: "Suggest verification gate focus for a task" },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to analyze",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "suggest",
+      { taskId: args.task },
+      { command: "intelligence", operation: "intelligence.suggest" }
+    );
+  }
+});
+var learnErrorsCommand = defineCommand({
+  meta: {
+    name: "learn-errors",
+    description: "Extract recurring failure patterns from task and brain history"
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of patterns to return"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "learn-errors",
+      { limit: args.limit !== void 0 ? Number.parseInt(args.limit, 10) : void 0 },
+      { command: "intelligence", operation: "intelligence.learn-errors" }
+    );
+  }
+});
+var confidenceCommand = defineCommand({
+  meta: {
+    name: "confidence",
+    description: "Score verification confidence for a task based on its current gate state"
+  },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to score",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "confidence",
+      { taskId: args.task },
+      { command: "intelligence", operation: "intelligence.confidence" }
+    );
+  }
+});
+var matchCommand = defineCommand({
+  meta: { name: "match", description: "Match known brain patterns against a task" },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to match",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "match",
+      { taskId: args.task },
+      { command: "intelligence", operation: "intelligence.match" }
+    );
+  }
+});
+var intelligenceCommand = defineCommand({
+  meta: { name: "intelligence", description: "Predictive intelligence and quality analysis" },
+  subCommands: {
+    predict: predictCommand,
+    suggest: suggestCommand,
+    "learn-errors": learnErrorsCommand,
+    confidence: confidenceCommand,
+    match: matchCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  intelligenceCommand
+};
+//# sourceMappingURL=intelligence-2OSFOGD2.js.map

package/dist/cli/issue-IIWEDNFC.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 {
+  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 {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/issue.ts
+import { execFileSync } from "node:child_process";
+import { addIssue, BUILD_CONFIG } from "@cleocode/core/internal";
+var CLEO_REPO = BUILD_CONFIG.repository.fullName;
+async function handleIssueType(issueType, opts) {
+  let result;
+  try {
+    result = addIssue({
+      issueType,
+      title: opts["title"],
+      body: opts["body"],
+      severity: opts["severity"],
+      area: opts["area"],
+      dryRun: !!opts["dryRun"]
+    });
+  } catch (err) {
+    cliError(`Failed to create issue: ${err instanceof Error ? err.message : String(err)}`, 1, {
+      name: "E_ISSUE_CREATE"
+    });
+    process.exitCode = 1;
+    return;
+  }
+  if (opts["open"] && typeof result.url === "string" && result.url.startsWith("https://")) {
+    const issueNumber = result.url.match(/(\d+)$/)?.[1] ?? "unknown";
+    try {
+      execFileSync("gh", ["issue", "view", issueNumber, "--repo", CLEO_REPO, "--web"], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+    }
+  }
+  cliOutput(result, { command: "issue", operation: `tools.issue.add.${issueType}` });
+}
+var bugCommand = defineCommand({
+  meta: { name: "bug", description: "File a bug report" },
+  args: {
+    title: { type: "string", description: "Issue title", required: true },
+    body: { type: "string", description: "Issue description", required: true },
+    severity: {
+      type: "string",
+      description: "Severity level (Blocker, Major, Moderate, Minor)"
+    },
+    area: { type: "string", description: "Affected area (cli, dispatch, docs, tests, other)" },
+    open: { type: "boolean", description: "Open issue in browser after creation" },
+    "dry-run": { type: "boolean", description: "Preview without filing" }
+  },
+  async run({ args }) {
+    await handleIssueType("bug", {
+      title: args.title,
+      body: args.body,
+      severity: args.severity,
+      area: args.area,
+      open: args.open,
+      dryRun: args["dry-run"]
+    });
+  }
+});
+var featureCommand = defineCommand({
+  meta: { name: "feature", description: "Request a new feature" },
+  args: {
+    title: { type: "string", description: "Issue title", required: true },
+    body: { type: "string", description: "Issue description", required: true },
+    area: { type: "string", description: "Affected area" },
+    open: { type: "boolean", description: "Open issue in browser after creation" },
+    "dry-run": { type: "boolean", description: "Preview without filing" }
+  },
+  async run({ args }) {
+    await handleIssueType("feature", {
+      title: args.title,
+      body: args.body,
+      area: args.area,
+      open: args.open,
+      dryRun: args["dry-run"]
+    });
+  }
+});
+var helpCommand = defineCommand({
+  meta: { name: "help", description: "Ask a question" },
+  args: {
+    title: { type: "string", description: "Issue title", required: true },
+    body: { type: "string", description: "Issue description", required: true },
+    open: { type: "boolean", description: "Open issue in browser after creation" },
+    "dry-run": { type: "boolean", description: "Preview without filing" }
+  },
+  async run({ args }) {
+    await handleIssueType("help", {
+      title: args.title,
+      body: args.body,
+      open: args.open,
+      dryRun: args["dry-run"]
+    });
+  }
+});
+var diagnosticsCommand = defineCommand({
+  meta: { name: "diagnostics", description: "Show system diagnostics (no issue filed)" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "issue.diagnostics",
+      {},
+      { command: "issue", operation: "tools.issue.diagnostics" }
+    );
+  }
+});
+var issueCommand = defineCommand({
+  meta: {
+    name: "issue",
+    description: "File bug reports, feature requests, or questions to CLEO GitHub repo"
+  },
+  subCommands: {
+    bug: bugCommand,
+    feature: featureCommand,
+    help: helpCommand,
+    diagnostics: diagnosticsCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  issueCommand
+};
+//# sourceMappingURL=issue-IIWEDNFC.js.map

package/dist/cli/janitor-GPMC7VOR.js

@@ -0,0 +1,111 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/janitor.ts
+import { runJanitor } from "@cleocode/core/gc/janitor.js";
+import { resolveLegacyCleoDir } from "@cleocode/paths";
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Run the janitor sweep: reap orphan processes, stop dead scopes, reclaim stale locks, prune temp debris."
+  },
+  args: {
+    "cleo-dir": {
+      type: "string",
+      description: "Override .cleo/ directory path"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Report planned actions without mutating anything",
+      default: false
+    },
+    "grace-min": {
+      type: "string",
+      description: "Minimum age (minutes) of an unregistered process before reap eligibility (default: 10)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const cleoDir = resolveLegacyCleoDir(args["cleo-dir"]);
+    const dryRun = args["dry-run"];
+    const graceMinRaw = args["grace-min"];
+    const gracePeriodMs = graceMinRaw !== void 0 ? Number(graceMinRaw) * 6e4 : void 0;
+    try {
+      const result = await runJanitor({ dryRun, cleoDir, gracePeriodMs });
+      const dryLabel = dryRun ? " (dry run)" : "";
+      const total = result.reaped + result.scopesStopped + result.locksReclaimed + result.semaphoreSlotsCleared + result.worktreesPruned + result.worktreesQuarantined + result.tmpRemoved + result.attachmentsRepaired + result.configsRepaired;
+      const humanMsg = `janitor${dryLabel} \u2014 ${total} action(s): ` + [
+        result.reaped > 0 && `${result.reaped} process(es) reaped`,
+        result.scopesStopped > 0 && `${result.scopesStopped} scope(s) stopped`,
+        result.locksReclaimed > 0 && `${result.locksReclaimed} lock(s) reclaimed`,
+        result.semaphoreSlotsCleared > 0 && `${result.semaphoreSlotsCleared} semaphore slot(s) cleared`,
+        result.worktreesPruned > 0 && `${result.worktreesPruned} worktree(s) pruned`,
+        result.worktreesQuarantined > 0 && `${result.worktreesQuarantined} quarantined`,
+        result.tmpRemoved > 0 && `${result.tmpRemoved} tmp dir(s) removed`,
+        result.attachmentsRepaired > 0 && `${result.attachmentsRepaired} attachment(s) repaired`,
+        result.configsRepaired > 0 && `${result.configsRepaired} config(s) repaired`,
+        result.errors > 0 && `${result.errors} error(s)`
+      ].filter(Boolean).join(", ") || "nothing to do";
+      cliOutput(result, {
+        command: "janitor",
+        operation: "admin.janitor.run",
+        message: humanMsg
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `janitor run failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "admin.janitor.run"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var janitorCommand = defineCommand({
+  meta: {
+    name: "janitor",
+    description: "Orphan process reaper and stale scope/lock/debris sweep (silent, idempotent)"
+  },
+  subCommands: {
+    run: runCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  janitorCommand
+};
+//# sourceMappingURL=janitor-GPMC7VOR.js.map