@renseiai/agentfactory 0.8.7 → 0.8.9

package/dist/src/workflow/phase-output-collector.js

@@ -0,0 +1,141 @@
+/**
+ * Phase Output Collector
+ *
+ * Extracts structured outputs from agent result text using marker comments.
+ * Supports two marker formats:
+ *   - <!-- PHASE_OUTPUT:key=value -->         (string, url, boolean types)
+ *   - <!-- PHASE_OUTPUT_JSON:key={...} -->    (json type)
+ *
+ * Validates collected outputs against PhaseOutputDeclaration when provided.
+ */
+/**
+ * Regex to match string-type output markers.
+ * Captures: key and value from <!-- PHASE_OUTPUT:key=value -->
+ */
+const STRING_MARKER_RE = /<!--\s*PHASE_OUTPUT:(\w+)=(.*?)\s*-->/g;
+/**
+ * Regex to match JSON-type output markers.
+ * Captures: key and JSON value from <!-- PHASE_OUTPUT_JSON:key={...} -->
+ */
+const JSON_MARKER_RE = /<!--\s*PHASE_OUTPUT_JSON:(\w+)=([\s\S]*?)\s*-->/g;
+/**
+ * Utility class to extract structured outputs from agent result text.
+ */
+export class PhaseOutputCollector {
+    /**
+     * Collect structured outputs from agent output text.
+     *
+     * @param agentOutput - The raw text output from an agent
+     * @param declarations - Optional output declarations for validation
+     * @returns Record of collected output key-value pairs
+     * @throws Error if a required output is missing or type validation fails
+     */
+    collect(agentOutput, declarations) {
+        const outputs = {};
+        // Extract string-type markers
+        for (const match of agentOutput.matchAll(STRING_MARKER_RE)) {
+            const key = match[1];
+            const rawValue = match[2];
+            outputs[key] = rawValue;
+        }
+        // Extract JSON-type markers (these override string markers for same key)
+        for (const match of agentOutput.matchAll(JSON_MARKER_RE)) {
+            const key = match[1];
+            const rawJson = match[2];
+            try {
+                outputs[key] = JSON.parse(rawJson);
+            }
+            catch {
+                // If JSON parsing fails, store as raw string
+                outputs[key] = rawJson;
+            }
+        }
+        // Validate against declarations if provided
+        if (declarations) {
+            this.validate(outputs, declarations);
+        }
+        // Coerce types based on declarations
+        if (declarations) {
+            for (const [key, value] of Object.entries(outputs)) {
+                const decl = declarations[key];
+                if (decl) {
+                    outputs[key] = this.coerceType(value, decl.type);
+                }
+            }
+        }
+        return outputs;
+    }
+    /**
+     * Validate collected outputs against declarations.
+     * Checks required fields and type compatibility.
+     */
+    validate(outputs, declarations) {
+        for (const [key, decl] of Object.entries(declarations)) {
+            // Check required outputs
+            if (decl.required && !(key in outputs)) {
+                throw new Error(`Required phase output "${key}" is missing`);
+            }
+            // Validate type if value is present
+            if (key in outputs) {
+                const value = outputs[key];
+                this.validateType(key, value, decl.type);
+            }
+        }
+    }
+    /**
+     * Validate that a collected value is compatible with the declared type.
+     */
+    validateType(key, value, type) {
+        switch (type) {
+            case 'string':
+            case 'url':
+                if (typeof value !== 'string') {
+                    throw new Error(`Phase output "${key}" expected type "${type}" but got ${typeof value}`);
+                }
+                if (type === 'url' && typeof value === 'string') {
+                    // Basic URL validation: must have a protocol-like prefix
+                    if (!/^https?:\/\/.+/.test(value)) {
+                        throw new Error(`Phase output "${key}" expected a valid URL but got "${value}"`);
+                    }
+                }
+                break;
+            case 'boolean':
+                // Booleans may arrive as strings from markers; we accept string booleans
+                if (typeof value === 'string') {
+                    if (value !== 'true' && value !== 'false') {
+                        throw new Error(`Phase output "${key}" expected boolean but got "${value}"`);
+                    }
+                }
+                else if (typeof value !== 'boolean') {
+                    throw new Error(`Phase output "${key}" expected type "boolean" but got ${typeof value}`);
+                }
+                break;
+            case 'json':
+                // JSON type accepts any non-string parsed value, or a string that was kept as-is
+                // No additional validation needed — the value was either parsed or kept raw
+                break;
+        }
+    }
+    /**
+     * Coerce a raw collected value to the declared type.
+     */
+    coerceType(value, type) {
+        switch (type) {
+            case 'boolean':
+                if (typeof value === 'string') {
+                    return value === 'true';
+                }
+                return value;
+            case 'string':
+            case 'url':
+                if (typeof value !== 'string') {
+                    return String(value);
+                }
+                return value;
+            case 'json':
+                return value;
+            default:
+                return value;
+        }
+    }
+}

