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

package/dist/cli/pipeline-TCZPOEDR.js

@@ -0,0 +1,697 @@
+(() => {
+  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 {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch,
+  wrapCoreResult
+} from "./chunk-QWNKLLLG.js";
+import {
+  lazyOperation
+} from "./chunk-TYC7G5LF.js";
+import {
+  dispatchMeta,
+  envelopeToEngineResult,
+  errorResult,
+  getListParams,
+  handleErrorResult,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/pipeline.ts
+import { execFileSync } from "node:child_process";
+import { buildStageGuidance, formatStageGuidance } from "@cleocode/core/lifecycle/stage-guidance";
+import { isValidStage } from "@cleocode/core/lifecycle/stages";
+import { getLogger } from "@cleocode/core/logger";
+import { pipelineManifestList } from "@cleocode/core/memory/pipeline-manifest-sqlite";
+import { paginate } from "@cleocode/core/pagination";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import {
+  channelToDistTag,
+  describeChannel,
+  resolveChannelFromBranch
+} from "@cleocode/core/release/channel";
+var lifecycleCheck = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleCheck
+);
+var lifecycleGateFail = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleGateFail
+);
+var lifecycleGatePass = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleGatePass
+);
+var lifecycleHistory = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleHistory
+);
+var lifecycleProgress = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleProgress
+);
+var lifecycleReset = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleReset
+);
+var lifecycleSkip = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleSkip
+);
+var lifecycleStatus = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/engine-ops")).lifecycleStatus
+);
+var phaseAdvance = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseAdvance
+);
+var phaseComplete = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseComplete
+);
+var phaseDelete = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseDelete
+);
+var phaseList = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseList
+);
+var phaseRename = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseRename
+);
+var phaseSet = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseSet
+);
+var phaseShow = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseShow
+);
+var phaseStart = lazyOperation(
+  async () => (await import("@cleocode/core/pipeline/engine-ops")).phaseStart
+);
+var pipelineManifestAppend = lazyOperation(
+  async () => (await import("@cleocode/core/memory/pipeline-manifest-sqlite")).pipelineManifestAppend
+);
+var pipelineManifestArchive = lazyOperation(
+  async () => (await import("@cleocode/core/memory/pipeline-manifest-sqlite")).pipelineManifestArchive
+);
+var pipelineManifestFind = lazyOperation(
+  async () => (await import("@cleocode/core/memory/pipeline-manifest-sqlite")).pipelineManifestFind
+);
+var pipelineManifestShow = lazyOperation(
+  async () => (await import("@cleocode/core/memory/pipeline-manifest-sqlite")).pipelineManifestShow
+);
+var pipelineManifestStats = lazyOperation(
+  async () => (await import("@cleocode/core/memory/pipeline-manifest-sqlite")).pipelineManifestStats
+);
+var releaseCancel = lazyOperation(
+  async () => (await import("@cleocode/core/release/engine-ops")).releaseCancel
+);
+var releaseList = lazyOperation(
+  async () => (await import("@cleocode/core/release/engine-ops")).releaseList
+);
+var releasePrStatus = lazyOperation(
+  async () => (await import("@cleocode/core/release/engine-ops")).releasePrStatus
+);
+var releaseRollback = lazyOperation(
+  async () => (await import("@cleocode/core/release/engine-ops")).releaseRollback
+);
+var releaseRollbackFull = lazyOperation(
+  async () => (await import("@cleocode/core/release/engine-ops")).releaseRollbackFull
+);
+var releaseShow = lazyOperation(
+  async () => (await import("@cleocode/core/release/engine-ops")).releaseShow
+);
+async function stageValidateOp(params) {
+  return lifecycleCheck(params.epicId, params.targetStage, getProjectRoot());
+}
+async function stageStatusOp(params) {
+  return lifecycleStatus(params.epicId, getProjectRoot());
+}
+async function stageHistoryOp(params) {
+  return lifecycleHistory(params.taskId, getProjectRoot());
+}
+async function stageGuidanceOp(params) {
+  let stage = params.stage;
+  const epicId = params.epicId;
+  const format = params.format ?? "markdown";
+  const projectRoot = getProjectRoot();
+  if (!stage && epicId) {
+    const statusResult = await lifecycleStatus(epicId, projectRoot);
+    if (statusResult.success) {
+      const data = statusResult.data;
+      stage = data?.currentStage ?? data?.activeStage;
+    }
+  }
+  return { _stage: stage, _format: format, _projectRoot: projectRoot };
+}
+async function stageRecordOp(params) {
+  return lifecycleProgress(
+    params.taskId,
+    params.stage,
+    params.status,
+    params.notes,
+    getProjectRoot()
+  );
+}
+async function stageSkipOp(params) {
+  return lifecycleSkip(params.taskId, params.stage, params.reason, getProjectRoot());
+}
+async function stageResetOp(params) {
+  return lifecycleReset(params.taskId, params.stage, params.reason, getProjectRoot());
+}
+async function stageGatePassOp(params) {
+  return lifecycleGatePass(
+    params.taskId,
+    params.gateName,
+    params.agent,
+    params.notes,
+    getProjectRoot()
+  );
+}
+async function stageGateFailOp(params) {
+  return lifecycleGateFail(params.taskId, params.gateName, params.reason, getProjectRoot());
+}
+async function releaseListOp(params) {
+  return releaseList(
+    { status: params.status, limit: params.limit, offset: params.offset },
+    getProjectRoot()
+  );
+}
+async function releaseShowOp(params) {
+  return releaseShow(params.version, getProjectRoot());
+}
+async function releaseChannelShowOp(_params) {
+  let currentBranch = "unknown";
+  const projectRoot = getProjectRoot();
+  try {
+    currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      encoding: "utf-8",
+      stdio: "pipe",
+      cwd: projectRoot
+    }).trim();
+  } catch {
+  }
+  const resolvedChannel = resolveChannelFromBranch(currentBranch);
+  const distTag = channelToDistTag(resolvedChannel);
+  const description = describeChannel(resolvedChannel);
+  return {
+    success: true,
+    data: { branch: currentBranch, channel: resolvedChannel, distTag, description }
+  };
+}
+async function releasePrStatusOp(params) {
+  return releasePrStatus(params.version, getProjectRoot());
+}
+async function releaseCancelOp(params) {
+  return releaseCancel(params.version, getProjectRoot());
+}
+async function releaseRollbackOp(params) {
+  return releaseRollback(params.version, params.reason, getProjectRoot());
+}
+async function releaseRollbackFullOp(params) {
+  return releaseRollbackFull(
+    params.version,
+    { reason: params.reason, force: params.force, unpublish: params.unpublish },
+    getProjectRoot()
+  );
+}
+async function manifestShowOp(params) {
+  return pipelineManifestShow(params.entryId, getProjectRoot());
+}
+async function manifestListOp(params) {
+  return pipelineManifestList(params, getProjectRoot());
+}
+async function manifestFindOp(params) {
+  return pipelineManifestFind(
+    params.query,
+    { confidence: params.confidence, limit: params.limit },
+    getProjectRoot()
+  );
+}
+async function manifestStatsOp(params) {
+  return pipelineManifestStats(params.epicId, getProjectRoot());
+}
+async function manifestAppendOp(params) {
+  return pipelineManifestAppend(params.entry, getProjectRoot(), { requireExistingTasks: true });
+}
+async function manifestArchiveOp(params) {
+  return pipelineManifestArchive(params.beforeDate, getProjectRoot());
+}
+async function phaseShowOp(params) {
+  return phaseShow(params.phaseId, getProjectRoot());
+}
+async function phaseListOp(_params) {
+  return phaseList(getProjectRoot());
+}
+async function phaseSetOp(params) {
+  const { phaseId, action, rollback, force, dryRun } = params;
+  const projectRoot = getProjectRoot();
+  if (action === "start") {
+    return phaseStart(phaseId, projectRoot);
+  }
+  if (action === "complete") {
+    return phaseComplete(phaseId, projectRoot);
+  }
+  return phaseSet({ phaseId, rollback, force, dryRun }, projectRoot);
+}
+async function phaseAdvanceOp(params) {
+  return phaseAdvance(params.force, getProjectRoot());
+}
+async function phaseRenameOp(params) {
+  return phaseRename(params.oldName, params.newName, getProjectRoot());
+}
+async function phaseDeleteOp(params) {
+  return phaseDelete(
+    params.phaseId,
+    { reassignTo: params.reassignTo, force: params.force },
+    getProjectRoot()
+  );
+}
+var coreOps = {
+  "stage.validate": stageValidateOp,
+  "stage.status": stageStatusOp,
+  "stage.history": stageHistoryOp,
+  "stage.guidance": stageGuidanceOp,
+  "stage.record": stageRecordOp,
+  "stage.skip": stageSkipOp,
+  "stage.reset": stageResetOp,
+  "stage.gate.pass": stageGatePassOp,
+  "stage.gate.fail": stageGateFailOp,
+  "release.list": releaseListOp,
+  "release.show": releaseShowOp,
+  "release.channel.show": releaseChannelShowOp,
+  "release.pr-status": releasePrStatusOp,
+  "release.cancel": releaseCancelOp,
+  "release.rollback": releaseRollbackOp,
+  "release.rollback.full": releaseRollbackFullOp,
+  "manifest.show": manifestShowOp,
+  "manifest.list": manifestListOp,
+  "manifest.find": manifestFindOp,
+  "manifest.stats": manifestStatsOp,
+  "manifest.append": manifestAppendOp,
+  "manifest.archive": manifestArchiveOp,
+  "phase.show": phaseShowOp,
+  "phase.list": phaseListOp,
+  "phase.set": phaseSetOp,
+  "phase.advance": phaseAdvanceOp,
+  "phase.rename": phaseRenameOp,
+  "phase.delete": phaseDeleteOp
+};
+var _pipelineTypedHandler = defineTypedHandler("pipeline", {
+  // -------------------------------------------------------------------------
+  // Stage queries
+  // -------------------------------------------------------------------------
+  "stage.validate": async (params) => {
+    if (!params.epicId || !params.targetStage) {
+      return lafsError("E_INVALID_INPUT", "epicId and targetStage are required", "stage.validate");
+    }
+    return wrapCoreResult(await coreOps["stage.validate"](params), "stage.validate");
+  },
+  "stage.status": async (params) => {
+    if (!params.epicId) {
+      return lafsError("E_INVALID_INPUT", "epicId is required", "stage.status");
+    }
+    return wrapCoreResult(await coreOps["stage.status"](params), "stage.status");
+  },
+  "stage.history": async (params) => {
+    if (!params.taskId) {
+      return lafsError("E_INVALID_INPUT", "taskId is required", "stage.history");
+    }
+    return wrapCoreResult(await coreOps["stage.history"](params), "stage.history");
+  },
+  // SSoT-EXEMPT: sentinel-unwrap from stageGuidanceOp + isValidStage + buildStageGuidance
+  // + formatStageGuidance — Core fn returns an intermediate sentinel shape; dispatch
+  // cannot simply delegate and wrap — ADR-058
+  "stage.guidance": async (params) => {
+    const {
+      _stage: stage,
+      _format: format,
+      _projectRoot: projectRoot
+    } = await coreOps["stage.guidance"](params);
+    if (!stage) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        "Either stage or epicId (with an active pipeline stage) is required",
+        "stage.guidance"
+      );
+    }
+    if (!isValidStage(stage)) {
+      return lafsError("E_INVALID_INPUT", `Unknown stage: ${stage}`, "stage.guidance");
+    }
+    const guidance = buildStageGuidance(stage, projectRoot);
+    const data = format === "json" ? { stage: guidance.stage, guidance } : {
+      stage: guidance.stage,
+      name: guidance.name,
+      order: guidance.order,
+      primarySkill: guidance.primarySkill,
+      loadedSkills: guidance.loadedSkills,
+      requiredGates: guidance.requiredGates,
+      expectedArtifacts: guidance.expectedArtifacts,
+      source: guidance.source,
+      prompt: formatStageGuidance(guidance)
+    };
+    return lafsSuccess(data, "stage.guidance");
+  },
+  // -------------------------------------------------------------------------
+  // Stage mutations
+  // -------------------------------------------------------------------------
+  "stage.record": async (params) => {
+    if (!params.taskId || !params.stage || !params.status) {
+      return lafsError("E_INVALID_INPUT", "taskId, stage, and status are required", "stage.record");
+    }
+    return wrapCoreResult(await coreOps["stage.record"](params), "stage.record");
+  },
+  "stage.skip": async (params) => {
+    if (!params.taskId || !params.stage || !params.reason) {
+      return lafsError("E_INVALID_INPUT", "taskId, stage, and reason are required", "stage.skip");
+    }
+    return wrapCoreResult(await coreOps["stage.skip"](params), "stage.skip");
+  },
+  "stage.reset": async (params) => {
+    if (!params.taskId || !params.stage || !params.reason) {
+      return lafsError("E_INVALID_INPUT", "taskId, stage, and reason are required", "stage.reset");
+    }
+    return wrapCoreResult(await coreOps["stage.reset"](params), "stage.reset");
+  },
+  "stage.gate.pass": async (params) => {
+    if (!params.taskId || !params.gateName) {
+      return lafsError("E_INVALID_INPUT", "taskId and gateName are required", "stage.gate.pass");
+    }
+    return wrapCoreResult(await coreOps["stage.gate.pass"](params), "stage.gate.pass");
+  },
+  "stage.gate.fail": async (params) => {
+    if (!params.taskId || !params.gateName) {
+      return lafsError("E_INVALID_INPUT", "taskId and gateName are required", "stage.gate.fail");
+    }
+    return wrapCoreResult(await coreOps["stage.gate.fail"](params), "stage.gate.fail");
+  },
+  // -------------------------------------------------------------------------
+  // Release queries
+  // -------------------------------------------------------------------------
+  "release.list": async (params) => {
+    const result = await coreOps["release.list"](params);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "release.list"
+      );
+    }
+    return lafsSuccess(
+      { ...result.data, _enginePage: result.page },
+      "release.list"
+    );
+  },
+  "release.show": async (params) => {
+    if (!params.version) {
+      return lafsError("E_INVALID_INPUT", "version is required", "release.show");
+    }
+    return wrapCoreResult(await coreOps["release.show"](params), "release.show");
+  },
+  // Always succeeds (git branch detection falls back to 'unknown') — no error path.
+  "release.channel.show": async (_params) => lafsSuccess((await coreOps["release.channel.show"](_params)).data, "release.channel.show"),
+  // -------------------------------------------------------------------------
+  // Release mutations
+  //
+  // T9540 removed `release.ship` from the pipeline domain — the
+  // `cleo release ship` CLI alias now forwards to `release.plan` +
+  // `release.open` (handled by the release domain), not the deleted
+  // `releaseShip` monolith.
+  // -------------------------------------------------------------------------
+  // release.pr-status — T9095 query: poll CI checks for an in-progress release PR
+  "release.pr-status": async (params) => {
+    if (!params.version) {
+      return lafsError("E_INVALID_INPUT", "version is required", "release.pr-status");
+    }
+    return wrapCoreResult(await coreOps["release.pr-status"](params), "release.pr-status");
+  },
+  "release.cancel": async (params) => {
+    if (!params.version) {
+      return lafsError("E_INVALID_INPUT", "version is required", "release.cancel");
+    }
+    return wrapCoreResult(await coreOps["release.cancel"](params), "release.cancel");
+  },
+  "release.rollback": async (params) => {
+    if (!params.version) {
+      return lafsError("E_INVALID_INPUT", "version is required", "release.rollback");
+    }
+    return wrapCoreResult(await coreOps["release.rollback"](params), "release.rollback");
+  },
+  "release.rollback.full": async (params) => {
+    if (!params.version) {
+      return lafsError("E_INVALID_INPUT", "version is required", "release.rollback.full");
+    }
+    return wrapCoreResult(await coreOps["release.rollback.full"](params), "release.rollback.full");
+  },
+  // -------------------------------------------------------------------------
+  // Manifest queries
+  // -------------------------------------------------------------------------
+  "manifest.show": async (params) => {
+    if (!params.entryId) {
+      return lafsError("E_INVALID_INPUT", "entryId is required", "manifest.show");
+    }
+    return wrapCoreResult(await coreOps["manifest.show"](params), "manifest.show");
+  },
+  "manifest.list": async (params) => {
+    const result = await coreOps["manifest.list"](params);
+    if (!result.success) {
+      return wrapCoreResult(result, "manifest.list");
+    }
+    return lafsSuccess(
+      { ...result.data, _enginePage: result.page },
+      "manifest.list"
+    );
+  },
+  "manifest.find": async (params) => {
+    if (!params.query) {
+      return lafsError("E_INVALID_INPUT", "query is required", "manifest.find");
+    }
+    return wrapCoreResult(await coreOps["manifest.find"](params), "manifest.find");
+  },
+  "manifest.stats": async (params) => wrapCoreResult(await coreOps["manifest.stats"](params), "manifest.stats"),
+  // -------------------------------------------------------------------------
+  // Manifest mutations
+  // -------------------------------------------------------------------------
+  "manifest.append": async (params) => {
+    if (!params.entry) {
+      return lafsError("E_INVALID_INPUT", "entry is required", "manifest.append");
+    }
+    return wrapCoreResult(await coreOps["manifest.append"](params), "manifest.append");
+  },
+  "manifest.archive": async (params) => {
+    if (!params.beforeDate) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        "beforeDate is required (ISO-8601: YYYY-MM-DD)",
+        "manifest.archive"
+      );
+    }
+    return wrapCoreResult(await coreOps["manifest.archive"](params), "manifest.archive");
+  },
+  // -------------------------------------------------------------------------
+  // Phase queries
+  // -------------------------------------------------------------------------
+  "phase.show": async (params) => wrapCoreResult(await coreOps["phase.show"](params), "phase.show"),
+  // Pagination is applied in PipelineHandler.query() for phase.list.
+  "phase.list": async (_params) => wrapCoreResult(await coreOps["phase.list"](_params), "phase.list"),
+  // -------------------------------------------------------------------------
+  // Phase mutations
+  // -------------------------------------------------------------------------
+  "phase.set": async (params) => {
+    if (!params.phaseId) {
+      return lafsError("E_INVALID_INPUT", "phaseId is required", "phase.set");
+    }
+    return wrapCoreResult(await coreOps["phase.set"](params), "phase.set");
+  },
+  "phase.advance": async (params) => wrapCoreResult(await coreOps["phase.advance"](params), "phase.advance"),
+  "phase.rename": async (params) => {
+    if (!params.oldName || !params.newName) {
+      return lafsError("E_INVALID_INPUT", "oldName and newName are required", "phase.rename");
+    }
+    return wrapCoreResult(await coreOps["phase.rename"](params), "phase.rename");
+  },
+  "phase.delete": async (params) => {
+    if (!params.phaseId) {
+      return lafsError("E_INVALID_INPUT", "phaseId is required", "phase.delete");
+    }
+    return wrapCoreResult(await coreOps["phase.delete"](params), "phase.delete");
+  }
+});
+function pipelinePhaseListResponse(envelope, params, operation, startTime) {
+  const listData = envelope.data ?? {};
+  const phases = listData?.phases ?? [];
+  const total = listData?.summary?.total ?? phases.length;
+  const { limit, offset } = getListParams(params);
+  const page = paginate(phases, limit, offset);
+  return {
+    meta: dispatchMeta("query", "pipeline", operation, startTime),
+    success: true,
+    data: { ...listData, phases: page.items, total, filtered: total },
+    page: page.page
+  };
+}
+function pipelineEnvelopeResponse(envelope, operation, startTime) {
+  const envelopeData = envelope.data;
+  const enginePage = envelopeData?._enginePage;
+  const responseData = envelopeData?._enginePage !== void 0 ? (({ _enginePage: _p, ...rest }) => rest)(
+    envelopeData
+  ) : envelopeData;
+  return {
+    meta: dispatchMeta("query", "pipeline", operation, startTime),
+    success: true,
+    data: responseData,
+    ...enginePage ? { page: enginePage } : {}
+  };
+}
+var PipelineHandler = class {
+  // -----------------------------------------------------------------------
+  // DomainHandler interface
+  // -----------------------------------------------------------------------
+  async query(operation, params) {
+    const startTime = Date.now();
+    const queryOps = /* @__PURE__ */ new Set([
+      "stage.validate",
+      "stage.status",
+      "stage.history",
+      "stage.guidance",
+      "manifest.show",
+      "manifest.list",
+      "manifest.find",
+      "manifest.stats",
+      "release.list",
+      "release.show",
+      "release.channel.show",
+      "release.pr-status",
+      "phase.show",
+      "phase.list"
+    ]);
+    if (!queryOps.has(operation)) {
+      return errorResult(
+        "query",
+        "pipeline",
+        operation,
+        "E_INVALID_OPERATION",
+        `Unknown pipeline query: ${operation}`,
+        startTime
+      );
+    }
+    try {
+      const envelope = await typedDispatch(
+        _pipelineTypedHandler,
+        operation,
+        params ?? {}
+      );
+      if (!envelope.success) {
+        return wrapResult(
+          envelopeToEngineResult(envelope),
+          "query",
+          "pipeline",
+          operation,
+          startTime
+        );
+      }
+      if (operation === "phase.list")
+        return pipelinePhaseListResponse(envelope, params, operation, startTime);
+      return pipelineEnvelopeResponse(envelope, operation, startTime);
+    } catch (error) {
+      getLogger("domain:pipeline").error(
+        { gateway: "query", domain: "pipeline", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("query", "pipeline", operation, error, startTime);
+    }
+  }
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    const mutateOps = /* @__PURE__ */ new Set([
+      "stage.record",
+      "stage.skip",
+      "stage.reset",
+      "stage.gate.pass",
+      "stage.gate.fail",
+      "release.cancel",
+      "release.rollback",
+      "release.rollback.full",
+      "manifest.append",
+      "manifest.archive",
+      "phase.set",
+      "phase.advance",
+      "phase.rename",
+      "phase.delete"
+    ]);
+    if (!mutateOps.has(operation)) {
+      return errorResult(
+        "mutate",
+        "pipeline",
+        operation,
+        "E_INVALID_OPERATION",
+        `Unknown pipeline mutation: ${operation}`,
+        startTime
+      );
+    }
+    try {
+      const envelope = await typedDispatch(
+        _pipelineTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(
+        envelopeToEngineResult(envelope),
+        "mutate",
+        "pipeline",
+        operation,
+        startTime
+      );
+    } catch (error) {
+      getLogger("domain:pipeline").error(
+        { gateway: "mutate", domain: "pipeline", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("mutate", "pipeline", operation, error, startTime);
+    }
+  }
+  getSupportedOperations() {
+    return {
+      query: [
+        "stage.validate",
+        "stage.status",
+        "stage.history",
+        "stage.guidance",
+        "manifest.show",
+        "manifest.list",
+        "manifest.find",
+        "manifest.stats",
+        "release.list",
+        "release.show",
+        "release.channel.show",
+        "phase.show",
+        "phase.list"
+      ],
+      mutate: [
+        "stage.record",
+        "stage.skip",
+        "stage.reset",
+        "stage.gate.pass",
+        "stage.gate.fail",
+        "release.cancel",
+        "release.rollback",
+        "release.rollback.full",
+        "manifest.append",
+        "manifest.archive",
+        "phase.set",
+        "phase.advance",
+        "phase.rename",
+        "phase.delete"
+      ]
+    };
+  }
+};
+export {
+  PipelineHandler
+};
+//# sourceMappingURL=pipeline-TCZPOEDR.js.map