stageflow 0.12.0 → 0.15.0

package/dist/agent/piIsolatedMcpProbe.js

@@ -0,0 +1,292 @@
+import { StageMcpError, resolveStageMcpServers, } from "../config/resolveStageMcpServers.js";
+import * as piIsolatedMcp from "./piIsolatedMcp.js";
+export const PROJECT_MCP_PROBE_TIMEOUT_MS = 30_000;
+const MCP_STATUS_EVENT = "pi-mcp-adapter/status/v1";
+function scrub(message, secrets) {
+    let out = message;
+    for (const secret of secrets) {
+        if (secret.length === 0)
+            continue;
+        out = out.split(secret).join("[redacted]");
+    }
+    return out;
+}
+function collectInterpolatedSecrets(entry) {
+    const secrets = [];
+    for (const field of ["env", "headers"]) {
+        const value = entry[field];
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            continue;
+        }
+        for (const item of Object.values(value)) {
+            if (typeof item === "string" && item.length > 0) {
+                secrets.push(item);
+            }
+        }
+    }
+    return secrets;
+}
+function catalogErrorResult(name, err) {
+    if (!(err instanceof StageMcpError))
+        return undefined;
+    if (err.code === "unresolved_var") {
+        return { name, status: "unresolved_var", error: err.message };
+    }
+    if (err.code === "missing_catalog") {
+        return { name, status: "missing_catalog" };
+    }
+    if (err.code === "invalid_config" ||
+        err.code === "reserved_name" ||
+        err.code === "unknown_server") {
+        return { name, status: "invalid_config" };
+    }
+    return undefined;
+}
+function asStatusServers(data) {
+    if (data === null || typeof data !== "object")
+        return undefined;
+    const servers = data.servers;
+    if (!Array.isArray(servers))
+        return undefined;
+    const parsed = [];
+    for (const entry of servers) {
+        if (entry === null || typeof entry !== "object")
+            continue;
+        const name = entry.name;
+        const status = entry.status;
+        if (typeof name === "string" && typeof status === "string") {
+            parsed.push({ name, status });
+        }
+    }
+    return parsed;
+}
+function mapRuntimeStatus(status) {
+    if (status === "connected" || status === "cached")
+        return "connected";
+    if (status === "needs-auth")
+        return "needs_auth";
+    if (status === "failed" || status === "disabled")
+        return "connect_failed";
+    return undefined;
+}
+function createProbeExtensionApi(eventBus) {
+    const handlers = new Map();
+    const api = {
+        events: eventBus,
+        on(event, handler) {
+            const list = handlers.get(event) ?? [];
+            list.push(handler);
+            handlers.set(event, list);
+        },
+        registerTool() { },
+        registerCommand() { },
+        registerShortcut() { },
+        registerFlag() { },
+        getFlag() {
+            return undefined;
+        },
+        registerMessageRenderer() { },
+        registerMarkdownTransformer() { },
+        registerEntryRenderer() { },
+        sendMessage() { },
+        sendUserMessage() { },
+        appendEntry() { },
+        setSessionName() { },
+        getSessionName() {
+            return undefined;
+        },
+        setLabel() { },
+        async exec() {
+            return { code: 0, stdout: "", stderr: "" };
+        },
+        getActiveTools() {
+            return [];
+        },
+        setActiveTools() { },
+        getAllTools() {
+            return [];
+        },
+    };
+    async function emit(event, ...args) {
+        for (const handler of handlers.get(event) ?? []) {
+            await handler(...args);
+        }
+    }
+    return {
+        api: api,
+        emitSessionStart(cwd) {
+            void emit("session_start", {}, { mode: "print", hasUI: false, cwd });
+        },
+        emitSessionShutdown() {
+            return emit("session_shutdown", {});
+        },
+    };
+}
+function instantiateProbeFactories(attached, projectRoot) {
+    const factories = attached.extensionFactories ?? [];
+    const eventBus = attached.eventBus;
+    if (factories.length === 0 || eventBus === undefined) {
+        return async () => { };
+    }
+    const probeApi = createProbeExtensionApi(eventBus);
+    for (const ext of factories) {
+        const factory = typeof ext === "function" ? ext : ext.factory;
+        factory(probeApi.api);
+    }
+    probeApi.emitSessionStart(projectRoot);
+    return () => probeApi.emitSessionShutdown();
+}
+function mapConnectingError(err, aborted) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (aborted || /cancelled/i.test(message)) {
+        return { kind: "cancelled" };
+    }
+    if (/needs-auth/.test(message)) {
+        return { kind: "mapped", status: "needs_auth" };
+    }
+    return {
+        kind: "mapped",
+        status: "connect_failed",
+        error: message.length > 0 ? message : undefined,
+    };
+}
+async function waitForProbeStatus(eventBus, serverName, connecting, options) {
+    if (options.signal?.aborted) {
+        return { kind: "cancelled" };
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        let unsubscribe;
+        let timer;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            unsubscribe?.();
+            if (timer !== undefined)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+            resolve(result);
+        };
+        const onAbort = () => finish({ kind: "cancelled" });
+        const consider = (data) => {
+            const servers = asStatusServers(data);
+            if (servers === undefined)
+                return;
+            const entry = servers.find((server) => server.name === serverName);
+            if (entry === undefined)
+                return;
+            const mapped = mapRuntimeStatus(entry.status);
+            if (mapped === undefined)
+                return;
+            if (mapped === "connect_failed") {
+                finish({
+                    kind: "mapped",
+                    status: "connect_failed",
+                    error: `MCP server "${serverName}" failed to connect (status: ${entry.status})`,
+                });
+                return;
+            }
+            finish({ kind: "mapped", status: mapped });
+        };
+        const handler = (data) => consider(data);
+        const maybeUnsub = eventBus.on(MCP_STATUS_EVENT, handler);
+        unsubscribe = typeof maybeUnsub === "function" ? maybeUnsub : undefined;
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        void (connecting ?? Promise.resolve()).then(() => finish({ kind: "mapped", status: "connected" }), (err) => finish(mapConnectingError(err, options.signal?.aborted === true)));
+        timer = setTimeout(() => {
+            finish({
+                kind: "mapped",
+                status: "connect_failed",
+                error: `MCP server "${serverName}" failed to connect (status: timed out)`,
+            });
+        }, options.timeoutMs);
+    });
+}
+export async function probeProjectMcpServer(options) {
+    const name = options.name;
+    const timeoutMs = options.timeoutMs ?? PROJECT_MCP_PROBE_TIMEOUT_MS;
+    const env = options.env ?? process.env;
+    if (options.signal?.aborted) {
+        return { name, status: "cancelled" };
+    }
+    let snapshot;
+    try {
+        snapshot = await resolveStageMcpServers({
+            projectRoot: options.projectRoot,
+            allowlist: [name],
+            env,
+        });
+    }
+    catch (err) {
+        return (catalogErrorResult(name, err) ?? {
+            name,
+            status: "invalid_config",
+        });
+    }
+    const resolved = snapshot[name];
+    if (resolved === undefined) {
+        return { name, status: "invalid_config" };
+    }
+    const secrets = collectInterpolatedSecrets(resolved);
+    let attached;
+    let shutdownFactories;
+    const dispose = async () => {
+        if (attached?.connecting !== undefined) {
+            void attached.connecting.then(() => undefined, () => undefined);
+        }
+        attached?.cancel?.();
+        if (shutdownFactories !== undefined) {
+            const stop = shutdownFactories;
+            shutdownFactories = undefined;
+            await stop();
+        }
+    };
+    try {
+        if (options.signal?.aborted) {
+            return { name, status: "cancelled" };
+        }
+        attached = await piIsolatedMcp.attachIsolatedMcp(snapshot, {
+            timeoutMs,
+            lifecycle: "eager",
+        });
+        if (attached.eventBus === undefined) {
+            return { name, status: "invalid_config" };
+        }
+        shutdownFactories = instantiateProbeFactories(attached, options.projectRoot);
+        const waited = await waitForProbeStatus(attached.eventBus, name, attached.connecting, { timeoutMs, signal: options.signal });
+        if (waited.kind === "cancelled") {
+            return { name, status: "cancelled" };
+        }
+        if (waited.status === "connect_failed") {
+            return {
+                name,
+                status: "connect_failed",
+                ...(waited.error !== undefined
+                    ? { error: scrub(waited.error, secrets) }
+                    : {}),
+            };
+        }
+        return { name, status: waited.status };
+    }
+    catch (err) {
+        if (options.signal?.aborted) {
+            return { name, status: "cancelled" };
+        }
+        const catalog = catalogErrorResult(name, err);
+        if (catalog)
+            return catalog;
+        const message = err instanceof Error ? err.message : String(err);
+        if (/cancelled/i.test(message)) {
+            return { name, status: "cancelled" };
+        }
+        return {
+            name,
+            status: "connect_failed",
+            error: scrub(message, secrets),
+        };
+    }
+    finally {
+        await dispose();
+    }
+}

