stageflow 0.15.0 → 0.18.0

package/dist/config/cloneChain.js

@@ -0,0 +1,322 @@
+import { loadFailure, loadSuccess } from "./loadOutcome.js";
+import { toRouteEdges, toRouteLoopEntries } from "./pipelineRoute.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function namedSchemaRef(schema) {
+    if (!isPlainObject(schema))
+        return undefined;
+    const keys = Object.keys(schema);
+    if (keys.length !== 1 || keys[0] !== "$ref")
+        return undefined;
+    const ref = schema.$ref;
+    if (typeof ref !== "string" || !ref.startsWith("#/schemas/"))
+        return undefined;
+    const name = ref.slice("#/schemas/".length);
+    if (!name || name.includes("/"))
+        return undefined;
+    return ref;
+}
+function inspectOutput(schema) {
+    const empty = {
+        namedRefArrays: [],
+        nonRefArrayFields: [],
+        isRootArray: false,
+        rootArrayRef: undefined,
+    };
+    if (!isPlainObject(schema))
+        return empty;
+    if (schema.type === "array") {
+        const ref = namedSchemaRef(schema.items);
+        return {
+            namedRefArrays: [],
+            nonRefArrayFields: ref === undefined ? ["<root>"] : [],
+            isRootArray: true,
+            rootArrayRef: ref,
+        };
+    }
+    if (schema.type !== "object" || !isPlainObject(schema.properties))
+        return empty;
+    const namedRefArrays = [];
+    const nonRefArrayFields = [];
+    for (const [field, prop] of Object.entries(schema.properties)) {
+        if (!isPlainObject(prop) || prop.type !== "array")
+            continue;
+        const ref = namedSchemaRef(prop.items);
+        if (ref !== undefined)
+            namedRefArrays.push({ field, ref });
+        else
+            nonRefArrayFields.push(field);
+    }
+    return {
+        namedRefArrays,
+        nonRefArrayFields,
+        isRootArray: false,
+        rootArrayRef: undefined,
+    };
+}
+function inboundSources(refs, targetId) {
+    return refs.filter((ref) => toRouteEdges(ref.route).some((edge) => edge.to === targetId));
+}
+function isSealedThreeStagePath(refs, stageById, refById, emitter, childId) {
+    const edges = toRouteEdges(emitter.route);
+    if (edges.length !== 1)
+        return false;
+    const childEdge = edges[0];
+    if (childEdge.to !== childId || childEdge.if !== undefined)
+        return false;
+    const childStage = stageById.get(childId);
+    const childRef = refById.get(childId);
+    if (!childStage || !childRef)
+        return false;
+    if (inboundSources(refs, childId).length !== 1)
+        return false;
+    const childEdges = toRouteEdges(childRef.route);
+    if (childEdges.length !== 1 || childEdges[0].if !== undefined)
+        return false;
+    const joinId = childEdges[0].to;
+    if (!stageById.has(joinId))
+        return false;
+    if (inboundSources(refs, joinId).length !== 1)
+        return false;
+    return true;
+}
+function dagError(pipelineId, message, stageId) {
+    return {
+        code: "pipeline.dag_error",
+        message: `Pipeline ${pipelineId}: ${message}`,
+        category: "pipeline",
+        pipelineId,
+        ...(stageId !== undefined ? { stageId } : {}),
+    };
+}
+function fail(pipelineId, message, stageId) {
+    return loadFailure([dagError(pipelineId, message, stageId)]);
+}
+function childOutputIsCloneArray(schema) {
+    const inspected = inspectOutput(schema);
+    return inspected.namedRefArrays.length > 0 || inspected.rootArrayRef !== undefined;
+}
+export function detectCloneChains(stages, refs, pipelineId) {
+    const stageById = new Map(stages.map((stage) => [stage.id, stage]));
+    const refById = new Map(refs.map((ref) => [ref.id, ref]));
+    const chains = [];
+    for (const emitter of refs) {
+        const emitterStage = stageById.get(emitter.id);
+        if (!emitterStage)
+            continue;
+        const edges = toRouteEdges(emitter.route);
+        const output = inspectOutput(emitterStage.payload_schema);
+        if (output.namedRefArrays.length >= 2 && edges.length > 0) {
+            return fail(pipelineId, `stage "${emitter.id}": Clone Chain emitter output must have exactly one named $ref Clone Array`, emitter.id);
+        }
+        if (output.isRootArray && edges.length > 0) {
+            const looksLikeChain = edges.some((edge) => {
+                const childStage = stageById.get(edge.to);
+                if (!childStage)
+                    return false;
+                if (namedSchemaRef(childStage.clone_input_schema) === undefined)
+                    return false;
+                return isSealedThreeStagePath(refs, stageById, refById, emitter, edge.to);
+            });
+            if (looksLikeChain) {
+                return fail(pipelineId, `stage "${emitter.id}": Clone Chain emitter output is a root-level array, which is not a Clone Array`, emitter.id);
+            }
+        }
+        if (output.namedRefArrays.length === 0 &&
+            output.nonRefArrayFields.length > 0 &&
+            edges.length > 0) {
+            for (const edge of edges) {
+                const childStage = stageById.get(edge.to);
+                const childRef = refById.get(edge.to);
+                if (!childStage || !childRef)
+                    continue;
+                if (namedSchemaRef(childStage.clone_input_schema) === undefined)
+                    continue;
+                if (toRouteEdges(childRef.route).length === 0)
+                    continue;
+                return fail(pipelineId, `stage "${emitter.id}": Clone Chain emitter Clone Array items must be a named $ref`, emitter.id);
+            }
+        }
+        if (output.namedRefArrays.length !== 1 || edges.length === 0)
+            continue;
+        const array = output.namedRefArrays[0];
+        const childTakesNamedRef = edges.some((edge) => {
+            const childStage = stageById.get(edge.to);
+            return (childStage !== undefined &&
+                namedSchemaRef(childStage.clone_input_schema) !== undefined);
+        });
+        const hasClonePolicy = emitter.clone_cap !== undefined || emitter.clone_mode !== undefined;
+        const sealedLookalike = edges.some((edge) => isSealedThreeStagePath(refs, stageById, refById, emitter, edge.to));
+        if (!childTakesNamedRef && !hasClonePolicy && !sealedLookalike) {
+            continue;
+        }
+        const matchingChildIds = edges
+            .filter((edge) => {
+            const childStage = stageById.get(edge.to);
+            return (childStage !== undefined &&
+                namedSchemaRef(childStage.clone_input_schema) === array.ref);
+        })
+            .map((edge) => edge.to);
+        const uniqueMatching = [...new Set(matchingChildIds)];
+        if (edges.length !== 1) {
+            if (uniqueMatching.length >= 2) {
+                return fail(pipelineId, `stage "${emitter.id}": Clone Chain emitter must have exactly one clone child`, emitter.id);
+            }
+            return fail(pipelineId, `stage "${emitter.id}": Clone Chain emitter must have exactly one forward Route (the clone child)`, emitter.id);
+        }
+        const childEdge = edges[0];
+        const cloneChildId = childEdge.to;
+        if (childEdge.if !== undefined) {
+            return fail(pipelineId, `stage "${emitter.id}": Clone Chain inbound edge to the clone child must not have if`, emitter.id);
+        }
+        const childStage = stageById.get(cloneChildId);
+        const childRef = refById.get(cloneChildId);
+        if (!childStage || !childRef) {
+            return fail(pipelineId, `stage "${emitter.id}": Clone Chain emitter must have exactly one forward Route (the clone child)`, emitter.id);
+        }
+        if (namedSchemaRef(childStage.clone_input_schema) !== array.ref) {
+            return fail(pipelineId, `stage "${cloneChildId}": Clone Chain clone child input must be exactly the named $ref of the emitter Clone Array`, cloneChildId);
+        }
+        if (inboundSources(refs, cloneChildId).length !== 1) {
+            return fail(pipelineId, `stage "${cloneChildId}": Clone Chain clone child must have exactly one parent (the emitter)`, cloneChildId);
+        }
+        const childEdges = toRouteEdges(childRef.route);
+        if (childEdges.length !== 1) {
+            return fail(pipelineId, `stage "${cloneChildId}": Clone Chain clone child must have exactly one forward Route (the Join)`, cloneChildId);
+        }
+        if (childEdges[0].if !== undefined) {
+            return fail(pipelineId, `stage "${cloneChildId}": Clone Chain inbound edge to the Join must not have if`, cloneChildId);
+        }
+        const joinId = childEdges[0].to;
+        if (!stageById.has(joinId)) {
+            return fail(pipelineId, `stage "${cloneChildId}": Clone Chain clone child must have exactly one forward Route (the Join)`, cloneChildId);
+        }
+        if (inboundSources(refs, joinId).length !== 1) {
+            return fail(pipelineId, `stage "${joinId}": Clone Chain Join must have exactly one parent (the clone child)`, joinId);
+        }
+        if (childOutputIsCloneArray(childStage.payload_schema)) {
+            return fail(pipelineId, `stage "${cloneChildId}": Clone Chain clone child output must not be a Clone Array`, cloneChildId);
+        }
+        chains.push({
+            emitterId: emitter.id,
+            cloneChildId,
+            joinId,
+            arrayField: array.field,
+            ref: array.ref,
+        });
+    }
+    const emitterIds = new Set();
+    const cloneChildIds = new Set();
+    const joinIds = new Set();
+    for (const chain of chains) {
+        if (emitterIds.has(chain.emitterId)) {
+            return fail(pipelineId, `stage "${chain.emitterId}": Clone Chain emitter is shared with another Clone Chain`, chain.emitterId);
+        }
+        if (cloneChildIds.has(chain.cloneChildId)) {
+            return fail(pipelineId, `stage "${chain.cloneChildId}": Clone Chain clone child is shared with another Clone Chain`, chain.cloneChildId);
+        }
+        if (joinIds.has(chain.joinId)) {
+            return fail(pipelineId, `stage "${chain.joinId}": Clone Chain Join is shared with another Clone Chain`, chain.joinId);
+        }
+        emitterIds.add(chain.emitterId);
+        cloneChildIds.add(chain.cloneChildId);
+        joinIds.add(chain.joinId);
+    }
+    return loadSuccess(chains);
+}
+function validateCloneChainLoops(refs, chains, pipelineId) {
+    if (chains.length === 0)
+        return loadSuccess(undefined);
+    const emitterIds = new Set(chains.map((chain) => chain.emitterId));
+    const cloneChildIds = new Set(chains.map((chain) => chain.cloneChildId));
+    const forbiddenTargets = new Map();
+    for (const chain of chains) {
+        forbiddenTargets.set(chain.emitterId, "emitter");
+        forbiddenTargets.set(chain.cloneChildId, "clone child");
+        forbiddenTargets.set(chain.joinId, "Join");
+    }
+    for (const ref of refs) {
+        const loops = toRouteLoopEntries(ref.route);
+        if (loops.length === 0)
+            continue;
+        if (emitterIds.has(ref.id)) {
+            return loadFailure([
+                dagError(pipelineId, `stage "${ref.id}": Clone Chain emitter cannot originate a Loop`, ref.id),
+            ]);
+        }
+        if (cloneChildIds.has(ref.id)) {
+            return loadFailure([
+                dagError(pipelineId, `stage "${ref.id}": Clone Chain clone child cannot originate a Loop`, ref.id),
+            ]);
+        }
+        for (const loop of loops) {
+            const role = forbiddenTargets.get(loop.to);
+            if (role === undefined)
+                continue;
+            return loadFailure([
+                dagError(pipelineId, `stage "${ref.id}": Loop target "${loop.to}" is a Clone Chain ${role}`, ref.id),
+            ]);
+        }
+    }
+    return loadSuccess(undefined);
+}
+function applyCloneCapToSchema(schema, field, cap) {
+    if (!isPlainObject(schema) || !isPlainObject(schema.properties))
+        return;
+    const prop = schema.properties[field];
+    if (!isPlainObject(prop))
+        return;
+    prop.minItems = 1;
+    prop.maxItems = cap;
+}
+export function applyCloneChains(stages, refs, dag, pipelineId) {
+    const detected = detectCloneChains(stages, refs, pipelineId);
+    if (!detected.ok)
+        return detected;
+    const chains = detected.value;
+    const emitterIds = new Set(chains.map((chain) => chain.emitterId));
+    const refById = new Map(refs.map((ref) => [ref.id, ref]));
+    const nodeById = new Map(dag.nodes.map((node) => [node.id, node]));
+    for (const ref of refs) {
+        const isEmitter = emitterIds.has(ref.id);
+        if (isEmitter) {
+            if (ref.clone_cap === undefined || ref.clone_mode === undefined) {
+                return loadFailure([
+                    dagError(pipelineId, `stage "${ref.id}": Clone Chain emitter requires clone_cap and clone_mode`, ref.id),
+                ]);
+            }
+            continue;
+        }
+        if (ref.clone_cap !== undefined) {
+            return loadFailure([
+                dagError(pipelineId, `stage "${ref.id}": "clone_cap" is no longer supported — use a Clone Chain instead`, ref.id),
+            ]);
+        }
+        if (ref.clone_mode !== undefined) {
+            return loadFailure([
+                dagError(pipelineId, `stage "${ref.id}": "clone_mode" is only valid on a Clone Chain emitter`, ref.id),
+            ]);
+        }
+    }
+    const loopsOutcome = validateCloneChainLoops(refs, chains, pipelineId);
+    if (!loopsOutcome.ok)
+        return loopsOutcome;
+    const stageById = new Map(stages.map((stage) => [stage.id, stage]));
+    for (const chain of chains) {
+        const ref = refById.get(chain.emitterId);
+        const cap = ref.clone_cap;
+        const mode = ref.clone_mode;
+        const node = nodeById.get(chain.emitterId);
+        if (node) {
+            node.clone_cap = cap;
+            node.clone_mode = mode;
+            node.clone_array_field = chain.arrayField;
+        }
+        const emitterStage = stageById.get(chain.emitterId);
+        if (emitterStage?.payload_schema !== undefined) {
+            applyCloneCapToSchema(emitterStage.payload_schema, chain.arrayField, cap);
+        }
+    }
+    return loadSuccess(undefined);
+}

