stageflow 0.16.0 → 0.19.0

package/dist/config/loadStage.js

@@ -1,6 +1,5 @@
 import { parseAgentField } from "../agent/agentBackend.js";
 import { STAGEFLOW_MCP_SERVER_NAME } from "../agent/claudeTools.js";
-import { CLONE_ACTIONS } from "../types/forkChoice.js";
 import { STAGE_GATE_KINDS, } from "../types/stage.js";
 import { compilePayloadSchema, UnresolvedSchemaRefError } from "../envelope/payloadSchema.js";
 import { loadFailure, loadSuccess } from "./loadOutcome.js";
@@ -8,7 +7,7 @@ import { parseModelField } from "./modelField.js";
 import { allowLegacyYamlAuthoring, dialectWarningForDocument, legacyAuthoringRejected, presentLegacyKeys, } from "./legacyYaml.js";
 import { parsePreEmitChecks } from "./parsePreEmitChecks.js";
 import { readYamlObject } from "./readYamlObject.js";
-import { applyCompiledBody, classifyYamlDocument, compileTargetContract, dialectFromKeys, mixedDialectIssue, STAGE_FILE_WIRING_KEYS, } from "./yamlDialect.js";
+import { classifyYamlDocument, compileTargetContract, dialectFromKeys, mixedDialectIssue, STAGE_FILE_WIRING_KEYS, } from "./yamlDialect.js";
 const afterCompletionByStage = new WeakMap();
 /** After-phase IR from target `verify` (`when` includes after). Stamped onto DAG `completion`. */
 export function afterCompletionForStage(stage) {
@@ -17,45 +16,6 @@ export function afterCompletionForStage(stage) {
 function isGateKind(value) {
     return STAGE_GATE_KINDS.includes(value);
 }
-function isCloneAction(value) {
-    return CLONE_ACTIONS.includes(value);
-}
-function parseCloneActions(raw, label) {
-    if (raw === undefined)
-        return loadSuccess(undefined);
-    if (!Array.isArray(raw) || !raw.every((item) => typeof item === "string")) {
-        return loadFailure([
-            {
-                code: "stage.invalid_clone_actions",
-                message: `Invalid stage ${label}: clone_actions must be a non-empty array of strings`,
-                category: "stage",
-            },
-        ]);
-    }
-    if (raw.length === 0) {
-        return loadFailure([
-            {
-                code: "stage.invalid_clone_actions",
-                message: `Invalid stage ${label}: clone_actions must not be empty`,
-                category: "stage",
-            },
-        ]);
-    }
-    const actions = [];
-    for (const item of raw) {
-        if (!isCloneAction(item)) {
-            return loadFailure([
-                {
-                    code: "stage.invalid_clone_actions",
-                    message: `Invalid stage ${label}: unsupported clone_actions value "${item}" (allowed: ${CLONE_ACTIONS.join(", ")})`,
-                    category: "stage",
-                },
-            ]);
-        }
-        actions.push(item);
-    }
-    return loadSuccess(actions);
-}
 function parseTimeoutMs(raw, label) {
     if (raw === undefined)
         return loadSuccess(undefined);
@@ -162,9 +122,7 @@ export function parseStageMcp(raw, label, stageId) {
     }
     return loadSuccess(names);
 }
-function parseStageFields(raw, label, entryId, deferSchemaRefs) {
-    // Reads IR field names. Target YAML must already be compiled via
-    // applyCompiledBody; legacy YAML uses these keys as authoring.
+function parseStageFields(raw, label, entryId, deferSchemaRefs, requireIo, compiled) {
     if (typeof raw.system_prompt !== "string") {
         return loadFailure([
             {
@@ -179,6 +137,16 @@ function parseStageFields(raw, label, entryId, deferSchemaRefs) {
         id: entryId,
         system_prompt: raw.system_prompt,
     };
+    if (raw.clone_actions !== undefined) {
+        return loadFailure([
+            {
+                code: "stage.invalid_clone_actions",
+                message: `Invalid stage ${label}: "clone_actions" is no longer supported — use a Clone Chain instead`,
+                category: "stage",
+                stageId: entryId,
+            },
+        ]);
+    }
     const modelField = parseModelField(raw.model);
     if (!modelField.ok) {
         return loadFailure([
@@ -193,102 +161,133 @@ function parseStageFields(raw, label, entryId, deferSchemaRefs) {
     if (modelField.value !== undefined) {
         stage.model = modelField.value;
     }
-    if (raw.payload_schema !== undefined) {
-        if (raw.payload_schema === null ||
-            typeof raw.payload_schema !== "object" ||
-            Array.isArray(raw.payload_schema)) {
-            return loadFailure([
-                {
-                    code: "stage.invalid_payload_schema",
-                    message: `Invalid stage ${label}: payload_schema must be an object`,
-                    category: "stage",
-                    stageId: entryId,
-                },
-            ]);
+    if (compiled) {
+        if (compiled.payload_schema !== undefined) {
+            stage.payload_schema = compiled.payload_schema;
         }
-        try {
-            compilePayloadSchema(raw.payload_schema);
+        if (compiled.clone_input_schema !== undefined) {
+            stage.clone_input_schema = compiled.clone_input_schema;
         }
-        catch (err) {
-            if (err instanceof UnresolvedSchemaRefError) {
-                if (!deferSchemaRefs) {
+    }
+    else {
+        if (raw.payload_schema !== undefined) {
+            if (raw.payload_schema === null ||
+                typeof raw.payload_schema !== "object" ||
+                Array.isArray(raw.payload_schema)) {
+                return loadFailure([
+                    {
+                        code: "stage.invalid_payload_schema",
+                        message: `Invalid stage ${label}: io.output.schema must be an object`,
+                        category: "stage",
+                        stageId: entryId,
+                    },
+                ]);
+            }
+            try {
+                compilePayloadSchema(raw.payload_schema);
+            }
+            catch (err) {
+                if (err instanceof UnresolvedSchemaRefError) {
+                    if (!deferSchemaRefs) {
+                        return loadFailure([
+                            {
+                                code: "stage.unresolved_schema_ref",
+                                message: `Invalid stage ${label}: ${err.message}`,
+                                category: "stage",
+                                stageId: entryId,
+                            },
+                        ]);
+                    }
+                }
+                else {
+                    const message = err instanceof Error ? err.message : String(err);
                     return loadFailure([
                         {
-                            code: "stage.unresolved_schema_ref",
-                            message: `Invalid stage ${label}: ${err.message}`,
+                            code: "stage.invalid_payload_schema",
+                            message: `Invalid stage ${label}: invalid io.output.schema: ${message}`,
                             category: "stage",
                             stageId: entryId,
                         },
                     ]);
                 }
             }
-            else {
-                const message = err instanceof Error ? err.message : String(err);
+            stage.payload_schema = raw.payload_schema;
+        }
+        if (raw.clone_input_schema !== undefined) {
+            if (raw.clone_input_schema === null ||
+                typeof raw.clone_input_schema !== "object" ||
+                Array.isArray(raw.clone_input_schema)) {
                 return loadFailure([
                     {
-                        code: "stage.invalid_payload_schema",
-                        message: `Invalid stage ${label}: invalid payload_schema: ${message}`,
+                        code: "stage.invalid_clone_input_schema",
+                        message: `Invalid stage ${label}: io.input.schema must be an object`,
                         category: "stage",
                         stageId: entryId,
                     },
                 ]);
             }
-        }
-        stage.payload_schema = raw.payload_schema;
-    }
-    if (raw.clone_input_schema !== undefined) {
-        if (raw.clone_input_schema === null ||
-            typeof raw.clone_input_schema !== "object" ||
-            Array.isArray(raw.clone_input_schema)) {
-            return loadFailure([
-                {
-                    code: "stage.invalid_clone_input_schema",
-                    message: `Invalid stage ${label}: clone_input_schema must be an object`,
-                    category: "stage",
-                    stageId: entryId,
-                },
-            ]);
-        }
-        try {
-            compilePayloadSchema(raw.clone_input_schema);
-        }
-        catch (err) {
-            if (err instanceof UnresolvedSchemaRefError) {
-                if (!deferSchemaRefs) {
+            try {
+                compilePayloadSchema(raw.clone_input_schema);
+            }
+            catch (err) {
+                if (err instanceof UnresolvedSchemaRefError) {
+                    if (!deferSchemaRefs) {
+                        return loadFailure([
+                            {
+                                code: "stage.unresolved_schema_ref",
+                                message: `Invalid stage ${label}: ${err.message}`,
+                                category: "stage",
+                                stageId: entryId,
+                            },
+                        ]);
+                    }
+                }
+                else {
+                    const message = err instanceof Error ? err.message : String(err);
                     return loadFailure([
                         {
-                            code: "stage.unresolved_schema_ref",
-                            message: `Invalid stage ${label}: ${err.message}`,
+                            code: "stage.invalid_clone_input_schema",
+                            message: `Invalid stage ${label}: invalid io.input.schema: ${message}`,
                             category: "stage",
                             stageId: entryId,
                         },
                     ]);
                 }
             }
-            else {
-                const message = err instanceof Error ? err.message : String(err);
+            stage.clone_input_schema = raw.clone_input_schema;
+        }
+        if (requireIo) {
+            if (raw.payload_schema === undefined && raw.clone_input_schema === undefined) {
                 return loadFailure([
                     {
-                        code: "stage.invalid_clone_input_schema",
-                        message: `Invalid stage ${label}: invalid clone_input_schema: ${message}`,
+                        code: "stage.invalid_io",
+                        message: `Invalid stage ${label}: io is required`,
+                        category: "stage",
+                        stageId: entryId,
+                    },
+                ]);
+            }
+            if (raw.payload_schema === undefined) {
+                return loadFailure([
+                    {
+                        code: "stage.invalid_io",
+                        message: `Invalid stage ${label}: io.output.schema is required`,
+                        category: "stage",
+                        stageId: entryId,
+                    },
+                ]);
+            }
+            if (raw.clone_input_schema === undefined) {
+                return loadFailure([
+                    {
+                        code: "stage.invalid_io",
+                        message: `Invalid stage ${label}: io.input.schema is required`,
                         category: "stage",
                         stageId: entryId,
                     },
                 ]);
             }
         }
-        stage.clone_input_schema = raw.clone_input_schema;
-    }
-    const cloneActionsOutcome = parseCloneActions(raw.clone_actions, label);
-    if (!cloneActionsOutcome.ok) {
-        const issues = cloneActionsOutcome.issues.map((issue) => ({
-            ...issue,
-            stageId: entryId,
-        }));
-        return loadFailure(issues);
-    }
-    if (cloneActionsOutcome.value !== undefined) {
-        stage.clone_actions = cloneActionsOutcome.value;
     }
     const gateKindsOutcome = parseGateKinds(raw.gate_kinds, label);
     if (!gateKindsOutcome.ok) {
@@ -312,16 +311,23 @@ function parseStageFields(raw, label, entryId, deferSchemaRefs) {
     if (timeoutMsOutcome.value !== undefined) {
         stage.timeout_ms = timeoutMsOutcome.value;
     }
-    const preEmitChecksOutcome = parsePreEmitChecks(raw.pre_emit_checks, label);
-    if (!preEmitChecksOutcome.ok) {
-        const issues = preEmitChecksOutcome.issues.map((issue) => ({
-            ...issue,
-            stageId: entryId,
-        }));
-        return loadFailure(issues);
+    if (compiled) {
+        if (compiled.pre_emit_checks !== undefined) {
+            stage.pre_emit_checks = compiled.pre_emit_checks;
+        }
     }
-    if (preEmitChecksOutcome.value !== undefined) {
-        stage.pre_emit_checks = preEmitChecksOutcome.value;
+    else {
+        const preEmitChecksOutcome = parsePreEmitChecks(raw.pre_emit_checks, label);
+        if (!preEmitChecksOutcome.ok) {
+            const issues = preEmitChecksOutcome.issues.map((issue) => ({
+                ...issue,
+                stageId: entryId,
+            }));
+            return loadFailure(issues);
+        }
+        if (preEmitChecksOutcome.value !== undefined) {
+            stage.pre_emit_checks = preEmitChecksOutcome.value;
+        }
     }
     if (raw.skill !== undefined) {
         if (typeof raw.skill !== "string" || raw.skill.trim() === "") {
@@ -361,6 +367,7 @@ function parseStageFields(raw, label, entryId, deferSchemaRefs) {
 export function loadStageFromObjectOutcome(raw, ctx) {
     const label = `${ctx.entryId} (${ctx.declaringPath})`;
     const deferSchemaRefs = ctx.deferSchemaRefs === true;
+    const requireIo = ctx.requireIo !== false;
     const dialect = dialectFromKeys(Object.keys(raw));
     if (dialect === "invalid") {
         return loadFailure([mixedDialectIssue()]);
@@ -374,12 +381,13 @@ export function loadStageFromObjectOutcome(raw, ctx) {
             label,
             category: "stage",
             deferSchemaRefs,
+            requireIo,
         });
         if (!compiled.ok)
             return compiled;
-        return parseStageFields(applyCompiledBody(raw, compiled.value), label, ctx.entryId, deferSchemaRefs);
+        return parseStageFields(raw, label, ctx.entryId, deferSchemaRefs, requireIo, compiled.value);
     }
-    return parseStageFields(raw, label, ctx.entryId, deferSchemaRefs);
+    return parseStageFields(raw, label, ctx.entryId, deferSchemaRefs, requireIo);
 }
 export async function loadStageOutcome(filePath, options = {}) {
     let raw;
@@ -425,22 +433,24 @@ export async function loadStageOutcome(filePath, options = {}) {
             ]);
         }
     }
-    let parseRaw = raw;
+    let compiled;
     let afterCompletion;
     const deferSchemaRefs = options.deferSchemaRefs === true;
+    const requireIo = options.requireIo !== false;
     if (dialect === "target") {
-        const compiled = compileTargetContract(raw, {
+        const compiledOutcome = compileTargetContract(raw, {
             stageId: raw.id,
             label: `file ${filePath}`,
             category: "stage",
             deferSchemaRefs,
+            requireIo,
         });
-        if (!compiled.ok)
-            return compiled;
-        parseRaw = applyCompiledBody(raw, compiled.value);
-        afterCompletion = compiled.value.completion;
+        if (!compiledOutcome.ok)
+            return compiledOutcome;
+        compiled = compiledOutcome.value;
+        afterCompletion = compiled.completion;
     }
-    const outcome = parseStageFields(parseRaw, `file ${filePath}`, raw.id, deferSchemaRefs);
+    const outcome = parseStageFields(raw, `file ${filePath}`, raw.id, deferSchemaRefs, requireIo, compiled);
     if (!outcome.ok)
         return outcome;
     if (outcome.value.id !== raw.id) {

package/dist/config/migrateYaml.js

@@ -333,7 +333,11 @@ async function refuseOutOfScopeUsesFolds(usesCompile, scopePipelines, catalogRoo
             catch {
                 outsideId = undefined;
             }
-            const outcome = await loadPipelineOutcome(pipelinePath, { cwd, projectRoot });
+            const outcome = await loadPipelineOutcome(pipelinePath, {
+                cwd,
+                projectRoot,
+                requireIo: false,
+            });
             if (outcome.ok) {
                 const other = new Map();
                 const otherErrors = [];
@@ -415,7 +419,11 @@ async function planMigrateYamlInner(targetPath, options) {
             skipped.add(relPath(cwd, pipelinePath));
             continue;
         }
-        const outcome = await loadPipelineOutcome(pipelinePath, { cwd, projectRoot });
+        const outcome = await loadPipelineOutcome(pipelinePath, {
+            cwd,
+            projectRoot,
+            requireIo: false,
+        });
         if (!outcome.ok) {
             if (outcome.issues.some((issue) => issue.code === "catalog.mixed_yaml_dialect")) {
                 skipped.add(relPath(cwd, pipelinePath));
@@ -518,7 +526,10 @@ async function planMigrateYamlInner(targetPath, options) {
             skipped.add(relPath(cwd, stagePath));
             continue;
         }
-        const outcome = await loadStageOutcome(stagePath, { deferSchemaRefs: true });
+        const outcome = await loadStageOutcome(stagePath, {
+            deferSchemaRefs: true,
+            requireIo: false,
+        });
         if (!outcome.ok) {
             if (outcome.issues.some((issue) => issue.code === "catalog.mixed_yaml_dialect")) {
                 skipped.add(relPath(cwd, stagePath));

package/dist/config/normalizePipelineStageEntry.d.ts

@@ -1,5 +1,5 @@
 import type { CompletionContract, RecoveryPolicy } from "../types/completion.js";
-import type { NormalizedPipelineStageEntry, PipelineNeeds } from "../types/pipeline.js";
+import type { CloneMode, NormalizedPipelineStageEntry, PipelineRouteEntry } from "../types/pipeline.js";
 import { type LoadOutcome } from "./loadOutcome.js";
 import type { RawMergedEntry } from "./mergePipelineIncludes.js";
 export declare function inferIdFromUsesPath(usesPath: string): string | null;
@@ -9,15 +9,11 @@ export declare function normalizePipelineStageEntries(rawEntries: RawMergedEntry
 }): LoadOutcome<NormalizedPipelineStageEntry[]>;
 export declare function toWiringRefs(entries: NormalizedPipelineStageEntry[]): Array<{
     id: string;
-    needs?: PipelineNeeds;
-    fork?: {
-        select: "one" | "subset";
-        allow_none?: boolean;
-    };
-    clonable?: boolean;
-    clone_cap?: number;
     completion?: CompletionContract;
     recovery?: RecoveryPolicy;
-    feedback_loop?: NormalizedPipelineStageEntry["feedback_loop"];
     replay_safe?: boolean;
+    route?: PipelineRouteEntry[];
+    entry?: boolean;
+    clone_cap?: number;
+    clone_mode?: CloneMode;
 }>;