package/dist/src/workflow/phase-output-collector.test.d.ts

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

package/dist/src/workflow/phase-output-collector.test.d.ts.map

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

package/dist/src/workflow/phase-output-collector.test.js

@@ -0,0 +1,179 @@
+import { describe, it, expect } from 'vitest';
+import { PhaseOutputCollector } from './phase-output-collector.js';
+describe('PhaseOutputCollector', () => {
+    const collector = new PhaseOutputCollector();
+    describe('string marker parsing', () => {
+        it('extracts a single string output', () => {
+            const output = 'Some text <!-- PHASE_OUTPUT:prUrl=https://github.com/org/repo/pull/42 --> more text';
+            const result = collector.collect(output);
+            expect(result).toEqual({
+                prUrl: 'https://github.com/org/repo/pull/42',
+            });
+        });
+        it('extracts multiple string outputs', () => {
+            const output = [
+                '<!-- PHASE_OUTPUT:prUrl=https://github.com/org/repo/pull/42 -->',
+                '<!-- PHASE_OUTPUT:branch=feature/my-branch -->',
+                '<!-- PHASE_OUTPUT:status=success -->',
+            ].join('\n');
+            const result = collector.collect(output);
+            expect(result).toEqual({
+                prUrl: 'https://github.com/org/repo/pull/42',
+                branch: 'feature/my-branch',
+                status: 'success',
+            });
+        });
+        it('handles empty value', () => {
+            const output = '<!-- PHASE_OUTPUT:empty= -->';
+            const result = collector.collect(output);
+            expect(result).toEqual({ empty: '' });
+        });
+        it('handles whitespace in marker', () => {
+            const output = '<!--  PHASE_OUTPUT:key=value  -->';
+            const result = collector.collect(output);
+            expect(result).toEqual({ key: 'value' });
+        });
+        it('uses last value when same key appears multiple times', () => {
+            const output = [
+                '<!-- PHASE_OUTPUT:key=first -->',
+                '<!-- PHASE_OUTPUT:key=second -->',
+            ].join('\n');
+            const result = collector.collect(output);
+            expect(result.key).toBe('second');
+        });
+    });
+    describe('JSON marker parsing', () => {
+        it('extracts a JSON object output', () => {
+            const output = '<!-- PHASE_OUTPUT_JSON:config={"port":3000,"host":"localhost"} -->';
+            const result = collector.collect(output);
+            expect(result).toEqual({
+                config: { port: 3000, host: 'localhost' },
+            });
+        });
+        it('extracts a JSON array output', () => {
+            const output = '<!-- PHASE_OUTPUT_JSON:files=["a.ts","b.ts","c.ts"] -->';
+            const result = collector.collect(output);
+            expect(result).toEqual({
+                files: ['a.ts', 'b.ts', 'c.ts'],
+            });
+        });
+        it('falls back to raw string on invalid JSON', () => {
+            const output = '<!-- PHASE_OUTPUT_JSON:bad={not valid json} -->';
+            const result = collector.collect(output);
+            expect(result.bad).toBe('{not valid json}');
+        });
+        it('JSON marker overrides string marker for same key', () => {
+            const output = [
+                '<!-- PHASE_OUTPUT:data=string-value -->',
+                '<!-- PHASE_OUTPUT_JSON:data={"complex":true} -->',
+            ].join('\n');
+            const result = collector.collect(output);
+            expect(result.data).toEqual({ complex: true });
+        });
+    });
+    describe('mixed markers', () => {
+        it('extracts both string and JSON markers from same output', () => {
+            const output = [
+                'Agent completed successfully.',
+                '<!-- PHASE_OUTPUT:prUrl=https://github.com/org/repo/pull/42 -->',
+                '<!-- PHASE_OUTPUT:branch=feat/new-feature -->',
+                '<!-- PHASE_OUTPUT_JSON:testResults={"passed":10,"failed":0} -->',
+                'Done.',
+            ].join('\n');
+            const result = collector.collect(output);
+            expect(result).toEqual({
+                prUrl: 'https://github.com/org/repo/pull/42',
+                branch: 'feat/new-feature',
+                testResults: { passed: 10, failed: 0 },
+            });
+        });
+        it('returns empty record when no markers present', () => {
+            const output = 'Just some plain text with no markers at all.';
+            const result = collector.collect(output);
+            expect(result).toEqual({});
+        });
+        it('handles empty input', () => {
+            const result = collector.collect('');
+            expect(result).toEqual({});
+        });
+    });
+    describe('validation with declarations', () => {
+        it('passes validation for correct types', () => {
+            const declarations = {
+                prUrl: { type: 'url', required: true },
+                message: { type: 'string' },
+            };
+            const output = [
+                '<!-- PHASE_OUTPUT:prUrl=https://github.com/org/repo/pull/42 -->',
+                '<!-- PHASE_OUTPUT:message=All tests passed -->',
+            ].join('\n');
+            const result = collector.collect(output, declarations);
+            expect(result.prUrl).toBe('https://github.com/org/repo/pull/42');
+            expect(result.message).toBe('All tests passed');
+        });
+        it('throws on missing required output', () => {
+            const declarations = {
+                prUrl: { type: 'url', required: true },
+            };
+            expect(() => collector.collect('no markers here', declarations)).toThrow('Required phase output "prUrl" is missing');
+        });
+        it('does not throw for missing optional output', () => {
+            const declarations = {
+                prUrl: { type: 'url', required: false },
+                message: { type: 'string' },
+            };
+            const result = collector.collect('no markers', declarations);
+            expect(result).toEqual({});
+        });
+        it('throws on invalid URL format', () => {
+            const declarations = {
+                prUrl: { type: 'url', required: true },
+            };
+            const output = '<!-- PHASE_OUTPUT:prUrl=not-a-url -->';
+            expect(() => collector.collect(output, declarations)).toThrow('expected a valid URL');
+        });
+        it('throws on invalid boolean value', () => {
+            const declarations = {
+                passed: { type: 'boolean', required: true },
+            };
+            const output = '<!-- PHASE_OUTPUT:passed=maybe -->';
+            expect(() => collector.collect(output, declarations)).toThrow('expected boolean');
+        });
+        it('accepts string boolean "true"', () => {
+            const declarations = {
+                passed: { type: 'boolean' },
+            };
+            const output = '<!-- PHASE_OUTPUT:passed=true -->';
+            const result = collector.collect(output, declarations);
+            expect(result.passed).toBe(true);
+        });
+        it('coerces string boolean "false"', () => {
+            const declarations = {
+                passed: { type: 'boolean' },
+            };
+            const output = '<!-- PHASE_OUTPUT:passed=false -->';
+            const result = collector.collect(output, declarations);
+            expect(result.passed).toBe(false);
+        });
+        it('validates json type accepts objects', () => {
+            const declarations = {
+                data: { type: 'json', required: true },
+            };
+            const output = '<!-- PHASE_OUTPUT_JSON:data={"key":"value"} -->';
+            const result = collector.collect(output, declarations);
+            expect(result.data).toEqual({ key: 'value' });
+        });
+        it('allows undeclared outputs to pass through', () => {
+            const declarations = {
+                declared: { type: 'string' },
+            };
+            const output = [
+                '<!-- PHASE_OUTPUT:declared=yes -->',
+                '<!-- PHASE_OUTPUT:undeclared=also-yes -->',
+            ].join('\n');
+            const result = collector.collect(output, declarations);
+            expect(result.declared).toBe('yes');
+            expect(result.undeclared).toBe('also-yes');
+        });
+    });
+});