package/dist/agent/port.d.ts

@@ -1,10 +1,11 @@
 import type { StageEnvelope, TerminalEnvelope } from "../types/envelope.js";
 import type { CompletionContract } from "../types/completion.js";
 import type { CloneEmitContext, ForkEmitContext } from "../types/forkChoice.js";
-import type { StageConfig } from "../types/stage.js";
+import type { LoadedStageConfig } from "../types/stage.js";
 import type { FeedbackLoopConfig } from "../types/pipeline.js";
 import type { TaskFile } from "../types/task.js";
 import type { StageActivityEvent } from "./activity.js";
+import type { ResolvedMcpServers } from "../config/resolveStageMcpServers.js";
 import type { StageRoots } from "../runtime/stageRoots.js";
 import type { QaExchange } from "../hitl/qaTrail.js";
 /** Opaque to runtime; adapters interpret. */
@@ -44,7 +45,7 @@ export type FeedbackLoopContext = {
 };
 export type StageRunInput = {
     roots: StageRoots;
-    stage: StageConfig;
+    stage: LoadedStageConfig;
     /** Runtime instance id (`work~2`). Defaults to `stage.id` when omitted. */
     stageId?: string;
     task: TaskFile;
@@ -52,6 +53,7 @@ export type StageRunInput = {
     priorEnvelopes?: StageEnvelope[];
     priorEnvelopesByStage?: Record<string, TerminalEnvelope | TerminalEnvelope[]>;
     timeoutMs?: number;
+    resolvedMcpServers?: ResolvedMcpServers;
     resumeToken?: StageResumeToken;
     /** Launch/session mode; omitted is treated as `"fresh"`. */
     sessionMode?: StageSessionMode;

package/dist/agent/port.js

@@ -46,4 +46,4 @@ export function createCompletedOnlyStageHandle(options) {
         },
     };
 }