package/dist/config/createPipeline.js

@@ -1,6 +1,6 @@
 import { access, mkdir, readdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { parsePipelineNeeds } from "./pipelineNeeds.js";
+import { invertPredecessorEdgesToRoute, invertRouteToPredecessorEdges, parsePipelineNeeds, toPipelineNeeds, } from "./pipelineNeeds.js";
 import { STAGE_ID_PATTERN } from "./createStage.js";
 import { inferIdFromUsesPath, normalizePipelineStageEntries, toWiringRefs, } from "./normalizePipelineStageEntry.js";
 import { parseModelField } from "./modelField.js";
@@ -29,10 +29,12 @@ export function normalizeCreatePipelineStages(stages) {
         uses: stage.uses ?? (stage.inline ? undefined : defaultUsesPath(stage.id)),
     }));
 }
-function stageRefToRaw(ref) {
+function stageRefToRaw(ref, routeInfo) {
     const raw = { id: ref.id };
-    if (ref.needs !== undefined)
-        raw.needs = ref.needs;
+    if (routeInfo?.entry)
+        raw.entry = true;
+    if (routeInfo?.route && routeInfo.route.length > 0)
+        raw.route = routeInfo.route;
     if (ref.uses !== undefined)
         raw.uses = ref.uses;
     if (ref.inline) {
@@ -47,16 +49,20 @@ function stageRefToRaw(ref) {
     return raw;
 }
 function toAuthoringRawEntries(stages, declaringPath) {
+    const routeById = invertPredecessorEdgesToRoute(stages);
     return stages.map((stage) => ({
-        raw: stageRefToRaw(stage),
+        raw: stageRefToRaw(stage, routeById.get(stage.id)),
         declaringPath,
     }));
 }
 function normalizedToCreateRefs(entries) {
+    const inbound = invertRouteToPredecessorEdges(entries);
     return entries.map((entry) => {
         const ref = { id: entry.id };
-        if (entry.needs !== undefined)
-            ref.needs = entry.needs;
+        const edges = inbound.get(entry.id);
+        const needs = edges !== undefined ? toPipelineNeeds(edges) : undefined;
+        if (needs !== undefined)
+            ref.needs = needs;
         if (entry.body.kind === "uses") {
             ref.uses = entry.body.path;
         }
@@ -236,21 +242,86 @@ export function parseCreatePipelineBody(body) {
         stages: refs,
     };
 }
-function appendNeedsYaml(lines, needs) {
-    if (typeof needs === "string") {
-        lines.push(`    needs: ${needs}`);
+function formatRouteIfValue(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value === null)
+        return "null";
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => formatRouteIfValue(item)).join(", ")}]`;
+    }
+    return JSON.stringify(value);
+}
+function appendRouteIfYamlListItem(lines, indent, predicate) {
+    if ("all" in predicate) {
+        lines.push(`${indent}- all:`);
+        for (const child of predicate.all) {
+            appendRouteIfYamlListItem(lines, `${indent}  `, child);
+        }
         return;
     }
-    lines.push("    needs:");
-    for (const edge of needs) {
-        if (edge.on.length === 1 && edge.on[0] === "succeeded") {
-            lines.push(`      - ${edge.id}`);
-            continue;
+    if ("any" in predicate) {
+        lines.push(`${indent}- any:`);
+        for (const child of predicate.any) {
+            appendRouteIfYamlListItem(lines, `${indent}  `, child);
+        }
+        return;
+    }
+    if ("not" in predicate) {
+        lines.push(`${indent}- not:`);
+        appendRouteIfYaml(lines, `${indent}    `, predicate.not);
+        return;
+    }
+    lines.push(`${indent}- field: ${formatInlineYamlScalar(predicate.field)}`);
+    lines.push(`${indent}  op: ${predicate.op}`);
+    lines.push(`${indent}  value: ${formatRouteIfValue(predicate.value)}`);
+}
+function appendRouteIfYaml(lines, indent, predicate) {
+    if ("all" in predicate) {
+        lines.push(`${indent}all:`);
+        for (const child of predicate.all) {
+            appendRouteIfYamlListItem(lines, `${indent}  `, child);
+        }
+        return;
+    }
+    if ("any" in predicate) {
+        lines.push(`${indent}any:`);
+        for (const child of predicate.any) {
+            appendRouteIfYamlListItem(lines, `${indent}  `, child);
+        }
+        return;
+    }
+    if ("not" in predicate) {
+        lines.push(`${indent}not:`);
+        appendRouteIfYaml(lines, `${indent}  `, predicate.not);
+        return;
+    }
+    lines.push(`${indent}field: ${formatInlineYamlScalar(predicate.field)}`);
+    lines.push(`${indent}op: ${predicate.op}`);
+    lines.push(`${indent}value: ${formatRouteIfValue(predicate.value)}`);
+}
+function appendRouteYaml(lines, routeInfo) {
+    if (routeInfo.entry) {
+        lines.push("    entry: true");
+    }
+    if (!routeInfo.route || routeInfo.route.length === 0) {
+        return;
+    }
+    lines.push("    route:");
+    for (const item of routeInfo.route) {
+        const on = item.on === undefined ? ["succeeded"] : Array.isArray(item.on) ? item.on : [item.on];
+        lines.push(`      - to: ${item.to}`);
+        if (!(on.length === 1 && on[0] === "succeeded")) {
+            lines.push("        on:");
+            for (const state of on) {
+                lines.push(`          - ${state}`);
+            }
         }
-        lines.push(`      - id: ${edge.id}`);
-        lines.push("        on:");
-        for (const state of edge.on) {
-            lines.push(`          - ${state}`);
+        if (item.if !== undefined) {
+            lines.push("        if:");
+            appendRouteIfYaml(lines, "          ", item.if);
         }
     }
 }
@@ -266,6 +337,7 @@ function formatInlineYamlScalar(value) {
     return value;
 }
 export function pipelineConfigToYaml(pipeline, options) {
+    const routeById = invertPredecessorEdgesToRoute(pipeline.stages);
     const lines = [`id: ${pipeline.id}`, "stages:"];
     for (const stage of pipeline.stages) {
         if (options.format === "linear" && !stage.needs && !stage.inline && stage.uses) {
@@ -274,8 +346,9 @@ export function pipelineConfigToYaml(pipeline, options) {
             continue;
         }
         lines.push(`  - id: ${stage.id}`);
-        if (stage.needs) {
-            appendNeedsYaml(lines, stage.needs);
+        const routeInfo = routeById.get(stage.id);
+        if (routeInfo) {
+            appendRouteYaml(lines, routeInfo);
         }
         if (stage.inline) {
             if (stage.inline.gate_kinds !== undefined) {
@@ -301,6 +374,13 @@ export function pipelineConfigToYaml(pipeline, options) {
             if (stage.inline.model !== undefined && stage.inline.model.length > 0) {
                 lines.push(`    model: ${formatInlineYamlScalar(stage.inline.model)}`);
             }
+            lines.push("    io:");
+            lines.push("      input:");
+            lines.push("        schema:");
+            lines.push("          type: object");
+            lines.push("      output:");
+            lines.push("        schema:");
+            lines.push("          type: object");
         }
         else if (stage.uses) {
             lines.push(`    uses: ${stage.uses}`);

package/dist/config/createStage.js

@@ -122,6 +122,13 @@ export function stageConfigToYaml(stage) {
     if (stage.model !== undefined && stage.model.length > 0) {
         lines.push(`model: ${formatInlineYamlScalar(stage.model)}`);
     }
+    lines.push("io:");
+    lines.push("  input:");
+    lines.push("    schema:");
+    lines.push("      type: object");
+    lines.push("  output:");
+    lines.push("    schema:");
+    lines.push("      type: object");
     lines.push("");
     return lines.join("\n");
 }

package/dist/config/loadOutcome.d.ts

@@ -5,6 +5,7 @@ export type LoadIssue = {
     message: string;
     category: "pipeline";
     pipelineId?: string;
+    stageId?: string;
 } | {
     code: ValidationFindingCode;
     message: string;

package/dist/config/loadPipeline.d.ts

@@ -6,8 +6,10 @@ export declare function resolvePipelinePath(pipelinePath: string, cwd: string):
 export declare function loadPipelineOutcome(nameOrPath: string, options?: {
     cwd?: string;
     projectRoot?: string;
+    requireIo?: boolean;
 }): Promise<LoadOutcome<LoadedPipeline>>;
 export declare function loadPipeline(nameOrPath: string, options?: {
     cwd?: string;
     projectRoot?: string;
+    requireIo?: boolean;
 }): Promise<LoadedPipeline>;

package/dist/config/loadPipeline.js

@@ -10,6 +10,8 @@ import { predecessorEdges } from "./pipelineNeeds.js";
 import { resolvePipelineDagFromRefs } from "./resolvePipelineDag.js";
 import { recoveryRequiresCompletionIssue } from "./parseCompletionContract.js";
 import { validateCompletionContractForStage } from "./validateCompletionContract.js";
+import { applyCloneChains } from "./cloneChain.js";
+import { collectRouteIfSchemaIssues, collectRouteIfIllegalCombos, collectRouteAllGatedWarnings, } from "./routeIf.js";
 function schemaCompileIssue(stageId, field, err, pipelineId) {
     const message = err instanceof Error ? err.message : String(err);
     if (err instanceof UnresolvedSchemaRefError) {
@@ -59,26 +61,23 @@ function checkSequentialIoCompatibility(stages, dag, pipelineId, schemas) {
         const node = nodeById.get(child.id);
         if (!node)
             continue;
-        const parents = predecessorEdges(node);
-        if (parents.length !== 1)
-            continue;
-        if (node.clonable)
-            continue;
-        const parentNode = nodeById.get(parents[0].id);
-        if (parentNode?.clonable)
-            continue;
-        const parent = stageById.get(parents[0].id);
-        if (!parent?.payload_schema || child.clone_input_schema === undefined)
-            continue;
-        if (!isPayloadSchemaSubset(child.clone_input_schema, parent.payload_schema, options)) {
-            return loadFailure([
-                {
-                    code: "pipeline.io_incompatible",
-                    message: `Pipeline ${pipelineId}: stage "${child.id}" io.input is not a structural subset of "${parent.id}" io.output`,
-                    category: "pipeline",
-                    pipelineId,
-                },
-            ]);
+        for (const parentEdge of predecessorEdges(node)) {
+            const parentNode = nodeById.get(parentEdge.id);
+            if (parentNode?.clone_array_field !== undefined)
+                continue;
+            const parent = stageById.get(parentEdge.id);
+            if (!parent?.payload_schema || child.clone_input_schema === undefined)
+                continue;
+            if (!isPayloadSchemaSubset(child.clone_input_schema, parent.payload_schema, options)) {
+                return loadFailure([
+                    {
+                        code: "pipeline.io_incompatible",
+                        message: `Pipeline ${pipelineId}: stage "${child.id}" io.input is not a structural subset of "${parent.id}" io.output`,
+                        category: "pipeline",
+                        pipelineId,
+                    },
+                ]);
+            }
         }
     }
     return loadSuccess(undefined);
@@ -93,7 +92,7 @@ export async function resolvePipelinePath(pipelinePath, cwd) {
         throw new Error(`Pipeline file not found: ${resolved}. Pass a filesystem path to --pipeline (e.g. pipelines/hello.pipeline.yaml), not a bare pipeline id.`);
     }
 }
-async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd) {
+async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd, requireIo = true) {
     const normalizedPipelinePath = path.normalize(path.resolve(pipelinePath));
     const mergeOutcome = await mergePipelineStages(normalizedPipelinePath);
     if (!mergeOutcome.ok) {
@@ -147,6 +146,7 @@ async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd) {
                 entryId: entry.id,
                 declaringPath: entry.declaringPath,
                 deferSchemaRefs: true,
+                requireIo,
             });
             if (!inlineOutcome.ok) {
                 return loadFailure(inlineOutcome.issues);
@@ -157,6 +157,7 @@ async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd) {
         }
         const stageOutcome = await loadStageOutcome(entry.body.absolutePath, {
             deferSchemaRefs: true,
+            requireIo,
         });
         if (!stageOutcome.ok) {
             if (stageOutcome.issues.some((issue) => issue.code === "catalog.mixed_yaml_dialect")) {
@@ -206,9 +207,20 @@ async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd) {
         stages.push(stage);
         stageSources[stageId] = { kind: "file", path: entry.body.absolutePath };
     }
+    const cloneChainOutcome = applyCloneChains(stages, wiringRefs, dag, pipelineId);
+    if (!cloneChainOutcome.ok)
+        return cloneChainOutcome;
     const schemaOutcome = attachPipelineSchemas(stages, pipelineSchemas, pipelineId);
     if (!schemaOutcome.ok)
         return schemaOutcome;
+    const routeIfIssues = [
+        ...collectRouteIfSchemaIssues(stages, wiringRefs, pipelineId),
+        ...collectRouteIfIllegalCombos(wiringRefs, pipelineId),
+    ];
+    if (routeIfIssues.length > 0) {
+        return loadFailure(routeIfIssues);
+    }
+    warnings.push(...collectRouteAllGatedWarnings(wiringRefs, pipelineId));
     const ioOutcome = checkSequentialIoCompatibility(stages, dag, pipelineId, pipelineSchemas);
     if (!ioOutcome.ok)
         return ioOutcome;
@@ -283,7 +295,7 @@ export async function loadPipelineOutcome(nameOrPath, options = {}) {
             },
         ]);
     }
-    return loadPipelineFromPath(pipelinePath, cwd, projectRoot);
+    return loadPipelineFromPath(pipelinePath, cwd, projectRoot, options.requireIo !== false);
 }
 export async function loadPipeline(nameOrPath, options = {}) {
     const outcome = await loadPipelineOutcome(nameOrPath, options);

package/dist/config/loadStage.d.ts

@@ -6,11 +6,13 @@ export declare function afterCompletionForStage(stage: StageConfig): CompletionC
 export declare function parseStageMcp(raw: unknown, label: string, stageId?: string): LoadOutcome<string[] | undefined>;
 export type LoadStageOptions = {
     deferSchemaRefs?: boolean;
+    requireIo?: boolean;
 };
 export declare function loadStageFromObjectOutcome(raw: Record<string, unknown>, ctx: {
     entryId: string;
     declaringPath: string;
     deferSchemaRefs?: boolean;
+    requireIo?: boolean;
 }): LoadOutcome<StageConfig>;
 export declare function loadStageOutcome(filePath: string, options?: LoadStageOptions): Promise<LoadOutcome<StageConfig>>;
 export declare function loadStage(filePath: string): Promise<StageConfig>;