dartmind 17.0.0

package/dist/__tests__/orchestrator.test.js

@@ -0,0 +1,840 @@
+/**
+ * DartMind V17 - Orchestrator Tests
+ * Days 20-21: Orchestrator (I1)
+ *
+ * Tests for task orchestration, scheduling, and workflow management.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { 
+// Factory functions
+createTaskQueue, createHighConcurrencyQueue, createSingleThreadedQueue, createOrchestrator, createFullOrchestrator, createMinimalOrchestrator, 
+// Utility functions
+generateTaskId, generateWorkflowId, getPriorityLevel, comparePriority, isTerminalStatus, canRetry, calculateRetryDelay, createTask, createSuccessResult, createFailureResult, formatTaskStatus, formatTaskPriority, 
+// Constants
+DEFAULT_TASK_QUEUE_CONFIG, DEFAULT_ORCHESTRATOR_CONFIG, } from '../orchestrator/index.js';
+// ============================================================================
+// Utility Function Tests
+// ============================================================================
+describe('Orchestrator Utility Functions', () => {
+    describe('generateTaskId', () => {
+        it('should generate unique IDs', () => {
+            const id1 = generateTaskId();
+            const id2 = generateTaskId();
+            expect(id1).toMatch(/^task_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id2).toMatch(/^task_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id1).not.toBe(id2);
+        });
+    });
+    describe('generateWorkflowId', () => {
+        it('should generate unique workflow IDs', () => {
+            const id1 = generateWorkflowId();
+            const id2 = generateWorkflowId();
+            expect(id1).toMatch(/^wf_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id2).toMatch(/^wf_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id1).not.toBe(id2);
+        });
+    });
+    describe('getPriorityLevel', () => {
+        it('should return correct priority levels', () => {
+            expect(getPriorityLevel('low')).toBe(0);
+            expect(getPriorityLevel('normal')).toBe(1);
+            expect(getPriorityLevel('high')).toBe(2);
+            expect(getPriorityLevel('critical')).toBe(3);
+        });
+    });
+    describe('comparePriority', () => {
+        it('should compare priorities correctly', () => {
+            expect(comparePriority('low', 'high')).toBeGreaterThan(0);
+            expect(comparePriority('high', 'low')).toBeLessThan(0);
+            expect(comparePriority('normal', 'normal')).toBe(0);
+            expect(comparePriority('critical', 'low')).toBeLessThan(0);
+        });
+    });
+    describe('isTerminalStatus', () => {
+        it('should identify terminal statuses', () => {
+            expect(isTerminalStatus('completed')).toBe(true);
+            expect(isTerminalStatus('failed')).toBe(true);
+            expect(isTerminalStatus('cancelled')).toBe(true);
+            expect(isTerminalStatus('timeout')).toBe(true);
+        });
+        it('should identify non-terminal statuses', () => {
+            expect(isTerminalStatus('pending')).toBe(false);
+            expect(isTerminalStatus('queued')).toBe(false);
+            expect(isTerminalStatus('running')).toBe(false);
+            expect(isTerminalStatus('paused')).toBe(false);
+        });
+    });
+    describe('canRetry', () => {
+        it('should allow retry when count is below max', () => {
+            const task = createTask('test', 'analysis', {});
+            task.status = 'failed';
+            task.metadata.retryCount = 0;
+            task.metadata.maxRetries = 2;
+            expect(canRetry(task)).toBe(true);
+        });
+        it('should not allow retry when at max', () => {
+            const task = createTask('test', 'analysis', {});
+            task.status = 'failed';
+            task.metadata.retryCount = 2;
+            task.metadata.maxRetries = 2;
+            expect(canRetry(task)).toBe(false);
+        });
+        it('should not allow retry for non-failed tasks', () => {
+            const task = createTask('test', 'analysis', {});
+            task.status = 'completed';
+            task.metadata.retryCount = 0;
+            task.metadata.maxRetries = 2;
+            expect(canRetry(task)).toBe(false);
+        });
+    });
+    describe('calculateRetryDelay', () => {
+        it('should calculate exponential backoff', () => {
+            expect(calculateRetryDelay(0, 1000, 2)).toBe(1000);
+            expect(calculateRetryDelay(1, 1000, 2)).toBe(2000);
+            expect(calculateRetryDelay(2, 1000, 2)).toBe(4000);
+            expect(calculateRetryDelay(3, 1000, 2)).toBe(8000);
+        });
+        it('should handle different base delays', () => {
+            expect(calculateRetryDelay(1, 500, 2)).toBe(1000);
+            expect(calculateRetryDelay(1, 100, 3)).toBe(300);
+        });
+    });
+    describe('createTask', () => {
+        it('should create task with defaults', () => {
+            const task = createTask('test-task', 'analysis', { key: 'value' });
+            expect(task.id).toMatch(/^task_/);
+            expect(task.name).toBe('test-task');
+            expect(task.type).toBe('analysis');
+            expect(task.priority).toBe('normal');
+            expect(task.status).toBe('pending');
+            expect(task.payload).toEqual({ key: 'value' });
+            expect(task.metadata.createdAt).toBeLessThanOrEqual(Date.now());
+            expect(task.metadata.maxRetries).toBe(DEFAULT_TASK_QUEUE_CONFIG.defaultMaxRetries);
+            expect(task.dependencies).toEqual([]);
+            expect(task.childIds).toEqual([]);
+        });
+        it('should create task with options', () => {
+            const task = createTask('test-task', 'generation', { data: 123 }, {
+                priority: 'high',
+                timeoutMs: 60000,
+                maxRetries: 5,
+                dependencies: ['dep-1', 'dep-2'],
+                tags: ['tag1', 'tag2'],
+                source: 'test',
+                correlationId: 'corr-123',
+            });
+            expect(task.priority).toBe('high');
+            expect(task.metadata.timeoutMs).toBe(60000);
+            expect(task.metadata.maxRetries).toBe(5);
+            expect(task.dependencies).toEqual(['dep-1', 'dep-2']);
+            expect(task.tags).toEqual(['tag1', 'tag2']);
+            expect(task.metadata.source).toBe('test');
+            expect(task.metadata.correlationId).toBe('corr-123');
+        });
+    });
+    describe('createSuccessResult', () => {
+        it('should create success result', () => {
+            const result = createSuccessResult({ output: 'test' });
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ output: 'test' });
+            expect(result.error).toBeUndefined();
+        });
+        it('should create success result with options', () => {
+            const result = createSuccessResult({ output: 'test' }, { warnings: ['warning1'], cost: 0.5 });
+            expect(result.success).toBe(true);
+            expect(result.warnings).toEqual(['warning1']);
+            expect(result.cost).toBe(0.5);
+        });
+    });
+    describe('createFailureResult', () => {
+        it('should create failure result', () => {
+            const result = createFailureResult('Something went wrong', 'Error stack');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Something went wrong');
+            expect(result.stack).toBe('Error stack');
+        });
+    });
+    describe('formatTaskStatus', () => {
+        it('should format task status with colors', () => {
+            const formatted = formatTaskStatus('completed');
+            expect(formatted).toContain('COMPLETED');
+            expect(formatted).toContain('\x1b[32m'); // Green
+        });
+        it('should format failed status with red', () => {
+            const formatted = formatTaskStatus('failed');
+            expect(formatted).toContain('FAILED');
+            expect(formatted).toContain('\x1b[31m'); // Red
+        });
+    });
+    describe('formatTaskPriority', () => {
+        it('should format task priority with colors', () => {
+            const formatted = formatTaskPriority('critical');
+            expect(formatted).toContain('CRITICAL');
+            expect(formatted).toContain('\x1b[31m'); // Red
+        });
+        it('should format high priority with yellow', () => {
+            const formatted = formatTaskPriority('high');
+            expect(formatted).toContain('HIGH');
+            expect(formatted).toContain('\x1b[33m'); // Yellow
+        });
+    });
+});
+// ============================================================================
+// TaskQueue Tests
+// ============================================================================
+describe('TaskQueue', () => {
+    let queue;
+    beforeEach(() => {
+        queue = createTaskQueue();
+    });
+    afterEach(() => {
+        queue.dispose();
+    });
+    describe('Constructor', () => {
+        it('should create with default config', () => {
+            expect(queue.isProcessing()).toBe(false);
+            expect(queue.getQueuedTasks()).toHaveLength(0);
+        });
+        it('should create with custom config', () => {
+            const customQueue = createTaskQueue({
+                maxConcurrency: 5,
+                maxQueueSize: 50,
+            });
+            expect(customQueue).toBeDefined();
+            customQueue.dispose();
+        });
+    });
+    describe('Factory Functions', () => {
+        it('should create high concurrency queue', () => {
+            const highQueue = createHighConcurrencyQueue();
+            expect(highQueue).toBeDefined();
+            highQueue.dispose();
+        });
+        it('should create single threaded queue', () => {
+            const singleQueue = createSingleThreadedQueue();
+            expect(singleQueue).toBeDefined();
+            singleQueue.dispose();
+        });
+    });
+    describe('Executor Registration', () => {
+        it('should register executor', () => {
+            const executor = async (task) => {
+                return createSuccessResult({ done: true });
+            };
+            queue.registerExecutor('analysis', executor);
+            expect(queue.getExecutor('analysis')).toBe(executor);
+        });
+        it('should unregister executor', () => {
+            queue.registerExecutor('analysis', async () => createSuccessResult());
+            expect(queue.unregisterExecutor('analysis')).toBe(true);
+            expect(queue.getExecutor('analysis')).toBeUndefined();
+        });
+        it('should return false when unregistering non-existent executor', () => {
+            expect(queue.unregisterExecutor('nonexistent')).toBe(false);
+        });
+    });
+    describe('Enqueue', () => {
+        it('should enqueue task', () => {
+            const task = createTask('test', 'analysis', {});
+            const result = queue.enqueue(task);
+            expect(result).toBe(true);
+            expect(task.status).toBe('queued');
+            expect(task.metadata.queuedAt).toBeDefined();
+            expect(queue.getQueuedTasks()).toHaveLength(1);
+        });
+        it('should reject when queue is full', () => {
+            const smallQueue = createTaskQueue({ maxQueueSize: 2 });
+            const task1 = createTask('test1', 'analysis', {});
+            const task2 = createTask('test2', 'analysis', {});
+            const task3 = createTask('test3', 'analysis', {});
+            expect(smallQueue.enqueue(task1)).toBe(true);
+            expect(smallQueue.enqueue(task2)).toBe(true);
+            expect(smallQueue.enqueue(task3)).toBe(false);
+            smallQueue.dispose();
+        });
+        it('should deduplicate tasks when enabled', () => {
+            const dedupeQueue = createTaskQueue({ enableDeduplication: true });
+            const task1 = createTask('test', 'analysis', { key: 'value' });
+            const task2 = createTask('test', 'analysis', { key: 'value' });
+            expect(dedupeQueue.enqueue(task1)).toBe(true);
+            expect(dedupeQueue.enqueue(task2)).toBe(false);
+            expect(dedupeQueue.getQueuedTasks()).toHaveLength(1);
+            dedupeQueue.dispose();
+        });
+        it('should emit task:queued event', () => {
+            const events = [];
+            queue.onEvent((event) => { events.push(event); });
+            const task = createTask('test', 'analysis', {});
+            queue.enqueue(task);
+            expect(events).toHaveLength(1);
+            expect(events[0].type).toBe('task:queued');
+        });
+    });
+    describe('Priority Ordering', () => {
+        it('should dequeue high priority tasks first', () => {
+            const lowTask = createTask('low', 'analysis', {}, { priority: 'low' });
+            const highTask = createTask('high', 'analysis', {}, { priority: 'high' });
+            const normalTask = createTask('normal', 'analysis', {}, { priority: 'normal' });
+            queue.enqueue(lowTask);
+            queue.enqueue(normalTask);
+            queue.enqueue(highTask);
+            const first = queue.dequeue();
+            const second = queue.dequeue();
+            const third = queue.dequeue();
+            expect(first?.name).toBe('high');
+            expect(second?.name).toBe('normal');
+            expect(third?.name).toBe('low');
+        });
+        it('should respect critical priority', () => {
+            const normalTask = createTask('normal', 'analysis', {}, { priority: 'normal' });
+            const criticalTask = createTask('critical', 'analysis', {}, { priority: 'critical' });
+            queue.enqueue(normalTask);
+            queue.enqueue(criticalTask);
+            const first = queue.dequeue();
+            expect(first?.name).toBe('critical');
+        });
+    });
+    describe('Cancel', () => {
+        it('should cancel queued task', () => {
+            const task = createTask('test', 'analysis', {});
+            queue.enqueue(task);
+            const result = queue.cancel(task.id);
+            expect(result).toBe(true);
+            expect(task.status).toBe('cancelled');
+            expect(queue.getQueuedTasks()).toHaveLength(0);
+        });
+        it('should return false for non-existent task', () => {
+            expect(queue.cancel('nonexistent')).toBe(false);
+        });
+    });
+    describe('Task Lookup', () => {
+        it('should get task by ID from queue', () => {
+            const task = createTask('test', 'analysis', {});
+            queue.enqueue(task);
+            const found = queue.getTask(task.id);
+            expect(found).toBe(task);
+        });
+        it('should return undefined for non-existent task', () => {
+            expect(queue.getTask('nonexistent')).toBeUndefined();
+        });
+    });
+    describe('Task Execution', () => {
+        it('should execute task when started', async () => {
+            const task = createTask('test', 'analysis', {});
+            let executed = false;
+            queue.registerExecutor('analysis', async () => {
+                executed = true;
+                return createSuccessResult({ done: true });
+            });
+            queue.enqueue(task);
+            queue.start();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            expect(executed).toBe(true);
+            expect(task.status).toBe('completed');
+            expect(task.result?.success).toBe(true);
+        });
+        it('should handle task failure', async () => {
+            const task = createTask('test', 'analysis', {}, { maxRetries: 0 });
+            queue.registerExecutor('analysis', async () => {
+                throw new Error('Execution failed');
+            });
+            queue.enqueue(task);
+            queue.start();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            expect(task.status).toBe('failed');
+            expect(task.result?.success).toBe(false);
+            expect(task.result?.error).toContain('Execution failed');
+        });
+        it('should fail task when no executor registered', async () => {
+            const task = createTask('test', 'custom', {});
+            queue.enqueue(task);
+            queue.start();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            expect(task.status).toBe('failed');
+            expect(task.result?.error).toContain('No executor registered');
+        });
+        it('should retry failed task', async () => {
+            const task = createTask('test', 'analysis', {}, { maxRetries: 1 });
+            let attempts = 0;
+            queue.registerExecutor('analysis', async () => {
+                attempts++;
+                if (attempts === 1) {
+                    throw new Error('First attempt failed');
+                }
+                return createSuccessResult({ attempt: attempts });
+            });
+            const retryQueue = createTaskQueue({
+                retryDelayMs: 50,
+                retryBackoffMultiplier: 1,
+            });
+            retryQueue.registerExecutor('analysis', queue.getExecutor('analysis'));
+            retryQueue.enqueue(task);
+            retryQueue.start();
+            // Wait longer for retry cycle to complete (first attempt + retry delay + second attempt)
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            expect(attempts).toBe(2);
+            expect(task.status).toBe('completed');
+            retryQueue.dispose();
+        });
+    });
+    describe('Statistics', () => {
+        it('should track queue statistics', () => {
+            const stats = queue.getStats();
+            expect(stats.pending).toBe(0);
+            expect(stats.running).toBe(0);
+            expect(stats.completed).toBe(0);
+            expect(stats.failed).toBe(0);
+            expect(stats.cancelled).toBe(0);
+            expect(stats.totalProcessed).toBe(0);
+        });
+        it('should update stats on enqueue', () => {
+            const task = createTask('test', 'analysis', {});
+            queue.enqueue(task);
+            const stats = queue.getStats();
+            expect(stats.pending).toBe(1);
+        });
+        it('should reset statistics', () => {
+            queue.resetStats();
+            const stats = queue.getStats();
+            expect(stats.totalProcessed).toBe(0);
+        });
+    });
+    describe('Start/Stop', () => {
+        it('should start processing', () => {
+            queue.start();
+            expect(queue.isProcessing()).toBe(true);
+        });
+        it('should stop processing', () => {
+            queue.start();
+            queue.stop();
+            expect(queue.isProcessing()).toBe(false);
+        });
+    });
+});
+// ============================================================================
+// Orchestrator Tests
+// ============================================================================
+describe('Orchestrator', () => {
+    let orchestrator;
+    beforeEach(() => {
+        orchestrator = createOrchestrator();
+    });
+    afterEach(() => {
+        orchestrator.dispose();
+    });
+    describe('Constructor', () => {
+        it('should create with default config', () => {
+            expect(orchestrator.getState()).toBe('idle');
+            expect(orchestrator.getTotalCost()).toBe(0);
+        });
+        it('should create with custom config', () => {
+            const custom = createOrchestrator({
+                totalCostCeiling: 100,
+            });
+            expect(custom).toBeDefined();
+            custom.dispose();
+        });
+    });
+    describe('Factory Functions', () => {
+        it('should create full orchestrator', () => {
+            const full = createFullOrchestrator();
+            expect(full).toBeDefined();
+            full.dispose();
+        });
+        it('should create minimal orchestrator', () => {
+            const minimal = createMinimalOrchestrator();
+            expect(minimal).toBeDefined();
+            minimal.dispose();
+        });
+    });
+    describe('Lifecycle', () => {
+        it('should start orchestrator', () => {
+            orchestrator.start();
+            expect(orchestrator.getState()).toBe('running');
+            expect(orchestrator.isRunning()).toBe(true);
+        });
+        it('should stop orchestrator', () => {
+            orchestrator.start();
+            orchestrator.stop();
+            expect(orchestrator.getState()).toBe('stopped');
+            expect(orchestrator.isRunning()).toBe(false);
+        });
+        it('should pause orchestrator', () => {
+            orchestrator.start();
+            orchestrator.pause();
+            expect(orchestrator.getState()).toBe('paused');
+            expect(orchestrator.isRunning()).toBe(false);
+        });
+        it('should resume orchestrator', () => {
+            orchestrator.start();
+            orchestrator.pause();
+            orchestrator.resume();
+            expect(orchestrator.getState()).toBe('running');
+            expect(orchestrator.isRunning()).toBe(true);
+        });
+        it('should not start when already running', () => {
+            const events = [];
+            orchestrator.onEvent((event) => { events.push(event); });
+            orchestrator.start();
+            orchestrator.start();
+            const startEvents = events.filter((e) => e.type === 'orchestrator:started');
+            expect(startEvents).toHaveLength(1);
+        });
+        it('should emit lifecycle events', () => {
+            const events = [];
+            orchestrator.onEvent((event) => { events.push(event); });
+            orchestrator.start();
+            orchestrator.pause();
+            orchestrator.resume();
+            orchestrator.stop();
+            const types = events.map((e) => e.type);
+            expect(types).toContain('orchestrator:started');
+            expect(types).toContain('orchestrator:paused');
+            expect(types).toContain('orchestrator:resumed');
+            expect(types).toContain('orchestrator:stopped');
+        });
+    });
+    describe('Task Submission', () => {
+        it('should submit task', () => {
+            const task = orchestrator.submitTask('test', 'analysis', { key: 'value' });
+            expect(task).toBeDefined();
+            expect(task.name).toBe('test');
+            expect(task.type).toBe('analysis');
+            expect(task.payload).toEqual({ key: 'value' });
+        });
+        it('should submit task with options', () => {
+            const task = orchestrator.submitTask('test', 'generation', {}, {
+                priority: 'high',
+                timeoutMs: 30000,
+                maxRetries: 5,
+                tags: ['tag1'],
+            });
+            expect(task.priority).toBe('high');
+            expect(task.metadata.maxRetries).toBe(5);
+            expect(task.tags).toEqual(['tag1']);
+        });
+        it('should emit task:created event', () => {
+            const events = [];
+            orchestrator.onEvent((event) => { events.push(event); });
+            orchestrator.submitTask('test', 'analysis', {});
+            const createdEvent = events.find((e) => e.type === 'task:created');
+            expect(createdEvent).toBeDefined();
+        });
+        it('should submit multiple tasks', () => {
+            const tasks = orchestrator.submitTasks([
+                { name: 'task1', type: 'analysis', payload: {} },
+                { name: 'task2', type: 'generation', payload: {} },
+                { name: 'task3', type: 'review', payload: {} },
+            ]);
+            expect(tasks).toHaveLength(3);
+            expect(tasks[0].name).toBe('task1');
+            expect(tasks[1].name).toBe('task2');
+            expect(tasks[2].name).toBe('task3');
+        });
+    });
+    describe('Task Cancellation', () => {
+        it('should cancel task', () => {
+            const task = orchestrator.submitTask('test', 'analysis', {});
+            const result = orchestrator.cancelTask(task.id);
+            expect(result).toBe(true);
+        });
+        it('should return false for non-existent task', () => {
+            expect(orchestrator.cancelTask('nonexistent')).toBe(false);
+        });
+    });
+    describe('Task Lookup', () => {
+        it('should get task by ID', () => {
+            const task = orchestrator.submitTask('test', 'analysis', {});
+            const found = orchestrator.getTask(task.id);
+            expect(found).toBe(task);
+        });
+    });
+    describe('Task Execution', () => {
+        it('should execute task', async () => {
+            orchestrator.registerExecutor('analysis', async (task) => {
+                return createSuccessResult({ analyzed: true });
+            });
+            orchestrator.start();
+            const task = orchestrator.submitTask('test', 'analysis', {});
+            const completed = await orchestrator.waitForTask(task.id, 1000);
+            expect(completed).toBeDefined();
+            expect(completed?.status).toBe('completed');
+            expect(completed?.result?.data).toEqual({ analyzed: true });
+        });
+        it('should handle execution failure', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                throw new Error('Analysis failed');
+            });
+            orchestrator.start();
+            // Explicitly set maxRetries: 0 to fail immediately without retry
+            const task = orchestrator.submitTask('test', 'analysis', {}, { maxRetries: 0 });
+            const completed = await orchestrator.waitForTask(task.id, 1000);
+            expect(completed?.status).toBe('failed');
+            expect(completed?.result?.error).toContain('Analysis failed');
+        });
+        it('should return undefined on timeout', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                return createSuccessResult();
+            });
+            orchestrator.start();
+            const task = orchestrator.submitTask('test', 'analysis', {});
+            const completed = await orchestrator.waitForTask(task.id, 50);
+            expect(completed).toBeUndefined();
+        });
+    });
+    describe('Executor Registration', () => {
+        it('should register executor', () => {
+            const executor = async (task) => {
+                return createSuccessResult();
+            };
+            orchestrator.registerExecutor('analysis', executor);
+            // Executor is registered on internal task queue
+        });
+        it('should unregister executor', () => {
+            orchestrator.registerExecutor('analysis', async () => createSuccessResult());
+            const result = orchestrator.unregisterExecutor('analysis');
+            expect(result).toBe(true);
+        });
+    });
+    describe('Hooks', () => {
+        it('should run beforeQueue hook', () => {
+            let hookCalled = false;
+            orchestrator.addHook('beforeQueue', (task) => {
+                hookCalled = true;
+                expect(task.name).toBe('test');
+            });
+            orchestrator.submitTask('test', 'analysis', {});
+            expect(hookCalled).toBe(true);
+        });
+        it('should run afterQueue hook', () => {
+            let hookCalled = false;
+            orchestrator.addHook('afterQueue', () => {
+                hookCalled = true;
+            });
+            orchestrator.submitTask('test', 'analysis', {});
+            expect(hookCalled).toBe(true);
+        });
+        it('should remove hook', () => {
+            const hook = () => { };
+            orchestrator.addHook('beforeQueue', hook);
+            const removed = orchestrator.removeHook('beforeQueue', hook);
+            expect(removed).toBe(true);
+        });
+        it('should return false when removing non-existent hook', () => {
+            const removed = orchestrator.removeHook('beforeQueue', () => { });
+            expect(removed).toBe(false);
+        });
+    });
+    describe('Workflow Management', () => {
+        it('should create workflow', () => {
+            const workflow = orchestrator.createWorkflow('test-workflow', [
+                {
+                    name: 'step1',
+                    taskType: 'analysis',
+                    optional: false,
+                },
+                {
+                    name: 'step2',
+                    taskType: 'generation',
+                    optional: false,
+                },
+            ]);
+            expect(workflow.id).toMatch(/^wf_/);
+            expect(workflow.name).toBe('test-workflow');
+            expect(workflow.steps).toHaveLength(2);
+            expect(workflow.status).toBe('pending');
+            expect(workflow.currentStep).toBe(0);
+        });
+        it('should get workflow by ID', () => {
+            const workflow = orchestrator.createWorkflow('test', []);
+            const found = orchestrator.getWorkflow(workflow.id);
+            expect(found).toBe(workflow);
+        });
+        it('should list workflows', () => {
+            orchestrator.createWorkflow('workflow1', []);
+            orchestrator.createWorkflow('workflow2', []);
+            orchestrator.createWorkflow('workflow3', []);
+            const workflows = orchestrator.listWorkflows();
+            expect(workflows).toHaveLength(3);
+        });
+        it('should run workflow', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                return createSuccessResult({ analyzed: true });
+            });
+            orchestrator.registerExecutor('generation', async () => {
+                return createSuccessResult({ generated: true });
+            });
+            orchestrator.start();
+            const workflow = orchestrator.createWorkflow('test-workflow', [
+                { name: 'analyze', taskType: 'analysis', optional: false },
+                { name: 'generate', taskType: 'generation', optional: false },
+            ]);
+            const completed = await orchestrator.runWorkflow(workflow.id);
+            expect(completed.status).toBe('completed');
+            expect(completed.context.analyzed).toBe(true);
+            expect(completed.context.generated).toBe(true);
+        });
+        it('should handle workflow step failure', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                return createFailureResult('Analysis failed');
+            });
+            orchestrator.start();
+            const workflow = orchestrator.createWorkflow('test-workflow', [
+                { name: 'analyze', taskType: 'analysis', optional: false },
+            ]);
+            const completed = await orchestrator.runWorkflow(workflow.id);
+            expect(completed.status).toBe('failed');
+        });
+        it('should skip optional failed steps', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                return createFailureResult('Analysis failed');
+            });
+            orchestrator.registerExecutor('generation', async () => {
+                return createSuccessResult({ generated: true });
+            });
+            orchestrator.start();
+            const workflow = orchestrator.createWorkflow('test-workflow', [
+                { name: 'analyze', taskType: 'analysis', optional: true },
+                { name: 'generate', taskType: 'generation', optional: false },
+            ]);
+            const completed = await orchestrator.runWorkflow(workflow.id);
+            expect(completed.status).toBe('completed');
+            expect(completed.context.generated).toBe(true);
+        });
+        it('should run condition function', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                return createSuccessResult({ shouldGenerate: false });
+            });
+            orchestrator.registerExecutor('generation', async () => {
+                return createSuccessResult({ generated: true });
+            });
+            orchestrator.start();
+            const workflow = orchestrator.createWorkflow('test-workflow', [
+                { name: 'analyze', taskType: 'analysis', optional: false },
+                {
+                    name: 'generate',
+                    taskType: 'generation',
+                    optional: true,
+                    conditionFn: (ctx) => ctx.shouldGenerate === true,
+                },
+            ]);
+            const completed = await orchestrator.runWorkflow(workflow.id);
+            expect(completed.status).toBe('completed');
+            expect(completed.context.generated).toBeUndefined();
+        });
+        it('should cancel workflow', () => {
+            const workflow = orchestrator.createWorkflow('test', []);
+            const result = orchestrator.cancelWorkflow(workflow.id);
+            expect(result).toBe(true);
+            expect(workflow.status).toBe('cancelled');
+        });
+        it('should throw for non-existent workflow', async () => {
+            await expect(orchestrator.runWorkflow('nonexistent')).rejects.toThrow('Workflow not found');
+        });
+    });
+    describe('Cost Tracking', () => {
+        it('should track task cost', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                return createSuccessResult({}, { cost: 0.5 });
+            });
+            orchestrator.start();
+            const task = orchestrator.submitTask('test', 'analysis', {});
+            await orchestrator.waitForTask(task.id, 1000);
+            expect(orchestrator.getTotalCost()).toBe(0.5);
+        });
+        it('should reset cost', async () => {
+            orchestrator.registerExecutor('analysis', async () => {
+                return createSuccessResult({}, { cost: 1.0 });
+            });
+            orchestrator.start();
+            await orchestrator.waitForTask(orchestrator.submitTask('test', 'analysis', {}).id, 1000);
+            orchestrator.resetCost();
+            expect(orchestrator.getTotalCost()).toBe(0);
+        });
+        it('should reject task when cost ceiling exceeded', () => {
+            const lowCeilingOrch = createOrchestrator({
+                totalCostCeiling: 1.0,
+            });
+            // Manually set cost above ceiling
+            lowCeilingOrch.totalCost = 1.5;
+            const task = lowCeilingOrch.submitTask('test', 'analysis', {});
+            expect(task.status).toBe('failed');
+            expect(task.result?.error).toContain('cost ceiling exceeded');
+            lowCeilingOrch.dispose();
+        });
+        it('should emit cost warning', async () => {
+            const events = [];
+            const lowCeilingOrch = createOrchestrator({
+                totalCostCeiling: 1.0,
+            });
+            lowCeilingOrch.onEvent((event) => { events.push(event); });
+            lowCeilingOrch.registerExecutor('analysis', async () => {
+                return createSuccessResult({}, { cost: 0.9 });
+            });
+            lowCeilingOrch.start();
+            await lowCeilingOrch.waitForTask(lowCeilingOrch.submitTask('test', 'analysis', {}).id, 1000);
+            const warningEvent = events.find((e) => e.type === 'cost:warning');
+            expect(warningEvent).toBeDefined();
+            lowCeilingOrch.dispose();
+        });
+    });
+    describe('Statistics', () => {
+        it('should get orchestrator stats', () => {
+            const stats = orchestrator.getStats();
+            expect(stats.state).toBe('idle');
+            expect(stats.uptime).toBe(0);
+            expect(stats.totalCost).toBe(0);
+            expect(stats.costCeiling).toBe(DEFAULT_ORCHESTRATOR_CONFIG.totalCostCeiling);
+            expect(stats.queueStats).toBeDefined();
+            expect(stats.workflows).toBeDefined();
+        });
+        it('should track uptime when running', () => {
+            orchestrator.start();
+            // Small delay to ensure uptime > 0
+            const stats = orchestrator.getStats();
+            expect(stats.uptime).toBeGreaterThanOrEqual(0);
+        });
+        it('should track workflow counts', () => {
+            orchestrator.createWorkflow('w1', []);
+            orchestrator.createWorkflow('w2', []);
+            const stats = orchestrator.getStats();
+            expect(stats.workflows.total).toBe(2);
+        });
+    });
+    describe('Dispose', () => {
+        it('should clean up resources', () => {
+            orchestrator.start();
+            orchestrator.createWorkflow('test', []);
+            orchestrator.dispose();
+            expect(orchestrator.getState()).toBe('stopped');
+            expect(orchestrator.listWorkflows()).toHaveLength(0);
+        });
+    });
+});
+// ============================================================================
+// Default Configuration Tests
+// ============================================================================
+describe('Default Configurations', () => {
+    describe('DEFAULT_TASK_QUEUE_CONFIG', () => {
+        it('should have expected values', () => {
+            expect(DEFAULT_TASK_QUEUE_CONFIG.maxConcurrency).toBe(3);
+            expect(DEFAULT_TASK_QUEUE_CONFIG.maxQueueSize).toBe(100);
+            expect(DEFAULT_TASK_QUEUE_CONFIG.defaultTimeoutMs).toBe(300000);
+            expect(DEFAULT_TASK_QUEUE_CONFIG.defaultMaxRetries).toBe(2);
+            expect(DEFAULT_TASK_QUEUE_CONFIG.enablePriority).toBe(true);
+            expect(DEFAULT_TASK_QUEUE_CONFIG.enableDeduplication).toBe(true);
+        });
+    });
+    describe('DEFAULT_ORCHESTRATOR_CONFIG', () => {
+        it('should have expected values', () => {
+            expect(DEFAULT_ORCHESTRATOR_CONFIG.enabled).toBe(true);
+            expect(DEFAULT_ORCHESTRATOR_CONFIG.enableGateChecks).toBe(true);
+            expect(DEFAULT_ORCHESTRATOR_CONFIG.enableCriticReview).toBe(true);
+            expect(DEFAULT_ORCHESTRATOR_CONFIG.enableApprovalWorkflow).toBe(false);
+            expect(DEFAULT_ORCHESTRATOR_CONFIG.costCeilingPerTask).toBe(2.0);
+            expect(DEFAULT_ORCHESTRATOR_CONFIG.totalCostCeiling).toBe(50.0);
+        });
+    });
+});
+//# sourceMappingURL=orchestrator.test.js.map