-export const DEFAULT_STAGE_TIMEOUT_MS = 15 * 60 * 1000;
+export const DEFAULT_STAGE_TIMEOUT_MS = 60 * 60 * 1000;

package/dist/cli/initTemplates.d.ts

@@ -1,3 +1,3 @@
 export declare const STAGEFLOW_YAML = "version: 1\ncatalog:\n  pipelines:\n    - pipelines\n  tasks:\n    - tasks\n  patterns:\n    pipeline: \"*.pipeline.yaml\"\n    task: \"*.task.yaml\"\n";
-export declare const HELLO_PIPELINE_YAML = "id: hello\nstages:\n  - id: hello\n    system_prompt: Say hello and emit a success envelope.\n    model: anthropic/claude-sonnet-4-5\n";
+export declare const HELLO_PIPELINE_YAML = "id: hello\nmodel: anthropic/claude-sonnet-4-5\nstages:\n  - id: hello\n    system_prompt: Say hello and emit a success envelope.\n";
 export declare const HELLO_TASK_YAML = "id: hello\ngoal: Run the hello pipeline scaffold.\n";

package/dist/cli/initTemplates.js

@@ -9,10 +9,10 @@ catalog:
     task: "*.task.yaml"
 `;
 export const HELLO_PIPELINE_YAML = `id: hello
