stageflow 0.12.0 → 0.15.0

package/dist/config/createPipeline.d.ts

@@ -3,7 +3,7 @@ import type { StageGateKind } from "../types/stage.js";
 import type { PipelineListing } from "./listConfig.js";
 export type CreatePipelineStageInline = {
     system_prompt: string;
-    model: string;
+    model?: string;
     gate_kinds?: StageGateKind[];
 };
 export type CreatePipelineStageRef = {

package/dist/config/createPipeline.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { parsePipelineNeeds } from "./pipelineNeeds.js";
 import { STAGE_ID_PATTERN } from "./createStage.js";
 import { inferIdFromUsesPath, normalizePipelineStageEntries, toWiringRefs, } from "./normalizePipelineStageEntry.js";
+import { parseModelField } from "./modelField.js";
 import { readYamlObject } from "./readYamlObject.js";
 import { resolvePipelineDagFromRefs } from "./resolvePipelineDag.js";
 import { validatePipeline } from "./validateCatalog.js";
@@ -36,7 +37,9 @@ function stageRefToRaw(ref) {
         raw.uses = ref.uses;
     if (ref.inline) {
         raw.system_prompt = ref.inline.system_prompt;
-        raw.model = ref.inline.model;
+        if (ref.inline.model !== undefined && ref.inline.model.length > 0) {
+            raw.model = ref.inline.model;
+        }
         if (ref.inline.gate_kinds !== undefined) {
             raw.gate_kinds = ref.inline.gate_kinds;
         }
@@ -61,7 +64,9 @@ function normalizedToCreateRefs(entries) {
             const raw = entry.body.raw;
             ref.inline = {
                 system_prompt: String(raw.system_prompt ?? ""),
-                model: String(raw.model ?? ""),
+                ...(typeof raw.model === "string" && raw.model.length > 0
+                    ? { model: raw.model }
+                    : {}),
                 ...(Array.isArray(raw.gate_kinds)
                     ? { gate_kinds: raw.gate_kinds }
                     : {}),
@@ -97,17 +102,22 @@ function parseInlineBody(entry, index) {
             error: `stages[${index}].system_prompt is required for inline stage`,
         };
     }
-    if (typeof entry.model !== "string" || entry.model.length === 0) {
-        return {
-            ok: false,
-            status: 400,
-            error: `stages[${index}].model is required for inline stage`,
-        };
-    }
     const inline = {
         system_prompt: entry.system_prompt,
-        model: entry.model,
     };
+    if (entry.model !== undefined) {
+        const modelField = parseModelField(entry.model);
+        if (!modelField.ok) {
+            return {
+                ok: false,
+                status: 400,
+                error: `stages[${index}].${modelField.message}`,
+            };
+        }
+        if (modelField.value !== undefined) {
+            inline.model = modelField.value;
+        }
+    }
     if (entry.gate_kinds !== undefined) {
         if (!Array.isArray(entry.gate_kinds)) {
             return {
@@ -288,7 +298,9 @@ export function pipelineConfigToYaml(pipeline, options) {
             else {
                 lines.push(`    system_prompt: ${formatInlineYamlScalar(stage.inline.system_prompt)}`);
             }
-            lines.push(`    model: ${formatInlineYamlScalar(stage.inline.model)}`);
+            if (stage.inline.model !== undefined && stage.inline.model.length > 0) {
+                lines.push(`    model: ${formatInlineYamlScalar(stage.inline.model)}`);
+            }
         }
         else if (stage.uses) {
             lines.push(`    uses: ${stage.uses}`);

package/dist/config/createStage.d.ts

@@ -5,7 +5,7 @@ export type CreateStageInput = {
     filename: string;
     id: string;
     system_prompt: string;
-    model: string;
+    model?: string;
     gate_kinds?: StageGateKind[];
 };
 export type CreatedStageListing = {

package/dist/config/createStage.js

@@ -2,6 +2,7 @@ import { access, mkdir, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { STAGE_GATE_KINDS, } from "../types/stage.js";
 import { loadStage } from "./loadStage.js";
+import { parseModelField } from "./modelField.js";
 import { readYamlObject } from "./readYamlObject.js";
 export const STAGE_ID_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function isGateKind(value) {
@@ -63,9 +64,11 @@ export function parseCreateStageBody(body) {
     if (typeof body.system_prompt !== "string" || body.system_prompt.length === 0) {
         return { ok: false, status: 400, error: "system_prompt is required" };
     }
-    if (typeof body.model !== "string" || body.model.length === 0) {
-        return { ok: false, status: 400, error: "model is required" };
+    const modelField = parseModelField(body.model);
+    if (!modelField.ok) {
+        return { ok: false, status: 400, error: modelField.message };
     }
+    const model = modelField.value;
     const gateKinds = parseGateKinds(body.gate_kinds);
     if (gateKinds === "invalid") {
         return {
@@ -79,7 +82,7 @@ export function parseCreateStageBody(body) {
         filename,
         id: body.id,
         system_prompt: body.system_prompt,
-        model: body.model,
+        ...(model !== undefined ? { model } : {}),
         ...(gateKinds !== undefined ? { gate_kinds: gateKinds } : {}),
     };
 }
@@ -116,7 +119,9 @@ export function stageConfigToYaml(stage) {
     else {
         lines.push(`system_prompt: ${formatInlineYamlScalar(stage.system_prompt)}`);
     }
-    lines.push(`model: ${formatInlineYamlScalar(stage.model)}`);
+    if (stage.model !== undefined && stage.model.length > 0) {
+        lines.push(`model: ${formatInlineYamlScalar(stage.model)}`);
+    }
     lines.push("");
     return lines.join("\n");
 }
@@ -190,7 +195,7 @@ export async function createStage(projectRoot, input) {
         await writeFile(filePath, stageConfigToYaml({
             id: input.id,
             system_prompt: input.system_prompt,
-            model: input.model,
+            ...(input.model !== undefined && input.model.length > 0 ? { model: input.model } : {}),
             ...(input.gate_kinds !== undefined ? { gate_kinds: input.gate_kinds } : {}),
         }), "utf8");
     }

package/dist/config/legacyYaml.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Dual-read adapter: accept old YAML authoring keys and warn (`catalog.legacy_yaml`).
+ *
+ * This is not the runtime IR. Stage workers, snapshots, emit, and VSE already
+ * use those same strings as TypeScript fields (`StageConfig.payload_schema`,
+ * DAG `completion` / `recovery`). Target YAML compiles onto that IR in
+ * `yamlDialect.ts`. New catalog fields go on `io` / `verify` / `on_verify_fail`,
+ * not here.
+ *
+ * Off: STAGEFLOW_LEGACY_YAML=0. migrate-yaml still reads legacy via
+ * withLegacyYamlAllowedAsync.
+ *
+ * Delete this file plus migrateYaml.ts, printTargetYaml.ts,
+ * migrateYamlCommand.ts, and tests/fixtures/dual-read to stop accepting
+ * payload_schema / pre_emit_checks / completion / recovery as authoring keys.
+ */
+import type { LoadIssue } from "./loadOutcome.js";
+import type { YamlDialect } from "./yamlDialect.js";
+export declare const LEGACY_CONTRACT_KEYS: Set<string>;
+export declare const LEGACY_KEY_REPLACEMENTS: Record<string, string>;
+export declare function formatLegacyReplacements(keys: string[]): string;
+export declare function presentLegacyKeys(keys: Iterable<string>): string[];
+export declare function legacyYamlIssue(fileLabel: string, keys: string[]): LoadIssue;
+export declare function dialectWarningForDocument(raw: Record<string, unknown>, fileLabel: string): LoadIssue | undefined;
+export declare function allowLegacyYamlAuthoring(): boolean;
+export declare function withLegacyYamlAllowed<T>(fn: () => T): T;
+export declare function withLegacyYamlAllowedAsync<T>(fn: () => Promise<T>): Promise<T>;
+export declare function legacyAuthoringRejected(dialect: YamlDialect, fileLabel: string, keys: string[]): LoadIssue | undefined;

package/dist/config/legacyYaml.js

@@ -0,0 +1,98 @@
+/**
+ * Dual-read adapter: accept old YAML authoring keys and warn (`catalog.legacy_yaml`).
+ *
+ * This is not the runtime IR. Stage workers, snapshots, emit, and VSE already
+ * use those same strings as TypeScript fields (`StageConfig.payload_schema`,
+ * DAG `completion` / `recovery`). Target YAML compiles onto that IR in
+ * `yamlDialect.ts`. New catalog fields go on `io` / `verify` / `on_verify_fail`,
+ * not here.
+ *
+ * Off: STAGEFLOW_LEGACY_YAML=0. migrate-yaml still reads legacy via
+ * withLegacyYamlAllowedAsync.
+ *
+ * Delete this file plus migrateYaml.ts, printTargetYaml.ts,
+ * migrateYamlCommand.ts, and tests/fixtures/dual-read to stop accepting
+ * payload_schema / pre_emit_checks / completion / recovery as authoring keys.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+export const LEGACY_CONTRACT_KEYS = new Set([
+    "payload_schema",
+    "clone_input_schema",
+    "pre_emit_checks",
+    "completion",
+    "recovery",
+]);
+export const LEGACY_KEY_REPLACEMENTS = {
+    payload_schema: "io.output.schema",
+    clone_input_schema: "io.input.schema",
+    pre_emit_checks: "verify items with when including emit",
+    completion: "verify items with when including after",
+    recovery: "on_verify_fail",
+};
+const TARGET_AUTHORING_KEYS = new Set(["io", "verify", "on_verify_fail"]);
+const legacyYamlOverride = new AsyncLocalStorage();
+function collectDocumentKeys(raw) {
+    const keys = new Set(Object.keys(raw));
+    if (Array.isArray(raw.stages)) {
+        for (const entry of raw.stages) {
+            if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+                for (const key of Object.keys(entry))
+                    keys.add(key);
+            }
+        }
+    }
+    return keys;
+}
+export function formatLegacyReplacements(keys) {
+    return keys
+        .map((key) => {
+        const replacement = LEGACY_KEY_REPLACEMENTS[key];
+        return replacement ? `${key} → ${replacement}` : key;
+    })
+        .join(", ");
+}
+export function presentLegacyKeys(keys) {
+    const set = keys instanceof Set ? keys : new Set(keys);
+    return [...LEGACY_CONTRACT_KEYS].filter((key) => set.has(key));
+}
+export function legacyYamlIssue(fileLabel, keys) {
+    return {
+        code: "catalog.legacy_yaml",
+        message: `${fileLabel} uses legacy YAML keys (${formatLegacyReplacements(keys)})`,
+        category: "catalog",
+    };
+}
+export function dialectWarningForDocument(raw, fileLabel) {
+    const keys = collectDocumentKeys(raw);
+    const legacyKeys = presentLegacyKeys(keys);
+    if (legacyKeys.length === 0)
+        return undefined;
+    for (const key of keys) {
+        if (TARGET_AUTHORING_KEYS.has(key))
+            return undefined;
+    }
+    return legacyYamlIssue(fileLabel, legacyKeys);
+}
+export function allowLegacyYamlAuthoring() {
+    if (legacyYamlOverride.getStore() === true)
+        return true;
+    const raw = process.env.STAGEFLOW_LEGACY_YAML;
+    if (raw === "0" || raw === "false")
+        return false;
+    return true;
+}
+export function withLegacyYamlAllowed(fn) {
+    return legacyYamlOverride.run(true, fn);
+}
+export function withLegacyYamlAllowedAsync(fn) {
+    return legacyYamlOverride.run(true, fn);
+}
+export function legacyAuthoringRejected(dialect, fileLabel, keys) {
+    if (dialect !== "legacy" || allowLegacyYamlAuthoring())
+        return undefined;
+    return {
+        code: "catalog.legacy_yaml",
+        message: `${fileLabel}: dual-read is disabled (STAGEFLOW_LEGACY_YAML=0). Run sf migrate-yaml or author io / verify / on_verify_fail (${formatLegacyReplacements(keys)}).`,
+        category: "catalog",
+    };
+}

package/dist/config/loadOutcome.d.ts

@@ -23,9 +23,10 @@ export type LoadIssue = {
 export type LoadOutcome<T> = {
     ok: true;
     value: T;
+    issues?: LoadIssue[];
 } | {
     ok: false;
     issues: LoadIssue[];
 };
 export declare function loadFailure<T>(issues: LoadIssue[]): LoadOutcome<T>;
-export declare function loadSuccess<T>(value: T): LoadOutcome<T>;
+export declare function loadSuccess<T>(value: T, issues?: LoadIssue[]): LoadOutcome<T>;

package/dist/config/loadOutcome.js

@@ -1,6 +1,9 @@
 export function loadFailure(issues) {
     return { ok: false, issues };
 }
-export function loadSuccess(value) {
+export function loadSuccess(value, issues) {
+    if (issues && issues.length > 0) {
+        return { ok: true, value, issues };
+    }
     return { ok: true, value };
 }

package/dist/config/loadPipeline.d.ts

@@ -5,7 +5,9 @@ export type { LoadIssue, LoadOutcome } from "./loadOutcome.js";
 export declare function resolvePipelinePath(pipelinePath: string, cwd: string): Promise<string>;
 export declare function loadPipelineOutcome(nameOrPath: string, options?: {
     cwd?: string;
+    projectRoot?: string;
 }): Promise<LoadOutcome<LoadedPipeline>>;
 export declare function loadPipeline(nameOrPath: string, options?: {
     cwd?: string;
+    projectRoot?: string;
 }): Promise<LoadedPipeline>;

package/dist/config/loadPipeline.js

@@ -1,11 +1,88 @@
 import { access } from "node:fs/promises";
 import path from "node:path";
+import { compilePayloadSchema, expandPayloadSchemaRefs, isPayloadSchemaSubset, UnresolvedSchemaRefError, } from "../envelope/payloadSchema.js";
 import { loadFailure, loadSuccess } from "./loadOutcome.js";
 import { mergePipelineStages } from "./mergePipelineIncludes.js";
 import { normalizePipelineStageEntries, toWiringRefs, } from "./normalizePipelineStageEntry.js";
-import { loadStageFromObjectOutcome, loadStageOutcome } from "./loadStage.js";
+import { loadStageFromObjectOutcome, loadStageOutcome, afterCompletionForStage } from "./loadStage.js";
+import { materializeStageModels } from "./materializeStageModels.js";
+import { predecessorEdges } from "./pipelineNeeds.js";
 import { resolvePipelineDagFromRefs } from "./resolvePipelineDag.js";
+import { recoveryRequiresCompletionIssue } from "./parseCompletionContract.js";
 import { validateCompletionContractForStage } from "./validateCompletionContract.js";
+function schemaCompileIssue(stageId, field, err, pipelineId) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof UnresolvedSchemaRefError) {
+        return {
+            code: "stage.unresolved_schema_ref",
+            message: `Pipeline ${pipelineId}: stage "${stageId}" ${field}: ${message}`,
+            category: "stage",
+            stageId,
+        };
+    }
+    return {
+        code: field === "payload_schema" ? "stage.invalid_payload_schema" : "stage.invalid_clone_input_schema",
+        message: `Pipeline ${pipelineId}: stage "${stageId}" ${field}: ${message}`,
+        category: "stage",
+        stageId,
+    };
+}
+function attachPipelineSchemas(stages, schemas, pipelineId) {
+    const options = schemas !== undefined ? { schemas } : undefined;
+    for (const stage of stages) {
+        if (stage.payload_schema !== undefined) {
+            try {
+                compilePayloadSchema(stage.payload_schema, options);
+                stage.payload_schema = expandPayloadSchemaRefs(stage.payload_schema, options);
+            }
+            catch (err) {
+                return loadFailure([schemaCompileIssue(stage.id, "payload_schema", err, pipelineId)]);
+            }
+        }
+        if (stage.clone_input_schema !== undefined) {
+            try {
+                compilePayloadSchema(stage.clone_input_schema, options);
+                stage.clone_input_schema = expandPayloadSchemaRefs(stage.clone_input_schema, options);
+            }
+            catch (err) {
+                return loadFailure([schemaCompileIssue(stage.id, "clone_input_schema", err, pipelineId)]);
+            }
+        }
+    }
+    return loadSuccess(undefined);
+}
+function checkSequentialIoCompatibility(stages, dag, pipelineId, schemas) {
+    const stageById = new Map(stages.map((stage) => [stage.id, stage]));
+    const nodeById = new Map(dag.nodes.map((node) => [node.id, node]));
+    const options = schemas !== undefined ? { schemas } : undefined;
+    for (const child of stages) {
+        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,
+                },
+            ]);
+        }
+    }
+    return loadSuccess(undefined);
+}
 export async function resolvePipelinePath(pipelinePath, cwd) {
     const resolved = path.normalize(path.resolve(cwd, pipelinePath));
     try {
@@ -16,14 +93,15 @@ 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) {
+async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd) {
     const normalizedPipelinePath = path.normalize(path.resolve(pipelinePath));
     const mergeOutcome = await mergePipelineStages(normalizedPipelinePath);
     if (!mergeOutcome.ok) {
         return loadFailure(mergeOutcome.issues);
     }
-    const { entries: rawEntries, pipelineId, agent: pipelineAgent } = mergeOutcome.value;
+    const { entries: rawEntries, pipelineId, agent: pipelineAgent, model: pipelineModel, schemas: pipelineSchemas, warnings: mergeWarnings, } = mergeOutcome.value;
     const ctx = { pipelineId, path: normalizedPipelinePath };
+    const warnings = [...mergeWarnings];
     const normalizeOutcome = normalizePipelineStageEntries(rawEntries, ctx);
     if (!normalizeOutcome.ok) {
         return loadFailure(normalizeOutcome.issues);
@@ -51,6 +129,7 @@ async function loadPipelineFromPath(pipelinePath) {
     const entryById = new Map(normalizedEntries.map((entry) => [entry.id, entry]));
     const stageSources = {};
     const stages = [];
+    const fileAfterById = new Map();
     for (const stageId of stageIds) {
         const entry = entryById.get(stageId);
         if (!entry) {
@@ -67,6 +146,7 @@ async function loadPipelineFromPath(pipelinePath) {
             const inlineOutcome = loadStageFromObjectOutcome(entry.body.raw, {
                 entryId: entry.id,
                 declaringPath: entry.declaringPath,
+                deferSchemaRefs: true,
             });
             if (!inlineOutcome.ok) {
                 return loadFailure(inlineOutcome.issues);
@@ -75,8 +155,13 @@ async function loadPipelineFromPath(pipelinePath) {
             stageSources[stageId] = { kind: "inline" };
             continue;
         }
-        const stageOutcome = await loadStageOutcome(entry.body.absolutePath);
+        const stageOutcome = await loadStageOutcome(entry.body.absolutePath, {
+            deferSchemaRefs: true,
+        });
         if (!stageOutcome.ok) {
+            if (stageOutcome.issues.some((issue) => issue.code === "catalog.mixed_yaml_dialect")) {
+                return loadFailure(stageOutcome.issues);
+            }
             return loadFailure([
                 {
                     code: "pipeline.missing_stage",
@@ -87,6 +172,22 @@ async function loadPipelineFromPath(pipelinePath) {
                 ...stageOutcome.issues,
             ]);
         }
+        if (stageOutcome.issues)
+            warnings.push(...stageOutcome.issues);
+        const fileAfter = afterCompletionForStage(stageOutcome.value);
+        if (fileAfter && entry.completion) {
+            return loadFailure([
+                {
+                    code: "pipeline.invalid_completion",
+                    message: `Pipeline ${pipelineId}: stage "${stageId}" after-checks come from both body verify and wrapper completion`,
+                    category: "pipeline",
+                    pipelineId,
+                },
+            ]);
+        }
+        if (fileAfter && !entry.completion) {
+            fileAfterById.set(stageId, fileAfter);
+        }
         if (stageOutcome.value.id !== entry.id) {
             return loadFailure([
                 {
@@ -100,17 +201,58 @@ async function loadPipelineFromPath(pipelinePath) {
         const stage = {
             ...stageOutcome.value,
             ...(entry.skill !== undefined ? { skill: entry.skill } : {}),
+            ...(entry.mcp !== undefined ? { mcp: entry.mcp } : {}),
         };
         stages.push(stage);
         stageSources[stageId] = { kind: "file", path: entry.body.absolutePath };
     }
+    const schemaOutcome = attachPipelineSchemas(stages, pipelineSchemas, pipelineId);
+    if (!schemaOutcome.ok)
+        return schemaOutcome;
+    const ioOutcome = checkSequentialIoCompatibility(stages, dag, pipelineId, pipelineSchemas);
+    if (!ioOutcome.ok)
+        return ioOutcome;
+    if (pipelineModel !== undefined) {
+        const inheritingIds = stages
+            .filter((stage) => stage.model === undefined)
+            .map((stage) => stage.id);
+        if (inheritingIds.length > 0) {
+            warnings.push({
+                code: "pipeline.model_applies",
+                message: `Pipeline ${pipelineId}: pipeline-root model now applies to stages that omit model (${inheritingIds.join(", ")})`,
+                category: "pipeline",
+                pipelineId,
+            });
+        }
+    }
+    const materializeOutcome = await materializeStageModels(stages, {
+        pipelineModel,
+        pipelineId,
+        projectRoot,
+    });
+    if (!materializeOutcome.ok) {
+        return loadFailure(materializeOutcome.issues);
+    }
+    const loadedStages = materializeOutcome.value;
     const pipeline = {
         id: pipelineId,
         stages: stageIds,
         ...(pipelineAgent !== undefined ? { agent: pipelineAgent } : {}),
+        ...(pipelineModel !== undefined ? { model: pipelineModel } : {}),
+        ...(pipelineSchemas !== undefined ? { schemas: pipelineSchemas } : {}),
     };
     const nodeById = new Map(dag.nodes.map((node) => [node.id, node]));
-    for (const stage of stages) {
+    for (const [stageId, after] of fileAfterById) {
+        const node = nodeById.get(stageId);
+        if (node)
+            node.completion = after;
+    }
+    for (const node of dag.nodes) {
+        if (node.recovery !== undefined && node.completion === undefined) {
+            return loadFailure([recoveryRequiresCompletionIssue(node.id)]);
+        }
+    }
+    for (const stage of loadedStages) {
         const completion = nodeById.get(stage.id)?.completion;
         const completionOutcome = validateCompletionContractForStage(stage, completion);
         if (!completionOutcome.ok)
@@ -118,14 +260,15 @@ async function loadPipelineFromPath(pipelinePath) {
     }
     return loadSuccess({
         pipeline,
-        stages,
+        stages: loadedStages,
         dag,
         pipelinePath: normalizedPipelinePath,
         stageSources,
-    });
+    }, warnings);
 }
 export async function loadPipelineOutcome(nameOrPath, options = {}) {
     const cwd = options.cwd ?? process.cwd();
+    const projectRoot = options.projectRoot ?? cwd;
     let pipelinePath;
     try {
         pipelinePath = await resolvePipelinePath(nameOrPath, cwd);
@@ -140,7 +283,7 @@ export async function loadPipelineOutcome(nameOrPath, options = {}) {
             },
         ]);
     }
-    return loadPipelineFromPath(pipelinePath);
+    return loadPipelineFromPath(pipelinePath, cwd, projectRoot);
 }
 export async function loadPipeline(nameOrPath, options = {}) {
     const outcome = await loadPipelineOutcome(nameOrPath, options);

package/dist/config/loadStage.d.ts

@@ -1,8 +1,16 @@
+import type { CompletionContract } from "../types/completion.js";
 import { type StageConfig } from "../types/stage.js";
 import { type LoadOutcome } from "./loadOutcome.js";
+/** After-phase IR from target `verify` (`when` includes after). Stamped onto DAG `completion`. */
+export declare function afterCompletionForStage(stage: StageConfig): CompletionContract | undefined;
+export declare function parseStageMcp(raw: unknown, label: string, stageId?: string): LoadOutcome<string[] | undefined>;
+export type LoadStageOptions = {
+    deferSchemaRefs?: boolean;
+};
 export declare function loadStageFromObjectOutcome(raw: Record<string, unknown>, ctx: {
     entryId: string;
     declaringPath: string;
+    deferSchemaRefs?: boolean;
 }): LoadOutcome<StageConfig>;
-export declare function loadStageOutcome(filePath: string): Promise<LoadOutcome<StageConfig>>;
+export declare function loadStageOutcome(filePath: string, options?: LoadStageOptions): Promise<LoadOutcome<StageConfig>>;
 export declare function loadStage(filePath: string): Promise<StageConfig>;