@cleocode/cleo 2026.4.161 → 2026.5.1

package/dist/dispatch/domains/orchestrate.js

@@ -0,0 +1,986 @@
+/**
+ * Orchestrate Domain Handler (Dispatch Layer)
+ *
+ * Handles multi-agent orchestration: dependency analysis, wave computation,
+ * spawn readiness, parallel coordination, and orchestration context.
+ * All operations delegate to native engine functions.
+ *
+ * Wave 7a additions (T379):
+ * - orchestrate.classify (T408) — prompt-based team routing stub
+ * - orchestrate.fanout (T409) — Promise.allSettled spawn wrapper
+ * - orchestrate.fanout.status (T415) — fanout status stub
+ * - orchestrate.analyze mode="parallel-safety" (T410) — dep-graph grouping
+ *
+ * Type-safe dispatch via OpsFromCore<typeof coreOps> per ADR-058.
+ * Param extraction inferred by coreOps — zero `params?.x as Type` casts.
+ *
+ * @epic T4820
+ * @epic T377
+ * @task T1538 — OpsFromCore migration per ADR-058
+ */
+import { getLogger, getProjectRoot, instantiateTessera, listTesseraTemplates, paginate, pivotTask, showTessera, } from '@cleocode/core/internal';
+import { CLEO_DIR_NAME, WORKFLOWS_SUBDIR } from '../../cli/paths.js';
+import { orchestrateAnalyze, orchestrateBootstrap, orchestrateContext, orchestrateHandoff, orchestrateNext, orchestrateParallelEnd, orchestrateParallelStart, orchestratePlan, orchestrateReady, orchestrateSpawn, orchestrateSpawnExecute, orchestrateStartup, orchestrateStatus, orchestrateUnblockOpportunities, orchestrateValidate, orchestrateWaves, sessionContextInject, sessionEnd, sessionStatus, } from '../lib/engine.js';
+import { errorResult, getListParams, handleErrorResult, wrapResult } from './_base.js';
+import { dispatchMeta } from './_meta.js';
+import { routeByParam } from './_routing.js';
+import { IvtrHandler } from './ivtr.js';
+import { acquirePlaybookDb, listPendingApprovalsForDispatch, lookupApprovalByTokenForDispatch, } from './playbook.js';
+/** Shared IvtrHandler instance for ivtr.* sub-operations (T811). */
+const ivtrHandler = new IvtrHandler();
+/** Maximum number of fanout manifest entries retained in memory. */
+const FANOUT_MANIFEST_MAX_SIZE = 64;
+const fanoutManifestStore = new Map();
+/**
+ * Evict oldest entries when the manifest store exceeds the size cap.
+ */
+function evictFanoutManifest() {
+    while (fanoutManifestStore.size > FANOUT_MANIFEST_MAX_SIZE) {
+        const oldest = fanoutManifestStore.keys().next().value;
+        if (oldest !== undefined)
+            fanoutManifestStore.delete(oldest);
+    }
+}
+// ---------------------------------------------------------------------------
+// Core op wrappers — single-param functions for OpsFromCore inference
+// ---------------------------------------------------------------------------
+async function orchestrateStatusOp(params) {
+    return orchestrateStatus(params.epicId, getProjectRoot());
+}
+async function orchestrateNextOp(params) {
+    return orchestrateNext(params.epicId, getProjectRoot());
+}
+async function orchestrateReadyOp(params) {
+    return orchestrateReady(params.epicId, getProjectRoot());
+}
+async function orchestrateAnalyzeOp(params) {
+    if (params.mode === 'parallel-safety') {
+        return orchestrateAnalyzeParallelSafety(params.taskIds ?? [], getProjectRoot());
+    }
+    return orchestrateAnalyze(params.epicId, getProjectRoot(), params.mode);
+}
+async function orchestrateClassifyOp(params) {
+    return orchestrateClassify(params.request, params.context, getProjectRoot());
+}
+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, getProjectRoot());
+}
+async function orchestrateWavesOp(params) {
+    return orchestrateWaves(params.epicId, getProjectRoot());
+}
+async function orchestratePlanOp(params) {
+    return orchestratePlan({
+        epicId: params.epicId,
+        projectRoot: getProjectRoot(),
+        preferTier: params.preferTier,
+    });
+}
+async function orchestrateBootstrapOp(params) {
+    return orchestrateBootstrap(getProjectRoot(), { speed: params.speed });
+}
+async function orchestrateUnblockOp(_params) {
+    return orchestrateUnblockOpportunities(getProjectRoot());
+}
+async function orchestrateTesseraListOp(params) {
+    return Promise.resolve({ success: true, data: params }); // sentinel — handled inline
+}
+async function orchestrateIvtrStatusOp(params) {
+    return ivtrHandler.query('status', params);
+}
+async function orchestratePendingOp(_params) {
+    return Promise.resolve({ success: true, data: {} }); // sentinel — handled inline
+}
+async function orchestrateStartOp(params) {
+    return orchestrateStartup(params.epicId, getProjectRoot());
+}
+async function orchestrateSpawnOp(params) {
+    return orchestrateSpawn(params.taskId, params.protocolType, getProjectRoot(), params.tier, params.noWorktree);
+}
+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 }, getProjectRoot());
+}
+async function orchestrateSpawnExecuteOp(params) {
+    return orchestrateSpawnExecute(params.taskId, params.adapterId, params.protocolType, getProjectRoot(), params.tier);
+}
+async function orchestrateValidateOp(params) {
+    return orchestrateValidate(params.taskId, getProjectRoot());
+}
+async function orchestratePivotOp(params) {
+    try {
+        const result = await pivotTask(params.fromTaskId, params.toTaskId, {
+            reason: params.reason,
+            blocksFrom: params.blocksFrom,
+            projectRoot: getProjectRoot(),
+        });
+        return { success: true, data: result };
+    }
+    catch (err) {
+        const code = err?.code;
+        const message = err instanceof Error ? err.message : String(err);
+        // Map ExitCode 38 (ACTIVE_TASK_REQUIRED) → spec-named E_NOT_ACTIVE
+        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';
+        return {
+            success: false,
+            error: { code: errorCode, message },
+        };
+    }
+}
+async function orchestrateWorktreeCompleteOp(params) {
+    return handleWorktreeComplete(params.taskId, getProjectRoot());
+}
+async function orchestrateWorktreeCleanupOp(params) {
+    return handleWorktreeCleanup(getProjectRoot(), params.taskIds);
+}
+async function orchestrateWorktreePruneOp(params) {
+    return handleWorktreePrune(getProjectRoot(), params.taskId);
+}
+async function orchestrateParallelOp(params) {
+    return Promise.resolve({ success: true, data: params }); // sentinel — handled inline via routeByParam
+}
+async function orchestrateFanoutOp(params) {
+    return orchestrateFanoutImpl(params.items, getProjectRoot());
+}
+async function orchestrateTesseraInstantiateOp(params) {
+    return Promise.resolve({ success: true, data: params }); // sentinel — handled inline
+}
+async function orchestrateApproveOp(params) {
+    return Promise.resolve({ success: true, data: params }); // sentinel — handled inline
+}
+async function orchestrateRejectOp(params) {
+    return Promise.resolve({ success: true, data: params }); // sentinel — handled inline
+}
+// ---------------------------------------------------------------------------
+// Core op registry — OpsFromCore inference source
+// ---------------------------------------------------------------------------
+/**
+ * Orchestrate operation registry for `OpsFromCore<typeof coreOps>` inference.
+ *
+ * @task T1538 — orchestrate dispatch OpsFromCore migration
+ */
+const coreOps = {
+    status: orchestrateStatusOp,
+    next: orchestrateNextOp,
+    ready: orchestrateReadyOp,
+    analyze: orchestrateAnalyzeOp,
+    classify: orchestrateClassifyOp,
+    'fanout.status': orchestrateFanoutStatusOp,
+    context: orchestrateContextOp,
+    waves: orchestrateWavesOp,
+    plan: orchestratePlanOp,
+    bootstrap: orchestrateBootstrapOp,
+    'unblock.opportunities': orchestrateUnblockOp,
+    'tessera.list': orchestrateTesseraListOp,
+    '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,
+    'tessera.instantiate': orchestrateTesseraInstantiateOp,
+    approve: orchestrateApproveOp,
+    reject: orchestrateRejectOp,
+};
+// ---------------------------------------------------------------------------
+// OrchestrateHandler
+// ---------------------------------------------------------------------------
+export class OrchestrateHandler {
+    // -----------------------------------------------------------------------
+    // 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 p = { epicId: params.epicId };
+                    return wrapResult(await coreOps.ready(p), '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 p = { epicId: params.epicId };
+                    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 'tessera.list': {
+                    const id = params?.id;
+                    if (id) {
+                        const template = showTessera(id);
+                        if (!template)
+                            return errorResult('query', 'orchestrate', 'tessera.list', 'E_NOT_FOUND', `Tessera template "${id}" not found`, startTime);
+                        return {
+                            meta: dispatchMeta('query', 'orchestrate', 'tessera.list', startTime),
+                            success: true,
+                            data: template,
+                        };
+                    }
+                    const templates = listTesseraTemplates();
+                    const { limit, offset } = getListParams(params);
+                    const page = paginate(templates, limit, offset);
+                    return {
+                        meta: dispatchMeta('query', 'orchestrate', 'tessera.list', startTime),
+                        success: true,
+                        data: {
+                            templates: page.items,
+                            count: templates.length,
+                            total: templates.length,
+                            filtered: templates.length,
+                        },
+                        page: page.page,
+                    };
+                }
+                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) {
+            getLogger('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 : undefined;
+                    const p = {
+                        taskId: params.taskId,
+                        protocolType: params.protocolType,
+                        tier,
+                        noWorktree: params.noWorktree,
+                    };
+                    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 : undefined;
+                    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 : undefined;
+                    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,
+                    };
+                    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 p = { taskId: params.taskId };
+                    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 === undefined || wave === null)
+                                return errorResult('mutate', 'orchestrate', 'parallel', 'E_INVALID_INPUT', 'wave number is required', startTime);
+                            return wrapResult(await orchestrateParallelStart(epicId, wave, getProjectRoot()), '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 === undefined || wave === null)
+                                return errorResult('mutate', 'orchestrate', 'parallel', 'E_INVALID_INPUT', 'wave number is required', startTime);
+                            return wrapResult(await orchestrateParallelEnd(epicId, wave, getProjectRoot()), '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 'tessera.instantiate': {
+                    if (!params?.templateId)
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'templateId is required', startTime);
+                    if (!params?.epicId)
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'epicId is required', startTime);
+                    const template = showTessera(params.templateId);
+                    if (!template)
+                        return errorResult('mutate', 'orchestrate', operation, 'E_NOT_FOUND', `Tessera template "${params.templateId}" not found`, startTime);
+                    const variables = params.variables ?? {};
+                    const epicId = params.epicId;
+                    const instance = await instantiateTessera(template, {
+                        templateId: params.templateId,
+                        epicId,
+                        variables: { epicId, ...variables },
+                    }, getProjectRoot());
+                    return {
+                        meta: dispatchMeta('mutate', 'orchestrate', operation, startTime),
+                        success: true,
+                        data: instance,
+                    };
+                }
+                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) {
+            getLogger('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',
+                'tessera.list',
+                'classify',
+                'fanout.status',
+                'ivtr.status',
+                'pending',
+            ],
+            mutate: [
+                'start',
+                'spawn',
+                'handoff',
+                'spawn.execute',
+                'validate',
+                'pivot',
+                'parallel',
+                'tessera.instantiate',
+                'fanout',
+                'ivtr.start',
+                'ivtr.next',
+                'ivtr.release',
+                'ivtr.loop-back',
+                'approve',
+                'reject',
+                'worktree.complete',
+                'worktree.cleanup',
+                'worktree.prune',
+            ],
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Wave 7a handler functions (T408, T409, T410)
+// ---------------------------------------------------------------------------
+/**
+ * T408 — Classify a request against the CANT team registry.
+ *
+ * @param request - The request text to classify.
+ * @param context - Optional additional context.
+ * @param projectRoot - Project root directory.
+ */
+async function orchestrateClassify(request, context, projectRoot) {
+    try {
+        const { getCleoCantWorkflowsDir } = await import('@cleocode/core/internal');
+        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 {
+                    // skip unreadable files
+                }
+            }
+        }
+        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 {
+                    // skip
+                }
+            }
+        }
+        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];
+        return {
+            success: true,
+            data: {
+                team: best.team,
+                lead: null,
+                protocol: 'base-subagent',
+                stage: best.stages[0] ?? null,
+                confidence: best.score > 0 ? 0.5 : 0.1,
+                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) {
+        getLogger('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),
+            },
+        };
+    }
+}
+/**
+ * T409 / T433 — Fan out N spawn requests via Promise.allSettled.
+ */
+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, undefined, undefined, projectRoot, undefined);
+            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 : undefined,
+            };
+        }));
+        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: 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) {
+        getLogger('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),
+            },
+        };
+    }
+}
+/**
+ * T410 — Analyze a list of tasks for parallel safety.
+ */
+async function orchestrateAnalyzeParallelSafety(taskIds, projectRoot) {
+    if (taskIds.length === 0) {
+        return {
+            success: true,
+            data: {
+                parallelSafe: true,
+                groups: [],
+                note: 'No tasks provided — trivially parallel-safe',
+            },
+        };
+    }
+    try {
+        const { getAccessor } = await import('@cleocode/core/internal');
+        const accessor = await getAccessor(projectRoot);
+        const result = await accessor.queryTasks({});
+        const allTasks = result?.tasks ?? [];
+        const depMap = new Map();
+        for (const t of allTasks) {
+            const deps = t.blockers ?? [];
+            depMap.set(t.id, deps);
+        }
+        function transitiveClose(id, visited = new Set()) {
+            if (visited.has(id))
+                return visited;
+            visited.add(id);
+            const deps = depMap.get(id) ?? [];
+            for (const dep of deps) {
+                transitiveClose(dep, visited);
+            }
+            return visited;
+        }
+        const closures = new Map();
+        for (const id of taskIds) {
+            closures.set(id, transitiveClose(id));
+        }
+        function parallelSafe(a, b) {
+            const closureA = closures.get(a) ?? new Set();
+            const closureB = closures.get(b) ?? new Set();
+            return !closureA.has(b) && !closureB.has(a);
+        }
+        const groups = [];
+        for (const id of taskIds) {
+            let placed = false;
+            for (const group of groups) {
+                if (group.every((member) => parallelSafe(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) {
+        getLogger('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),
+            },
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// T1118 L1 — Worktree lifecycle handlers
+// ---------------------------------------------------------------------------
+/**
+ * Dispatch handler for `cleo orchestrate worktree.complete`.
+ *
+ * Per ADR-062 / T1587 / T1601 — uses `git merge --no-ff` rather than
+ * cherry-pick so the agent's commit SHAs are preserved in the integration
+ * branch's history. Project-agnostic: delegates target-branch resolution to
+ * {@link getDefaultBranch} (no hardcoded `main`).
+ *
+ * @task T1601
+ * @adr ADR-062
+ */
+async function handleWorktreeComplete(taskId, projectRoot) {
+    try {
+        const { completeAgentWorktreeViaMerge } = await import('@cleocode/core/internal');
+        const result = completeAgentWorktreeViaMerge(taskId, projectRoot);
+        // Surface a non-fatal merge error as a dispatch-level failure so callers
+        // can react (rebase conflicts, missing branch, etc.) rather than treating
+        // a partial result as success.
+        if (!result.merged && result.error) {
+            return {
+                success: false,
+                error: {
+                    code: 'E_WORKTREE_COMPLETE_FAILED',
+                    message: result.error,
+                },
+            };
+        }
+        return { success: true, data: result };
+    }
+    catch (error) {
+        getLogger('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/internal');
+        const activeSet = taskIds ? new Set(taskIds) : undefined;
+        const result = pruneOrphanedWorktrees(projectRoot, activeSet);
+        return { success: true, data: result };
+    }
+    catch (error) {
+        getLogger('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/internal');
+        if (taskId) {
+            const result = pruneWorktree(taskId, projectRoot);
+            return { success: true, data: result };
+        }
+        const result = pruneOrphanedWorktrees(projectRoot, undefined);
+        return { success: true, data: { ...result, mode: 'bulk' } };
+    }
+    catch (error) {
+        getLogger('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),
+            },
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// T935 — HITL approval gate handlers
+// ---------------------------------------------------------------------------
+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) {
+        getLogger('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 : undefined;
+    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('@cleocode/playbooks');
+        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);
+        getLogger('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('@cleocode/playbooks');
+        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);
+        getLogger('domain:orchestrate').error({ operation: 'reject', err: error }, message);
+        return handleErrorResult('mutate', 'orchestrate', 'reject', error, startTime);
+    }
+}
+//# sourceMappingURL=orchestrate.js.map