+model: anthropic/claude-sonnet-4-5
 stages:
   - id: hello
     system_prompt: Say hello and emit a success envelope.
-    model: anthropic/claude-sonnet-4-5
 `;
 export const HELLO_TASK_YAML = `id: hello
 goal: Run the hello pipeline scaffold.

package/dist/cli/migrateYamlCommand.d.ts

@@ -0,0 +1,18 @@
+export declare const MIGRATE_YAML_USAGE = "Usage:\n  sf migrate-yaml [path] [--root <path>] [--write] [--json] [--force]\n\n  Convert legacy catalog YAML to target YAML (io / verify / on_verify_fail).\n  Dry-run is the default. --write applies changes. Path may be a pipeline,\n  stage, task, or catalog root. Does not rewrite .stageflow snapshots.";
+export type MigrateYamlCommandIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+};
+export type MigrateYamlJson = {
+    ok: boolean;
+    write: boolean;
+    planned: string[];
+    written: string[];
+    skipped: string[];
+    errors: string[];
+};
+export declare function runMigrateYamlCommand(args: string[], options?: {
+    cwd?: string;
+    projectRoot?: string;
+    io?: Partial<MigrateYamlCommandIo>;
+}): Promise<number>;

package/dist/cli/migrateYamlCommand.js

@@ -0,0 +1,180 @@
+import path from "node:path";
+import { applyMigrateYamlPlan, fileDirtyVsHead, planMigrateYaml, } from "../config/migrateYaml.js";
+export const MIGRATE_YAML_USAGE = `Usage:
+  sf migrate-yaml [path] [--root <path>] [--write] [--json] [--force]
+
+  Convert legacy catalog YAML to target YAML (io / verify / on_verify_fail).
+  Dry-run is the default. --write applies changes. Path may be a pipeline,
+  stage, task, or catalog root. Does not rewrite .stageflow snapshots.`;
+const defaultIo = {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line),
+};
+function parseMigrateYamlArgs(args) {
+    if (args.length === 0) {
+        return { help: false, write: false, json: false, force: false };
+    }
+    if (args[0] === "--help" || args[0] === "-h") {
+        return { help: true, write: false, json: false, force: false };
+    }
+    let target;
+    let root;
+    let write = false;
+    let json = false;
+    let force = false;
+    let help = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else if (arg === "--write") {
+            write = true;
+        }
+        else if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--force") {
+            force = true;
+        }
+        else if (arg === "--root") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --root");
+            }
+            root = value;
+        }
+        else if (arg.startsWith("-")) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        else if (target !== undefined) {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+        else {
+            target = arg;
+        }
+    }
+    if (target !== undefined && root !== undefined) {
+        throw new Error("Use at most one of a positional path or --root");
+    }
+    return { help, target: target ?? root, write, json, force };
+}
+function planToJson(plan, options) {
+    return {
+        ok: options.ok,
+        write: options.write,
+        planned: plan.writes.map((item) => item.file),
+        written: options.written,
+        skipped: plan.skipped,
+        errors: [...plan.errors, ...(options.extraErrors ?? [])],
+    };
+}
+function formatHuman(plan, write, extraErrors) {
+    const lines = [];
+    const errors = [...plan.errors, ...extraErrors];
+    if (errors.length > 0) {
+        lines.push("Migration failed:");
+        for (const error of errors)
+            lines.push(`  ${error}`);
+        return lines.join("\n");
+    }
+    if (write) {
+        if (plan.writes.length === 0) {
+            lines.push("Nothing to write.");
+        }
+        else {
+            lines.push("Wrote:");
+            for (const item of plan.writes)
+                lines.push(`  ${item.file}`);
+        }
+    }
+    else if (plan.writes.length === 0) {
+        lines.push("Nothing to migrate.");
+    }
+    else {
+        lines.push("Would write:");
+        for (const item of plan.writes)
+            lines.push(`  ${item.file}`);
+        lines.push("");
+        lines.push("Dry-run; pass --write to apply.");
+    }
+    if (plan.skipped.length > 0) {
+        lines.push("");
+        lines.push("Skipped:");
+        for (const file of plan.skipped)
+            lines.push(`  ${file}`);
+    }
+    return lines.join("\n");
+}
+export async function runMigrateYamlCommand(args, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const projectRoot = options.projectRoot ?? cwd;
+    const out = { ...defaultIo, ...options.io };
+    try {
+        const parsed = parseMigrateYamlArgs(args);
+        if (parsed.help) {
+            out.error(MIGRATE_YAML_USAGE);
+            return 0;
+        }
+        const target = path.resolve(cwd, parsed.target ?? ".");
+        const plan = await planMigrateYaml(target, { cwd, projectRoot });
+        const extraErrors = [];
+        if (plan.errors.length > 0) {
+            if (parsed.json) {
+                out.log(JSON.stringify(planToJson(plan, { write: parsed.write, written: [], ok: false }), null, 2));
+            }
+            else {
+                out.error(formatHuman(plan, parsed.write, extraErrors));
+                out.error(MIGRATE_YAML_USAGE);
+            }
+            return 1;
+        }
+        if (parsed.write && !parsed.force) {
+            for (const item of plan.writes) {
+                if (fileDirtyVsHead(item.absPath)) {
+                    extraErrors.push(`Refusing to overwrite uncommitted changes in ${item.file} (pass --force)`);
+                }
+            }
+            if (extraErrors.length > 0) {
+                if (parsed.json) {
+                    out.log(JSON.stringify(planToJson(plan, {
+                        write: true,
+                        written: [],
+                        ok: false,
+                        extraErrors,
+                    }), null, 2));
+                }
+                else {
+                    out.error(formatHuman(plan, parsed.write, extraErrors));
+                }
+                return 1;
+            }
+        }
+        let written = [];
+        if (parsed.write) {
+            await applyMigrateYamlPlan(plan);
+            written = plan.writes.map((item) => item.file);
+        }
+        if (parsed.json) {
+            out.log(JSON.stringify(planToJson(plan, {
+                write: parsed.write,
+                written,
+                ok: true,
+            }), null, 2));
+        }
+        else {
+            out.log(formatHuman(plan, parsed.write, extraErrors));
+        }
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error
+            ? err.message
+            : typeof err === "string"
+                ? err
+                : "Migrate-yaml command failed";
+        out.error(message);
+        out.error(MIGRATE_YAML_USAGE);
+        return 1;
+    }
+}

