@cleocode/cleo 2026.4.158 → 2026.5.0

package/dist/dispatch/domains/pipeline.js

@@ -0,0 +1,689 @@
+/**
+ * Pipeline Domain Handler (Dispatch Layer)
+ *
+ * Consolidates legacy lifecycle and release domains into a single "pipeline"
+ * domain with dot-prefixed operation names. All operations delegate to
+ * native engine functions from the respective dispatch engines.
+ *
+ * Sub-domains:
+ *   stage.*    - RCASD-IVTR+C lifecycle stage management
+ *   release.*  - Release lifecycle (prepare, changelog, commit, tag, push)
+ *   manifest.* - Research manifest (JSONL) operations
+ *   phase.*    - Project phase management
+ *   chain.*    - Warp-chain operations (T5405)
+ *
+ * Uses typed-handler pattern (Wave D · T975) for compile-time param narrowing.
+ * Param extraction is type-safe via OpsFromCore<typeof coreOps> inference.
+ * Zero `as string` / `as unknown` param casts in per-op code.
+ *
+ * @epic T4820
+ * @task T1441 — OpsFromCore inference migration
+ * @task T1435 — Wave 1 dispatch refactor
+ */
+import { execFileSync } from 'node:child_process';
+import { addChain, advanceInstance, buildStageGuidance, channelToDistTag, createInstance, describeChannel, formatStageGuidance, getLogger, getProjectRoot, isValidStage, listChains, paginate, resolveChannelFromBranch, showChain, } from '@cleocode/core/internal';
+import { defineTypedHandler, lafsError, lafsSuccess, typedDispatch, wrapCoreResult, } from '../adapters/typed.js';
+import { lifecycleCheck, lifecycleGateFail, lifecycleGatePass, lifecycleHistory, lifecycleProgress, lifecycleReset, lifecycleSkip, lifecycleStatus, phaseAdvance, phaseComplete, phaseDelete, phaseList, phaseRename, phaseSet, phaseShow, phaseStart, pipelineManifestAppend, pipelineManifestArchive, pipelineManifestFind, pipelineManifestList, pipelineManifestShow, pipelineManifestStats, releaseCancel, releaseChangelogSince, releaseList, releaseRollback, releaseRollbackFull, releaseShip, releaseShow, } from '../lib/engine.js';
+import { errorResult, getListParams, handleErrorResult } from './_base.js';
+import { dispatchMeta } from './_meta.js';
+// ---------------------------------------------------------------------------
+// Core op wrappers — single-param functions for OpsFromCore inference
+// ---------------------------------------------------------------------------
+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) {
+    // Perform the full guidance resolution here so OpsFromCore correctly infers
+    // params as StageGuidanceParams (not a sentinel wrapper shape).
+    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 {
+        // git not available or not a git repo — leave as 'unknown'
+    }
+    const resolvedChannel = resolveChannelFromBranch(currentBranch);
+    const distTag = channelToDistTag(resolvedChannel);
+    const description = describeChannel(resolvedChannel);
+    return {
+        success: true,
+        data: { branch: currentBranch, channel: resolvedChannel, distTag, description },
+    };
+}
+async function releaseChangelogSinceOp(params) {
+    return releaseChangelogSince(params.sinceTag, getProjectRoot());
+}
+async function releaseShipOp(params) {
+    return releaseShip({
+        version: params.version,
+        epicId: params.epicId,
+        remote: params.remote,
+        dryRun: params.dryRun,
+        bump: params.bump,
+        force: params.force,
+    }, 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());
+}
+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());
+}
+async function chainShowOp(params) {
+    const chain = await showChain(params.chainId, getProjectRoot());
+    // Return both chain and chainId so typed handler can produce E_NOT_FOUND.
+    return { _chain: chain, _chainId: params.chainId };
+}
+async function chainListOp(_params) {
+    // Return raw chains; outer query() applies pagination to avoid LAFSPage type conflicts.
+    const chains = await listChains(getProjectRoot());
+    return { _chains: chains };
+}
+async function chainAddOp(params) {
+    await addChain(params.chain, getProjectRoot());
+    return { id: params.chain.id };
+}
+async function chainInstantiateOp(params) {
+    return createInstance({
+        chainId: params.chainId,
+        epicId: params.epicId,
+        variables: params.variables,
+        stageToTask: params.stageToTask,
+    }, getProjectRoot());
+}
+async function chainAdvanceOp(params) {
+    return advanceInstance(params.instanceId, params.nextStage, params.gateResults ?? [], getProjectRoot());
+}
+// ---------------------------------------------------------------------------
+// Core ops registry
+// ---------------------------------------------------------------------------
+const 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.changelog.since': releaseChangelogSinceOp,
+    'release.ship': releaseShipOp,
+    '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,
+    'chain.show': chainShowOp,
+    'chain.list': chainListOp,
+    'chain.add': chainAddOp,
+    'chain.instantiate': chainInstantiateOp,
+    'chain.advance': chainAdvanceOp,
+};
+// ---------------------------------------------------------------------------
+// Typed inner handler (Wave D · T1441)
+// ---------------------------------------------------------------------------
+const _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) => {
+        // stage.guidance — stageGuidanceOp resolves the stage from epicId and returns
+        // a { _stage, _format, _projectRoot } sentinel. Validation and guidance
+        // building happen here after unwrapping.
+        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');
+        }
+        // Embed engine page in data so outer query() can populate DispatchResponse.page.
+        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.changelog.since': async (params) => {
+        if (!params.sinceTag) {
+            return lafsError('E_INVALID_INPUT', 'sinceTag is required', 'release.changelog.since');
+        }
+        return wrapCoreResult(await coreOps['release.changelog.since'](params), 'release.changelog.since');
+    },
+    // -------------------------------------------------------------------------
+    // Release mutations
+    // -------------------------------------------------------------------------
+    'release.ship': async (params) => {
+        if (!params.version || !params.epicId) {
+            return lafsError('E_INVALID_INPUT', 'version and epicId are required', 'release.ship');
+        }
+        return wrapCoreResult(await coreOps['release.ship'](params), 'release.ship');
+    },
+    '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 lafsError(String(result.error?.code ?? 'E_INTERNAL'), result.error?.message ?? 'Unknown error', 'manifest.list');
+        }
+        // Embed engine page in data so outer query() can populate DispatchResponse.page.
+        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');
+    },
+    // -------------------------------------------------------------------------
+    // Chain queries
+    // -------------------------------------------------------------------------
+    'chain.show': async (params) => {
+        if (!params.chainId) {
+            return lafsError('E_INVALID_INPUT', 'chainId is required', 'chain.show');
+        }
+        const { _chain, _chainId } = await coreOps['chain.show'](params);
+        if (!_chain) {
+            return lafsError('E_NOT_FOUND', `Chain "${_chainId}" not found`, 'chain.show');
+        }
+        return lafsSuccess(_chain, 'chain.show');
+    },
+    'chain.list': async (params) => {
+        // Returns raw chains; pagination is applied in PipelineHandler.query().
+        return lafsSuccess(await coreOps['chain.list'](params), 'chain.list');
+    },
+    // -------------------------------------------------------------------------
+    // Chain mutations
+    // -------------------------------------------------------------------------
+    'chain.add': async (params) => {
+        if (!params.chain) {
+            return lafsError('E_INVALID_INPUT', 'chain is required', 'chain.add');
+        }
+        return lafsSuccess(await coreOps['chain.add'](params), 'chain.add');
+    },
+    'chain.instantiate': async (params) => {
+        if (!params.chainId || !params.epicId) {
+            return lafsError('E_INVALID_INPUT', 'chainId and epicId are required', 'chain.instantiate');
+        }
+        try {
+            return lafsSuccess(await coreOps['chain.instantiate'](params), 'chain.instantiate');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes(`Chain "${params.chainId}" not found`) ||
+                message.includes('FOREIGN KEY constraint failed') ||
+                message.includes('SQLITE_CONSTRAINT_FOREIGNKEY')) {
+                return lafsError('E_NOT_FOUND', `Chain "${params.chainId}" not found`, 'chain.instantiate');
+            }
+            throw error;
+        }
+    },
+    'chain.advance': async (params) => {
+        if (!params.instanceId || !params.nextStage) {
+            return lafsError('E_INVALID_INPUT', 'instanceId and nextStage are required', 'chain.advance');
+        }
+        return lafsSuccess(await coreOps['chain.advance'](params), 'chain.advance');
+    },
+});
+// ---------------------------------------------------------------------------
+// PipelineHandler post-dispatch helpers (ADR-058 thin-handler T1492/P1-1)
+//
+// These helpers extract the fat post-dispatch transformation blocks from
+// PipelineHandler.query so each branch in the query method is ≤5 LOC.
+// SSoT-EXEMPT: pagination + page-envelope lifting are dispatch-layer concerns
+// (LAFSPage type incompatibility between @cleocode/lafs and @cleocode/contracts).
+// ---------------------------------------------------------------------------
+/** Apply phase.list pagination to a typed-dispatch envelope. */
+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,
+    };
+}
+/** Apply chain.list pagination to a typed-dispatch envelope. */
+function pipelineChainListResponse(envelope, params, operation, startTime) {
+    const rawData = envelope.data ?? { _chains: [] };
+    const chains = rawData._chains ?? [];
+    const { limit, offset } = getListParams(params);
+    const page = paginate(chains, limit, offset);
+    return {
+        meta: dispatchMeta('query', 'pipeline', operation, startTime),
+        success: true,
+        data: { chains: page.items, total: chains.length, filtered: chains.length },
+        page: page.page,
+    };
+}
+/** Extract _enginePage from typed-dispatch envelope and return DispatchResponse. */
+function pipelineEnvelopeResponse(envelope, operation, startTime) {
+    const envelopeData = envelope.data;
+    const enginePage = envelopeData?._enginePage;
+    const responseData = envelopeData?._enginePage !== undefined
+        ? (({ _enginePage: _p, ...rest }) => rest)(envelopeData)
+        : envelopeData;
+    return {
+        meta: dispatchMeta('query', 'pipeline', operation, startTime),
+        success: true,
+        data: responseData,
+        ...(enginePage ? { page: enginePage } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// PipelineHandler
+// ---------------------------------------------------------------------------
+/**
+ * Pipeline domain handler.
+ *
+ * Delegates all operations to the typed inner handler via `typedDispatch`.
+ * Special cases:
+ * - `stage.guidance` — resolved in the typed handler (stage-from-epicId logic).
+ * - `phase.list` / `chain.list` — pagination applied in this outer handler to avoid
+ *   LAFSPage type incompatibility between `@cleocode/lafs` and `@cleocode/contracts`.
+ *
+ * @task T1441 — OpsFromCore inference migration (Wave D · T1435)
+ */
+export class PipelineHandler {
+    // -----------------------------------------------------------------------
+    // DomainHandler interface
+    // -----------------------------------------------------------------------
+    async query(operation, params) {
+        const startTime = Date.now();
+        const queryOps = 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.changelog.since',
+            'phase.show',
+            'phase.list',
+            'chain.show',
+            'chain.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 {
+                    meta: dispatchMeta('query', 'pipeline', operation, startTime),
+                    success: false,
+                    error: {
+                        code: envelope.error?.code !== undefined ? String(envelope.error.code) : 'E_INTERNAL',
+                        message: envelope.error?.message ?? 'Unknown error',
+                    },
+                };
+            }
+            // phase.list / chain.list — pagination applied via helpers (ADR-058 T1492/P1-1)
+            if (operation === 'phase.list')
+                return pipelinePhaseListResponse(envelope, params, operation, startTime);
+            if (operation === 'chain.list')
+                return pipelineChainListResponse(envelope, params, operation, startTime);
+            // All other ops — extract _enginePage from envelope (manifest.list, release.list, etc.)
+            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 = new Set([
+            'stage.record',
+            'stage.skip',
+            'stage.reset',
+            'stage.gate.pass',
+            'stage.gate.fail',
+            'release.ship',
+            'release.cancel',
+            'release.rollback',
+            'release.rollback.full',
+            'manifest.append',
+            'manifest.archive',
+            'phase.set',
+            'phase.advance',
+            'phase.rename',
+            'phase.delete',
+            'chain.add',
+            'chain.instantiate',
+            'chain.advance',
+        ]);
+        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 {
+                meta: dispatchMeta('mutate', 'pipeline', operation, startTime),
+                success: envelope.success,
+                ...(envelope.success
+                    ? { data: envelope.data }
+                    : {
+                        error: {
+                            code: envelope.error?.code !== undefined ? String(envelope.error.code) : 'E_INTERNAL',
+                            message: envelope.error?.message ?? 'Unknown error',
+                        },
+                    }),
+            };
+        }
+        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',
+                'release.changelog.since',
+                'phase.show',
+                'phase.list',
+                'chain.show',
+                'chain.list',
+            ],
+            mutate: [
+                'stage.record',
+                'stage.skip',
+                'stage.reset',
+                'stage.gate.pass',
+                'stage.gate.fail',
+                'release.ship',
+                'release.cancel',
+                'release.rollback',
+                'release.rollback.full',
+                'manifest.append',
+                'manifest.archive',
+                'phase.set',
+                'phase.advance',
+                'phase.rename',
+                'phase.delete',
+                'chain.add',
+                'chain.instantiate',
+                'chain.advance',
+            ],
+        };
+    }
+}
+//# sourceMappingURL=pipeline.js.map