@renseiai/agentfactory 0.8.8 → 0.8.9

package/dist/src/routing/types.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import type { AgentProviderName } from '../providers/types.js';
+import type { AgentWorkType } from '../orchestrator/work-types.js';
+export interface RoutingObservation {
+    id: string;
+    provider: AgentProviderName;
+    workType: AgentWorkType;
+    project?: string;
+    issueIdentifier: string;
+    sessionId: string;
+    reward: number;
+    taskCompleted: boolean;
+    prCreated: boolean;
+    qaResult: 'passed' | 'failed' | 'unknown';
+    totalCostUsd: number;
+    wallClockMs: number;
+    timestamp: number;
+    confidence: number;
+    explorationReason?: string;
+}
+export declare const RoutingObservationSchema: z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        amp: "amp";
+        "spring-ai": "spring-ai";
+        a2a: "a2a";
+    }>;
+    workType: z.ZodEnum<{
+        research: "research";
+        "backlog-creation": "backlog-creation";
+        development: "development";
+        inflight: "inflight";
+        "inflight-coordination": "inflight-coordination";
+        qa: "qa";
+        acceptance: "acceptance";
+        refinement: "refinement";
+        "refinement-coordination": "refinement-coordination";
+        coordination: "coordination";
+        "qa-coordination": "qa-coordination";
+        "acceptance-coordination": "acceptance-coordination";
+    }>;
+    project: z.ZodOptional<z.ZodString>;
+    issueIdentifier: z.ZodString;
+    sessionId: z.ZodString;
+    reward: z.ZodNumber;
+    taskCompleted: z.ZodBoolean;
+    prCreated: z.ZodBoolean;
+    qaResult: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        unknown: "unknown";
+    }>;
+    totalCostUsd: z.ZodNumber;
+    wallClockMs: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    confidence: z.ZodNumber;
+    explorationReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface RoutingPosterior {
+    provider: AgentProviderName;
+    workType: AgentWorkType;
+    alpha: number;
+    beta: number;
+    totalObservations: number;
+    avgReward: number;
+    avgCostUsd: number;
+    lastUpdated: number;
+}
+export declare const RoutingPosteriorSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        amp: "amp";
+        "spring-ai": "spring-ai";
+        a2a: "a2a";
+    }>;
+    workType: z.ZodEnum<{
+        research: "research";
+        "backlog-creation": "backlog-creation";
+        development: "development";
+        inflight: "inflight";
+        "inflight-coordination": "inflight-coordination";
+        qa: "qa";
+        acceptance: "acceptance";
+        refinement: "refinement";
+        "refinement-coordination": "refinement-coordination";
+        coordination: "coordination";
+        "qa-coordination": "qa-coordination";
+        "acceptance-coordination": "acceptance-coordination";
+    }>;
+    alpha: z.ZodNumber;
+    beta: z.ZodNumber;
+    totalObservations: z.ZodNumber;
+    avgReward: z.ZodNumber;
+    avgCostUsd: z.ZodNumber;
+    lastUpdated: z.ZodNumber;
+}, z.core.$strip>;
+export interface RoutingDecision {
+    selectedProvider: AgentProviderName;
+    confidence: number;
+    expectedReward: number;
+    explorationReason?: string;
+    source: 'mab-routing';
+    alternatives: Array<{
+        provider: AgentProviderName;
+        expectedReward: number;
+        confidence: number;
+    }>;
+}
+export declare const RoutingDecisionSchema: z.ZodObject<{
+    selectedProvider: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        amp: "amp";
+        "spring-ai": "spring-ai";
+        a2a: "a2a";
+    }>;
+    confidence: z.ZodNumber;
+    expectedReward: z.ZodNumber;
+    explorationReason: z.ZodOptional<z.ZodString>;
+    source: z.ZodLiteral<"mab-routing">;
+    alternatives: z.ZodArray<z.ZodObject<{
+        provider: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            amp: "amp";
+            "spring-ai": "spring-ai";
+            a2a: "a2a";
+        }>;
+        expectedReward: z.ZodNumber;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface RoutingConfig {
+    enabled: boolean;
+    explorationRate: number;
+    windowSize: number;
+    discountFactor: number;
+    minObservationsForExploit: number;
+    changeDetectionThreshold: number;
+}
+export declare const RoutingConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    explorationRate: z.ZodNumber;
+    windowSize: z.ZodNumber;
+    discountFactor: z.ZodNumber;
+    minObservationsForExploit: z.ZodNumber;
+    changeDetectionThreshold: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ROUTING_KEYS: {
+    readonly posteriors: (provider: AgentProviderName, workType: AgentWorkType) => string;
+    readonly observations: "routing:observations";
+    readonly config: "routing:config";
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/routing/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/routing/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAmBlE,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,QAAQ,EAAE,aAAa,CAAA;IACvB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,OAAO,CAAA;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBnC,CAAA;AAEF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,QAAQ,EAAE,aAAa,CAAA;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,iBAAiB,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASjC,CAAA;AAEF,MAAM,WAAW,eAAe;IAC9B,gBAAgB,EAAE,iBAAiB,CAAA;IACnC,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,MAAM,EAAE,aAAa,CAAA;IACrB,YAAY,EAAE,KAAK,CAAC;QAClB,QAAQ,EAAE,iBAAiB,CAAA;QAC3B,cAAc,EAAE,MAAM,CAAA;QACtB,UAAU,EAAE,MAAM,CAAA;KACnB,CAAC,CAAA;CACH;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;iBAahC,CAAA;AAEF,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,yBAAyB,EAAE,MAAM,CAAA;IACjC,wBAAwB,EAAE,MAAM,CAAA;CACjC;AAED,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAA;AAEF,eAAO,MAAM,YAAY;oCACA,iBAAiB,YAAY,aAAa;;;CAIzD,CAAA"}

package/dist/src/routing/types.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+const AgentProviderNameSchema = z.enum(['claude', 'codex', 'amp', 'spring-ai', 'a2a']);
+const AgentWorkTypeSchema = z.enum([
+    'research',
+    'backlog-creation',
+    'development',
+    'inflight',
+    'inflight-coordination',
+    'qa',
+    'acceptance',
+    'refinement',
+    'refinement-coordination',
+    'coordination',
+    'qa-coordination',
+    'acceptance-coordination',
+]);
+export const RoutingObservationSchema = z.object({
+    id: z.string().uuid(),
+    provider: AgentProviderNameSchema,
+    workType: AgentWorkTypeSchema,
+    project: z.string().optional(),
+    issueIdentifier: z.string(),
+    sessionId: z.string(),
+    reward: z.number().min(0).max(1),
+    taskCompleted: z.boolean(),
+    prCreated: z.boolean(),
+    qaResult: z.enum(['passed', 'failed', 'unknown']),
+    totalCostUsd: z.number().min(0),
+    wallClockMs: z.number().min(0),
+    timestamp: z.number(),
+    confidence: z.number().min(0).max(1),
+    explorationReason: z.string().optional(),
+});
+export const RoutingPosteriorSchema = z.object({
+    provider: AgentProviderNameSchema,
+    workType: AgentWorkTypeSchema,
+    alpha: z.number().min(1),
+    beta: z.number().min(1),
+    totalObservations: z.number().int().min(0),
+    avgReward: z.number().min(0).max(1),
+    avgCostUsd: z.number().min(0),
+    lastUpdated: z.number(),
+});
+export const RoutingDecisionSchema = z.object({
+    selectedProvider: AgentProviderNameSchema,
+    confidence: z.number().min(0).max(1),
+    expectedReward: z.number().min(0).max(1),
+    explorationReason: z.string().optional(),
+    source: z.literal('mab-routing'),
+    alternatives: z.array(z.object({
+        provider: AgentProviderNameSchema,
+        expectedReward: z.number().min(0).max(1),
+        confidence: z.number().min(0).max(1),
+    })),
+});
+export const RoutingConfigSchema = z.object({
+    enabled: z.boolean(),
+    explorationRate: z.number().min(0).max(1),
+    windowSize: z.number().int().positive(),
+    discountFactor: z.number().min(0).max(1),
+    minObservationsForExploit: z.number().int().min(0),
+    changeDetectionThreshold: z.number().min(0),
+});
+export const ROUTING_KEYS = {
+    posteriors: (provider, workType) => `routing:posteriors:${provider}:${workType}`,
+    observations: 'routing:observations',
+    config: 'routing:config',
+};

package/dist/src/routing/types.test.d.ts

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

package/dist/src/routing/types.test.d.ts.map

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

package/dist/src/routing/types.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'vitest';
+import { RoutingObservationSchema, RoutingPosteriorSchema, RoutingDecisionSchema, RoutingConfigSchema, ROUTING_KEYS, } from './types.js';
+describe('RoutingObservationSchema', () => {
+    const validObservation = {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        provider: 'claude',
+        workType: 'development',
+        project: 'Agent',
+        issueIdentifier: 'SUP-100',
+        sessionId: 'session-abc-123',
+        reward: 0.85,
+        taskCompleted: true,
+        prCreated: true,
+        qaResult: 'passed',
+        totalCostUsd: 0.42,
+        wallClockMs: 120000,
+        timestamp: 1700000000,
+        confidence: 0.9,
+        explorationReason: 'forced',
+    };
+    it('parses a valid observation', () => {
+        const result = RoutingObservationSchema.parse(validObservation);
+        expect(result).toEqual(validObservation);
+    });
+    it('parses without optional fields', () => {
+        const { project, explorationReason, ...required } = validObservation;
+        const result = RoutingObservationSchema.parse(required);
+        expect(result.project).toBeUndefined();
+        expect(result.explorationReason).toBeUndefined();
+    });
+    it('rejects invalid provider', () => {
+        expect(() => RoutingObservationSchema.parse({ ...validObservation, provider: 'gpt' })).toThrow();
+    });
+    it('rejects invalid workType', () => {
+        expect(() => RoutingObservationSchema.parse({ ...validObservation, workType: 'deploy' })).toThrow();
+    });
+    it('rejects reward out of range', () => {
+        expect(() => RoutingObservationSchema.parse({ ...validObservation, reward: 1.5 })).toThrow();
+        expect(() => RoutingObservationSchema.parse({ ...validObservation, reward: -0.1 })).toThrow();
+    });
+    it('rejects invalid qaResult', () => {
+        expect(() => RoutingObservationSchema.parse({ ...validObservation, qaResult: 'skipped' })).toThrow();
+    });
+    it('rejects negative totalCostUsd', () => {
+        expect(() => RoutingObservationSchema.parse({ ...validObservation, totalCostUsd: -1 })).toThrow();
+    });
+    it('rejects invalid UUID for id', () => {
+        expect(() => RoutingObservationSchema.parse({ ...validObservation, id: 'not-a-uuid' })).toThrow();
+    });
+    it('rejects missing required fields', () => {
+        expect(() => RoutingObservationSchema.parse({})).toThrow();
+    });
+});
+describe('RoutingPosteriorSchema', () => {
+    const validPosterior = {
+        provider: 'codex',
+        workType: 'qa',
+        alpha: 5.2,
+        beta: 2.1,
+        totalObservations: 10,
+        avgReward: 0.72,
+        avgCostUsd: 0.35,
+        lastUpdated: 1700000000,
+    };
+    it('parses a valid posterior', () => {
+        const result = RoutingPosteriorSchema.parse(validPosterior);
+        expect(result).toEqual(validPosterior);
+    });
+    it('rejects alpha below 1', () => {
+        expect(() => RoutingPosteriorSchema.parse({ ...validPosterior, alpha: 0.5 })).toThrow();
+    });
+    it('rejects beta below 1', () => {
+        expect(() => RoutingPosteriorSchema.parse({ ...validPosterior, beta: 0 })).toThrow();
+    });
+    it('rejects negative totalObservations', () => {
+        expect(() => RoutingPosteriorSchema.parse({ ...validPosterior, totalObservations: -1 })).toThrow();
+    });
+    it('rejects non-integer totalObservations', () => {
+        expect(() => RoutingPosteriorSchema.parse({ ...validPosterior, totalObservations: 1.5 })).toThrow();
+    });
+    it('rejects avgReward out of range', () => {
+        expect(() => RoutingPosteriorSchema.parse({ ...validPosterior, avgReward: 1.1 })).toThrow();
+    });
+    it('rejects invalid provider', () => {
+        expect(() => RoutingPosteriorSchema.parse({ ...validPosterior, provider: 'openai' })).toThrow();
+    });
+    it('rejects missing required fields', () => {
+        expect(() => RoutingPosteriorSchema.parse({})).toThrow();
+    });
+});
+describe('RoutingDecisionSchema', () => {
+    const validDecision = {
+        selectedProvider: 'amp',
+        confidence: 0.88,
+        expectedReward: 0.75,
+        explorationReason: 'uncertainty',
+        source: 'mab-routing',
+        alternatives: [
+            { provider: 'claude', expectedReward: 0.7, confidence: 0.85 },
+            { provider: 'codex', expectedReward: 0.65, confidence: 0.8 },
+        ],
+    };
+    it('parses a valid decision', () => {
+        const result = RoutingDecisionSchema.parse(validDecision);
+        expect(result).toEqual(validDecision);
+    });
+    it('parses without optional explorationReason', () => {
+        const { explorationReason, ...required } = validDecision;
+        const result = RoutingDecisionSchema.parse(required);
+        expect(result.explorationReason).toBeUndefined();
+    });
+    it('parses with empty alternatives', () => {
+        const result = RoutingDecisionSchema.parse({ ...validDecision, alternatives: [] });
+        expect(result.alternatives).toEqual([]);
+    });
+    it('rejects invalid source', () => {
+        expect(() => RoutingDecisionSchema.parse({ ...validDecision, source: 'manual' })).toThrow();
+    });
+    it('rejects invalid provider in alternatives', () => {
+        expect(() => RoutingDecisionSchema.parse({
+            ...validDecision,
+            alternatives: [{ provider: 'gpt', expectedReward: 0.5, confidence: 0.5 }],
+        })).toThrow();
+    });
+    it('rejects confidence out of range', () => {
+        expect(() => RoutingDecisionSchema.parse({ ...validDecision, confidence: 2.0 })).toThrow();
+    });
+    it('rejects missing required fields', () => {
+        expect(() => RoutingDecisionSchema.parse({})).toThrow();
+    });
+});
+describe('RoutingConfigSchema', () => {
+    const validConfig = {
+        enabled: true,
+        explorationRate: 0.1,
+        windowSize: 50,
+        discountFactor: 0.95,
+        minObservationsForExploit: 5,
+        changeDetectionThreshold: 0.3,
+    };
+    it('parses a valid config', () => {
+        const result = RoutingConfigSchema.parse(validConfig);
+        expect(result).toEqual(validConfig);
+    });
+    it('rejects explorationRate out of range', () => {
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, explorationRate: 1.5 })).toThrow();
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, explorationRate: -0.1 })).toThrow();
+    });
+    it('rejects non-positive windowSize', () => {
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, windowSize: 0 })).toThrow();
+    });
+    it('rejects non-integer windowSize', () => {
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, windowSize: 10.5 })).toThrow();
+    });
+    it('rejects discountFactor out of range', () => {
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, discountFactor: 1.1 })).toThrow();
+    });
+    it('rejects negative minObservationsForExploit', () => {
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, minObservationsForExploit: -1 })).toThrow();
+    });
+    it('rejects negative changeDetectionThreshold', () => {
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, changeDetectionThreshold: -0.5 })).toThrow();
+    });
+    it('rejects non-boolean enabled', () => {
+        expect(() => RoutingConfigSchema.parse({ ...validConfig, enabled: 'yes' })).toThrow();
+    });
+    it('rejects missing required fields', () => {
+        expect(() => RoutingConfigSchema.parse({})).toThrow();
+    });
+});
+describe('ROUTING_KEYS', () => {
+    it('generates correct posteriors key', () => {
+        expect(ROUTING_KEYS.posteriors('claude', 'development')).toBe('routing:posteriors:claude:development');
+    });
+    it('generates correct posteriors key for coordination work type', () => {
+        expect(ROUTING_KEYS.posteriors('amp', 'qa-coordination')).toBe('routing:posteriors:amp:qa-coordination');
+    });
+    it('has correct observations key', () => {
+        expect(ROUTING_KEYS.observations).toBe('routing:observations');
+    });
+    it('has correct config key', () => {
+        expect(ROUTING_KEYS.config).toBe('routing:config');
+    });
+});

