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

package/dist/cli/orchestrate-CZ2J6W3L.js

@@ -0,0 +1,1650 @@
+(() => {
+  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 {
+  routeByParam
+} from "./chunk-QY76BRUZ.js";
+import {
+  acquirePlaybookDb,
+  listPendingApprovalsForDispatch,
+  lookupApprovalByTokenForDispatch
+} from "./chunk-NEFMQYLE.js";
+import "./chunk-NU6CQQVB.js";
+import {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch
+} from "./chunk-QWNKLLLG.js";
+import {
+  lazyOperation
+} from "./chunk-TYC7G5LF.js";
+import {
+  dispatchMeta,
+  errorResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/orchestrate.ts
+import { CleoError } from "@cleocode/core/errors";
+import { getLogger as getLogger2 } from "@cleocode/core/logger";
+import { getProjectRoot as getProjectRoot2 } from "@cleocode/core/project-scope";
+import { sessionContextInject } from "@cleocode/core/session/engine-ops";
+import { CLEO_DIR_NAME, WORKFLOWS_SUBDIR } from "@cleocode/runtime/gateway/dispatch";
+
+// packages/cleo/src/dispatch/domains/ivtr.ts
+import { getIvtrState } from "@cleocode/core/lifecycle/ivtr-loop";
+import { getLogger } from "@cleocode/core/logger";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { engineSuccess } from "@cleocode/runtime/gateway/dispatch";
+var log = getLogger("domain:ivtr");
+var E_DEPRECATED_USE_PLAYBOOK = "E_DEPRECATED_USE_PLAYBOOK";
+function deprecatedMutateEnvelope(op, taskId) {
+  const id = taskId ?? "T####";
+  const manual = `cleo playbook run ivtr --context '{"taskId":"${id}"}'`;
+  const autonomous = "cleo go";
+  const migration = {
+    deprecatedBy: "T11764-state-machine-collapse",
+    deprecatedOp: op,
+    survivor: "cantbook-runtime (ivtr.cantbook)",
+    autonomous,
+    manual,
+    ...taskId !== void 0 ? { taskId } : {}
+  };
+  return lafsError(
+    E_DEPRECATED_USE_PLAYBOOK,
+    `'cleo orchestrate ivtr --${op}' is deprecated. The hand-rolled IVTR phase walk was collapsed into the cantbook runtime (T11764). Drive IVTR through the playbook runtime instead: '${autonomous}' (autonomous, default) or '${manual}' (single manual run).`,
+    op,
+    manual,
+    {
+      migration,
+      alternatives: [
+        { action: "Autonomous IVTR loop (default)", command: autonomous },
+        { action: "Manual single IVTR run", command: manual }
+      ]
+    }
+  );
+}
+function isAlternativesList(value) {
+  return Array.isArray(value) && value.every(
+    (v) => typeof v === "object" && v !== null && typeof v.action === "string" && typeof v.command === "string"
+  );
+}
+async function ivtrStatusOp(params) {
+  const cwd = getProjectRoot();
+  const state = await getIvtrState(params.taskId, { cwd });
+  if (!state) {
+    return engineSuccess({
+      taskId: params.taskId,
+      started: false,
+      currentPhase: null,
+      phaseHistory: [],
+      message: `Task ${params.taskId} has no IVTR state. The IVTR loop now runs on the cantbook runtime (T11764) \u2014 drive it with 'cleo go' (autonomous) or 'cleo playbook run ivtr --context '{"taskId":"${params.taskId}"}''.`
+    });
+  }
+  return engineSuccess({
+    taskId: params.taskId,
+    started: true,
+    currentPhase: state.currentPhase,
+    startedAt: state.startedAt,
+    phaseHistory: state.phaseHistory,
+    loopBackCount: state.loopBackCount ?? {
+      implement: 0,
+      validate: 0,
+      test: 0,
+      released: 0
+    },
+    evidenceCount: state.phaseHistory.reduce(
+      (acc, e) => acc + e.evidenceRefs.length,
+      0
+    )
+  });
+}
+var DEPRECATED_OP_RESULT = {
+  success: false,
+  error: { code: E_DEPRECATED_USE_PLAYBOOK, message: "IVTR mutate ops are deprecated (T11764)." }
+};
+function ivtrStartOp(_params) {
+  return Promise.resolve(DEPRECATED_OP_RESULT);
+}
+function ivtrNextOp(_params) {
+  return Promise.resolve(DEPRECATED_OP_RESULT);
+}
+function ivtrReleaseOp(_params) {
+  return Promise.resolve(DEPRECATED_OP_RESULT);
+}
+function ivtrLoopBackOp(_params) {
+  return Promise.resolve(DEPRECATED_OP_RESULT);
+}
+var ivtrCoreOps = {
+  status: ivtrStatusOp,
+  start: ivtrStartOp,
+  next: ivtrNextOp,
+  release: ivtrReleaseOp,
+  "loop-back": ivtrLoopBackOp
+};
+var _ivtrTypedHandler = defineTypedHandler("ivtr", {
+  status: async (params) => {
+    const result = await ivtrCoreOps.status(params);
+    return result.success ? lafsSuccess(result.data, "status") : lafsError(result.error?.code ?? "E_INTERNAL", result.error?.message ?? "", "status");
+  },
+  // ── DEPRECATED mutate ops (T11896 · T11764 collapse) ────────────────────
+  // The per-step phase walk has no 1:1 mapping onto the whole-run cantbook
+  // primitives (`executePlaybook`/`resumePlaybook`), so each op returns the
+  // typed E_DEPRECATED_USE_PLAYBOOK migration envelope (ADR-086) rather than
+  // silently breaking. `params.taskId` is woven into the migration command.
+  start: async (params) => deprecatedMutateEnvelope("start", params.taskId),
+  next: async (params) => deprecatedMutateEnvelope("next", params.taskId),
+  release: async (params) => deprecatedMutateEnvelope("release", params.taskId),
+  "loop-back": async (params) => deprecatedMutateEnvelope("loop-back", params.taskId)
+});
+var IvtrHandler = class {
+  // -----------------------------------------------------------------------
+  // query — read-only
+  // -----------------------------------------------------------------------
+  /**
+   * Handle read-only IVTR queries.
+   *
+   * Supported operations:
+   * - `status` — return IvtrState + resolved summary for a task
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    const queryOps = /* @__PURE__ */ new Set(["status"]);
+    if (!queryOps.has(operation)) {
+      return unsupportedOp("query", "ivtr", operation, startTime);
+    }
+    try {
+      if (!params?.["taskId"]) {
+        return {
+          meta: dispatchMeta("query", "ivtr", operation, startTime),
+          success: false,
+          error: { code: "E_INVALID_INPUT", message: "taskId is required" }
+        };
+      }
+      const envelope = await typedDispatch(
+        _ivtrTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return {
+        meta: dispatchMeta("query", "ivtr", operation, startTime),
+        success: envelope.success,
+        ...envelope.success ? { data: envelope.data } : {
+          error: {
+            code: envelope.error?.code !== void 0 ? String(envelope.error.code) : "E_INTERNAL",
+            message: envelope.error?.message ?? "Unknown error"
+          }
+        }
+      };
+    } catch (err) {
+      log.error({ err, operation }, "IvtrHandler query error");
+      return handleErrorResult("query", "ivtr", operation, err, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // mutate — state-modifying
+  // -----------------------------------------------------------------------
+  /**
+   * Handle state-modifying IVTR mutations — all DEPRECATED (T11896).
+   *
+   * `start`/`next`/`release`/`loop-back` are no longer driven by the hand-rolled
+   * phase walk; each returns the typed {@link E_DEPRECATED_USE_PLAYBOOK}
+   * migration envelope (carrying `fix`, `details.migration`, and `alternatives`
+   * per ADR-086) so the caller is routed onto the cantbook runtime. The full
+   * migration-hint payload is forwarded onto the `DispatchResponse.error` —
+   * nothing is orphaned silently.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    const mutateOps = /* @__PURE__ */ new Set(["start", "next", "release", "loop-back"]);
+    if (!mutateOps.has(operation)) {
+      return unsupportedOp("mutate", "ivtr", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _ivtrTypedHandler,
+        operation,
+        params ?? {}
+      );
+      if (envelope.success) {
+        return {
+          meta: dispatchMeta("mutate", "ivtr", operation, startTime),
+          success: true,
+          data: envelope.data
+        };
+      }
+      const err = envelope.error;
+      const error = {
+        code: err?.code !== void 0 ? String(err.code) : "E_INTERNAL",
+        message: err?.message ?? "Unknown error"
+      };
+      if (err?.fix !== void 0) error.fix = err.fix;
+      if (err?.details !== void 0) error.details = err.details;
+      const alternatives = err?.details?.["alternatives"];
+      if (isAlternativesList(alternatives)) error.alternatives = alternatives;
+      return {
+        meta: dispatchMeta("mutate", "ivtr", operation, startTime),
+        success: false,
+        error
+      };
+    } catch (err) {
+      log.error({ err, operation }, "IvtrHandler mutate error");
+      return handleErrorResult("mutate", "ivtr", operation, err, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // getSupportedOperations
+  // -----------------------------------------------------------------------
+  /** Return declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: ["status"],
+      mutate: ["start", "next", "release", "loop-back"]
+    };
+  }
+};
+
+// packages/cleo/src/dispatch/domains/orchestrate.ts
+var orchestrateAnalyze = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateAnalyze
+);
+var orchestrateBootstrap = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/lifecycle-ops")).orchestrateBootstrap
+);
+var orchestrateContext = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateContext
+);
+var orchestrateHandoff = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/handoff-ops")).orchestrateHandoff
+);
+var orchestrateNext = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateNext
+);
+var orchestrateParallelEnd = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/lifecycle-ops")).orchestrateParallelEnd
+);
+var orchestrateParallelStart = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/lifecycle-ops")).orchestrateParallelStart
+);
+var orchestratePlan = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/plan")).orchestratePlan
+);
+var orchestrateReady = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateReady
+);
+var orchestrateReport = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateReport
+);
+var orchestrateSpawn = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/spawn-ops")).orchestrateSpawn
+);
+var orchestrateSpawnExecute = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/spawn-ops")).orchestrateSpawnExecute
+);
+var orchestrateStartup = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/lifecycle-ops")).orchestrateStartup
+);
+var orchestrateStatus = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateStatus
+);
+var orchestrateUnblockOpportunities = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/lifecycle-ops")).orchestrateUnblockOpportunities
+);
+var orchestrateValidate = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateValidate
+);
+var orchestrateWaves = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/query-ops")).orchestrateWaves
+);
+var pivotTask = lazyOperation(
+  async () => (await import("@cleocode/core/orchestrate/pivot")).pivotTask
+);
+var sessionEnd = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).sessionEnd
+);
+var sessionStatus = lazyOperation(
+  async () => (await import("@cleocode/core/session/status-op")).sessionStatus
+);
+var ivtrHandler = new IvtrHandler();
+var FANOUT_MANIFEST_MAX_SIZE = 64;
+var fanoutManifestStore = /* @__PURE__ */ new Map();
+function evictFanoutManifest() {
+  while (fanoutManifestStore.size > FANOUT_MANIFEST_MAX_SIZE) {
+    const oldest = fanoutManifestStore.keys().next().value;
+    if (oldest !== void 0) fanoutManifestStore.delete(oldest);
+  }
+}
+async function orchestrateStatusOp(params) {
+  return orchestrateStatus(params.epicId, getProjectRoot2());
+}
+async function orchestrateNextOp(params) {
+  return orchestrateNext(params.epicId, getProjectRoot2());
+}
+async function orchestrateReadyOp(params) {
+  return orchestrateReady(params.epicId, getProjectRoot2(), {
+    ignoreDepsValidate: params.ignoreDepsValidate,
+    via: params.via
+  });
+}
+async function orchestrateReportOp(params) {
+  return orchestrateReport(params.epicId, getProjectRoot2(), params);
+}
+async function orchestrateAnalyzeOp(params) {
+  if (params.mode === "parallel-safety") {
+    return orchestrateAnalyzeParallelSafety(params.taskIds ?? [], getProjectRoot2());
+  }
+  return orchestrateAnalyze(params.epicId, getProjectRoot2(), params.mode);
+}
+async function orchestrateClassifyOp(params) {
+  return orchestrateClassify(params.request, params.context, getProjectRoot2(), params.taskId);
+}
+function orchestrateFanoutStatusOp(params) {
+  const entry = fanoutManifestStore.get(params.manifestEntryId);
+  if (!entry) {
+    return Promise.resolve({
+      success: true,
+      data: {
+        manifestEntryId: params.manifestEntryId,
+        pending: [],
+        running: [],
+        complete: [],
+        failed: [],
+        found: false
+      }
+    });
+  }
+  const spawned = entry.results.filter((r) => r.status === "spawned").map((r) => r.taskId);
+  const failed = entry.results.filter((r) => r.status === "failed").map((r) => r.taskId);
+  return Promise.resolve({
+    success: true,
+    data: {
+      manifestEntryId: params.manifestEntryId,
+      pending: [],
+      running: spawned,
+      complete: [],
+      failed,
+      found: true,
+      completedAt: entry.completedAt
+    }
+  });
+}
+async function orchestrateContextOp(params) {
+  return orchestrateContext(params.epicId, getProjectRoot2());
+}
+async function orchestrateWavesOp(params) {
+  return orchestrateWaves(params.epicId, getProjectRoot2(), {
+    via: params.via,
+    ...params.hideCompleted === true ? { hideCompleted: true } : {}
+  });
+}
+async function orchestratePlanOp(params) {
+  return orchestratePlan({
+    epicId: params.epicId,
+    projectRoot: getProjectRoot2(),
+    preferTier: params.preferTier
+  });
+}
+async function orchestrateBootstrapOp(params) {
+  return orchestrateBootstrap(getProjectRoot2(), { speed: params.speed });
+}
+async function orchestrateUnblockOp(_params) {
+  return orchestrateUnblockOpportunities(getProjectRoot2());
+}
+async function orchestrateIvtrStatusOp(params) {
+  return ivtrHandler.query("status", params);
+}
+async function orchestratePendingOp(_params) {
+  return Promise.resolve({ success: true, data: {} });
+}
+async function orchestrateStartOp(params) {
+  return orchestrateStartup(params.epicId, getProjectRoot2());
+}
+async function orchestrateSpawnOp(params) {
+  return orchestrateSpawn(
+    params.taskId,
+    params.protocolType,
+    getProjectRoot2(),
+    params.tier,
+    params.noWorktree,
+    params.spawnScope,
+    params.atomicityScope,
+    params.resume
+  );
+}
+async function orchestrateHandoffOp(params) {
+  return orchestrateHandoff(
+    {
+      taskId: params.taskId,
+      protocolType: params.protocolType,
+      note: params.note,
+      nextAction: params.nextAction,
+      variant: params.variant,
+      tier: params.tier,
+      idempotencyKey: params.idempotencyKey
+    },
+    // Inject cleo session ops to avoid core→cleo import cycle (T1570 ADR-057)
+    { sessionStatus, sessionEnd, sessionContextInject },
+    getProjectRoot2()
+  );
+}
+async function orchestrateSpawnExecuteOp(params) {
+  return orchestrateSpawnExecute(
+    params.taskId,
+    params.adapterId,
+    params.protocolType,
+    getProjectRoot2(),
+    params.tier
+  );
+}
+async function orchestrateValidateOp(params) {
+  return orchestrateValidate(params.taskId, getProjectRoot2());
+}
+async function orchestratePivotOp(params) {
+  try {
+    const result = await pivotTask(params.fromTaskId, params.toTaskId, {
+      reason: params.reason,
+      blocksFrom: params.blocksFrom,
+      projectRoot: getProjectRoot2(),
+      takeOver: params.takeOver === true,
+      forceClaim: params.forceClaim === true
+    });
+    return { success: true, data: result };
+  } catch (err) {
+    const code = err?.code;
+    const message = err instanceof Error ? err.message : String(err);
+    let errorCode = "E_GENERAL";
+    if (code === 2) errorCode = "E_INVALID_INPUT";
+    else if (code === 4) errorCode = "E_NOT_FOUND";
+    else if (code === 6) errorCode = "E_VALIDATION";
+    else if (code === 38) errorCode = "E_NOT_ACTIVE";
+    else if (code === 35) errorCode = "E_TASK_CLAIMED";
+    else if (code === 24) errorCode = "E_SESSION_UNBOUND";
+    else if (code === 26) errorCode = "E_TASK_RENAMED";
+    const cleo = err instanceof CleoError ? err : void 0;
+    return {
+      success: false,
+      error: {
+        code: errorCode,
+        message,
+        ...typeof code === "number" && code !== 0 ? { exitCode: code } : {},
+        ...cleo?.fix ? { fix: cleo.fix } : {},
+        ...cleo?.details ? { details: cleo.details } : {}
+      }
+    };
+  }
+}
+async function orchestrateWorktreeCompleteOp(params) {
+  return handleWorktreeComplete(params.taskId, getProjectRoot2(), params.resolve);
+}
+async function orchestrateWorktreeCleanupOp(params) {
+  return handleWorktreeCleanup(getProjectRoot2(), params.taskIds);
+}
+async function orchestrateWorktreePruneOp(params) {
+  return handleWorktreePrune(getProjectRoot2(), params.taskId);
+}
+async function orchestrateParallelOp(params) {
+  return Promise.resolve({ success: true, data: params });
+}
+async function orchestrateFanoutOp(params) {
+  return orchestrateFanoutImpl(params.items, getProjectRoot2());
+}
+async function orchestrateApproveOp(params) {
+  return Promise.resolve({ success: true, data: params });
+}
+async function orchestrateRejectOp(params) {
+  return Promise.resolve({ success: true, data: params });
+}
+var coreOps = {
+  status: orchestrateStatusOp,
+  next: orchestrateNextOp,
+  ready: orchestrateReadyOp,
+  report: orchestrateReportOp,
+  analyze: orchestrateAnalyzeOp,
+  classify: orchestrateClassifyOp,
+  "fanout.status": orchestrateFanoutStatusOp,
+  context: orchestrateContextOp,
+  waves: orchestrateWavesOp,
+  plan: orchestratePlanOp,
+  bootstrap: orchestrateBootstrapOp,
+  "unblock.opportunities": orchestrateUnblockOp,
+  "ivtr.status": orchestrateIvtrStatusOp,
+  pending: orchestratePendingOp,
+  start: orchestrateStartOp,
+  spawn: orchestrateSpawnOp,
+  handoff: orchestrateHandoffOp,
+  "spawn.execute": orchestrateSpawnExecuteOp,
+  validate: orchestrateValidateOp,
+  pivot: orchestratePivotOp,
+  "worktree.complete": orchestrateWorktreeCompleteOp,
+  "worktree.cleanup": orchestrateWorktreeCleanupOp,
+  "worktree.prune": orchestrateWorktreePruneOp,
+  parallel: orchestrateParallelOp,
+  fanout: orchestrateFanoutOp,
+  approve: orchestrateApproveOp,
+  reject: orchestrateRejectOp
+};
+var OrchestrateHandler = class {
+  // -----------------------------------------------------------------------
+  // DomainHandler interface
+  // -----------------------------------------------------------------------
+  async query(operation, params) {
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        case "status": {
+          const p = { epicId: params?.epicId };
+          return wrapResult(await coreOps.status(p), "query", "orchestrate", operation, startTime);
+        }
+        case "next": {
+          if (!params?.epicId)
+            return errorResult(
+              "query",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const p = { epicId: params.epicId };
+          return wrapResult(await coreOps.next(p), "query", "orchestrate", operation, startTime);
+        }
+        case "ready": {
+          if (!params?.epicId)
+            return errorResult(
+              "query",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const viaRaw = params.via;
+          const via = viaRaw === "parent" || viaRaw === "saga" || viaRaw === "both" ? viaRaw : void 0;
+          const p = {
+            epicId: params.epicId,
+            ignoreDepsValidate: params.ignoreDepsValidate,
+            ...via !== void 0 && { via }
+          };
+          return wrapResult(await coreOps.ready(p), "query", "orchestrate", operation, startTime);
+        }
+        case "report": {
+          if (!params?.epicId)
+            return errorResult(
+              "query",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const rp = {
+            epicId: params.epicId,
+            page: params.page,
+            pageSize: params.pageSize
+          };
+          return wrapResult(await coreOps.report(rp), "query", "orchestrate", operation, startTime);
+        }
+        case "analyze": {
+          const p = {
+            epicId: params?.epicId,
+            mode: params?.mode,
+            taskIds: params?.taskIds
+          };
+          return wrapResult(
+            await coreOps.analyze(p),
+            "query",
+            "orchestrate",
+            "analyze",
+            startTime
+          );
+        }
+        case "classify": {
+          if (!params?.request)
+            return errorResult(
+              "query",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "request is required",
+              startTime
+            );
+          const p = {
+            request: params.request,
+            context: params.context
+          };
+          return wrapResult(
+            await coreOps.classify(p),
+            "query",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "fanout.status": {
+          if (!params?.manifestEntryId)
+            return errorResult(
+              "query",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "manifestEntryId is required",
+              startTime
+            );
+          const p = {
+            manifestEntryId: params.manifestEntryId
+          };
+          const result = await coreOps["fanout.status"](p);
+          return {
+            meta: dispatchMeta("query", "orchestrate", operation, startTime),
+            success: true,
+            data: result.data
+          };
+        }
+        case "context": {
+          const p = { epicId: params?.epicId };
+          return wrapResult(await coreOps.context(p), "query", "orchestrate", operation, startTime);
+        }
+        case "waves": {
+          if (!params?.epicId)
+            return errorResult(
+              "query",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const wavesViaRaw = params.via;
+          const wavesVia = wavesViaRaw === "parent" || wavesViaRaw === "saga" || wavesViaRaw === "both" ? wavesViaRaw : void 0;
+          const p = {
+            epicId: params.epicId,
+            ...wavesVia !== void 0 && { via: wavesVia },
+            ...params.hideCompleted === true && { hideCompleted: true }
+          };
+          return wrapResult(await coreOps.waves(p), "query", "orchestrate", operation, startTime);
+        }
+        case "plan": {
+          if (!params?.epicId)
+            return errorResult(
+              "query",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const preferTierRaw = params.preferTier;
+          let preferTier;
+          if (preferTierRaw === 0 || preferTierRaw === 1 || preferTierRaw === 2) {
+            preferTier = preferTierRaw;
+          }
+          const p = { epicId: params.epicId, preferTier };
+          return wrapResult(await coreOps.plan(p), "query", "orchestrate", operation, startTime);
+        }
+        case "bootstrap": {
+          const p = {
+            speed: params?.speed
+          };
+          return wrapResult(
+            await coreOps.bootstrap(p),
+            "query",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "unblock.opportunities":
+          return wrapResult(
+            await coreOps["unblock.opportunities"]({}),
+            "query",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        case "ivtr.status":
+          return ivtrHandler.query("status", params);
+        case "pending":
+          return handlePendingApprovals(startTime);
+        default:
+          return errorResult(
+            "query",
+            "orchestrate",
+            operation,
+            "E_INVALID_OPERATION",
+            `Unknown orchestrate query: ${operation}`,
+            startTime
+          );
+      }
+    } catch (error) {
+      getLogger2("domain:orchestrate").error(
+        { gateway: "query", domain: "orchestrate", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("query", "orchestrate", operation, error, startTime);
+    }
+  }
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        case "start": {
+          if (!params?.epicId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const p = { epicId: params.epicId };
+          return wrapResult(await coreOps.start(p), "mutate", "orchestrate", operation, startTime);
+        }
+        case "spawn": {
+          if (!params?.taskId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          const tierRaw = params.tier;
+          const tier = tierRaw === 0 || tierRaw === 1 || tierRaw === 2 ? tierRaw : void 0;
+          const atomicityScopeRaw = params.atomicityScope;
+          const atomicityScope = atomicityScopeRaw === "orchestrator-defer" ? "orchestrator-defer" : void 0;
+          const p = {
+            taskId: params.taskId,
+            protocolType: params.protocolType,
+            tier,
+            noWorktree: params.noWorktree,
+            spawnScope: params.spawnScope,
+            ...atomicityScope ? { atomicityScope } : {},
+            // T12506 — `--resume` was dropped here, so every resume ran the
+            // normal provisioning path (and hit the worktree lock).
+            ...params.resume === true ? { resume: true } : {}
+          };
+          return wrapResult(await coreOps.spawn(p), "mutate", "orchestrate", operation, startTime);
+        }
+        case "handoff": {
+          if (!params?.taskId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          if (!params?.protocolType)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "protocolType is required",
+              startTime
+            );
+          const tierRaw = params.tier;
+          const tier = tierRaw === 0 || tierRaw === 1 || tierRaw === 2 ? tierRaw : void 0;
+          const p = {
+            taskId: params.taskId,
+            protocolType: params.protocolType,
+            note: params.note,
+            nextAction: params.nextAction,
+            variant: params.variant,
+            tier,
+            idempotencyKey: params.idempotencyKey
+          };
+          return wrapResult(
+            await coreOps.handoff(p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "spawn.execute": {
+          if (!params?.taskId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          const tierRaw = params.tier;
+          const tier = tierRaw === 0 || tierRaw === 1 || tierRaw === 2 ? tierRaw : void 0;
+          const p = {
+            taskId: params.taskId,
+            adapterId: params.adapterId,
+            protocolType: params.protocolType,
+            tier
+          };
+          return wrapResult(
+            await coreOps["spawn.execute"](p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "validate": {
+          if (!params?.taskId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          const p = { taskId: params.taskId };
+          return wrapResult(
+            await coreOps.validate(p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "pivot": {
+          if (!params?.fromTaskId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "fromTaskId is required",
+              startTime
+            );
+          if (!params?.toTaskId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "toTaskId is required",
+              startTime
+            );
+          if (!params?.reason || typeof params.reason !== "string" || !params.reason.trim())
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_VALIDATION",
+              "reason is required (no silent pivots)",
+              startTime
+            );
+          const p = {
+            fromTaskId: params.fromTaskId,
+            toTaskId: params.toTaskId,
+            reason: params.reason,
+            blocksFrom: params.blocksFrom,
+            takeOver: params.takeOver === true,
+            forceClaim: params.forceClaim === true
+          };
+          return wrapResult(
+            await coreOps.pivot(p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "worktree.complete": {
+          if (!params?.taskId)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          const rawResolve = params.resolve;
+          const resolve = rawResolve === "manual" ? "manual" : rawResolve === "auto" ? "auto" : void 0;
+          const p = {
+            taskId: params.taskId,
+            ...resolve !== void 0 ? { resolve } : {}
+          };
+          return wrapResult(
+            await coreOps["worktree.complete"](p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "worktree.cleanup": {
+          const p = {
+            taskIds: params?.taskIds
+          };
+          return wrapResult(
+            await coreOps["worktree.cleanup"](p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "worktree.prune": {
+          const p = {
+            taskId: params?.taskId
+          };
+          return wrapResult(
+            await coreOps["worktree.prune"](p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "parallel": {
+          return routeByParam(params, "action", {
+            start: async () => {
+              const epicId = params?.epicId;
+              const wave = params?.wave;
+              if (!epicId)
+                return errorResult(
+                  "mutate",
+                  "orchestrate",
+                  "parallel",
+                  "E_INVALID_INPUT",
+                  "epicId is required",
+                  startTime
+                );
+              if (wave === void 0 || wave === null)
+                return errorResult(
+                  "mutate",
+                  "orchestrate",
+                  "parallel",
+                  "E_INVALID_INPUT",
+                  "wave number is required",
+                  startTime
+                );
+              return wrapResult(
+                await orchestrateParallelStart(epicId, wave, getProjectRoot2()),
+                "mutate",
+                "orchestrate",
+                "parallel",
+                startTime
+              );
+            },
+            end: async () => {
+              const epicId = params?.epicId;
+              const wave = params?.wave;
+              if (!epicId)
+                return errorResult(
+                  "mutate",
+                  "orchestrate",
+                  "parallel",
+                  "E_INVALID_INPUT",
+                  "epicId is required",
+                  startTime
+                );
+              if (wave === void 0 || wave === null)
+                return errorResult(
+                  "mutate",
+                  "orchestrate",
+                  "parallel",
+                  "E_INVALID_INPUT",
+                  "wave number is required",
+                  startTime
+                );
+              return wrapResult(
+                await orchestrateParallelEnd(epicId, wave, getProjectRoot2()),
+                "mutate",
+                "orchestrate",
+                "parallel",
+                startTime
+              );
+            }
+          });
+        }
+        case "fanout": {
+          const items = params?.items;
+          if (!items || !Array.isArray(items) || items.length === 0)
+            return errorResult(
+              "mutate",
+              "orchestrate",
+              operation,
+              "E_INVALID_INPUT",
+              "items array is required and must be non-empty",
+              startTime
+            );
+          const p = { items };
+          return wrapResult(
+            await coreOps.fanout(p),
+            "mutate",
+            "orchestrate",
+            operation,
+            startTime
+          );
+        }
+        case "ivtr.start":
+          return ivtrHandler.mutate("start", params);
+        case "ivtr.next":
+          return ivtrHandler.mutate("next", params);
+        case "ivtr.release":
+          return ivtrHandler.mutate("release", params);
+        case "ivtr.loop-back":
+          return ivtrHandler.mutate("loop-back", params);
+        case "approve":
+          return handleApproveGate(params, startTime);
+        case "reject":
+          return handleRejectGate(params, startTime);
+        default:
+          return errorResult(
+            "mutate",
+            "orchestrate",
+            operation,
+            "E_INVALID_OPERATION",
+            `Unknown orchestrate mutation: ${operation}`,
+            startTime
+          );
+      }
+    } catch (error) {
+      getLogger2("domain:orchestrate").error(
+        { gateway: "mutate", domain: "orchestrate", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("mutate", "orchestrate", operation, error, startTime);
+    }
+  }
+  getSupportedOperations() {
+    return {
+      query: [
+        "status",
+        "next",
+        "ready",
+        "analyze",
+        "context",
+        "waves",
+        "plan",
+        "bootstrap",
+        "unblock.opportunities",
+        "classify",
+        "fanout.status",
+        "ivtr.status",
+        "pending"
+      ],
+      mutate: [
+        "start",
+        "spawn",
+        "handoff",
+        "spawn.execute",
+        "validate",
+        "pivot",
+        "parallel",
+        "fanout",
+        "ivtr.start",
+        "ivtr.next",
+        "ivtr.release",
+        "ivtr.loop-back",
+        "approve",
+        "reject",
+        "worktree.complete",
+        "worktree.cleanup",
+        "worktree.prune"
+      ]
+    };
+  }
+};
+async function orchestrateClassify(request, context, projectRoot, taskId) {
+  if (taskId) {
+    try {
+      const { getDb } = await import("@cleocode/core/store/sqlite");
+      const { tasks } = await import("@cleocode/core/store/tasks-schema");
+      const { eq } = await import("drizzle-orm");
+      const { classifyTask } = await import("@cleocode/core");
+      const db = await getDb(projectRoot);
+      const row = await db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+      if (!row) {
+        return {
+          success: false,
+          error: {
+            code: "E_NOT_FOUND",
+            message: `Task ${taskId} not found`
+          }
+        };
+      }
+      const task = {
+        id: row.id,
+        title: row.title,
+        description: row.description ?? "",
+        status: row.status,
+        priority: row.priority ?? "medium",
+        type: row.type ?? void 0,
+        kind: row.kind ?? void 0,
+        size: row.size ?? void 0,
+        labels: (() => {
+          try {
+            const parsed = JSON.parse(row.labelsJson ?? "[]");
+            return Array.isArray(parsed) ? parsed : [];
+          } catch {
+            return [];
+          }
+        })(),
+        createdAt: row.createdAt
+      };
+      const result = classifyTask(task);
+      return {
+        success: true,
+        data: {
+          team: result.agentId,
+          lead: result.role === "lead" ? result.agentId : null,
+          protocol: result.role,
+          stage: null,
+          confidence: result.confidence,
+          reasoning: result.warning ? `${result.reason} | warning: ${result.warning}` : result.reason
+        }
+      };
+    } catch (error) {
+      getLogger2("domain:orchestrate").error(
+        { operation: "classify", taskId, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return {
+        success: false,
+        error: {
+          code: "E_CLASSIFY_FAILED",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  try {
+    const { getCleoCantWorkflowsDir } = await import("@cleocode/core/core-paths");
+    const { readFileSync, readdirSync, existsSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const workflowsDir = getCleoCantWorkflowsDir();
+    const combined = `${request} ${context ?? ""}`.toLowerCase();
+    const matches = [];
+    if (existsSync(workflowsDir)) {
+      const files = readdirSync(workflowsDir).filter((f) => f.endsWith(".cant"));
+      for (const file of files) {
+        try {
+          const src = readFileSync(join(workflowsDir, file), "utf-8");
+          const teamMatch = /^team\s+(\S+):/m.exec(src);
+          if (!teamMatch) continue;
+          const teamName = teamMatch[1];
+          const cwMatch = /consult-when:\s*["']?(.+?)["']?\s*$/m.exec(src);
+          const consultWhen = cwMatch ? cwMatch[1].trim() : "";
+          const stagesMatch = /stages:\s*\[([^\]]+)\]/.exec(src);
+          const stages = stagesMatch ? stagesMatch[1].split(",").map((s) => s.trim()) : [];
+          const hintWords = consultWhen.toLowerCase().split(/\s+/);
+          const score = hintWords.filter((w) => combined.includes(w)).length;
+          matches.push({ team: teamName, score, consultWhen, stages });
+        } catch {
+        }
+      }
+    }
+    const localCantDir = join(projectRoot, CLEO_DIR_NAME, WORKFLOWS_SUBDIR);
+    if (existsSync(localCantDir)) {
+      const files = readdirSync(localCantDir).filter((f) => f.endsWith(".cant"));
+      for (const file of files) {
+        try {
+          const src = readFileSync(join(localCantDir, file), "utf-8");
+          const teamMatch = /^team\s+(\S+):/m.exec(src);
+          if (!teamMatch) continue;
+          const teamName = teamMatch[1];
+          const cwMatch = /consult-when:\s*["']?(.+?)["']?\s*$/m.exec(src);
+          const consultWhen = cwMatch ? cwMatch[1].trim() : "";
+          const stagesMatch = /stages:\s*\[([^\]]+)\]/.exec(src);
+          const stages = stagesMatch ? stagesMatch[1].split(",").map((s) => s.trim()) : [];
+          const hintWords = consultWhen.toLowerCase().split(/\s+/);
+          const score = hintWords.filter((w) => combined.includes(w)).length;
+          matches.push({ team: teamName, score, consultWhen, stages });
+        } catch {
+        }
+      }
+    }
+    if (matches.length === 0) {
+      return {
+        success: true,
+        data: {
+          team: null,
+          lead: null,
+          protocol: null,
+          stage: null,
+          confidence: 0,
+          reasoning: "No CANT team definitions found. Seed teams.cant in the global workflows dir (W7b runtime enforcement) to enable team routing."
+        }
+      };
+    }
+    matches.sort((a, b) => b.score - a.score);
+    const best = matches[0];
+    const allHintWords = best.consultWhen.toLowerCase().split(/\s+/).filter(Boolean);
+    const normalised = allHintWords.length > 0 ? Math.min(best.score / allHintWords.length, 1) : 0;
+    const confidence = best.score > 0 ? Math.max(normalised, 0.5) : 0.1;
+    return {
+      success: true,
+      data: {
+        team: best.team,
+        lead: null,
+        protocol: "base-subagent",
+        stage: best.stages[0] ?? null,
+        confidence,
+        reasoning: best.score > 0 ? `Matched team '${best.team}' via consult-when hint: "${best.consultWhen}"` : `No strong match found; defaulting to first registered team '${best.team}'`
+      }
+    };
+  } catch (error) {
+    getLogger2("domain:orchestrate").error(
+      { operation: "classify", err: error },
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_CLASSIFY_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function orchestrateFanoutImpl(items, projectRoot) {
+  const manifestEntryId = `fanout-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    const settled = await Promise.allSettled(
+      items.map(async (item) => {
+        const spawnResult = await orchestrateSpawnExecute(
+          item.taskId,
+          void 0,
+          void 0,
+          projectRoot,
+          void 0
+        );
+        if (!spawnResult.success) {
+          return {
+            taskId: item.taskId,
+            status: "failed",
+            error: spawnResult.error?.message ?? `Spawn failed for task ${item.taskId}`
+          };
+        }
+        const data = spawnResult.data;
+        return {
+          taskId: item.taskId,
+          status: "spawned",
+          instanceId: typeof data?.instanceId === "string" ? data.instanceId : void 0
+        };
+      })
+    );
+    const results = settled.map((outcome, i) => {
+      if (outcome.status === "fulfilled") return outcome.value;
+      return {
+        taskId: items[i].taskId,
+        status: "failed",
+        error: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)
+      };
+    });
+    fanoutManifestStore.set(manifestEntryId, { results, completedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    evictFanoutManifest();
+    return {
+      success: true,
+      data: {
+        manifestEntryId,
+        results,
+        total: items.length,
+        spawned: results.filter((r) => r.status === "spawned").length,
+        failed: results.filter((r) => r.status === "failed").length
+      }
+    };
+  } catch (error) {
+    getLogger2("domain:orchestrate").error(
+      { operation: "fanout", err: error },
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_FANOUT_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function orchestrateAnalyzeParallelSafety(taskIds, projectRoot) {
+  if (taskIds.length === 0) {
+    return {
+      success: true,
+      data: {
+        parallelSafe: true,
+        groups: [],
+        note: "No tasks provided \u2014 trivially parallel-safe"
+      }
+    };
+  }
+  try {
+    let transitiveClose2 = function(id, visited = /* @__PURE__ */ new Set()) {
+      if (visited.has(id)) return visited;
+      visited.add(id);
+      const deps = depMap.get(id) ?? [];
+      for (const dep of deps) {
+        transitiveClose2(dep, visited);
+      }
+      return visited;
+    }, parallelSafe2 = function(a, b) {
+      const closureA = closures.get(a) ?? /* @__PURE__ */ new Set();
+      const closureB = closures.get(b) ?? /* @__PURE__ */ new Set();
+      return !closureA.has(b) && !closureB.has(a);
+    };
+    var transitiveClose = transitiveClose2, parallelSafe = parallelSafe2;
+    const { getTaskAccessor } = await import("@cleocode/core/store/data-accessor");
+    const accessor = await getTaskAccessor(projectRoot);
+    const result = await accessor.queryTasks({});
+    const allTasks = result?.tasks ?? [];
+    const depMap = /* @__PURE__ */ new Map();
+    for (const t of allTasks) {
+      const deps = t.blockers ?? [];
+      depMap.set(t.id, deps);
+    }
+    const closures = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      closures.set(id, transitiveClose2(id));
+    }
+    const groups = [];
+    for (const id of taskIds) {
+      let placed = false;
+      for (const group of groups) {
+        if (group.every((member) => parallelSafe2(id, member))) {
+          group.push(id);
+          placed = true;
+          break;
+        }
+      }
+      if (!placed) {
+        groups.push([id]);
+      }
+    }
+    return {
+      success: true,
+      data: {
+        parallelSafe: groups.length <= 1,
+        groups,
+        taskCount: taskIds.length,
+        groupCount: groups.length
+      }
+    };
+  } catch (error) {
+    getLogger2("domain:orchestrate").error(
+      { operation: "analyze/parallel-safety", err: error },
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_ANALYZE_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function handleWorktreeComplete(taskId, projectRoot, resolve) {
+  try {
+    const { completeWorktreeForTask } = await import("@cleocode/core/orchestrate/worktree-complete");
+    const result = completeWorktreeForTask(taskId, projectRoot, {
+      resolve: resolve ?? "auto"
+    });
+    if (result.outcome === "conflict") {
+      return {
+        success: false,
+        error: {
+          code: "E_WORKTREE_COMPLETE_FAILED",
+          message: result.reason,
+          details: {
+            taskId: result.taskId,
+            integration: result.integration,
+            recovery: result.recovery
+          }
+        }
+      };
+    }
+    return { success: true, data: result };
+  } catch (error) {
+    getLogger2("domain:orchestrate").error(
+      { operation: "worktree.complete", taskId, err: error },
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_WORKTREE_COMPLETE_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function handleWorktreeCleanup(projectRoot, taskIds) {
+  try {
+    const { pruneOrphanedWorktrees } = await import("@cleocode/core/spawn/branch-lock");
+    const activeSet = taskIds ? new Set(taskIds) : void 0;
+    const result = pruneOrphanedWorktrees(projectRoot, activeSet);
+    return { success: true, data: result };
+  } catch (error) {
+    getLogger2("domain:orchestrate").error(
+      { operation: "worktree.cleanup", err: error },
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_WORKTREE_CLEANUP_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function handleWorktreePrune(projectRoot, taskId) {
+  try {
+    const { pruneWorktree, pruneOrphanedWorktrees } = await import("@cleocode/core/spawn/branch-lock");
+    if (taskId) {
+      const result2 = pruneWorktree(taskId, projectRoot);
+      return { success: true, data: result2 };
+    }
+    const result = pruneOrphanedWorktrees(projectRoot, void 0);
+    return { success: true, data: { ...result, mode: "bulk" } };
+  } catch (error) {
+    getLogger2("domain:orchestrate").error(
+      { operation: "worktree.prune", taskId, err: error },
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_WORKTREE_PRUNE_FAILED",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function handlePendingApprovals(startTime) {
+  try {
+    const approvals = await listPendingApprovalsForDispatch();
+    return {
+      meta: dispatchMeta("query", "orchestrate", "pending", startTime),
+      success: true,
+      data: { approvals, count: approvals.length, total: approvals.length }
+    };
+  } catch (error) {
+    getLogger2("domain:orchestrate").error(
+      { operation: "pending", err: error },
+      error instanceof Error ? error.message : String(error)
+    );
+    return handleErrorResult("query", "orchestrate", "pending", error, startTime);
+  }
+}
+async function handleApproveGate(params, startTime) {
+  const resumeToken = params?.resumeToken;
+  if (!resumeToken)
+    return errorResult(
+      "mutate",
+      "orchestrate",
+      "approve",
+      "E_VALIDATION",
+      "resumeToken is required",
+      startTime
+    );
+  const approver = typeof params?.approver === "string" && params.approver.length > 0 ? params.approver : "cli-user";
+  const reason = typeof params?.reason === "string" ? params.reason : void 0;
+  try {
+    const existing = await lookupApprovalByTokenForDispatch(resumeToken);
+    if (existing === null)
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "approve",
+        "E_APPROVAL_NOT_FOUND",
+        `no approval gate for token ${resumeToken}`,
+        startTime
+      );
+    if (existing.status === "approved") {
+      return {
+        meta: dispatchMeta("mutate", "orchestrate", "approve", startTime),
+        success: true,
+        data: { ...existing, idempotent: true }
+      };
+    }
+    if (existing.status === "rejected")
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "approve",
+        "E_APPROVAL_ALREADY_DECIDED",
+        `gate ${existing.approvalId} was rejected${existing.reason ? ` (${existing.reason})` : ""}`,
+        startTime
+      );
+    const db = await acquirePlaybookDb();
+    const { approveGate } = await import("./src-LYLXHXHH.js");
+    const updated = approveGate(db, resumeToken, approver, reason);
+    return {
+      meta: dispatchMeta("mutate", "orchestrate", "approve", startTime),
+      success: true,
+      data: updated
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("E_APPROVAL_ALREADY_DECIDED"))
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "approve",
+        "E_APPROVAL_ALREADY_DECIDED",
+        message,
+        startTime
+      );
+    if (message.includes("E_APPROVAL_NOT_FOUND"))
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "approve",
+        "E_APPROVAL_NOT_FOUND",
+        message,
+        startTime
+      );
+    getLogger2("domain:orchestrate").error({ operation: "approve", err: error }, message);
+    return handleErrorResult("mutate", "orchestrate", "approve", error, startTime);
+  }
+}
+async function handleRejectGate(params, startTime) {
+  const resumeToken = params?.resumeToken;
+  if (!resumeToken)
+    return errorResult(
+      "mutate",
+      "orchestrate",
+      "reject",
+      "E_VALIDATION",
+      "resumeToken is required",
+      startTime
+    );
+  const reason = typeof params?.reason === "string" ? params.reason.trim() : "";
+  if (reason.length === 0)
+    return errorResult(
+      "mutate",
+      "orchestrate",
+      "reject",
+      "E_VALIDATION",
+      "reason is required for rejection",
+      startTime
+    );
+  const approver = typeof params?.approver === "string" && params.approver.length > 0 ? params.approver : "cli-user";
+  try {
+    const existing = await lookupApprovalByTokenForDispatch(resumeToken);
+    if (existing === null)
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "reject",
+        "E_APPROVAL_NOT_FOUND",
+        `no approval gate for token ${resumeToken}`,
+        startTime
+      );
+    if (existing.status === "rejected") {
+      return {
+        meta: dispatchMeta("mutate", "orchestrate", "reject", startTime),
+        success: true,
+        data: { ...existing, idempotent: true }
+      };
+    }
+    if (existing.status === "approved")
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "reject",
+        "E_APPROVAL_ALREADY_DECIDED",
+        `gate ${existing.approvalId} was already approved`,
+        startTime
+      );
+    const db = await acquirePlaybookDb();
+    const { rejectGate } = await import("./src-LYLXHXHH.js");
+    const updated = rejectGate(db, resumeToken, approver, reason);
+    return {
+      meta: dispatchMeta("mutate", "orchestrate", "reject", startTime),
+      success: true,
+      data: updated
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("E_APPROVAL_ALREADY_DECIDED"))
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "reject",
+        "E_APPROVAL_ALREADY_DECIDED",
+        message,
+        startTime
+      );
+    if (message.includes("E_APPROVAL_NOT_FOUND"))
+      return errorResult(
+        "mutate",
+        "orchestrate",
+        "reject",
+        "E_APPROVAL_NOT_FOUND",
+        message,
+        startTime
+      );
+    getLogger2("domain:orchestrate").error({ operation: "reject", err: error }, message);
+    return handleErrorResult("mutate", "orchestrate", "reject", error, startTime);
+  }
+}
+export {
+  OrchestrateHandler
+};
+//# sourceMappingURL=orchestrate-CZ2J6W3L.js.map