@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/orchestrate-HOYZY3VX.js

@@ -0,0 +1,948 @@
+(() => {
+  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 {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/orchestrate.ts
+import { execFileSync } from "node:child_process";
+import { orchestration } from "@cleocode/core";
+import { BUILD_CONFIG, getProjectRoot } from "@cleocode/core/internal";
+function formatRollupTable(rollup) {
+  const waves = "waves" in rollup ? rollup.waves : [rollup];
+  const lines = [];
+  const header = ["WAVE", "TASK", "TITLE", "STATUS", "GATES", "LATEST"];
+  const rows = [header];
+  const blockers = [];
+  for (const wave of waves) {
+    for (const w of wave.workers) {
+      const gateSummary = Object.entries(w.gates ?? {}).map(([k, v]) => `${k}=${v === true ? "ok" : v === false ? "fail" : "-"}`).join(",");
+      const latest = w.latestManifestStatus ? `${w.latestManifestStatus}@${(w.latestManifestAt ?? "").slice(0, 19)}` : "-";
+      rows.push([
+        String(wave.waveId),
+        w.taskId,
+        (w.title ?? "").slice(0, 40),
+        String(w.status ?? "-"),
+        gateSummary || "-",
+        latest
+      ]);
+    }
+    for (const b of wave.blockers) blockers.push(b);
+  }
+  const widths = header.map((_, ci) => Math.max(...rows.map((r) => (r[ci] ?? "").length)));
+  for (const row of rows) {
+    lines.push(row.map((c, i) => (c ?? "").padEnd(widths[i] ?? 0)).join("  "));
+  }
+  if (blockers.length > 0) {
+    lines.push("");
+    lines.push("Blockers:");
+    for (const b of blockers) {
+      lines.push(`  - ${b.taskId} [${b.reason}]${b.detail ? ` ${b.detail}` : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+var rollupCommand = defineCommand({
+  meta: {
+    name: "roll-up",
+    description: "Lead-tier rollup of an epic (all waves or filtered by --wave)"
+  },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to roll up",
+      required: true
+    },
+    wave: {
+      type: "string",
+      description: "Filter to one wave, numbered from 1 as `cleo orchestrate waves` prints it (the n of topic epic-<id>.wave-<n>)"
+    },
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON instead of a human table"
+    }
+  },
+  async run({ args }) {
+    const epicId = String(args.epicId);
+    const result = args.wave !== void 0 && args.wave !== "" ? await orchestration.rollupWaveStatus(epicId, Number(args.wave)) : await orchestration.rollupEpicStatus(epicId);
+    cliOutput(result, { command: "orchestrate", operation: "orchestrate.waves" });
+  }
+});
+var startCommand = defineCommand({
+  meta: { name: "start", description: "Start orchestrator session for an epic" },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to orchestrate",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "start",
+      { epicId: args.epicId },
+      { command: "orchestrate" }
+    );
+  }
+});
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Get orchestration status for an epic or overall project" },
+  args: {
+    epic: {
+      type: "string",
+      description: "Epic ID to scope status to"
+    },
+    "merge-queue": {
+      type: "boolean",
+      description: "Show GitHub merge queue depth instead of epic status (T10445)"
+    }
+  },
+  async run({ args }) {
+    if (args["merge-queue"]) {
+      const repo = BUILD_CONFIG.repository.fullName;
+      let queueDepth = 0;
+      let estimatedWaitMinutes = 0;
+      let blocked = false;
+      let note = "merge queue not enabled";
+      try {
+        const raw = execFileSync(
+          "gh",
+          ["api", `repos/${repo}/merge-queue`, "--jq", ".entries | length"],
+          { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 15e3 }
+        );
+        queueDepth = Number(raw.trim()) || 0;
+        estimatedWaitMinutes = queueDepth * 5;
+        blocked = queueDepth > 10;
+        note = queueDepth > 0 ? "active" : "empty";
+      } catch {
+      }
+      cliOutput({ queueDepth, estimatedWaitMinutes, blocked, note }, { command: "orchestrate" });
+      return;
+    }
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "status",
+      { epicId: args.epic },
+      { command: "orchestrate" }
+    );
+  }
+});
+var dashboardCommand = defineCommand({
+  meta: {
+    name: "dashboard",
+    description: "Show queue depth, admin-merge rate, force-bypass rate, and active worktree count"
+  },
+  args: {
+    window: {
+      type: "string",
+      description: "Audit rate window in hours (default: 24)"
+    }
+  },
+  async run({ args }) {
+    const rateWindowHours = args.window !== void 0 ? Number.parseFloat(String(args.window)) : void 0;
+    const metrics = await orchestration.collectOrchestrateDashboard(getProjectRoot(), {
+      ...rateWindowHours !== void 0 && Number.isFinite(rateWindowHours) && rateWindowHours > 0 ? { rateWindowHours } : {}
+    });
+    cliOutput(metrics, {
+      command: "orchestrate-dashboard",
+      operation: "orchestrate.dashboard"
+    });
+  }
+});
+var analyzeCommand = defineCommand({
+  meta: { name: "analyze", description: "Analyze epic dependency structure" },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to analyze",
+      required: true
+    },
+    mode: {
+      type: "string",
+      description: "Analysis mode: critical-path or parallel-safety"
+    },
+    tasks: {
+      type: "string",
+      description: "Comma-separated task IDs for parallel-safety mode"
+    }
+  },
+  async run({ args }) {
+    const taskIds = typeof args.tasks === "string" ? args.tasks.split(",").map((s) => s.trim()) : void 0;
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "analyze",
+      { epicId: args.epicId, mode: args.mode, taskIds },
+      { command: "orchestrate" }
+    );
+  }
+});
+var readyCommand = defineCommand({
+  meta: {
+    name: "ready",
+    description: "Get parallel-safe ready tasks. When the epic is a Saga (label='saga', ADR-073), traverses task_relations.type='groups' instead of parentId."
+  },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to query",
+      required: true
+    },
+    "ignore-deps-validate": {
+      type: "boolean",
+      description: "Skip dep-graph validation and proceed even if issues exist (audit-logged bypass). CLI-only \u2014 sentient mode does not support this flag."
+    },
+    via: {
+      type: "string",
+      description: "Traversal mode (gh-390/ADR-073): 'parent' walks parentId only, 'saga' walks task_relations.type='groups' only, 'both' (default) auto-detects saga-labeled epics."
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "ready",
+      {
+        epicId: args.epicId,
+        ignoreDepsValidate: args["ignore-deps-validate"] === true,
+        ...args.via !== void 0 && { via: args.via }
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var reportCommand = defineCommand({
+  meta: {
+    name: "report",
+    description: "Grouped readiness report: ready, blocked, blockedBy, gate-blocked, invalid. Aligns with orchestrate.ready frontier. Supports pagination."
+  },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to generate the report for",
+      required: true
+    },
+    page: {
+      type: "string",
+      description: "Page number for paginated output (1-indexed, default 1)"
+    },
+    "page-size": {
+      type: "string",
+      description: "Page size for paginated output (default 50, max 200)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "report",
+      {
+        epicId: args.epicId,
+        ...args.page !== void 0 && { page: Number(args.page) },
+        ...args["page-size"] !== void 0 && { pageSize: Number(args["page-size"]) }
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var nextCommand = defineCommand({
+  meta: { name: "next", description: "Get next task to spawn" },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to query",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "next",
+      { epicId: args.epicId },
+      { command: "orchestrate" }
+    );
+  }
+});
+var wavesCommand = defineCommand({
+  meta: {
+    name: "waves",
+    description: "Compute dependency waves for an epic. Wave numbers are stable: a finished wave keeps its number and is listed as completed (--hide-completed omits it). When the epic is a Saga (label='saga', ADR-073), per-member wave plans are merged by index (wave N across all members \u2192 one unified wave N)."
+  },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to compute waves for",
+      required: true
+    },
+    via: {
+      type: "string",
+      description: "Traversal mode (gh-390/ADR-073): 'parent' walks parentId only, 'saga' walks task_relations.type='groups' only, 'both' (default) auto-detects saga-labeled epics."
+    },
+    "hide-completed": {
+      type: "boolean",
+      description: "Omit finished waves. Wave numbers are stable, so the remaining waves keep their numbers (the n of topic epic-<id>.wave-<n>)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "waves",
+      {
+        epicId: args.epicId,
+        ...args.via !== void 0 && { via: args.via },
+        ...args["hide-completed"] === true && { hideCompleted: true }
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var planCommand = defineCommand({
+  meta: {
+    name: "plan",
+    description: "Emit a deterministic wave+worker plan for an epic (machine-readable)"
+  },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to plan",
+      required: true
+    },
+    tier: {
+      type: "string",
+      description: "Preferred resolver tier (0=project, 1=global, 2=packaged)"
+    }
+  },
+  async run({ args }) {
+    const preferTier = args.tier !== void 0 ? Number.parseInt(args.tier, 10) : void 0;
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "plan",
+      { epicId: args.epicId, preferTier },
+      { command: "orchestrate", operation: "orchestrate.plan" }
+    );
+  }
+});
+var spawnCommand = defineCommand({
+  meta: { name: "spawn", description: "Prepare spawn context for a subagent" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to prepare spawn context for",
+      required: true
+    },
+    protocol: {
+      type: "string",
+      description: "Protocol type override"
+    },
+    tier: {
+      type: "string",
+      description: "Protocol tier: 0 (minimal), 1 (standard), 2 (full), or auto (default \u2014 inferred from role+size+labels via T892 heuristics)"
+    },
+    "no-worktree": {
+      type: "boolean",
+      description: "Skip worktree provisioning for this spawn. The opt-out is logged to the audit log (T1140)."
+    },
+    scope: {
+      type: "string",
+      description: "T9807 sparse-checkout scope: directory prefix to check out in the worktree (cone mode). Example: --scope packages/cleo creates a worktree with only that subtree checked out. Reduces disk usage and checkout time for tasks scoped to a single package."
+    },
+    "orchestrator-defer": {
+      type: "boolean",
+      description: "T9214 atomicity waiver: defer worker file-scope declaration to commit time. Tier-1+ orchestrators only \u2014 records auditable atomicity_waiver in the spawn manifest. Bypasses E_ATOMICITY_NO_SCOPE for worker tasks without explicit AC.files."
+    },
+    resume: {
+      type: "boolean",
+      description: "T10078 \u2014 skip worktree provisioning and attach to an existing locked worktree at the canonical XDG path. If the worktree does not exist, returns E_RESUME_WORKTREE_MISSING. Use after a prior aborted spawn left a worktree behind."
+    }
+  },
+  async run({ args }) {
+    let tier;
+    if (args.tier !== void 0 && args.tier !== "auto") {
+      const parsed = Number.parseInt(args.tier, 10);
+      if (parsed === 0 || parsed === 1 || parsed === 2) {
+        tier = parsed;
+      }
+    }
+    const atomicityScope = args["orchestrator-defer"] ? "orchestrator-defer" : void 0;
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "spawn",
+      {
+        taskId: args.taskId,
+        protocolType: args.protocol,
+        tier,
+        // T12520 — citty parses `--no-worktree` as the NEGATION of `worktree`
+        // (`{ worktree: false }`), never as `{ 'no-worktree': true }`, so reading
+        // only `args['no-worktree']` made the opt-out a silent no-op: a worktree
+        // was provisioned and the Worktree Setup block emitted anyway.
+        noWorktree: args.worktree === false || args["no-worktree"] === true,
+        ...args.scope ? { spawnScope: args.scope } : {},
+        ...atomicityScope ? { atomicityScope } : {},
+        resume: args.resume === true
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var validateCommand = defineCommand({
+  meta: { name: "validate", description: "Validate subagent output" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to validate output for",
+      required: true
+    },
+    file: {
+      type: "string",
+      description: "Output file path"
+    },
+    manifest: {
+      type: "boolean",
+      description: "Manifest entry was appended"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "validate",
+      { taskId: args.taskId, file: args.file, manifestEntry: args.manifest },
+      { command: "orchestrate" }
+    );
+  }
+});
+var contextCommand = defineCommand({
+  meta: { name: "context", description: "Get orchestrator context summary" },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to get context for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "context",
+      { epicId: args.epicId },
+      { command: "orchestrate" }
+    );
+  }
+});
+var ivtrCommand = defineCommand({
+  meta: {
+    name: "ivtr",
+    description: "Drive an Implement\u2192Validate\u2192Test phased loop on a task with evidence-bound gates"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to drive IVTR loop for",
+      required: true
+    },
+    start: {
+      type: "boolean",
+      description: "Begin Implement phase"
+    },
+    next: {
+      type: "boolean",
+      description: "Advance to next phase (requires prior-phase evidence)"
+    },
+    status: {
+      type: "boolean",
+      description: "Show current IVTR state + history"
+    },
+    release: {
+      type: "boolean",
+      description: "Final gate \u2014 require I+V+T evidence, then release"
+    },
+    "loop-back": {
+      type: "boolean",
+      description: "Rewind to specified phase on failure"
+    },
+    phase: {
+      type: "string",
+      description: "Phase for --loop-back (implement|validate|test)"
+    },
+    reason: {
+      type: "string",
+      description: "Reason for loop-back"
+    },
+    evidence: {
+      type: "string",
+      description: "Attachment sha256 to attach"
+    }
+  },
+  async run({ args }) {
+    const action = args.start ? "start" : args.next ? "next" : args.release ? "release" : args["loop-back"] ? "loop-back" : "status";
+    const kind = action === "status" ? "query" : "mutate";
+    await dispatchFromCli(
+      kind,
+      "orchestrate",
+      `ivtr.${action}`,
+      { taskId: args.taskId, phase: args.phase, reason: args.reason, evidence: args.evidence },
+      { command: "orchestrate" }
+    );
+  }
+});
+var parallelCommand = defineCommand({
+  meta: { name: "parallel", description: "Manage parallel wave execution (action: start | end)" },
+  args: {
+    action: {
+      type: "positional",
+      description: "Action to perform: start or end",
+      required: true
+    },
+    epicId: {
+      type: "positional",
+      description: "Epic ID for wave execution",
+      required: true
+    },
+    wave: {
+      type: "string",
+      description: "Wave number"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "parallel",
+      {
+        action: args.action,
+        epicId: args.epicId,
+        wave: args.wave !== void 0 ? Number.parseInt(args.wave, 10) : void 0
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var unblockCommand = defineCommand({
+  meta: { name: "unblock", description: "Analyze dependency graph for unblocking opportunities" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "unblock.opportunities",
+      {},
+      { command: "orchestrate" }
+    );
+  }
+});
+var bootstrapCommand = defineCommand({
+  meta: { name: "bootstrap", description: "Load brain state for agent bootstrapping" },
+  args: {
+    epic: {
+      type: "string",
+      description: "Epic ID to scope bootstrap context to"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "bootstrap",
+      { epicId: args.epic },
+      { command: "orchestrate" }
+    );
+  }
+});
+var classifyCommand = defineCommand({
+  meta: {
+    name: "classify",
+    description: "Classify a request using CANT prompt-based team routing"
+  },
+  args: {
+    request: {
+      type: "positional",
+      description: "Request text to classify",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "classify",
+      { request: args.request },
+      { command: "orchestrate" }
+    );
+  }
+});
+var fanoutStatusCommand = defineCommand({
+  meta: { name: "fanout-status", description: "Get fanout status by manifest entry ID" },
+  args: {
+    "manifest-entry-id": {
+      type: "string",
+      description: "Manifest entry ID returned by orchestrate.fanout",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "fanout.status",
+      { manifestEntryId: args["manifest-entry-id"] },
+      { command: "orchestrate" }
+    );
+  }
+});
+var handoffCommand = defineCommand({
+  meta: { name: "handoff", description: "Perform session handoff and spawn successor for a task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to hand off",
+      required: true
+    },
+    protocol: {
+      type: "string",
+      description: "Protocol type for handoff",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "handoff",
+      { taskId: args.taskId, protocolType: args.protocol },
+      { command: "orchestrate" }
+    );
+  }
+});
+var spawnExecuteCommand = defineCommand({
+  meta: { name: "spawn-execute", description: "Execute spawn for a task via the adapter registry" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to execute spawn for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "spawn.execute",
+      { taskId: args.taskId },
+      { command: "orchestrate" }
+    );
+  }
+});
+var fanoutCommand = defineCommand({
+  meta: { name: "fanout", description: "Fan out tasks for an epic using parallel spawn" },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to fan out",
+      required: true
+    },
+    tasks: {
+      type: "string",
+      description: "Comma-separated task IDs to fan out"
+    }
+  },
+  async run({ args }) {
+    const taskIds = typeof args.tasks === "string" ? args.tasks.split(",").map((s) => s.trim()) : void 0;
+    const items = taskIds ? taskIds.map((taskId) => ({ taskId, team: "default" })) : void 0;
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "fanout",
+      { epicId: args.epicId, items },
+      { command: "orchestrate" }
+    );
+  }
+});
+var pruneCommand = defineCommand({
+  meta: {
+    name: "prune",
+    description: "Remove stale agent worktrees (after task completion or crash)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID whose worktree should be pruned (omit for bulk prune)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const taskId = typeof args.taskId === "string" && args.taskId.length > 0 ? args.taskId : void 0;
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "worktree.prune",
+      { taskId },
+      { command: "orchestrate" }
+    );
+  }
+});
+var worktreeCompleteCommand = defineCommand({
+  meta: {
+    name: "worktree-complete",
+    description: "Integrate subagent worktree into default branch via canonical git merge --no-ff (ADR-062). T9548: idempotent \u2014 re-running on a completed worktree is a no-op."
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID whose worktree branch should be merged (e.g. T1625)",
+      required: true
+    },
+    resolve: {
+      type: "string",
+      description: 'T9548 conflict-recovery mode: "auto" (default \u2014 attempt merge) or "manual" (skip merge, mark worktree as manually-handled in audit log)',
+      default: "auto"
+    }
+  },
+  async run({ args }) {
+    const resolveArg = typeof args.resolve === "string" ? args.resolve : void 0;
+    const params = { taskId: args.taskId };
+    if (resolveArg === "manual") {
+      params.resolve = "manual";
+    }
+    await dispatchFromCli("mutate", "orchestrate", "worktree.complete", params, {
+      command: "orchestrate"
+    });
+  }
+});
+var conduitStatusCommand = defineCommand({
+  meta: { name: "conduit-status", description: "Get conduit messaging status" },
+  async run() {
+    await dispatchFromCli("query", "conduit", "status", {}, { command: "orchestrate" });
+  }
+});
+var conduitPeekCommand = defineCommand({
+  meta: { name: "conduit-peek", description: "Peek at queued conduit messages" },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of messages to return"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "conduit",
+      "peek",
+      { limit: args.limit !== void 0 ? Number.parseInt(args.limit, 10) : void 0 },
+      { command: "orchestrate" }
+    );
+  }
+});
+var conduitStartCommand = defineCommand({
+  meta: { name: "conduit-start", description: "Start the conduit message loop" },
+  args: {
+    "poll-interval": {
+      type: "string",
+      description: "Polling interval in milliseconds"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "conduit",
+      "start",
+      {
+        pollIntervalMs: args["poll-interval"] !== void 0 ? Number.parseInt(args["poll-interval"], 10) : void 0
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var conduitStopCommand = defineCommand({
+  meta: { name: "conduit-stop", description: "Stop the conduit message loop" },
+  async run() {
+    await dispatchFromCli("mutate", "conduit", "stop", {}, { command: "orchestrate" });
+  }
+});
+var approveCommand = defineCommand({
+  meta: {
+    name: "approve",
+    description: "Approve a pending HITL playbook approval gate by its resume token"
+  },
+  args: {
+    resumeToken: {
+      type: "positional",
+      description: "HMAC-signed resume token returned when the gate was created",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Optional justification note recorded on the audit row"
+    },
+    approver: {
+      type: "string",
+      description: "Identity of the approver (defaults to cli-user)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "approve",
+      {
+        resumeToken: args.resumeToken,
+        reason: args.reason,
+        approver: args.approver
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var rejectCommand = defineCommand({
+  meta: {
+    name: "reject",
+    description: "Reject a pending HITL playbook approval gate with a mandatory reason"
+  },
+  args: {
+    resumeToken: {
+      type: "positional",
+      description: "HMAC-signed resume token returned when the gate was created",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Justification for the rejection (mandatory, recorded on the audit row)",
+      required: true
+    },
+    approver: {
+      type: "string",
+      description: "Identity of the rejector (defaults to cli-user)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "reject",
+      {
+        resumeToken: args.resumeToken,
+        reason: args.reason,
+        approver: args.approver
+      },
+      { command: "orchestrate" }
+    );
+  }
+});
+var pendingCommand = defineCommand({
+  meta: {
+    name: "pending",
+    description: "List all pending HITL playbook approval gates awaiting a decision"
+  },
+  async run() {
+    await dispatchFromCli("query", "orchestrate", "pending", {}, { command: "orchestrate" });
+  }
+});
+var conduitSendCommand = defineCommand({
+  meta: {
+    name: "conduit-send",
+    description: "Send a message via conduit to an agent or conversation"
+  },
+  args: {
+    content: {
+      type: "positional",
+      description: "Message content to send",
+      required: true
+    },
+    to: {
+      type: "string",
+      description: "Target agent ID"
+    },
+    conversation: {
+      type: "string",
+      description: "Conversation ID to send into"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "conduit",
+      "send",
+      { content: args.content, to: args.to, conversationId: args.conversation },
+      { command: "orchestrate" }
+    );
+  }
+});
+var orchestrateCommand = defineCommand({
+  meta: { name: "orchestrate", description: "Multi-agent orchestration commands" },
+  subCommands: {
+    start: startCommand,
+    status: statusCommand,
+    dashboard: dashboardCommand,
+    "roll-up": rollupCommand,
+    analyze: analyzeCommand,
+    ready: readyCommand,
+    report: reportCommand,
+    next: nextCommand,
+    waves: wavesCommand,
+    plan: planCommand,
+    spawn: spawnCommand,
+    validate: validateCommand,
+    context: contextCommand,
+    ivtr: ivtrCommand,
+    parallel: parallelCommand,
+    unblock: unblockCommand,
+    bootstrap: bootstrapCommand,
+    classify: classifyCommand,
+    "fanout-status": fanoutStatusCommand,
+    handoff: handoffCommand,
+    "spawn-execute": spawnExecuteCommand,
+    fanout: fanoutCommand,
+    prune: pruneCommand,
+    "worktree-complete": worktreeCompleteCommand,
+    "conduit-status": conduitStatusCommand,
+    "conduit-peek": conduitPeekCommand,
+    "conduit-start": conduitStartCommand,
+    "conduit-stop": conduitStopCommand,
+    "conduit-send": conduitSendCommand,
+    // T935: HITL playbook approval gates
+    approve: approveCommand,
+    reject: rejectCommand,
+    pending: pendingCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  formatRollupTable,
+  orchestrateCommand
+};
+//# sourceMappingURL=orchestrate-HOYZY3VX.js.map