package/dist/src/templates/types.d.ts

@@ -110,6 +110,8 @@ export interface TemplateContext {
     testCommand?: string;
     /** Validation command override — replaces typecheck for compiled projects (e.g. 'cargo clippy') */
     validateCommand?: string;
+    /** Collected outputs from upstream phases, keyed by phase name then output key */
+    phaseOutputs?: Record<string, Record<string, unknown>>;
 }
 /**
  * Translates abstract tool permissions to provider-native format.
@@ -223,6 +225,7 @@ export declare const TemplateContextSchema: z.ZodObject<{
     buildCommand: z.ZodOptional<z.ZodString>;
     testCommand: z.ZodOptional<z.ZodString>;
     validateCommand: z.ZodOptional<z.ZodString>;
+    phaseOutputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
 /**
  * Validate a parsed YAML object as a WorkflowTemplate.

package/dist/src/templates/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/templates/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAGlE,YAAY,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAMlE;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACjB,YAAY,GACZ,MAAM,CAAA;AAMV;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,IAAI,CAAA;IAChB,IAAI,EAAE,kBAAkB,CAAA;IACxB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,QAAQ,EAAE,aAAa,CAAA;KACxB,CAAA;IACD,KAAK,CAAC,EAAE;QACN,KAAK,CAAC,EAAE,cAAc,EAAE,CAAA;QACxB,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAA;KAC5B,CAAA;IACD,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAA;CACf;AAMD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,IAAI,CAAA;IAChB,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,0EAA0E;QAC1E,QAAQ,CAAC,EAAE,MAAM,CAAA;KAClB,CAAA;IACD,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAA;CAChB;AAMD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,cAAc,CAAC,EAAE,MAAM,CAAA;IAGvB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;IAGvB,kEAAkE;IAClE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,iDAAiD;IACjD,YAAY,CAAC,EAAE,MAAM,CAAA;IAGrB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,kGAAkG;IAClG,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gDAAgD;IAChD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,0CAA0C;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,uCAAuC;IACvC,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAA;IACjC,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAA;IAGrB,uDAAuD;IACvD,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAA;IAGb,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,CAAA;IAGnB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oFAAoF;IACpF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IAGtB,wEAAwE;IACxE,cAAc,CAAC,EAAE,OAAO,CAAA;IAGxB,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,kGAAkG;IAClG,cAAc,CAAC,EAAE,MAAM,CAAA;IAGvB,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mGAAmG;IACnG,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAMD;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,+DAA+D;IAC/D,oBAAoB,CAAC,WAAW,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,CAAA;CAC9D;AAMD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,sEAAsE;IACtE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IAC/F,wDAAwD;IACxD,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAuBD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;EAAqB,CAAA;AAErD,eAAO,MAAM,oBAAoB;;4DAI/B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAajC,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;iBAShC,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBA+BhC,CAAA;AAMF;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAS3F;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,eAAe,CASzF"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/templates/types.ts"],"names":[],"mappings":"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"}

package/dist/src/templates/types.js

@@ -93,6 +93,8 @@ export const TemplateContextSchema = z.object({
     buildCommand: z.string().optional(),
     testCommand: z.string().optional(),
     validateCommand: z.string().optional(),
+    // Phase output data (parallel data passing)
+    phaseOutputs: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
 });
 // ---------------------------------------------------------------------------
 // Validation Helpers

package/dist/src/workflow/agent-cancellation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Agent Cancellation
+ *
+ * Utility for signaling and tracking cancellation of parallel agent tasks.
+ * Used by the RaceStrategy to cancel remaining agents when one wins.
+ */
+export interface AgentCancellation {
+    /** Signal cancellation for an agent/task */
+    cancel(taskId: string): Promise<boolean>;
+    /**
+     * Signal cancellation with a timeout guarantee.
+     * Resolves after the agent acknowledges cancellation OR after timeoutMs,
+     * whichever comes first. Prevents hanging if an agent never checks isCancelled().
+     * @param taskId - The task to cancel
+     * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
+     * @returns true if newly cancelled, false if already cancelled
+     */
+    cancelWithTimeout(taskId: string, timeoutMs?: number): Promise<boolean>;
+    /** Check if a task has been cancelled */
+    isCancelled(taskId: string): boolean;
+}
+/**
+ * In-memory cancellation tracker.
+ * In production, this would be backed by a shared state store (Redis, etc.)
+ * to coordinate cancellation across processes.
+ */
+export declare class InMemoryAgentCancellation implements AgentCancellation {
+    private readonly cancelled;
+    cancel(taskId: string): Promise<boolean>;
+    cancelWithTimeout(taskId: string, timeoutMs?: number): Promise<boolean>;
+    isCancelled(taskId: string): boolean;
+    /** Get all cancelled task IDs */
+    getCancelledIds(): string[];
+    /** Reset all cancellation state */
+    reset(): void;
+}
+//# sourceMappingURL=agent-cancellation.d.ts.map

