@cleocode/cleo 2026.4.58 → 2026.4.59

package/dist/dispatch/domains/orchestrate.js

@@ -0,0 +1,691 @@
+/**
+ * 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
+ *
+ * @epic T4820
+ * @epic T377
+ */
+import { getLogger, getProjectRoot, instantiateTessera, listTesseraTemplates, paginate, showTessera, } from '@cleocode/core/internal';
+import { orchestrateAnalyze, orchestrateBootstrap, orchestrateContext, orchestrateHandoff, orchestrateNext, orchestrateParallelEnd, orchestrateParallelStart, orchestrateReady, orchestrateSpawn, orchestrateSpawnExecute, orchestrateStartup, orchestrateStatus, orchestrateUnblockOpportunities, orchestrateValidate, orchestrateWaves, } from '../lib/engine.js';
+import { errorResult, getListParams, handleErrorResult, wrapResult } from './_base.js';
+import { dispatchMeta } from './_meta.js';
+import { routeByParam } from './_routing.js';
+import { ConduitHandler } from './conduit.js';
+/** Shared ConduitHandler instance for conduit.* sub-operations (ADR-042). */
+const conduitHandler = new ConduitHandler();
+// ---------------------------------------------------------------------------
+// OrchestrateHandler
+// ---------------------------------------------------------------------------
+export class OrchestrateHandler {
+    // -----------------------------------------------------------------------
+    // DomainHandler interface
+    // -----------------------------------------------------------------------
+    async query(operation, params) {
+        const projectRoot = getProjectRoot();
+        const startTime = Date.now();
+        try {
+            switch (operation) {
+                case 'status': {
+                    const epicId = params?.epicId;
+                    const result = await orchestrateStatus(epicId, projectRoot);
+                    return wrapResult(result, 'query', 'orchestrate', operation, startTime);
+                }
+                case 'next': {
+                    const epicId = params?.epicId;
+                    if (!epicId) {
+                        return errorResult('query', 'orchestrate', operation, 'E_INVALID_INPUT', 'epicId is required', startTime);
+                    }
+                    const result = await orchestrateNext(epicId, projectRoot);
+                    return wrapResult(result, 'query', 'orchestrate', operation, startTime);
+                }
+                case 'ready': {
+                    const epicId = params?.epicId;
+                    if (!epicId) {
+                        return errorResult('query', 'orchestrate', operation, 'E_INVALID_INPUT', 'epicId is required', startTime);
+                    }
+                    const result = await orchestrateReady(epicId, projectRoot);
+                    return wrapResult(result, 'query', 'orchestrate', operation, startTime);
+                }
+                case 'analyze': {
+                    const epicId = params?.epicId;
+                    const mode = params?.mode;
+                    // T410: parallel-safety mode — dep-graph grouping without epicId
+                    if (mode === 'parallel-safety') {
+                        const taskIds = params?.taskIds;
+                        const result = await orchestrateAnalyzeParallelSafety(taskIds ?? [], projectRoot);
+                        return wrapResult(result, 'query', 'orchestrate', 'analyze', startTime);
+                    }
+                    const result = await orchestrateAnalyze(epicId, projectRoot, mode);
+                    return wrapResult(result, 'query', 'orchestrate', 'analyze', startTime);
+                }
+                case 'classify': {
+                    // T408: prompt-based team routing stub.
+                    //
+                    // ADR-030 §5 Challenge Questions:
+                    // Q1: Is this operation idempotent? Yes — same request + context produces same routing.
+                    // Q2: What is the failure mode when no team matches? Returns confidence=0 with null team.
+                    // Q3: Should this be a query or mutate? Query — no state is written; routing is advisory.
+                    // Q4: How does this compose with orchestrate.spawn? Classify first, then spawn to the
+                    //     returned team's lead using the returned protocol.
+                    // Q5: What prevents stale team registry data? The classifier reads live .cant files at
+                    //     runtime; W7b adds cache invalidation on file-change events.
+                    const request = params?.request;
+                    if (!request) {
+                        return errorResult('query', 'orchestrate', operation, 'E_INVALID_INPUT', 'request is required', startTime);
+                    }
+                    const context = params?.context;
+                    const result = await orchestrateClassify(request, context, projectRoot);
+                    return wrapResult(result, 'query', 'orchestrate', operation, startTime);
+                }
+                case 'fanout.status': {
+                    // T433 STAB-1: reads results from the in-process fanoutManifestStore.
+                    const manifestEntryId = params?.manifestEntryId;
+                    if (!manifestEntryId) {
+                        return errorResult('query', 'orchestrate', operation, 'E_INVALID_INPUT', 'manifestEntryId is required', startTime);
+                    }
+                    const entry = fanoutManifestStore.get(manifestEntryId);
+                    if (!entry) {
+                        return {
+                            meta: dispatchMeta('query', 'orchestrate', operation, startTime),
+                            success: true,
+                            data: {
+                                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 {
+                        meta: dispatchMeta('query', 'orchestrate', operation, startTime),
+                        success: true,
+                        data: {
+                            manifestEntryId,
+                            pending: [],
+                            running: spawned,
+                            complete: [],
+                            failed,
+                            found: true,
+                            completedAt: entry.completedAt,
+                        },
+                    };
+                }
+                case 'context': {
+                    const epicId = params?.epicId;
+                    const result = await orchestrateContext(epicId, projectRoot);
+                    return wrapResult(result, 'query', 'orchestrate', operation, startTime);
+                }
+                case 'waves': {
+                    const epicId = params?.epicId;
+                    if (!epicId) {
+                        return errorResult('query', 'orchestrate', operation, 'E_INVALID_INPUT', 'epicId is required', startTime);
+                    }
+                    const result = await orchestrateWaves(epicId, projectRoot);
+                    return wrapResult(result, 'query', 'orchestrate', operation, startTime);
+                }
+                case 'bootstrap': {
+                    const speed = params?.speed;
+                    const result = await orchestrateBootstrap(projectRoot, { speed });
+                    return wrapResult(result, 'query', 'orchestrate', operation, startTime);
+                }
+                case 'unblock.opportunities': {
+                    const result = await orchestrateUnblockOpportunities(projectRoot);
+                    return wrapResult(result, '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,
+                    };
+                }
+                // ADR-042: conduit sub-operations routed through orchestrate domain
+                case 'conduit.status':
+                    return conduitHandler.query('status', params);
+                case 'conduit.peek':
+                    return conduitHandler.query('peek', params);
+                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 projectRoot = getProjectRoot();
+        const startTime = Date.now();
+        try {
+            switch (operation) {
+                case 'start': {
+                    const epicId = params?.epicId;
+                    if (!epicId) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'epicId is required', startTime);
+                    }
+                    const result = await orchestrateStartup(epicId, projectRoot);
+                    return wrapResult(result, 'mutate', 'orchestrate', operation, startTime);
+                }
+                case 'spawn': {
+                    const taskId = params?.taskId;
+                    if (!taskId) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                    }
+                    const protocolType = params?.protocolType;
+                    const tier = params?.tier;
+                    const result = await orchestrateSpawn(taskId, protocolType, projectRoot, tier);
+                    return wrapResult(result, 'mutate', 'orchestrate', operation, startTime);
+                }
+                case 'handoff': {
+                    const taskId = params?.taskId;
+                    const protocolType = params?.protocolType;
+                    if (!taskId) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                    }
+                    if (!protocolType) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'protocolType is required', startTime);
+                    }
+                    const tier = params?.tier;
+                    const result = await orchestrateHandoff({
+                        taskId,
+                        protocolType,
+                        note: params?.note,
+                        nextAction: params?.nextAction,
+                        variant: params?.variant,
+                        tier,
+                        idempotencyKey: params?.idempotencyKey,
+                    }, projectRoot);
+                    return wrapResult(result, 'mutate', 'orchestrate', operation, startTime);
+                }
+                case 'spawn.execute': {
+                    const taskId = params?.taskId;
+                    if (!taskId) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                    }
+                    const adapterId = params?.adapterId;
+                    const protocolType = params?.protocolType;
+                    const tier = params?.tier;
+                    const result = await orchestrateSpawnExecute(taskId, adapterId, protocolType, projectRoot, tier);
+                    return wrapResult(result, 'mutate', 'orchestrate', operation, startTime);
+                }
+                case 'validate': {
+                    const taskId = params?.taskId;
+                    if (!taskId) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                    }
+                    const result = await orchestrateValidate(taskId, projectRoot);
+                    return wrapResult(result, '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);
+                            }
+                            const result = await orchestrateParallelStart(epicId, wave, projectRoot);
+                            return wrapResult(result, '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);
+                            }
+                            const result = await orchestrateParallelEnd(epicId, wave, projectRoot);
+                            return wrapResult(result, 'mutate', 'orchestrate', 'parallel', startTime);
+                        },
+                    });
+                }
+                case 'fanout': {
+                    // T409: Promise.allSettled fanout wrapper.
+                    //
+                    // ADR-030 §5 Challenge Questions:
+                    // Q1: Is this idempotent? No — each call triggers new spawn attempts.
+                    // Q2: What happens on partial failure? allSettled collects all; results
+                    //     include per-item status and error fields. Orchestrator decides retry.
+                    // Q3: Does this block the orchestrator? No — allSettled runs concurrently
+                    //     and returns aggregate results. The caller decides whether to await.
+                    // Q4: How does this relate to orchestrate.spawn? fanout is the N-task
+                    //     coordinator; spawn is the single-task primitive. fanout wraps spawn.
+                    // Q5: What is the manifestEntryId for? Correlates with fanout.status so
+                    //     the orchestrator can poll fanout progress across turns.
+                    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 result = await orchestrateFanout(items, projectRoot);
+                    return wrapResult(result, 'mutate', 'orchestrate', operation, startTime);
+                }
+                case 'tessera.instantiate': {
+                    const templateId = params?.templateId;
+                    const epicId = params?.epicId;
+                    if (!templateId) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'templateId is required', startTime);
+                    }
+                    if (!epicId) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_INVALID_INPUT', 'epicId is required', startTime);
+                    }
+                    const template = showTessera(templateId);
+                    if (!template) {
+                        return errorResult('mutate', 'orchestrate', operation, 'E_NOT_FOUND', `Tessera template "${templateId}" not found`, startTime);
+                    }
+                    const variables = params?.variables ?? {};
+                    const instance = await instantiateTessera(template, { templateId, epicId, variables: { epicId, ...variables } }, projectRoot);
+                    return {
+                        meta: dispatchMeta('mutate', 'orchestrate', operation, startTime),
+                        success: true,
+                        data: instance,
+                    };
+                }
+                // ADR-042: conduit sub-operations routed through orchestrate domain
+                case 'conduit.start':
+                    return conduitHandler.mutate('start', params);
+                case 'conduit.stop':
+                    return conduitHandler.mutate('stop', params);
+                case 'conduit.send':
+                    return conduitHandler.mutate('send', params);
+                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',
+                'bootstrap',
+                'unblock.opportunities',
+                'tessera.list',
+                // Wave 7a (T379)
+                'classify',
+                'fanout.status',
+                // ADR-042: conduit sub-operations
+                'conduit.status',
+                'conduit.peek',
+            ],
+            mutate: [
+                'start',
+                'spawn',
+                'handoff',
+                'spawn.execute',
+                'validate',
+                'parallel',
+                'tessera.instantiate',
+                // Wave 7a (T379)
+                'fanout',
+                // ADR-042: conduit sub-operations
+                'conduit.start',
+                'conduit.stop',
+                'conduit.send',
+            ],
+        };
+    }
+}
+/**
+ * T408 — Classify a request against the CANT team registry.
+ *
+ * Implementation: prompt-based reasoning stub. Reads team definitions from the
+ * canonical CANT workflows dir and performs substring matching against each
+ * team's `consult-when` hint. Returns the highest-scoring team.
+ *
+ * Real LLM-based routing will replace this in a later wave once the runtime
+ * bridge (W7b) has loaded `.cant` team definitions into memory.
+ *
+ * @param request - The request text to classify.
+ * @param context - Optional additional context.
+ * @param projectRoot - Project root directory.
+ * @returns EngineResult containing ClassifyResult.
+ */
+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();
+        // Walk .cant files and look for `consult-when:` entries.
+        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');
+                    // Extract team name
+                    const teamMatch = /^team\s+(\S+):/m.exec(src);
+                    if (!teamMatch)
+                        continue;
+                    const teamName = teamMatch[1];
+                    // Extract consult-when hint
+                    const cwMatch = /consult-when:\s*["']?(.+?)["']?\s*$/m.exec(src);
+                    const consultWhen = cwMatch ? cwMatch[1].trim() : '';
+                    // Extract stages
+                    const stagesMatch = /stages:\s*\[([^\]]+)\]/.exec(src);
+                    const stages = stagesMatch ? stagesMatch[1].split(',').map((s) => s.trim()) : [];
+                    // Simple substring scoring: count hint word matches in request
+                    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
+                }
+            }
+        }
+        // Also check project-local .cant files
+        const localCantDir = join(projectRoot, '.cleo', 'workflows');
+        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.',
+                },
+            };
+        }
+        // Pick the best match
+        matches.sort((a, b) => b.score - a.score);
+        const best = matches[0];
+        return {
+            success: true,
+            data: {
+                team: best.team,
+                lead: null, // lead resolution requires W7b runtime bridge
+                protocol: 'base-subagent', // default protocol stub
+                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),
+            },
+        };
+    }
+}
+/**
+ * In-process store for fanout manifest entries.
+ *
+ * Keyed by manifestEntryId (generated in orchestrateFanout).
+ * Populated when a fanout completes so that orchestrate.fanout.status
+ * can categorise results across orchestrator turns.
+ */
+/** 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.
+ * Map iteration order is insertion order, so deleting the first key
+ * removes the oldest entry.
+ */
+function evictFanoutManifest() {
+    while (fanoutManifestStore.size > FANOUT_MANIFEST_MAX_SIZE) {
+        const oldest = fanoutManifestStore.keys().next().value;
+        if (oldest !== undefined)
+            fanoutManifestStore.delete(oldest);
+    }
+}
+/**
+ * T409 / T433 — Fan out N spawn requests via Promise.allSettled.
+ *
+ * Each item is dispatched concurrently through orchestrateSpawnExecute
+ * (T432/W7a adapter registry path). Results are persisted in the
+ * in-process fanoutManifestStore so that orchestrate.fanout.status can
+ * categorise them across orchestrator turns.
+ *
+ * @param items - Array of fanout items to dispatch.
+ * @param projectRoot - Project root directory.
+ * @returns EngineResult with aggregated results and a manifest entry ID.
+ */
+async function orchestrateFanout(items, projectRoot) {
+    const manifestEntryId = `fanout-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        // Promise.allSettled wrapper — each item is processed concurrently via
+        // the adapter registry's orchestrateSpawnExecute path (T432/W7a wired).
+        const settled = await Promise.allSettled(items.map(async (item) => {
+            const spawnResult = await orchestrateSpawnExecute(item.taskId, 
+            /* adapterId */ undefined, 
+            /* protocolType */ undefined, projectRoot, 
+            /* tier */ 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),
+            };
+        });
+        // Persist results in the in-process manifest store so that
+        // orchestrate.fanout.status can categorise them across turns.
+        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.
+ *
+ * Walks `Task.depends` (stored as `blockers` in the accessor) to build a
+ * transitive dependency closure. Two tasks are parallel-safe if neither
+ * appears in the other's transitive closure.
+ *
+ * Returns `{parallelSafe: boolean, groups: string[][]}` where each group
+ * contains tasks with no intra-group dependency edges.
+ *
+ * @param taskIds - List of task IDs to analyze.
+ * @param projectRoot - Project root directory.
+ * @returns EngineResult with parallel safety analysis.
+ */
+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 ?? [];
+        // Build a lookup map from task ID to its direct dependencies.
+        const depMap = new Map();
+        for (const t of allTasks) {
+            // Tasks store deps in `blockers` field which maps to Task.depends.
+            const deps = t.blockers ?? [];
+            depMap.set(t.id, deps);
+        }
+        /**
+         * Compute the transitive dependency closure for a given task ID.
+         * Returns the set of all task IDs that `id` transitively depends on.
+         */
+        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;
+        }
+        // Build the closure for each task in the input set.
+        const closures = new Map();
+        for (const id of taskIds) {
+            closures.set(id, transitiveClose(id));
+        }
+        /**
+         * Two tasks are parallel-safe if:
+         * - neither appears in the other's transitive closure.
+         */
+        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);
+        }
+        // Greedy group assignment — assigns tasks to the first group where they
+        // are safe relative to all existing members.
+        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]);
+            }
+        }
+        const isFullyParallelSafe = groups.length <= 1;
+        return {
+            success: true,
+            data: {
+                parallelSafe: isFullyParallelSafe,
+                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),
+            },
+        };
+    }
+}
+//# sourceMappingURL=orchestrate.js.map