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

package/dist/cli/issue-P5RNMRDG.js

@@ -0,0 +1,159 @@
+(() => {
+  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,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.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-P5RNMRDG.js.map

package/dist/cli/janitor-ZNCFQ7E3.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-4RGSNUUP.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-ZNCFQ7E3.js.map

package/dist/cli/labels-ORBM3T57.js

@@ -0,0 +1,88 @@
+(() => {
+  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/labels.ts
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all labels with task counts (default)" },
+  async run() {
+    await dispatchFromCli("query", "tasks", "label.list", {}, { command: "labels" });
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show tasks with specific label" },
+  args: {
+    label: { type: "positional", description: "Label name to filter by", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli("query", "tasks", "list", { label: args.label }, { command: "labels" });
+  }
+});
+var statsCommand = defineCommand({
+  meta: { name: "stats", description: "Show detailed label statistics" },
+  async run() {
+    await dispatchFromCli("query", "tasks", "label.list", {}, { command: "labels" });
+  }
+});
+var labelsCommand = defineCommand({
+  meta: {
+    name: "labels",
+    description: "List all labels (no args), or show tasks for a label (cleo labels <name>)"
+  },
+  args: {
+    // Optional positional — when present, dispatches to tasks.list with the
+    // label filter; when absent, falls through to the legacy label.list path.
+    // Required:false keeps the bare `cleo labels` invocation working.
+    name: {
+      type: "positional",
+      description: "Label name to filter tasks by (omit to list all labels)",
+      required: false
+    }
+  },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    stats: statsCommand
+  },
+  async run(ctx) {
+    const rawArgs = ctx.rawArgs ?? [];
+    if (rawArgs.some((a) => ["list", "show", "stats"].includes(a))) {
+      return;
+    }
+    const name = ctx.args.name;
+    if (typeof name === "string" && name.length > 0) {
+      await dispatchFromCli("query", "tasks", "list", { label: name }, { command: "labels" });
+      return;
+    }
+    await dispatchFromCli("query", "tasks", "label.list", {}, { command: "labels" });
+  }
+});
+export {
+  labelsCommand
+};
+//# sourceMappingURL=labels-ORBM3T57.js.map

package/dist/cli/lifecycle-MHR22TVI.js

@@ -0,0 +1,273 @@
+(() => {
+  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,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} 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/lifecycle.ts
+var VALID_STAGES = "research|consensus|architecture_decision|specification|decomposition|implementation|validation|testing|release|contribution";
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show lifecycle state for an epic" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "stage.status",
+      { epicId: args.epicId },
+      { command: "lifecycle" }
+    );
+  }
+});
+var startCommand = defineCommand({
+  meta: {
+    name: "start",
+    description: `Start a lifecycle stage. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.record",
+      { taskId: args.epicId, stage: args.stage, status: "in_progress" },
+      { command: "lifecycle" }
+    );
+  }
+});
+var completeCommand = defineCommand({
+  meta: {
+    name: "complete",
+    description: `Complete a lifecycle stage. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true },
+    artifacts: { type: "string", description: "Comma-separated artifact paths" },
+    notes: { type: "string", description: "Completion notes" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.record",
+      {
+        taskId: args.epicId,
+        stage: args.stage,
+        status: "completed",
+        notes: args.notes
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var skipCommand = defineCommand({
+  meta: {
+    name: "skip",
+    description: `Skip a lifecycle stage. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true },
+    reason: { type: "string", description: "Reason for skipping", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.skip",
+      { taskId: args.epicId, stage: args.stage, reason: args.reason },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateCommand = defineCommand({
+  meta: { name: "gate", description: "Check lifecycle gate for a stage" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true }
+  },
+  async run({ args }) {
+    const result = await dispatchRaw("query", "pipeline", "stage.validate", {
+      epicId: args.epicId,
+      targetStage: args.stage
+    });
+    if (result.success) {
+      const { cliOutput } = await import("./renderers-TGSW77J4.js");
+      cliOutput(result.data, { command: "lifecycle" });
+      const data = result.data;
+      if (data && !data["canProgress"]) {
+        process.exit(80);
+      }
+    } else {
+      handleRawError(result, { command: "lifecycle", operation: "pipeline.stage.validate" });
+    }
+  }
+});
+var guidanceCommand = defineCommand({
+  meta: {
+    name: "guidance",
+    description: "Get stage-aware LLM prompt guidance (Phase 2). Pi extensions shell out to this on before_agent_start."
+  },
+  args: {
+    stage: { type: "positional", description: "Stage name (optional)", required: false },
+    epicId: {
+      type: "string",
+      description: "Resolve stage from current epic pipeline status if no stage arg"
+    },
+    format: { type: "string", description: "Output format: markdown | json", default: "markdown" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "stage.guidance",
+      {
+        stage: args.stage,
+        epicId: args.epicId,
+        format: args.format
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var historyCommand = defineCommand({
+  meta: { name: "history", description: "Show full lifecycle stage history for a task or epic" },
+  args: {
+    taskId: { type: "positional", description: "Task or epic ID", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "stage.history",
+      { taskId: args.taskId },
+      { command: "lifecycle" }
+    );
+  }
+});
+var resetCommand = defineCommand({
+  meta: {
+    name: "reset",
+    description: `Reset a lifecycle stage back to pending. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true },
+    reason: { type: "string", description: "Reason for resetting the stage", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.reset",
+      { taskId: args.epicId, stage: args.stage, reason: args.reason },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateRecordPassCommand = defineCommand({
+  meta: { name: "pass", description: "Record a gate as passed for a lifecycle stage" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    gateName: { type: "positional", description: "Gate name", required: true },
+    agent: { type: "string", description: "Agent that performed the gate check" },
+    notes: { type: "string", description: "Notes on gate outcome" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.gate.pass",
+      {
+        taskId: args.epicId,
+        gateName: args.gateName,
+        agent: args.agent,
+        notes: args.notes
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateRecordFailCommand = defineCommand({
+  meta: { name: "fail", description: "Record a gate as failed for a lifecycle stage" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    gateName: { type: "positional", description: "Gate name", required: true },
+    reason: { type: "string", description: "Reason the gate failed" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.gate.fail",
+      {
+        taskId: args.epicId,
+        gateName: args.gateName,
+        reason: args.reason
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateRecordCommand = defineCommand({
+  meta: { name: "gate-record", description: "Record a gate pass or fail for a lifecycle stage" },
+  subCommands: {
+    pass: gateRecordPassCommand,
+    fail: gateRecordFailCommand
+  }
+});
+var lifecycleCommand = defineCommand({
+  meta: { name: "lifecycle", description: "RCASD-IVTR+C lifecycle pipeline management" },
+  subCommands: {
+    show: showCommand,
+    start: startCommand,
+    complete: completeCommand,
+    skip: skipCommand,
+    gate: gateCommand,
+    guidance: guidanceCommand,
+    history: historyCommand,
+    reset: resetCommand,
+    "gate-record": gateRecordCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  lifecycleCommand
+};
+//# sourceMappingURL=lifecycle-MHR22TVI.js.map