package/dist/cli/runOutput.js

@@ -46,30 +46,38 @@ function formatStartFailureJson(started) {
     return formatRunStartFailedJson(started);
 }
 function baseRunCompletionPayload(result) {
-    if (result.outcome === "succeeded") {
-        return {
+    const payload = result.outcome === "succeeded"
+        ? {
             ok: true,
             outcome: "succeeded",
             runId: result.runId,
             runDir: result.runDir,
-        };
+        }
+        : result.outcome === "waiting"
+            ? {
+                ok: false,
+                outcome: "waiting",
+                runId: result.runId,
+                runDir: result.runDir,
+            }
+            : {
+                ok: false,
+                outcome: "failed",
+                runId: result.runId,
+                runDir: result.runDir,
+            };
+    if (result.outcome === "failed" && result.reason !== undefined) {
+        payload.reason = result.reason;
     }
-    if (result.outcome === "waiting") {
-        return {
-            ok: false,
-            outcome: "waiting",
-            runId: result.runId,
-            runDir: result.runDir,
-        };
+    if (Array.isArray(result.findings) && result.findings.length > 0) {
+        payload.findings = result.findings.map((finding) => ({
+            severity: finding.severity,
+            code: finding.code,
+            file: finding.path,
+            message: finding.message,
+            category: finding.category,
+        }));
     }
-    const payload = {
-        ok: false,
-        outcome: "failed",
-        runId: result.runId,
-        runDir: result.runDir,
-    };
-    if (result.reason !== undefined)
-        payload.reason = result.reason;
     return payload;
 }
 function formatRunCompletionJson(result) {

package/dist/cli/validateCommand.d.ts

@@ -6,6 +6,7 @@ export type ValidateCommandIo = {
 };
 export declare function runValidateCommand(args: string[], options?: {
     cwd?: string;
+    projectRoot?: string;
     io?: Partial<ValidateCommandIo>;
     validateCatalog?: (options: Parameters<typeof defaultValidateCatalog>[0]) => Promise<ValidationResult>;
 }): Promise<number>;

package/dist/cli/validateCommand.js

@@ -61,6 +61,7 @@ function parseValidateArgs(args) {
 }
 export async function runValidateCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
+    const projectRoot = options.projectRoot ?? cwd;
     const out = { ...defaultIo, ...options.io };
     const validateCatalogFn = options.validateCatalog ?? defaultValidateCatalog;
     try {
@@ -73,6 +74,7 @@ export async function runValidateCommand(args, options = {}) {
         const result = await validateCatalogFn({
             scope,
             cwd,
+            projectRoot,
             pipeline: parsed.pipeline,
             task: parsed.task,
             strict: parsed.strict,

package/dist/cli.js

@@ -14,6 +14,7 @@ import { RUNS_USAGE, runRunsCommand } from "./cli/runsCommand.js";
 import { resolveOperatorCatalog } from "./cli/operatorCatalog.js";
 import { SKILLS_USAGE, runSkillsCommand } from "./cli/skillsCommand.js";
 import { VALIDATE_USAGE, runValidateCommand } from "./cli/validateCommand.js";
+import { MIGRATE_YAML_USAGE, runMigrateYamlCommand } from "./cli/migrateYamlCommand.js";
 import { createRunStore } from "./runstore/createStore.js";
 import { resolveStageflowContext } from "./project/resolveStageflowContext.js";
 import { exitForOutcome, runStageWorker } from "./runtime/stageWorker.js";
@@ -26,6 +27,7 @@ const USAGE = `Usage:
   sf init
   sf run --task <path> --pipeline <path> [--checkout <path>] [--json] [--include stages] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>] [--operator-cwd <path>] [--operator-agent-dir <path>]
   sf validate [--pipeline <path>] [--task <path>] [--strict] [--json]
+  sf migrate-yaml [path] [--root <path>] [--write] [--json] [--force]
   sf artifact read --run <runId> --path <relPath> [--out <file>]
   sf envelope get --run <runId> --stage <stageId> [--json] [--from <sf-run.json>] [--detect-stage <id>] [--format envelope|handoff]
   sf export-run --run <runId> [--from <sf-run.json>] [--out <file>]
@@ -64,6 +66,8 @@ ${RUN_USAGE}
 
 ${VALIDATE_USAGE}
 
+${MIGRATE_YAML_USAGE}
+
 ${ARTIFACT_USAGE}
 
 ${ENVELOPE_USAGE}
@@ -93,6 +97,7 @@ function parseArgs(argv) {
     const command = args[0];
     if (command === "providers" ||
         command === "validate" ||
+        command === "migrate-yaml" ||
         command === "run" ||
         command === "init" ||
         command === "artifact" ||
@@ -275,7 +280,16 @@ async function main(argv) {
             return runInitCommand(argv.slice(3), { cwd: ctx.invocationCwd });
         }
         if (parsed.command === "validate") {
-            return runValidateCommand(argv.slice(3), { cwd: ctx.invocationCwd });
+            return runValidateCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+                projectRoot: ctx.projectRoot,
+            });
+        }
+        if (parsed.command === "migrate-yaml") {
+            return runMigrateYamlCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+                projectRoot: ctx.projectRoot,
+            });
         }
         if (parsed.command === "run") {
             return runRunCommand(argv.slice(3), {

package/dist/config/browseCatalog.js

@@ -106,7 +106,7 @@ async function listModelsFromManifest(projectRoot, manifest) {
         try {
             const loaded = await loadPipeline(filePath, { cwd: projectRoot });
             for (const stage of loaded.stages) {
-                if (stage.model.trim()) {
+                if (stage.model?.trim()) {
                     models.add(stage.model);
                 }
             }