@renseiai/agentfactory 0.8.7 → 0.8.9

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

@@ -15,6 +15,27 @@ import { z } from 'zod';
  * Mirrors the hard-coded ladder in agent-tracking.ts:computeStrategy().
  */
 export type EscalationStrategy = 'normal' | 'context-enriched' | 'decompose' | 'escalate-human';
+/**
+ * Declares a structured output that a phase produces.
+ * Outputs are extracted from agent results using marker comments.
+ */
+export interface PhaseOutputDeclaration {
+    /** Data type of the output value */
+    type: 'string' | 'json' | 'url' | 'boolean';
+    /** Human-readable description of the output */
+    description?: string;
+    /** Whether this output must be present (default: false) */
+    required?: boolean;
+}
+/**
+ * Declares an input dependency on an upstream phase's output.
+ */
+export interface PhaseInputDeclaration {
+    /** Reference to upstream output in "phaseName.outputKey" format */
+    from: string;
+    /** Human-readable description of the input */
+    description?: string;
+}
 /**
  * A phase in the workflow graph. Each phase references a WorkflowTemplate
  * by name and optionally provides strategy-specific template variants.
@@ -32,6 +53,34 @@ export interface PhaseDefinition {
      * Example: { "context-enriched": "refinement-context-enriched" }
      */
     variants?: Record<string, string>;
+    /** Per-template retry configuration override */
+    retry?: TemplateRetryConfig;
+    /** Per-template timeout configuration */
+    timeout?: TemplateTimeoutConfig;
+    /**
+     * Structured outputs this phase produces.
+     * Keys are output names; values describe the output type and requirements.
+     *
+     * Outputs are extracted from agent session results using marker comments
+     * and made available to downstream phases via {@link PhaseInputDeclaration.from}.
+     *
+     * When a phase runs inside a parallelism group, each parallel branch
+     * produces its own output values. Downstream phases that declare inputs
+     * referencing these outputs receive an aggregated array of all branch values
+     * (e.g., an array of PR URLs from all parallel development branches).
+     */
+    outputs?: Record<string, PhaseOutputDeclaration>;
+    /**
+     * Input dependencies on upstream phase outputs.
+     * Keys are local input names; values reference upstream outputs
+     * using "phaseName.outputKey" dot-notation in the `from` field.
+     *
+     * The orchestrator resolves these references before phase execution,
+     * injecting the upstream output values into the agent session context.
+     * If the upstream phase is part of a parallelism group, the input receives
+     * the collected array of all branch outputs rather than a single value.
+     */
+    inputs?: Record<string, PhaseInputDeclaration>;
 }
 /**
  * A transition edge in the workflow graph. Maps a Linear status to a phase.
@@ -105,21 +154,116 @@ export interface GateDefinition {
 }
 /**
  * Defines a group of phases that can execute concurrently.
+ *
+ * Parallelism groups allow the orchestrator to spawn multiple concurrent
+ * executions of the listed phases (e.g., one per sub-issue). The strategy
+ * controls how branches are dispatched and how their results are collected.
+ *
+ * **Strategies:**
+ *
+ * - **fan-out** -- Spawn one execution per work item and let them run
+ *   independently. Use when downstream phases do not depend on the results
+ *   of all branches completing (e.g., independent deploys).
+ *
+ * - **fan-in** -- Spawn one execution per work item and **wait for every
+ *   branch to complete** before allowing downstream phases to proceed. Use
+ *   when a subsequent phase (e.g., QA) needs the collected outputs from all
+ *   branches (e.g., all PR URLs). This is the most common strategy for
+ *   parallel sub-issue development.
+ *
+ * - **race** -- Spawn multiple executions but **only keep the first one
+ *   that succeeds**, cancelling the rest. Use for speculative execution
+ *   where multiple approaches are tried and the fastest wins (e.g.,
+ *   competing solution strategies).
+ *
+ * **Output aggregation:** When phases inside a parallelism group declare
+ * `outputs`, each branch produces its own values. Downstream phases that
+ * reference those outputs via `inputs.from` receive an aggregated array
+ * of all branch results (fan-in) or the winning branch's result (race).
  */
 export interface ParallelismGroupDefinition {
-    /** Unique group name */
+    /** Unique group name used to reference this parallelism configuration */
     name: string;
-    /** Human-readable description */
+    /** Human-readable description of the parallelism group's purpose */
     description?: string;
-    /** Phase names to execute in parallel */
+    /**
+     * Phase names to execute in parallel. Each listed phase must be defined
+     * in the top-level `phases` array. The orchestrator spawns concurrent
+     * executions of these phases (e.g., one per sub-issue).
+     */
     phases: string[];
-    /** Parallelism strategy: fan-out, fan-in, or race */
+    /**
+     * Parallelism strategy controlling dispatch and result collection.
+     *
+     * - `fan-out`: fire-and-forget concurrent execution
+     * - `fan-in`: concurrent execution with barrier -- wait for all branches
+     * - `race`: concurrent execution -- keep first success, cancel the rest
+     */
     strategy: 'fan-out' | 'fan-in' | 'race';
-    /** Maximum concurrent executions (default: unlimited) */
+    /**
+     * Maximum number of concurrent branch executions (default: unlimited).
+     *
+     * This limit applies **within this parallelism group only** and is
+     * independent of the orchestrator-level `maxConcurrent` setting. The
+     * effective concurrency is the minimum of both values. For example, if
+     * the orchestrator allows 10 concurrent sessions and this group sets
+     * `maxConcurrent: 5`, at most 5 branches run at once for this group.
+     *
+     * Values above 10 trigger a validation warning as they may overwhelm
+     * downstream services or CI systems.
+     */
     maxConcurrent?: number;
-    /** Whether to wait for all parallel executions to complete */
+    /**
+     * Whether to wait for all parallel executions to complete before
+     * proceeding to downstream phases. Defaults to `false`.
+     *
+     * Typically set to `true` with the `fan-in` strategy so that a
+     * subsequent phase (e.g., QA) can consume outputs from every branch.
+     */
     waitForAll?: boolean;
 }
