@renseiai/agentfactory 0.8.7 → 0.8.9

package/dist/src/workflow/strategies/fan-in-strategy.js

@@ -0,0 +1,92 @@
+/**
+ * Fan-in parallelism strategy.
+ *
+ * Dispatches N agents in parallel and waits for results.
+ *
+ * When `waitForAll` is true (default): waits for ALL tasks to settle
+ * using Promise.allSettled() semantics.
+ *
+ * When `waitForAll` is false: resolves on the first successful result,
+ * but still waits for all remaining tasks to complete for full result
+ * collection.
+ *
+ * NOTE: Concurrency limiting (maxConcurrent) is handled by the
+ * ConcurrencySemaphore in the ParallelismExecutor — this strategy
+ * simply calls `options.dispatch()` for each task.
+ */
+export class FanInStrategy {
+    async execute(tasks, options) {
+        const completed = [];
+        const failed = [];
+        const outputs = {};
+        const waitForAll = options.waitForAll !== false; // default true
+        // Dispatch all tasks, wrapping each result
+        const taskPromises = tasks.map((task) => options.dispatch(task).then((result) => ({ status: 'fulfilled', value: result }), (error) => ({ status: 'rejected', reason: error, task })));
+        if (waitForAll) {
+            // Wait for all tasks to settle
+            const results = await Promise.allSettled(taskPromises);
+            for (const result of results) {
+                if (result.status === 'fulfilled') {
+                    const settled = result.value;
+                    if (settled.status === 'fulfilled') {
+                        completed.push(settled.value);
+                        if (settled.value.outputs) {
+                            outputs[settled.value.issueId] = settled.value.outputs;
+                        }
+                    }
+                    else {
+                        const errMsg = settled.reason instanceof Error
+                            ? settled.reason.message
+                            : String(settled.reason);
+                        failed.push({
+                            id: settled.task.id,
+                            issueId: settled.task.issueId,
+                            error: errMsg,
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            // Wait for first success, then collect remaining
+            let firstSuccessResolve = null;
+            const firstSuccessPromise = new Promise((resolve) => {
+                firstSuccessResolve = resolve;
+            });
+            let pendingCount = taskPromises.length;
+            let hasSuccess = false;
+            const wrappedPromises = taskPromises.map(async (promise) => {
+                const result = await promise;
+                if (result.status === 'fulfilled') {
+                    completed.push(result.value);
+                    if (result.value.outputs) {
+                        outputs[result.value.issueId] = result.value.outputs;
+                    }
+                    if (!hasSuccess && result.value.success) {
+                        hasSuccess = true;
+                        firstSuccessResolve?.(result.value);
+                    }
+                }
+                else {
+                    const errMsg = result.reason instanceof Error
+                        ? result.reason.message
+                        : String(result.reason);
+                    failed.push({
+                        id: result.task.id,
+                        issueId: result.task.issueId,
+                        error: errMsg,
+                    });
+                }
+                pendingCount--;
+                if (pendingCount === 0 && !hasSuccess) {
+                    firstSuccessResolve?.(null);
+                }
+            });
+            // Wait for first success or all to complete
+            await firstSuccessPromise;
+            // Still wait for all remaining to finish
+            await Promise.allSettled(wrappedPromises);
+        }
+        return { strategy: 'fan-in', completed, cancelled: [], failed, outputs };
+    }
+}

package/dist/src/workflow/strategies/fan-in-strategy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fan-in-strategy.test.d.ts.map

package/dist/src/workflow/strategies/fan-in-strategy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fan-in-strategy.test.d.ts","sourceRoot":"","sources":["../../../../src/workflow/strategies/fan-in-strategy.test.ts"],"names":[],"mappings":""}

package/dist/src/workflow/strategies/fan-in-strategy.test.js

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { FanInStrategy } from './fan-in-strategy.js';
+/** Helper: create sample tasks */
+function createTasks(count) {
+    return Array.from({ length: count }, (_, i) => ({
+        id: `task-${i + 1}`,
+        issueId: `SUP-${100 + i + 1}`,
+        phaseName: 'development',
+    }));
+}
+/** Helper: create a dispatch that returns success */
+function createSuccessDispatch() {
+    return async (task) => ({
+        id: task.id,
+        issueId: task.issueId,
+        success: true,
+        durationMs: 10,
+    });
+}
+/** Helper: create options with a dispatch function */
+function createOptions(dispatch, overrides = {}) {
+    return { dispatch, ...overrides };
+}
+describe('FanInStrategy', () => {
+    describe('waitForAll=true', () => {
+        it('waits for all tasks to complete', async () => {
+            const strategy = new FanInStrategy();
+            const tasks = createTasks(3);
+            const completionOrder = [];
+            const dispatch = async (task) => {
+                // Stagger completion times
+                const delay = task.id === 'task-1' ? 30 : task.id === 'task-2' ? 10 : 20;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                completionOrder.push(task.id);
+                return { id: task.id, issueId: task.issueId, success: true };
+            };
+            const result = await strategy.execute(tasks, createOptions(dispatch, { waitForAll: true }));
+            // All three tasks should be completed
+            expect(result.completed).toHaveLength(3);
+            // The result should include all task IDs
+            const completedIds = result.completed.map((r) => r.id).sort();
+            expect(completedIds).toEqual(['task-1', 'task-2', 'task-3']);
+        });
+        it('handles mix of success and failure', async () => {
+            const strategy = new FanInStrategy();
+            const tasks = createTasks(4);
+            const dispatch = async (task) => {
+                if (task.id === 'task-2' || task.id === 'task-4') {
+                    throw new Error(`failed: ${task.id}`);
+                }
+                return { id: task.id, issueId: task.issueId, success: true };
+            };
+            const result = await strategy.execute(tasks, createOptions(dispatch, { waitForAll: true }));
+            expect(result.completed).toHaveLength(2);
+            expect(result.failed).toHaveLength(2);
+            const completedIds = result.completed.map((r) => r.id).sort();
+            expect(completedIds).toEqual(['task-1', 'task-3']);
+            const failedIds = result.failed.map((r) => r.id).sort();
+            expect(failedIds).toEqual(['task-2', 'task-4']);
+            expect(result.failed.find((f) => f.id === 'task-2')?.error).toBe('failed: task-2');
+        });
+    });
+    describe('waitForAll=false', () => {
+        it('resolves after first success', async () => {
+            const strategy = new FanInStrategy();
+            const tasks = createTasks(3);
+            const dispatch = async (task) => {
+                // task-2 completes first with success
+                const delay = task.id === 'task-1' ? 50 : task.id === 'task-2' ? 10 : 50;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return { id: task.id, issueId: task.issueId, success: true };
+            };
+            const result = await strategy.execute(tasks, createOptions(dispatch, { waitForAll: false }));
+            // All tasks should still be collected (we wait for remaining after first success)
+            expect(result.completed).toHaveLength(3);
+            expect(result.strategy).toBe('fan-in');
+        });
+        it('all fail returns failure result', async () => {
+            const strategy = new FanInStrategy();
+            const tasks = createTasks(3);
+            const dispatch = async (task) => {
+                throw new Error(`failed: ${task.id}`);
+            };
+            const result = await strategy.execute(tasks, createOptions(dispatch, { waitForAll: false }));
+            expect(result.completed).toHaveLength(0);
+            expect(result.failed).toHaveLength(3);
+        });
+    });
+    it('collects outputs from completed tasks', async () => {
+        const strategy = new FanInStrategy();
+        const tasks = createTasks(2);
+        const dispatch = async (task) => ({
+            id: task.id,
+            issueId: task.issueId,
+            success: true,
+            outputs: { artifact: `build-${task.id}` },
+        });
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        expect(result.outputs['SUP-101']).toEqual({ artifact: 'build-task-1' });
+        expect(result.outputs['SUP-102']).toEqual({ artifact: 'build-task-2' });
+    });
+    it('maxConcurrent=2 with 5 tasks verifies queuing behavior', async () => {
+        // Note: The actual concurrency limiting is done by the ParallelismExecutor's
+        // semaphore wrapping the dispatch function. This test verifies that the
+        // strategy works correctly with a dispatch that simulates semaphore behavior.
+        const strategy = new FanInStrategy();
+        const tasks = createTasks(5);
+        let peakConcurrent = 0;
+        let currentConcurrent = 0;
+        const taskOrder = [];
+        // Simulate the semaphore-wrapped dispatch behavior
+        const maxConcurrent = 2;
+        let activeSlots = 0;
+        const waitQueue = [];
+        const dispatch = async (task) => {
+            // Simulate semaphore acquire
+            if (activeSlots >= maxConcurrent) {
+                await new Promise((resolve) => waitQueue.push(resolve));
+            }
+            activeSlots++;
+            currentConcurrent++;
+            peakConcurrent = Math.max(peakConcurrent, currentConcurrent);
+            taskOrder.push(`start:${task.id}`);
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            taskOrder.push(`end:${task.id}`);
+            currentConcurrent--;
+            activeSlots--;
+            // Simulate semaphore release
+            if (waitQueue.length > 0) {
+                const next = waitQueue.shift();
+                next();
+            }
+            return { id: task.id, issueId: task.issueId, success: true };
+        };
+        const result = await strategy.execute(tasks, createOptions(dispatch, { maxConcurrent: 2 }));
+        expect(result.completed).toHaveLength(5);
+        expect(peakConcurrent).toBeLessThanOrEqual(2);
+        // Verify at no point more than 2 tasks are active
+        let active = 0;
+        for (const entry of taskOrder) {
+            if (entry.startsWith('start:'))
+                active++;
+            if (entry.startsWith('end:'))
+                active--;
+            expect(active).toBeLessThanOrEqual(2);
+        }
+    });
+    it('returns empty result for empty task list', async () => {
+        const strategy = new FanInStrategy();
+        const dispatch = createSuccessDispatch();
+        const result = await strategy.execute([], createOptions(dispatch));
+        expect(result.completed).toEqual([]);
+        expect(result.failed).toEqual([]);
+        expect(result.cancelled).toEqual([]);
+        expect(result.outputs).toEqual({});
+    });
+    it('sets strategy to fan-in', async () => {
+        const strategy = new FanInStrategy();
+        const tasks = createTasks(1);
+        const dispatch = createSuccessDispatch();
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        expect(result.strategy).toBe('fan-in');
+    });
+    it('defaults to waitForAll=true when not specified', async () => {
+        const strategy = new FanInStrategy();
+        const tasks = createTasks(3);
+        const completionOrder = [];
+        const dispatch = async (task) => {
+            // Stagger completion: task-3 finishes first, task-1 last
+            const delay = task.id === 'task-1' ? 30 : task.id === 'task-2' ? 20 : 10;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            completionOrder.push(task.id);
+            return { id: task.id, issueId: task.issueId, success: true };
+        };
+        // Do NOT pass waitForAll — it should default to true
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        // All three should complete since default is waitForAll=true
+        expect(result.completed).toHaveLength(3);
+        const completedIds = result.completed.map((r) => r.id).sort();
+        expect(completedIds).toEqual(['task-1', 'task-2', 'task-3']);
+    });
+});

package/dist/src/workflow/strategies/fan-out-strategy.d.ts

@@ -0,0 +1,16 @@
+import type { ParallelTask, ParallelismResult, ParallelismStrategy, ParallelismStrategyOptions } from '../parallelism-types.js';
+/**
+ * Fan-out parallelism strategy.
+ *
+ * Dispatches N agents in parallel without waiting for completion.
+ * All dispatches are initiated concurrently and results are collected
+ * from whatever settles during the dispatch window.
+ *
+ * NOTE: Concurrency limiting (maxConcurrent) is handled by the
+ * ConcurrencySemaphore in the ParallelismExecutor — this strategy
+ * simply calls `options.dispatch()` for each task.
+ */
+export declare class FanOutStrategy implements ParallelismStrategy {
+    execute(tasks: ParallelTask[], options: ParallelismStrategyOptions): Promise<ParallelismResult>;
+}
+//# sourceMappingURL=fan-out-strategy.d.ts.map

package/dist/src/workflow/strategies/fan-out-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fan-out-strategy.d.ts","sourceRoot":"","sources":["../../../../src/workflow/strategies/fan-out-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAGZ,iBAAiB,EACjB,mBAAmB,EACnB,0BAA0B,EAC3B,MAAM,yBAAyB,CAAA;AAEhC;;;;;;;;;;GAUG;AACH,qBAAa,cAAe,YAAW,mBAAmB;IAClD,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,iBAAiB,CAAC;CA2C9B"}

package/dist/src/workflow/strategies/fan-out-strategy.js

@@ -0,0 +1,47 @@
+/**
+ * Fan-out parallelism strategy.
+ *
+ * Dispatches N agents in parallel without waiting for completion.
+ * All dispatches are initiated concurrently and results are collected
+ * from whatever settles during the dispatch window.
+ *
+ * NOTE: Concurrency limiting (maxConcurrent) is handled by the
+ * ConcurrencySemaphore in the ParallelismExecutor — this strategy
+ * simply calls `options.dispatch()` for each task.
+ */
+export class FanOutStrategy {
+    async execute(tasks, options) {
+        const completed = [];
+        const failed = [];
+        const outputs = {};
+        // Fire all dispatches concurrently but don't wait for them
+        // Use Promise.allSettled with a short window to catch immediate failures
+        const dispatchPromises = tasks.map((task) => options.dispatch(task).then((result) => ({ status: 'fulfilled', value: result, task }), (error) => ({ status: 'rejected', reason: error, task })));
+        // Wait for all dispatches to settle — since we already wrapped each
+        // promise, Promise.allSettled here will always return 'fulfilled' results
+        // containing our inner status objects.
+        const results = await Promise.allSettled(dispatchPromises);
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                const settled = result.value;
+                if (settled.status === 'fulfilled') {
+                    completed.push(settled.value);
+                    if (settled.value.outputs) {
+                        outputs[settled.value.issueId] = settled.value.outputs;
+                    }
+                }
+                else {
+                    const errMsg = settled.reason instanceof Error
+                        ? settled.reason.message
+                        : String(settled.reason);
+                    failed.push({
+                        id: settled.task.id,
+                        issueId: settled.task.issueId,
+                        error: errMsg,
+                    });
+                }
+            }
+        }
+        return { strategy: 'fan-out', completed, cancelled: [], failed, outputs };
+    }
+}

package/dist/src/workflow/strategies/fan-out-strategy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fan-out-strategy.test.d.ts.map

package/dist/src/workflow/strategies/fan-out-strategy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fan-out-strategy.test.d.ts","sourceRoot":"","sources":["../../../../src/workflow/strategies/fan-out-strategy.test.ts"],"names":[],"mappings":""}

package/dist/src/workflow/strategies/fan-out-strategy.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest';
+import { FanOutStrategy } from './fan-out-strategy.js';
+/** Helper: create sample tasks */
+function createTasks(count) {
+    return Array.from({ length: count }, (_, i) => ({
+        id: `task-${i + 1}`,
+        issueId: `SUP-${100 + i + 1}`,
+        phaseName: 'development',
+    }));
+}
+/** Helper: create a dispatch that returns success */
+function createSuccessDispatch() {
+    return async (task) => ({
+        id: task.id,
+        issueId: task.issueId,
+        success: true,
+        durationMs: 10,
+    });
+}
+/** Helper: create options with a dispatch function */
+function createOptions(dispatch, overrides = {}) {
+    return { dispatch, ...overrides };
+}
+describe('FanOutStrategy', () => {
+    it('dispatches all tasks and returns results', async () => {
+        const strategy = new FanOutStrategy();
+        const tasks = createTasks(3);
+        const dispatched = [];
+        const dispatch = async (task) => {
+            dispatched.push(task.id);
+            return { id: task.id, issueId: task.issueId, success: true };
+        };
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        expect(dispatched).toEqual(['task-1', 'task-2', 'task-3']);
+        expect(result.completed).toHaveLength(3);
+        expect(result.completed[0].issueId).toBe('SUP-101');
+        expect(result.completed[1].issueId).toBe('SUP-102');
+        expect(result.completed[2].issueId).toBe('SUP-103');
+    });
+    it('handles dispatch failures gracefully', async () => {
+        const strategy = new FanOutStrategy();
+        const tasks = createTasks(3);
+        const dispatch = async (task) => {
+            if (task.id === 'task-2') {
+                throw new Error('dispatch failed for task-2');
+            }
+            return { id: task.id, issueId: task.issueId, success: true };
+        };
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        expect(result.completed).toHaveLength(2);
+        expect(result.failed).toHaveLength(1);
+        expect(result.failed[0].id).toBe('task-2');
+        expect(result.failed[0].issueId).toBe('SUP-102');
+        expect(result.failed[0].error).toBe('dispatch failed for task-2');
+    });
+    it('collects outputs from successful tasks', async () => {
+        const strategy = new FanOutStrategy();
+        const tasks = createTasks(2);
+        const dispatch = async (task) => ({
+            id: task.id,
+            issueId: task.issueId,
+            success: true,
+            outputs: { artifact: `build-${task.id}` },
+        });
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        expect(result.outputs['SUP-101']).toEqual({ artifact: 'build-task-1' });
+        expect(result.outputs['SUP-102']).toEqual({ artifact: 'build-task-2' });
+    });
+    it('returns empty result for empty task list', async () => {
+        const strategy = new FanOutStrategy();
+        const dispatch = createSuccessDispatch();
+        const result = await strategy.execute([], createOptions(dispatch));
+        expect(result.completed).toEqual([]);
+        expect(result.failed).toEqual([]);
+        expect(result.cancelled).toEqual([]);
+        expect(result.outputs).toEqual({});
+    });
+    it('sets strategy to fan-out', async () => {
+        const strategy = new FanOutStrategy();
+        const tasks = createTasks(1);
+        const dispatch = createSuccessDispatch();
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        expect(result.strategy).toBe('fan-out');
+    });
+    it('cancelled array is always empty', async () => {
+        const strategy = new FanOutStrategy();
+        const tasks = createTasks(3);
+        const dispatch = async (task) => {
+            if (task.id === 'task-2') {
+                throw new Error('failed');
+            }
+            return { id: task.id, issueId: task.issueId, success: true };
+        };
+        const result = await strategy.execute(tasks, createOptions(dispatch));
+        expect(result.cancelled).toEqual([]);
+    });
+});

package/dist/src/workflow/strategies/index.d.ts

@@ -0,0 +1,4 @@
+export { FanOutStrategy } from './fan-out-strategy.js';
+export { FanInStrategy } from './fan-in-strategy.js';
+export { RaceStrategy } from './race-strategy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/workflow/strategies/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/workflow/strategies/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/src/workflow/strategies/index.js

@@ -0,0 +1,3 @@
+export { FanOutStrategy } from './fan-out-strategy.js';
+export { FanInStrategy } from './fan-in-strategy.js';
+export { RaceStrategy } from './race-strategy.js';

package/dist/src/workflow/strategies/race-strategy.d.ts

@@ -0,0 +1,19 @@
+import type { ParallelTask, ParallelismResult, ParallelismStrategy, ParallelismStrategyOptions } from '../parallelism-types.js';
+import { InMemoryAgentCancellation } from '../agent-cancellation.js';
+/**
+ * Race parallelism strategy.
+ *
+ * Dispatches N agents in parallel. The first successful completion wins,
+ * and cancellation is signaled for all remaining tasks.
+ *
+ * NOTE: Concurrency limiting (maxConcurrent) is handled by the
+ * ConcurrencySemaphore in the ParallelismExecutor — this strategy
+ * simply calls `options.dispatch()` for each task.
+ */
+export declare class RaceStrategy implements ParallelismStrategy {
+    private readonly cancellation;
+    private readonly cancellationTimeoutMs;
+    constructor(cancellation?: InMemoryAgentCancellation, cancellationTimeoutMs?: number);
+    execute(tasks: ParallelTask[], options: ParallelismStrategyOptions): Promise<ParallelismResult>;
+}
+//# sourceMappingURL=race-strategy.d.ts.map

package/dist/src/workflow/strategies/race-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"race-strategy.d.ts","sourceRoot":"","sources":["../../../../src/workflow/strategies/race-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAGZ,iBAAiB,EACjB,mBAAmB,EACnB,0BAA0B,EAC3B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAA;AAEpE;;;;;;;;;GASG;AACH,qBAAa,YAAa,YAAW,mBAAmB;IACtD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA2B;IACxD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;gBAElC,YAAY,CAAC,EAAE,yBAAyB,EAAE,qBAAqB,CAAC,EAAE,MAAM;IAK9E,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,iBAAiB,CAAC;CA4F9B"}

package/dist/src/workflow/strategies/race-strategy.js

@@ -0,0 +1,92 @@
+import { InMemoryAgentCancellation } from '../agent-cancellation.js';
+/**
+ * Race parallelism strategy.
+ *
+ * Dispatches N agents in parallel. The first successful completion wins,
+ * and cancellation is signaled for all remaining tasks.
+ *
+ * NOTE: Concurrency limiting (maxConcurrent) is handled by the
+ * ConcurrencySemaphore in the ParallelismExecutor — this strategy
+ * simply calls `options.dispatch()` for each task.
+ */
+export class RaceStrategy {
+    cancellation;
+    cancellationTimeoutMs;
+    constructor(cancellation, cancellationTimeoutMs) {
+        this.cancellation = cancellation ?? new InMemoryAgentCancellation();
+        this.cancellationTimeoutMs = cancellationTimeoutMs ?? 30_000;
+    }
+    async execute(tasks, options) {
+        if (tasks.length === 0) {
+            return { strategy: 'race', completed: [], cancelled: [], failed: [], outputs: {} };
+        }
+        const completed = [];
+        const failed = [];
+        const outputs = {};
+        let winner = null;
+        const taskPromises = tasks.map((task) => options.dispatch(task).then((result) => ({ status: 'fulfilled', value: result, task }), (error) => ({ status: 'rejected', reason: error, task })));
+        // Use a winner-detection approach: wrap each promise to detect the
+        // first successful result, signal cancellation, then wait for all to settle.
+        let resolveWinner = null;
+        const winnerPromise = new Promise((resolve) => {
+            resolveWinner = resolve;
+        });
+        let settledCount = 0;
+        const totalTasks = tasks.length;
+        const wrappedPromises = taskPromises.map(async (promise) => {
+            const settled = await promise;
+            settledCount++;
+            if (settled.status === 'fulfilled') {
+                completed.push(settled.value);
+                if (settled.value.success && !winner) {
+                    // First successful completion — this is the winner
+                    winner = settled.value;
+                    if (settled.value.outputs) {
+                        outputs[settled.value.issueId] = settled.value.outputs;
+                    }
+                    // Signal cancellation for all other tasks
+                    for (const task of tasks) {
+                        if (task.id !== settled.task.id) {
+                            await this.cancellation.cancel(task.id);
+                        }
+                    }
+                    resolveWinner?.(settled.value);
+                }
+                else if (settled.value.outputs && settled.value.success) {
+                    outputs[settled.value.issueId] = settled.value.outputs;
+                }
+            }
+            else {
+                const errMsg = settled.reason instanceof Error
+                    ? settled.reason.message
+                    : String(settled.reason);
+                failed.push({
+                    id: settled.task.id,
+                    issueId: settled.task.issueId,
+                    error: errMsg,
+                });
+            }
+            // If all tasks settled and no winner, resolve
+            if (settledCount === totalTasks && !winner) {
+                resolveWinner?.(null);
+            }
+        });
+        // Wait for the winner or all to fail
+        await winnerPromise;
+        // Wait for remaining tasks to settle, with a timeout to prevent hanging
+        // if agents never check isCancelled() and never complete
+        await Promise.race([
+            Promise.allSettled(wrappedPromises),
+            new Promise((resolve) => setTimeout(resolve, this.cancellationTimeoutMs)),
+        ]);
+        // Build cancelled list (all tasks that were cancelled, excluding winner and failed)
+        const cancelledIds = this.cancellation.getCancelledIds();
+        return {
+            strategy: 'race',
+            completed,
+            cancelled: cancelledIds,
+            failed,
+            outputs,
+        };
+    }
+}

package/dist/src/workflow/strategies/race-strategy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=race-strategy.test.d.ts.map

package/dist/src/workflow/strategies/race-strategy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"race-strategy.test.d.ts","sourceRoot":"","sources":["../../../../src/workflow/strategies/race-strategy.test.ts"],"names":[],"mappings":""}