package/dist/src/workflow/retry-resolver.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Retry & Timeout Resolution Logic
+ *
+ * Resolves per-template retry and timeout configurations with a layered
+ * override precedence:
+ *
+ *   template-level → phase-level → global escalation config → defaults
+ *
+ * All functions are pure — no side effects.
+ */
+import type { TemplateRetryConfig, TemplateTimeoutConfig, EscalationConfig, EscalationLadderRung } from './workflow-types.js';
+/**
+ * Resolved retry configuration with all values filled in.
+ */
+export interface ResolvedRetryConfig {
+    maxAttempts: number;
+    ladder: EscalationLadderRung[];
+}
+/**
+ * Resolved timeout configuration with duration in milliseconds.
+ */
+export interface ResolvedTimeoutConfig {
+    durationMs: number;
+    action: 'escalate' | 'skip' | 'fail';
+}
+/**
+ * Resolve retry configuration with override precedence:
+ * template-level retry → phase-level retry → global escalation config → defaults
+ *
+ * For each field (maxAttempts, ladder), the first defined value wins:
+ *   1. templateRetry (from branching block)
+ *   2. phaseRetry (from phase definition)
+ *   3. globalEscalation (from workflow definition)
+ *   4. Built-in defaults
+ *
+ * @param templateRetry - Per-template retry config (from branching block)
+ * @param phaseRetry - Per-phase retry config (from phase definition)
+ * @param globalEscalation - Global escalation config (from workflow definition)
+ * @returns Fully resolved retry config with fallback defaults
+ */
+export declare function resolveRetryConfig(templateRetry?: TemplateRetryConfig, phaseRetry?: TemplateRetryConfig, globalEscalation?: EscalationConfig): ResolvedRetryConfig;
+/**
+ * Resolve timeout configuration with override precedence:
+ * template-level timeout → phase-level timeout → null (no timeout)
+ *
+ * @param templateTimeout - Per-template timeout config (from branching block)
+ * @param phaseTimeout - Per-phase timeout config (from phase definition)
+ * @returns Resolved timeout config, or null if no timeout configured
+ */
+export declare function resolveTimeoutConfig(templateTimeout?: TemplateTimeoutConfig, phaseTimeout?: TemplateTimeoutConfig): ResolvedTimeoutConfig | null;
+//# sourceMappingURL=retry-resolver.d.ts.map