+/**
+ * Per-template retry configuration. Overrides phase-level and global
+ * escalation settings when attached to a phase or branching block.
+ */
+export interface TemplateRetryConfig {
+    /** Max attempts before escalation action. Overrides circuitBreaker.maxSessionsPerPhase */
+    maxAttempts?: number;
+    /** Override escalation ladder for this template */
+    ladder?: EscalationLadderRung[];
+}
+/**
+ * Per-template timeout configuration. When the duration elapses,
+ * the specified action is taken.
+ */
+export interface TemplateTimeoutConfig {
+    /** Duration string: "30m", "2h", "1d" */
+    duration: string;
+    /** Action when timeout is reached */
+    action: 'escalate' | 'skip' | 'fail';
+}
+/**
+ * A branching block that conditionally selects a template.
+ * Evaluated in order; the first matching branch wins.
+ */
+export interface BranchingDefinition {
+    /** Unique name for this branching rule */
+    name: string;
+    /** Condition expression (Handlebars-style, e.g., "{{ isParentIssue }}") */
+    condition: string;
+    /** Template to select when condition is true */
+    then: {
+        template: string;
+        retry?: TemplateRetryConfig;
+        timeout?: TemplateTimeoutConfig;
+    };
+    /** Optional template to select when condition is false */
+    else?: {
+        template: string;
+        retry?: TemplateRetryConfig;
+        timeout?: TemplateTimeoutConfig;
+    };
+}
 /**
  * A declarative workflow definition. This is the primary document kind
  * introduced in schema v1.1, replacing the hard-coded workflow graph
@@ -142,12 +286,22 @@ export interface WorkflowDefinition {
     gates?: GateDefinition[];
     /** Parallelism groups for concurrent phase execution (Phase 4) */
     parallelism?: ParallelismGroupDefinition[];
+    /** Branching blocks for conditional template selection */
+    branching?: BranchingDefinition[];
 }
