@renseiai/agentfactory 0.8.8 → 0.8.9

package/dist/src/workflow/gates/webhook-gate.test.js

@@ -0,0 +1,182 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { generateWebhookToken, buildCallbackUrl, validateWebhookCallback, evaluateWebhookGate, createWebhookGateActivation, } from './webhook-gate.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeGateDefinition(overrides = {}) {
+    return {
+        name: 'test-webhook',
+        type: 'webhook',
+        trigger: { endpoint: '/api/gates' },
+        ...overrides,
+    };
+}
+function makeGateState(overrides = {}) {
+    return {
+        issueId: 'issue-1',
+        gateName: 'test-webhook',
+        gateType: 'webhook',
+        status: 'active',
+        activatedAt: Date.now(),
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// generateWebhookToken
+// ---------------------------------------------------------------------------
+describe('generateWebhookToken', () => {
+    it('returns a 64-character hex string', () => {
+        const token = generateWebhookToken();
+        expect(token).toHaveLength(64);
+        expect(token).toMatch(/^[a-f0-9]{64}$/);
+    });
+    it('generates unique tokens', () => {
+        const token1 = generateWebhookToken();
+        const token2 = generateWebhookToken();
+        expect(token1).not.toBe(token2);
+    });
+});
+// ---------------------------------------------------------------------------
+// buildCallbackUrl
+// ---------------------------------------------------------------------------
+describe('buildCallbackUrl', () => {
+    it('builds correct URL format', () => {
+        const url = buildCallbackUrl('https://api.example.com', 'issue-1', 'my-gate', 'abc123');
+        expect(url).toBe('https://api.example.com/api/gates/issue-1/my-gate?token=abc123');
+    });
+    it('URI-encodes special characters in issueId', () => {
+        const url = buildCallbackUrl('https://api.example.com', 'issue/1', 'gate', 'token');
+        expect(url).toContain('issue%2F1');
+    });
+    it('URI-encodes special characters in gateName', () => {
+        const url = buildCallbackUrl('https://api.example.com', 'issue-1', 'my gate', 'token');
+        expect(url).toContain('my%20gate');
+    });
+    it('normalizes trailing slashes on base URL', () => {
+        const url = buildCallbackUrl('https://api.example.com/', 'issue-1', 'gate', 'token');
+        expect(url).toBe('https://api.example.com/api/gates/issue-1/gate?token=token');
+    });
+    it('normalizes multiple trailing slashes', () => {
+        const url = buildCallbackUrl('https://api.example.com///', 'issue-1', 'gate', 'token');
+        expect(url).toBe('https://api.example.com/api/gates/issue-1/gate?token=token');
+    });
+});
+// ---------------------------------------------------------------------------
+// validateWebhookCallback
+// ---------------------------------------------------------------------------
+describe('validateWebhookCallback', () => {
+    it('returns true for matching tokens', () => {
+        const token = 'test-webhook-token-value';
+        expect(validateWebhookCallback(token, token)).toBe(true);
+    });
+    it('returns false for mismatched tokens', () => {
+        expect(validateWebhookCallback('token-a', 'token-b')).toBe(false);
+    });
+    it('returns false for empty token', () => {
+        expect(validateWebhookCallback('', 'expected')).toBe(false);
+    });
+    it('returns false for empty expected token', () => {
+        expect(validateWebhookCallback('token', '')).toBe(false);
+    });
+    it('returns false for different length tokens', () => {
+        expect(validateWebhookCallback('short', 'a-much-longer-token')).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// evaluateWebhookGate
+// ---------------------------------------------------------------------------
+describe('evaluateWebhookGate', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('returns not satisfied for null state', () => {
+        const gate = makeGateDefinition();
+        const result = evaluateWebhookGate(gate, null);
+        expect(result.satisfied).toBe(false);
+        expect(result.callbackUrl).toBeUndefined();
+        expect(result.timedOut).toBeUndefined();
+    });
+    it('returns satisfied for satisfied state', () => {
+        const gate = makeGateDefinition();
+        const state = makeGateState({ status: 'satisfied', satisfiedAt: Date.now() });
+        const result = evaluateWebhookGate(gate, state);
+        expect(result.satisfied).toBe(true);
+    });
+    it('returns timedOut for timed-out state', () => {
+        const gate = makeGateDefinition();
+        const state = makeGateState({ status: 'timed-out', timedOutAt: Date.now() });
+        const result = evaluateWebhookGate(gate, state);
+        expect(result.satisfied).toBe(false);
+        expect(result.timedOut).toBe(true);
+    });
+    it('returns callbackUrl for active state', () => {
+        const gate = makeGateDefinition();
+        const state = makeGateState({
+            status: 'active',
+            signalSource: 'https://api.example.com/api/gates/issue-1/test-webhook?token=abc',
+        });
+        const result = evaluateWebhookGate(gate, state);
+        expect(result.satisfied).toBe(false);
+        expect(result.callbackUrl).toBe(state.signalSource);
+    });
+    it('returns timedOut when active gate has expired deadline', () => {
+        const gate = makeGateDefinition();
+        const state = makeGateState({
+            status: 'active',
+            timeoutDeadline: Date.now() - 1000, // deadline in the past
+        });
+        const result = evaluateWebhookGate(gate, state);
+        expect(result.satisfied).toBe(false);
+        expect(result.timedOut).toBe(true);
+    });
+    it('returns not timed out when active gate has future deadline', () => {
+        const gate = makeGateDefinition();
+        const state = makeGateState({
+            status: 'active',
+            timeoutDeadline: Date.now() + 60_000, // deadline in the future
+        });
+        const result = evaluateWebhookGate(gate, state);
+        expect(result.satisfied).toBe(false);
+        expect(result.timedOut).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// createWebhookGateActivation
+// ---------------------------------------------------------------------------
+describe('createWebhookGateActivation', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('generates a token', () => {
+        const gate = makeGateDefinition();
+        const activation = createWebhookGateActivation('issue-1', gate, 'https://api.example.com');
+        expect(activation.token).toHaveLength(64);
+        expect(activation.token).toMatch(/^[a-f0-9]{64}$/);
+    });
+    it('builds a callback URL with the generated token', () => {
+        const gate = makeGateDefinition({ name: 'review-gate' });
+        const activation = createWebhookGateActivation('issue-1', gate, 'https://api.example.com');
+        expect(activation.callbackUrl).toContain('https://api.example.com/api/gates/issue-1/review-gate');
+        expect(activation.callbackUrl).toContain(`token=${activation.token}`);
+    });
+    it('computes expiresAt from timeout duration', () => {
+        const gate = makeGateDefinition({
+            timeout: { duration: '4h', action: 'fail' },
+        });
+        const activation = createWebhookGateActivation('issue-1', gate, 'https://api.example.com');
+        expect(activation.expiresAt).toBe(Date.now() + 14_400_000);
+    });
+    it('does not set expiresAt when no timeout configured', () => {
+        const gate = makeGateDefinition();
+        const activation = createWebhookGateActivation('issue-1', gate, 'https://api.example.com');
+        expect(activation.expiresAt).toBeUndefined();
+    });
+});

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

@@ -4,8 +4,8 @@
  * Declarative workflow graph definitions using YAML (v1.1 schema extension).
  * Defines phases, transitions, escalation ladder, gates, and parallelism.
  */
-export type { EscalationStrategy, PhaseDefinition, TransitionDefinition, EscalationLadderRung, EscalationConfig, GateDefinition, ParallelismGroupDefinition, WorkflowDefinition, BranchingDefinition, TemplateRetryConfig, TemplateTimeoutConfig, } from './workflow-types.js';
-export { PhaseDefinitionSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
+export type { EscalationStrategy, PhaseDefinition, PhaseOutputDeclaration, PhaseInputDeclaration, TransitionDefinition, EscalationLadderRung, EscalationConfig, GateDefinition, ParallelismGroupDefinition, WorkflowDefinition, BranchingDefinition, TemplateRetryConfig, TemplateTimeoutConfig, } from './workflow-types.js';
+export { PhaseDefinitionSchema, PhaseOutputDeclarationSchema, PhaseInputDeclarationSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
 export { loadWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
 export type { WorkflowRegistryConfig, WorkflowStoreSource } from './workflow-registry.js';
 export { WorkflowRegistry } from './workflow-registry.js';
@@ -18,4 +18,25 @@ export type { ResolvedRetryConfig, ResolvedTimeoutConfig } from './retry-resolve
 export { resolveRetryConfig, resolveTimeoutConfig } from './retry-resolver.js';
 export type { EvaluationContext } from './expression/index.js';
 export { buildEvaluationContext, evaluateCondition } from './expression/index.js';
+export type { GateState, GateStorage } from './gate-state.js';
+export { InMemoryGateStorage, initGateStorage, activateGate, satisfyGate, timeoutGate, } from './gate-state.js';
+export { parseDuration as parseGateDuration } from './gate-state.js';
+export type { SignalGateTrigger, SignalGateResult } from './gates/signal-gate.js';
+export { isSignalGateTrigger, evaluateSignalGate, getApplicableSignalGates, createImplicitHoldGate, createImplicitResumeGate, IMPLICIT_HOLD_GATE_NAME, IMPLICIT_RESUME_GATE_NAME, } from './gates/signal-gate.js';
+export type { WebhookGateTrigger, WebhookGateResult, WebhookGateActivation } from './gates/webhook-gate.js';
+export { generateWebhookToken, buildCallbackUrl, validateWebhookCallback, evaluateWebhookGate, isWebhookGateTrigger, getApplicableWebhookGates, createWebhookGateActivation, } from './gates/webhook-gate.js';
+export type { TimeoutCheckResult, TimedOutGate, TimeoutResolution } from './gates/timeout-engine.js';
+export { checkGateTimeout, checkAllGateTimeouts, resolveTimeoutAction, processGateTimeouts, } from './gates/timeout-engine.js';
+export type { TimerGateTrigger, TimerGateResult } from './gates/timer-gate.js';
+export { evaluateTimerGate, computeNextCronFireTime, isTimerGateTrigger, getApplicableTimerGates, parseCronField, parseCronExpression, } from './gates/timer-gate.js';
+export type { GateEvaluationOptions, GateEvaluationResult } from './gates/gate-evaluator.js';
+export { evaluateGatesForPhase, activateGatesForPhase, clearGatesForIssue, getApplicableGates, } from './gates/gate-evaluator.js';
+export { PhaseOutputCollector } from './phase-output-collector.js';
+export { PhaseContextInjector } from './phase-context-injector.js';
+export type { ParallelTask, ParallelTaskResult, ParallelTaskError, ParallelismResult, ParallelismStrategy, ParallelismStrategyOptions, } from './parallelism-types.js';
+export { ConcurrencySemaphore } from './concurrency-semaphore.js';
+export { ParallelismExecutor } from './parallelism-executor.js';
+export type { AgentCancellation } from './agent-cancellation.js';
+export { InMemoryAgentCancellation } from './agent-cancellation.js';
+export { FanOutStrategy, FanInStrategy, RaceStrategy } from './strategies/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,0BAA0B,EAC1B,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,EAC1B,sBAAsB,EACtB,oBAAoB,EACpB,gCAAgC,EAChC,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,sBAAsB,CAAA;AAE7B,YAAY,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AACzF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAE5D,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAGzD,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAGjE,YAAY,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AACrF,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAG9E,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"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"}

package/dist/src/workflow/index.js

@@ -4,7 +4,7 @@
  * Declarative workflow graph definitions using YAML (v1.1 schema extension).
  * Defines phases, transitions, escalation ladder, gates, and parallelism.
  */
-export { PhaseDefinitionSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
+export { PhaseDefinitionSchema, PhaseOutputDeclarationSchema, PhaseInputDeclarationSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
 export { loadWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
 export { WorkflowRegistry } from './workflow-registry.js';
 export { evaluateTransitions } from './transition-engine.js';
@@ -13,3 +13,17 @@ export { evaluateBranching } from './branching-router.js';
 export { parseDuration, DurationParseError } from './duration.js';
 export { resolveRetryConfig, resolveTimeoutConfig } from './retry-resolver.js';
 export { buildEvaluationContext, evaluateCondition } from './expression/index.js';
+export { InMemoryGateStorage, initGateStorage, activateGate, satisfyGate, timeoutGate, } from './gate-state.js';
+export { parseDuration as parseGateDuration } from './gate-state.js';
+export { isSignalGateTrigger, evaluateSignalGate, getApplicableSignalGates, createImplicitHoldGate, createImplicitResumeGate, IMPLICIT_HOLD_GATE_NAME, IMPLICIT_RESUME_GATE_NAME, } from './gates/signal-gate.js';
+export { generateWebhookToken, buildCallbackUrl, validateWebhookCallback, evaluateWebhookGate, isWebhookGateTrigger, getApplicableWebhookGates, createWebhookGateActivation, } from './gates/webhook-gate.js';
+export { checkGateTimeout, checkAllGateTimeouts, resolveTimeoutAction, processGateTimeouts, } from './gates/timeout-engine.js';
+export { evaluateTimerGate, computeNextCronFireTime, isTimerGateTrigger, getApplicableTimerGates, parseCronField, parseCronExpression, } from './gates/timer-gate.js';
+export { evaluateGatesForPhase, activateGatesForPhase, clearGatesForIssue, getApplicableGates, } from './gates/gate-evaluator.js';
+// Phase output/input handling
+export { PhaseOutputCollector } from './phase-output-collector.js';
+export { PhaseContextInjector } from './phase-context-injector.js';
+export { ConcurrencySemaphore } from './concurrency-semaphore.js';
+export { ParallelismExecutor } from './parallelism-executor.js';
+export { InMemoryAgentCancellation } from './agent-cancellation.js';
+export { FanOutStrategy, FanInStrategy, RaceStrategy } from './strategies/index.js';

package/dist/src/workflow/parallelism-executor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ParallelismExecutor
+ *
+ * Orchestrates parallel task execution using strategy pattern.
+ * Each parallelism group in the workflow definition is executed
+ * through its configured strategy with concurrency limiting.
+ */
+import type { ParallelismGroupDefinition } from './workflow-types.js';
+import type { ParallelTask, ParallelTaskResult, ParallelismResult, ParallelismStrategy } from './parallelism-types.js';
+export declare class ParallelismExecutor {
+    private readonly strategies;
+    /**
+     * Register a strategy implementation for a strategy name.
+     */
+    registerStrategy(name: string, strategy: ParallelismStrategy): void;
+    /**
+     * Get a registered strategy by name.
+     */
+    getStrategy(name: string): ParallelismStrategy | undefined;
+    /**
+     * Execute a parallelism group with the configured strategy.
+     */
+    execute(group: ParallelismGroupDefinition, tasks: ParallelTask[], dispatch: (task: ParallelTask) => Promise<ParallelTaskResult>): Promise<ParallelismResult>;
+}
+//# sourceMappingURL=parallelism-executor.d.ts.map

package/dist/src/workflow/parallelism-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelism-executor.d.ts","sourceRoot":"","sources":["../../../src/workflow/parallelism-executor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,wBAAwB,CAAA;AAG/B,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8C;IAEzE;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAInE;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI1D;;OAEG;IACG,OAAO,CACX,KAAK,EAAE,0BAA0B,EACjC,KAAK,EAAE,YAAY,EAAE,EACrB,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,kBAAkB,CAAC,GAC5D,OAAO,CAAC,iBAAiB,CAAC;CA8B9B"}

package/dist/src/workflow/parallelism-executor.js

@@ -0,0 +1,53 @@
+/**
+ * ParallelismExecutor
+ *
+ * Orchestrates parallel task execution using strategy pattern.
+ * Each parallelism group in the workflow definition is executed
+ * through its configured strategy with concurrency limiting.
+ */
+import { ConcurrencySemaphore } from './concurrency-semaphore.js';
+export class ParallelismExecutor {
+    strategies = new Map();
+    /**
+     * Register a strategy implementation for a strategy name.
+     */
+    registerStrategy(name, strategy) {
+        this.strategies.set(name, strategy);
+    }
+    /**
+     * Get a registered strategy by name.
+     */
+    getStrategy(name) {
+        return this.strategies.get(name);
+    }
+    /**
+     * Execute a parallelism group with the configured strategy.
+     */
+    async execute(group, tasks, dispatch) {
+        const strategy = this.strategies.get(group.strategy);
+        if (!strategy) {
+            throw new Error(`No strategy registered for "${group.strategy}"`);
+        }
+        // Wrap dispatch with semaphore if maxConcurrent is set
+        const semaphore = group.maxConcurrent
+            ? new ConcurrencySemaphore(group.maxConcurrent)
+            : null;
+        const wrappedDispatch = async (task) => {
+            if (semaphore)
+                await semaphore.acquire();
+            try {
+                return await dispatch(task);
+            }
+            finally {
+                if (semaphore)
+                    semaphore.release();
+            }
+        };
+        const options = {
+            maxConcurrent: group.maxConcurrent,
+            waitForAll: group.waitForAll,
+            dispatch: wrappedDispatch,
+        };
+        return strategy.execute(tasks, options);
+    }
+}

package/dist/src/workflow/parallelism-executor.test.d.ts

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

package/dist/src/workflow/parallelism-executor.test.d.ts.map

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

package/dist/src/workflow/parallelism-executor.test.js

@@ -0,0 +1,191 @@
+import { describe, it, expect } from 'vitest';
+import { ParallelismExecutor } from './parallelism-executor.js';
+/** Helper: create a mock strategy that records calls and delegates to dispatch */
+function createMockStrategy() {
+    const executeCalls = [];
+    return {
+        executeCalls,
+        async execute(tasks, options) {
+            executeCalls.push({ tasks, options });
+            // Use the dispatch function to run all tasks, collecting results
+            const completed = [];
+            for (const task of tasks) {
+                const result = await options.dispatch(task);
+                completed.push(result);
+            }
+            return {
+                strategy: 'fan-out',
+                completed,
+                cancelled: [],
+                failed: [],
+                outputs: {},
+            };
+        },
+    };
+}
+/** Helper: create a simple dispatch function */
+function createDispatch() {
+    return async (task) => ({
+        id: task.id,
+        issueId: task.issueId,
+        success: true,
+        durationMs: 10,
+    });
+}
+/** Helper: create a sample group definition */
+function createGroup(overrides = {}) {
+    return {
+        name: 'test-group',
+        phases: ['development'],
+        strategy: 'fan-out',
+        ...overrides,
+    };
+}
+/** Helper: create sample tasks */
+function createTasks(count) {
+    return Array.from({ length: count }, (_, i) => ({
+        id: `task-${i + 1}`,
+        issueId: `SUP-${100 + i + 1}`,
+        phaseName: 'development',
+    }));
+}
+describe('ParallelismExecutor', () => {
+    describe('registerStrategy and getStrategy', () => {
+        it('registers and retrieves a strategy', () => {
+            const executor = new ParallelismExecutor();
+            const strategy = createMockStrategy();
+            executor.registerStrategy('fan-out', strategy);
+            expect(executor.getStrategy('fan-out')).toBe(strategy);
+        });
+        it('returns undefined for unregistered strategy', () => {
+            const executor = new ParallelismExecutor();
+            expect(executor.getStrategy('fan-out')).toBeUndefined();
+        });
+        it('overwrites a previously registered strategy', () => {
+            const executor = new ParallelismExecutor();
+            const strategy1 = createMockStrategy();
+            const strategy2 = createMockStrategy();
+            executor.registerStrategy('fan-out', strategy1);
+            executor.registerStrategy('fan-out', strategy2);
+            expect(executor.getStrategy('fan-out')).toBe(strategy2);
+        });
+    });
+    describe('execute with mock strategy', () => {
+        it('delegates to the registered strategy and returns result', async () => {
+            const executor = new ParallelismExecutor();
+            const strategy = createMockStrategy();
+            executor.registerStrategy('fan-out', strategy);
+            const group = createGroup();
+            const tasks = createTasks(3);
+            const dispatch = createDispatch();
+            const result = await executor.execute(group, tasks, dispatch);
+            expect(result.strategy).toBe('fan-out');
+            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');
+        });
+    });
+    describe('execute throws when strategy not registered', () => {
+        it('throws with a descriptive error', async () => {
+            const executor = new ParallelismExecutor();
+            const group = createGroup({ strategy: 'race' });
+            const tasks = createTasks(1);
+            const dispatch = createDispatch();
+            await expect(executor.execute(group, tasks, dispatch)).rejects.toThrow('No strategy registered for "race"');
+        });
+    });
+    describe('execute wraps dispatch with semaphore when maxConcurrent set', () => {
+        it('limits concurrency via semaphore', async () => {
+            const executor = new ParallelismExecutor();
+            let peakConcurrent = 0;
+            let currentConcurrent = 0;
+            // Create a strategy that dispatches all tasks in parallel
+            const concurrentStrategy = {
+                async execute(tasks, options) {
+                    const promises = tasks.map((task) => options.dispatch(task));
+                    const completed = await Promise.all(promises);
+                    return {
+                        strategy: 'fan-out',
+                        completed,
+                        cancelled: [],
+                        failed: [],
+                        outputs: {},
+                    };
+                },
+            };
+            executor.registerStrategy('fan-out', concurrentStrategy);
+            const dispatch = async (task) => {
+                currentConcurrent++;
+                peakConcurrent = Math.max(peakConcurrent, currentConcurrent);
+                await new Promise((resolve) => setTimeout(resolve, 20));
+                currentConcurrent--;
+                return { id: task.id, issueId: task.issueId, success: true };
+            };
+            const group = createGroup({ maxConcurrent: 2 });
+            const tasks = createTasks(5);
+            await executor.execute(group, tasks, dispatch);
+            expect(peakConcurrent).toBeLessThanOrEqual(2);
+        });
+    });
+    describe('execute passes options correctly', () => {
+        it('passes maxConcurrent and waitForAll to strategy', async () => {
+            const executor = new ParallelismExecutor();
+            const strategy = createMockStrategy();
+            executor.registerStrategy('fan-out', strategy);
+            const group = createGroup({ maxConcurrent: 3, waitForAll: true });
+            const tasks = createTasks(1);
+            const dispatch = createDispatch();
+            await executor.execute(group, tasks, dispatch);
+            expect(strategy.executeCalls).toHaveLength(1);
+            const passedOptions = strategy.executeCalls[0].options;
+            expect(passedOptions.maxConcurrent).toBe(3);
+            expect(passedOptions.waitForAll).toBe(true);
+            expect(typeof passedOptions.dispatch).toBe('function');
+        });
+        it('passes tasks through to the strategy', async () => {
+            const executor = new ParallelismExecutor();
+            const strategy = createMockStrategy();
+            executor.registerStrategy('fan-out', strategy);
+            const group = createGroup();
+            const tasks = createTasks(2);
+            const dispatch = createDispatch();
+            await executor.execute(group, tasks, dispatch);
+            expect(strategy.executeCalls[0].tasks).toBe(tasks);
+        });
+    });
+    describe('execute without maxConcurrent (no semaphore wrapping)', () => {
+        it('does not limit concurrency when maxConcurrent is not set', async () => {
+            const executor = new ParallelismExecutor();
+            let peakConcurrent = 0;
+            let currentConcurrent = 0;
+            const concurrentStrategy = {
+                async execute(tasks, options) {
+                    const promises = tasks.map((task) => options.dispatch(task));
+                    const completed = await Promise.all(promises);
+                    return {
+                        strategy: 'fan-out',
+                        completed,
+                        cancelled: [],
+                        failed: [],
+                        outputs: {},
+                    };
+                },
+            };
+            executor.registerStrategy('fan-out', concurrentStrategy);
+            const dispatch = async (task) => {
+                currentConcurrent++;
+                peakConcurrent = Math.max(peakConcurrent, currentConcurrent);
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                currentConcurrent--;
+                return { id: task.id, issueId: task.issueId, success: true };
+            };
+            // No maxConcurrent set on the group
+            const group = createGroup();
+            const tasks = createTasks(5);
+            await executor.execute(group, tasks, dispatch);
+            // All 5 tasks should have been able to run concurrently
+            expect(peakConcurrent).toBe(5);
+        });
+    });
+});

package/dist/src/workflow/parallelism-types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Parallelism Types
+ *
+ * Type definitions for the parallel task execution system.
+ * These types define the contract between the ParallelismExecutor,
+ * strategy implementations, and calling code.
+ */
+/**
+ * A single task to be executed in parallel.
+ */
+export interface ParallelTask {
+    /** Unique task identifier (typically the issue identifier) */
+    id: string;
+    /** Issue identifier (e.g., "SUP-123") */
+    issueId: string;
+    /** Phase name this task belongs to */
+    phaseName: string;
+    /** Additional context for the task */
+    context?: Record<string, unknown>;
+}
+/**
+ * Result of a single parallel task execution.
+ */
+export interface ParallelTaskResult {
+    /** Task identifier */
+    id: string;
+    /** Issue identifier */
+    issueId: string;
+    /** Whether the task completed successfully */
+    success: boolean;
+    /** Collected phase outputs (if any) */
+    outputs?: Record<string, unknown>;
+    /** Duration in milliseconds */
+    durationMs?: number;
+}
+/**
+ * Error details for a failed parallel task.
+ */
+export interface ParallelTaskError {
+    /** Task identifier */
+    id: string;
+    /** Issue identifier */
+    issueId: string;
+    /** Error message */
+    error: string;
+}
+/**
+ * Result of executing a parallelism group.
+ */
+export interface ParallelismResult {
+    /** Strategy that was used */
+    strategy: 'fan-out' | 'fan-in' | 'race';
+    /** Tasks that completed (successfully or not) */
+    completed: ParallelTaskResult[];
+    /** Issue IDs that were cancelled (race strategy) */
+    cancelled: string[];
+    /** Tasks that failed with errors */
+    failed: ParallelTaskError[];
+    /** Per-issue phase outputs collected from completed tasks */
+    outputs: Record<string, Record<string, unknown>>;
+}
+/**
+ * Interface for parallelism strategy implementations.
+ */
+export interface ParallelismStrategy {
+    /** Execute a set of parallel tasks with the given options */
+    execute(tasks: ParallelTask[], options: ParallelismStrategyOptions): Promise<ParallelismResult>;
+}
+/**
+ * Options passed to strategy implementations.
+ */
+export interface ParallelismStrategyOptions {
+    /** Maximum concurrent executions */
+    maxConcurrent?: number;
+    /** Whether to wait for all tasks to complete */
+    waitForAll?: boolean;
+    /** Dispatch function that actually starts the agent work */
+    dispatch: (task: ParallelTask) => Promise<ParallelTaskResult>;
+}
+//# sourceMappingURL=parallelism-types.d.ts.map

package/dist/src/workflow/parallelism-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelism-types.d.ts","sourceRoot":"","sources":["../../../src/workflow/parallelism-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,8DAA8D;IAC9D,EAAE,EAAE,MAAM,CAAA;IACV,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sBAAsB;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,+BAA+B;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,sBAAsB;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAA;IACvC,iDAAiD;IACjD,SAAS,EAAE,kBAAkB,EAAE,CAAA;IAC/B,oDAAoD;IACpD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,oCAAoC;IACpC,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAC3B,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,6DAA6D;IAC7D,OAAO,CACL,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,iBAAiB,CAAC,CAAA;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,oCAAoC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,gDAAgD;IAChD,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,4DAA4D;IAC5D,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAA;CAC9D"}

package/dist/src/workflow/parallelism-types.js

@@ -0,0 +1,8 @@
+/**
+ * Parallelism Types
+ *
+ * Type definitions for the parallel task execution system.
+ * These types define the contract between the ParallelismExecutor,
+ * strategy implementations, and calling code.
+ */
+export {};