package/dist/src/workflow/retry-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-resolver.d.ts","sourceRoot":"","sources":["../../../src/workflow/retry-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,qBAAqB,CAAA;AAO5B;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,oBAAoB,EAAE,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,CAAA;CACrC;AAkBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,CAAC,EAAE,mBAAmB,EACnC,UAAU,CAAC,EAAE,mBAAmB,EAChC,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,mBAAmB,CAcrB;AAMD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,CAAC,EAAE,qBAAqB,EACvC,YAAY,CAAC,EAAE,qBAAqB,GACnC,qBAAqB,GAAG,IAAI,CAW9B"}

package/dist/src/workflow/retry-resolver.js

@@ -0,0 +1,70 @@
+/**
+ * Retry & Timeout Resolution Logic
+ *
+ * Resolves per-template retry and timeout configurations with a layered
+ * override precedence:
+ *
+ *   template-level → phase-level → global escalation config → defaults
+ *
+ * All functions are pure — no side effects.
+ */
+import { parseDuration } from './duration.js';
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_LADDER = [
+    { cycle: 1, strategy: 'normal' },
+    { cycle: 2, strategy: 'context-enriched' },
+    { cycle: 3, strategy: 'decompose' },
+];
+// ---------------------------------------------------------------------------
+// Retry Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve retry configuration with override precedence:
+ * template-level retry → phase-level retry → global escalation config → defaults
+ *
+ * For each field (maxAttempts, ladder), the first defined value wins:
+ *   1. templateRetry (from branching block)
+ *   2. phaseRetry (from phase definition)
+ *   3. globalEscalation (from workflow definition)
+ *   4. Built-in defaults
+ *
+ * @param templateRetry - Per-template retry config (from branching block)
+ * @param phaseRetry - Per-phase retry config (from phase definition)
+ * @param globalEscalation - Global escalation config (from workflow definition)
+ * @returns Fully resolved retry config with fallback defaults
+ */
+export function resolveRetryConfig(templateRetry, phaseRetry, globalEscalation) {
+    const maxAttempts = templateRetry?.maxAttempts
+        ?? phaseRetry?.maxAttempts
+        ?? globalEscalation?.circuitBreaker.maxSessionsPerPhase
+        ?? DEFAULT_MAX_ATTEMPTS;
+    const ladder = templateRetry?.ladder
+        ?? phaseRetry?.ladder
+        ?? globalEscalation?.ladder
+        ?? DEFAULT_LADDER;
+    return { maxAttempts, ladder };
+}
+// ---------------------------------------------------------------------------
+// Timeout Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve timeout configuration with override precedence:
+ * template-level timeout → phase-level timeout → null (no timeout)
+ *
+ * @param templateTimeout - Per-template timeout config (from branching block)
+ * @param phaseTimeout - Per-phase timeout config (from phase definition)
+ * @returns Resolved timeout config, or null if no timeout configured
+ */
+export function resolveTimeoutConfig(templateTimeout, phaseTimeout) {
+    const timeout = templateTimeout ?? phaseTimeout;
+    if (!timeout) {
+        return null;
+    }
+    return {
+        durationMs: parseDuration(timeout.duration),
+        action: timeout.action,
+    };
+}