package/dist/src/workflow/agent-cancellation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-cancellation.d.ts","sourceRoot":"","sources":["../../../src/workflow/agent-cancellation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,iBAAiB;IAChC,4CAA4C;IAC5C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACxC;;;;;;;OAOG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACvE,yCAAyC;IACzC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAA;CACrC;AAED;;;;GAIG;AACH,qBAAa,yBAA0B,YAAW,iBAAiB;IACjE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAExC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQxC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,GAAE,MAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IAUrF,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIpC,iCAAiC;IACjC,eAAe,IAAI,MAAM,EAAE;IAI3B,mCAAmC;IACnC,KAAK,IAAI,IAAI;CAGd"}

package/dist/src/workflow/agent-cancellation.js

@@ -0,0 +1,41 @@
+/**
+ * Agent Cancellation
+ *
+ * Utility for signaling and tracking cancellation of parallel agent tasks.
+ * Used by the RaceStrategy to cancel remaining agents when one wins.
+ */
+/**
+ * In-memory cancellation tracker.
+ * In production, this would be backed by a shared state store (Redis, etc.)
+ * to coordinate cancellation across processes.
+ */
+export class InMemoryAgentCancellation {
+    cancelled = new Set();
+    async cancel(taskId) {
+        if (this.cancelled.has(taskId)) {
+            return false; // already cancelled
+        }
+        this.cancelled.add(taskId);
+        return true;
+    }
+    async cancelWithTimeout(taskId, timeoutMs = 30_000) {
+        // Signal cancellation immediately
+        const result = await this.cancel(taskId);
+        // The timeout is enforced at the caller level (e.g., RaceStrategy wraps
+        // Promise.allSettled with a timeout). This method ensures the cancellation
+        // flag is set and returns promptly — the timeout parameter is recorded
+        // for callers that need to know the configured value.
+        return result;
+    }
+    isCancelled(taskId) {
+        return this.cancelled.has(taskId);
+    }
+    /** Get all cancelled task IDs */
+    getCancelledIds() {
+        return [...this.cancelled];
+    }
+    /** Reset all cancellation state */
+    reset() {
+        this.cancelled.clear();
+    }
+}