-export declare const PhaseDefinitionSchema: z.ZodObject<{
-    name: z.ZodString;
+export declare const PhaseOutputDeclarationSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        boolean: "boolean";
+        url: "url";
+        json: "json";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const PhaseInputDeclarationSchema: z.ZodObject<{
+    from: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    template: z.ZodString;
-    variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export declare const TransitionDefinitionSchema: z.ZodObject<{
     from: z.ZodString;
@@ -159,6 +313,56 @@ export declare const EscalationLadderRungSchema: z.ZodObject<{
     cycle: z.ZodNumber;
     strategy: z.ZodString;
 }, z.core.$strip>;
+export declare const TemplateRetryConfigSchema: z.ZodObject<{
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+    ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        cycle: z.ZodNumber;
+        strategy: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const TemplateTimeoutConfigSchema: z.ZodObject<{
+    duration: z.ZodString;
+    action: z.ZodEnum<{
+        fail: "fail";
+        escalate: "escalate";
+        skip: "skip";
+    }>;
+}, z.core.$strip>;
+export declare const PhaseDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodString;
+    variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cycle: z.ZodNumber;
+            strategy: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    timeout: z.ZodOptional<z.ZodObject<{
+        duration: z.ZodString;
+        action: z.ZodEnum<{
+            fail: "fail";
+            escalate: "escalate";
+            skip: "skip";
+        }>;
+    }, z.core.$strip>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            url: "url";
+            json: "json";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        from: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export declare const EscalationConfigSchema: z.ZodObject<{
     ladder: z.ZodArray<z.ZodObject<{
         cycle: z.ZodNumber;
@@ -181,9 +385,9 @@ export declare const GateDefinitionSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodObject<{
         duration: z.ZodString;
         action: z.ZodEnum<{
+            fail: "fail";
             escalate: "escalate";
             skip: "skip";
-            fail: "fail";
         }>;
     }, z.core.$strip>>;
     appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -200,6 +404,46 @@ export declare const ParallelismGroupDefinitionSchema: z.ZodObject<{
     maxConcurrent: z.ZodOptional<z.ZodNumber>;
     waitForAll: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
+export declare const BranchingDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    condition: z.ZodString;
+    then: z.ZodObject<{
+        template: z.ZodString;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    else: z.ZodOptional<z.ZodObject<{
+        template: z.ZodString;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const WorkflowDefinitionSchema: z.ZodObject<{
     apiVersion: z.ZodLiteral<"v1.1">;
     kind: z.ZodLiteral<"WorkflowDefinition">;
@@ -212,6 +456,35 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         template: z.ZodString;
         variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                url: "url";
+                json: "json";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     transitions: z.ZodArray<z.ZodObject<{
         from: z.ZodString;
@@ -241,9 +514,9 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
         timeout: z.ZodOptional<z.ZodObject<{
             duration: z.ZodString;
             action: z.ZodEnum<{
+                fail: "fail";
                 escalate: "escalate";
                 skip: "skip";
-                fail: "fail";
             }>;
         }, z.core.$strip>>;
         appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -260,10 +533,55 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
         maxConcurrent: z.ZodOptional<z.ZodNumber>;
         waitForAll: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
+    branching: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        condition: z.ZodString;
+        then: z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        else: z.ZodOptional<z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 /**
  * Validate a parsed YAML object as a WorkflowDefinition.
  * Throws ZodError with detailed messages on failure.
+ *
+ * After Zod schema validation succeeds, performs cross-validation to ensure:
+ * - Parallelism group phase names reference defined phases
+ * - Phase input `from` references point to valid phase.output declarations
+ * - Warns (via console.warn) if maxConcurrent exceeds 10
  */
 export declare function validateWorkflowDefinition(data: unknown, filePath?: string): WorkflowDefinition;
 //# sourceMappingURL=workflow-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"workflow-types.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"workflow-types.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-types.ts"],"names":[],"mappings":"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"}

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

@@ -13,11 +13,14 @@ import { z } from 'zod';
 // ---------------------------------------------------------------------------
 // Zod Schemas
 // ---------------------------------------------------------------------------
-export const PhaseDefinitionSchema = z.object({
-    name: z.string().min(1),
+export const PhaseOutputDeclarationSchema = z.object({
+    type: z.enum(['string', 'json', 'url', 'boolean']),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+});
+export const PhaseInputDeclarationSchema = z.object({
+    from: z.string().min(1),
     description: z.string().optional(),
-    template: z.string().min(1),
-    variants: z.record(z.string(), z.string()).optional(),
 });
 export const TransitionDefinitionSchema = z.object({
     from: z.string().min(1),
@@ -29,6 +32,24 @@ export const EscalationLadderRungSchema = z.object({
     cycle: z.number().int().nonnegative(),
     strategy: z.string().min(1),
 });
+export const TemplateRetryConfigSchema = z.object({
+    maxAttempts: z.number().int().positive().optional(),
+    ladder: z.array(EscalationLadderRungSchema).min(1).optional(),
+});
+export const TemplateTimeoutConfigSchema = z.object({
+    duration: z.string().min(1),
+    action: z.enum(['escalate', 'skip', 'fail']),
+});
+export const PhaseDefinitionSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    template: z.string().min(1),
+    variants: z.record(z.string(), z.string()).optional(),
+    retry: TemplateRetryConfigSchema.optional(),
+    timeout: TemplateTimeoutConfigSchema.optional(),
+    outputs: z.record(z.string(), PhaseOutputDeclarationSchema).optional(),
+    inputs: z.record(z.string(), PhaseInputDeclarationSchema).optional(),
+});
 export const EscalationConfigSchema = z.object({
     ladder: z.array(EscalationLadderRungSchema).min(1),
     circuitBreaker: z.object({
@@ -55,6 +76,20 @@ export const ParallelismGroupDefinitionSchema = z.object({
     maxConcurrent: z.number().int().positive().optional(),
     waitForAll: z.boolean().optional(),
 });
+export const BranchingDefinitionSchema = z.object({
+    name: z.string().min(1),
+    condition: z.string().min(1),
+    then: z.object({
+        template: z.string().min(1),
+        retry: TemplateRetryConfigSchema.optional(),
+        timeout: TemplateTimeoutConfigSchema.optional(),
+    }),
+    else: z.object({
+        template: z.string().min(1),
+        retry: TemplateRetryConfigSchema.optional(),
+        timeout: TemplateTimeoutConfigSchema.optional(),
+    }).optional(),
+});
 export const WorkflowDefinitionSchema = z.object({
     apiVersion: z.literal('v1.1'),
     kind: z.literal('WorkflowDefinition'),
@@ -67,6 +102,7 @@ export const WorkflowDefinitionSchema = z.object({
     escalation: EscalationConfigSchema.optional(),
     gates: z.array(GateDefinitionSchema).optional(),
     parallelism: z.array(ParallelismGroupDefinitionSchema).optional(),
+    branching: z.array(BranchingDefinitionSchema).optional(),
 });
 // ---------------------------------------------------------------------------
 // Validation Helpers
@@ -74,10 +110,18 @@ export const WorkflowDefinitionSchema = z.object({
 /**
  * Validate a parsed YAML object as a WorkflowDefinition.
  * Throws ZodError with detailed messages on failure.
+ *
+ * After Zod schema validation succeeds, performs cross-validation to ensure:
+ * - Parallelism group phase names reference defined phases
+ * - Phase input `from` references point to valid phase.output declarations
+ * - Warns (via console.warn) if maxConcurrent exceeds 10
  */
 export function validateWorkflowDefinition(data, filePath) {
     try {
-        return WorkflowDefinitionSchema.parse(data);
+        const workflow = WorkflowDefinitionSchema.parse(data);
+        // Cross-validation after schema parse succeeds
+        crossValidateWorkflow(workflow, filePath);
+        return workflow;
     }
     catch (error) {
         if (filePath && error instanceof z.ZodError) {
@@ -86,3 +130,54 @@ export function validateWorkflowDefinition(data, filePath) {
         throw error;
     }
 }
+/**
+ * Perform cross-validation checks that go beyond what Zod schema can enforce.
+ * Validates referential integrity between phases, parallelism groups, and input/output declarations.
+ */
+function crossValidateWorkflow(workflow, filePath) {
+    const phaseNames = new Set(workflow.phases.map(p => p.name));
+    const phaseOutputs = new Map();
+    // Build map of phase outputs
+    for (const phase of workflow.phases) {
+        if (phase.outputs) {
+            phaseOutputs.set(phase.name, new Set(Object.keys(phase.outputs)));
+        }
+    }
+    // Validate parallelism group phase references
+    if (workflow.parallelism) {
+        for (const group of workflow.parallelism) {
+            for (const phaseName of group.phases) {
+                if (!phaseNames.has(phaseName)) {
+                    const loc = filePath ? ` in ${filePath}` : '';
+                    throw new Error(`Parallelism group "${group.name}" references undefined phase "${phaseName}"${loc}`);
+                }
+            }
+            // Warn if maxConcurrent is very high
+            if (group.maxConcurrent && group.maxConcurrent > 10) {
+                console.warn(`[workflow] Parallelism group "${group.name}" has maxConcurrent=${group.maxConcurrent} which may be excessive`);
+            }
+        }
+    }
+    // Validate phase input references
+    for (const phase of workflow.phases) {
+        if (phase.inputs) {
+            for (const [inputName, decl] of Object.entries(phase.inputs)) {
+                const parts = decl.from.split('.');
+                if (parts.length !== 2) {
+                    const loc = filePath ? ` in ${filePath}` : '';
+                    throw new Error(`Phase "${phase.name}" input "${inputName}" has invalid from reference "${decl.from}" — expected "phaseName.outputKey" format${loc}`);
+                }
+                const [sourcePhaseName, sourceOutputKey] = parts;
+                if (!phaseNames.has(sourcePhaseName)) {
+                    const loc = filePath ? ` in ${filePath}` : '';
+                    throw new Error(`Phase "${phase.name}" input "${inputName}" references undefined phase "${sourcePhaseName}"${loc}`);
+                }
+                const sourceOutputs = phaseOutputs.get(sourcePhaseName);
+                if (sourceOutputs && !sourceOutputs.has(sourceOutputKey)) {
+                    const loc = filePath ? ` in ${filePath}` : '';
+                    throw new Error(`Phase "${phase.name}" input "${inputName}" references undefined output "${sourceOutputKey}" on phase "${sourcePhaseName}"${loc}`);
+                }
+            }
+        }
+    }
+}