package/dist/src/workflow/retry-resolver.test.d.ts

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

package/dist/src/workflow/retry-resolver.test.d.ts.map

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

package/dist/src/workflow/retry-resolver.test.js

@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest';
+import { resolveRetryConfig, resolveTimeoutConfig } from './retry-resolver.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const globalEscalation = {
+    ladder: [
+        { cycle: 1, strategy: 'normal' },
+        { cycle: 2, strategy: 'context-enriched' },
+        { cycle: 3, strategy: 'decompose' },
+        { cycle: 4, strategy: 'escalate-human' },
+    ],
+    circuitBreaker: {
+        maxSessionsPerIssue: 8,
+        maxSessionsPerPhase: 5,
+    },
+};
+// ---------------------------------------------------------------------------
+// resolveRetryConfig
+// ---------------------------------------------------------------------------
+describe('resolveRetryConfig', () => {
+    it('template retry overrides phase retry', () => {
+        const templateRetry = {
+            maxAttempts: 2,
+            ladder: [{ cycle: 1, strategy: 'normal' }],
+        };
+        const phaseRetry = {
+            maxAttempts: 4,
+            ladder: [
+                { cycle: 1, strategy: 'normal' },
+                { cycle: 2, strategy: 'decompose' },
+            ],
+        };
+        const result = resolveRetryConfig(templateRetry, phaseRetry, globalEscalation);
+        expect(result.maxAttempts).toBe(2);
+        expect(result.ladder).toEqual([{ cycle: 1, strategy: 'normal' }]);
+    });
+    it('phase retry overrides global escalation', () => {
+        const phaseRetry = {
+            maxAttempts: 4,
+            ladder: [
+                { cycle: 1, strategy: 'normal' },
+                { cycle: 3, strategy: 'escalate-human' },
+            ],
+        };
+        const result = resolveRetryConfig(undefined, phaseRetry, globalEscalation);
+        expect(result.maxAttempts).toBe(4);
+        expect(result.ladder).toEqual([
+            { cycle: 1, strategy: 'normal' },
+            { cycle: 3, strategy: 'escalate-human' },
+        ]);
+    });
+    it('global escalation used as fallback when no overrides', () => {
+        const result = resolveRetryConfig(undefined, undefined, globalEscalation);
+        // maxAttempts falls back to circuitBreaker.maxSessionsPerPhase
+        expect(result.maxAttempts).toBe(5);
+        expect(result.ladder).toEqual(globalEscalation.ladder);
+    });
+    it('uses defaults when nothing is configured', () => {
+        const result = resolveRetryConfig(undefined, undefined, undefined);
+        expect(result.maxAttempts).toBe(3);
+        expect(result.ladder).toEqual([
+            { cycle: 1, strategy: 'normal' },
+            { cycle: 2, strategy: 'context-enriched' },
+            { cycle: 3, strategy: 'decompose' },
+        ]);
+    });
+    it('partial override: only maxAttempts overridden at template level', () => {
+        const templateRetry = { maxAttempts: 1 };
+        const phaseRetry = {
+            maxAttempts: 4,
+            ladder: [{ cycle: 1, strategy: 'decompose' }],
+        };
+        const result = resolveRetryConfig(templateRetry, phaseRetry, globalEscalation);
+        // maxAttempts from template, ladder from phase (template has none)
+        expect(result.maxAttempts).toBe(1);
+        expect(result.ladder).toEqual([{ cycle: 1, strategy: 'decompose' }]);
+    });
+    it('partial override: only ladder overridden at template level', () => {
+        const templateRetry = {
+            ladder: [{ cycle: 1, strategy: 'escalate-human' }],
+        };
+        const phaseRetry = { maxAttempts: 7 };
+        const result = resolveRetryConfig(templateRetry, phaseRetry, globalEscalation);
+        // maxAttempts falls through to phase, ladder from template
+        expect(result.maxAttempts).toBe(7);
+        expect(result.ladder).toEqual([{ cycle: 1, strategy: 'escalate-human' }]);
+    });
+    it('global escalation without maxSessionsPerPhase falls back to default', () => {
+        const escalationNoPhaseMax = {
+            ladder: [{ cycle: 1, strategy: 'normal' }],
+            circuitBreaker: {
+                maxSessionsPerIssue: 8,
+            },
+        };
+        const result = resolveRetryConfig(undefined, undefined, escalationNoPhaseMax);
+        expect(result.maxAttempts).toBe(3); // default
+        expect(result.ladder).toEqual([{ cycle: 1, strategy: 'normal' }]);
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveTimeoutConfig
+// ---------------------------------------------------------------------------
+describe('resolveTimeoutConfig', () => {
+    it('template timeout overrides phase timeout', () => {
+        const templateTimeout = { duration: '30m', action: 'fail' };
+        const phaseTimeout = { duration: '2h', action: 'escalate' };
+        const result = resolveTimeoutConfig(templateTimeout, phaseTimeout);
+        expect(result).not.toBeNull();
+        expect(result.durationMs).toBe(1_800_000); // 30m
+        expect(result.action).toBe('fail');
+    });
+    it('phase timeout used when no template timeout', () => {
+        const phaseTimeout = { duration: '2h', action: 'escalate' };
+        const result = resolveTimeoutConfig(undefined, phaseTimeout);
+        expect(result).not.toBeNull();
+        expect(result.durationMs).toBe(7_200_000); // 2h
+        expect(result.action).toBe('escalate');
+    });
+    it('returns null when no timeout configured', () => {
+        const result = resolveTimeoutConfig(undefined, undefined);
+        expect(result).toBeNull();
+    });
+    it('resolves "1d" duration correctly', () => {
+        const timeout = { duration: '1d', action: 'skip' };
+        const result = resolveTimeoutConfig(timeout);
+        expect(result).not.toBeNull();
+        expect(result.durationMs).toBe(86_400_000); // 1d
+        expect(result.action).toBe('skip');
+    });
+    it('resolves "90m" duration correctly', () => {
+        const timeout = { duration: '90m', action: 'escalate' };
+        const result = resolveTimeoutConfig(timeout);
+        expect(result).not.toBeNull();
+        expect(result.durationMs).toBe(5_400_000); // 90m
+    });
+    it('handles skip action', () => {
+        const timeout = { duration: '1h', action: 'skip' };
+        const result = resolveTimeoutConfig(timeout);
+        expect(result).not.toBeNull();
+        expect(result.action).toBe('skip');
+    });
+    it('handles fail action', () => {
+        const timeout = { duration: '1h', action: 'fail' };
+        const result = resolveTimeoutConfig(timeout);
+        expect(result).not.toBeNull();
+        expect(result.action).toBe('fail');
+    });
+});

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

@@ -0,0 +1,21 @@
+import type { ParallelTask, ParallelismResult, ParallelismStrategy, ParallelismStrategyOptions } from '../parallelism-types.js';
+/**
+ * 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 declare class FanInStrategy implements ParallelismStrategy {
+    execute(tasks: ParallelTask[], options: ParallelismStrategyOptions): Promise<ParallelismResult>;
+}
+//# sourceMappingURL=fan-in-strategy.d.ts.map

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

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