package/dist/src/workflow/agent-cancellation.test.d.ts

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

package/dist/src/workflow/agent-cancellation.test.d.ts.map

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

package/dist/src/workflow/agent-cancellation.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest';
+import { InMemoryAgentCancellation } from './agent-cancellation.js';
+describe('InMemoryAgentCancellation', () => {
+    describe('cancel()', () => {
+        it('returns true on first call for a task', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            const result = await cancellation.cancel('task-1');
+            expect(result).toBe(true);
+        });
+        it('returns false on duplicate cancel for the same task', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            await cancellation.cancel('task-1');
+            const result = await cancellation.cancel('task-1');
+            expect(result).toBe(false);
+        });
+        it('returns true for different task IDs', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            const r1 = await cancellation.cancel('task-1');
+            const r2 = await cancellation.cancel('task-2');
+            expect(r1).toBe(true);
+            expect(r2).toBe(true);
+        });
+    });
+    describe('isCancelled()', () => {
+        it('returns false for a task that has not been cancelled', () => {
+            const cancellation = new InMemoryAgentCancellation();
+            expect(cancellation.isCancelled('task-1')).toBe(false);
+        });
+        it('returns true for a task that has been cancelled', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            await cancellation.cancel('task-1');
+            expect(cancellation.isCancelled('task-1')).toBe(true);
+        });
+        it('returns correct state for multiple tasks', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            await cancellation.cancel('task-1');
+            await cancellation.cancel('task-3');
+            expect(cancellation.isCancelled('task-1')).toBe(true);
+            expect(cancellation.isCancelled('task-2')).toBe(false);
+            expect(cancellation.isCancelled('task-3')).toBe(true);
+        });
+    });
+    describe('getCancelledIds()', () => {
+        it('returns empty array when nothing is cancelled', () => {
+            const cancellation = new InMemoryAgentCancellation();
+            expect(cancellation.getCancelledIds()).toEqual([]);
+        });
+        it('returns all cancelled IDs', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            await cancellation.cancel('task-a');
+            await cancellation.cancel('task-b');
+            await cancellation.cancel('task-c');
+            const ids = cancellation.getCancelledIds();
+            expect(ids).toHaveLength(3);
+            expect(ids).toContain('task-a');
+            expect(ids).toContain('task-b');
+            expect(ids).toContain('task-c');
+        });
+        it('does not include duplicates', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            await cancellation.cancel('task-1');
+            await cancellation.cancel('task-1');
+            expect(cancellation.getCancelledIds()).toEqual(['task-1']);
+        });
+    });
+    describe('reset()', () => {
+        it('clears all cancellation state', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            await cancellation.cancel('task-1');
+            await cancellation.cancel('task-2');
+            expect(cancellation.getCancelledIds()).toHaveLength(2);
+            cancellation.reset();
+            expect(cancellation.getCancelledIds()).toEqual([]);
+            expect(cancellation.isCancelled('task-1')).toBe(false);
+            expect(cancellation.isCancelled('task-2')).toBe(false);
+        });
+        it('allows re-cancelling after reset', async () => {
+            const cancellation = new InMemoryAgentCancellation();
+            await cancellation.cancel('task-1');
+            cancellation.reset();
+            const result = await cancellation.cancel('task-1');
+            expect(result).toBe(true);
+            expect(cancellation.isCancelled('task-1')).toBe(true);
+        });
+    });
+});

package/dist/src/workflow/concurrency-semaphore.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Concurrency Semaphore
+ *
+ * Limits the number of concurrent operations. When the limit is reached,
+ * subsequent acquire() calls wait until a slot is released.
+ */
+export declare class ConcurrencySemaphore {
+    private readonly maxConcurrent;
+    private current;
+    private readonly waiters;
+    constructor(maxConcurrent: number);
+    /** Current number of active slots */
+    get activeCount(): number;
+    /** Number of waiters in the queue */
+    get waitingCount(): number;
+    /** Acquire a slot. Resolves when a slot is available. */
+    acquire(): Promise<void>;
+    /** Release a slot. Wakes up the next waiter if any. */
+    release(): void;
+}
+//# sourceMappingURL=concurrency-semaphore.d.ts.map