stageflow 0.19.0 → 0.23.0

package/dist/cli/runsCommand.js

@@ -1,18 +1,16 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
-import { resolveGlobalOnlyAgentPort } from "../agent/resolveAgentPort.js";
 import { projectRun } from "../projection/projectRun.js";
 import { waitRun } from "../mcp/waitRun.js";
 import { projectWaitingGates } from "../mcp/waitingGates.js";
-import { resolveOperatorCatalog } from "./operatorCatalog.js";
 import { completeCliRun } from "./runCommand.js";
 import { reportCliRun } from "./runOutput.js";
+import { globalStageflowHome } from "../project/globalHome.js";
 import { createRunStore } from "../runstore/createStore.js";
 import { readStageVerificationHistory } from "../runstore/verificationHistory.js";
-import { RunManager } from "../runtime/runManager.js";
-import { readStageExecutionMode } from "../runtime/stageConcurrency.js";
-import { DEFAULT_PORT } from "../server/createHttpHost.js";
+import { ensureGlobalService, hostBaseUrl, } from "../server/ensureGlobalService.js";
 import { mapRetryStageFailure } from "../server/operatorResults.js";
+import { httpAbandonStage, httpDecideFeedbackLoop, httpDeliverAnswer, httpRecoverManualStageUntilStop, httpRerun, httpResumeTimedOutStage, httpRetryStageUntilStop, httpStopManualRecovery, } from "./hostClient.js";
 import { AskOperatorError, parseAskOperatorAnswer, } from "../tools/askOperator.js";
 export const RUNS_USAGE = `Usage:
   sf runs list [--status created|running|succeeded|failed] [--since <iso>] [--pipeline <id-or-path>] [--json]
@@ -255,28 +253,6 @@ function resolveRunIdFromFile(fromPath, cwd) {
     }
     return runId;
 }
-function hostBaseUrl() {
-    return `http://127.0.0.1:${DEFAULT_PORT}`;
-}
-export async function defaultProbeHost() {
-    const ac = new AbortController();
-    const timer = setTimeout(() => ac.abort(), 1500);
-    try {
-        const res = await fetch(`${hostBaseUrl()}/api/health`, {
-            signal: ac.signal,
-        });
-        if (res.status !== 200)
-            return "down";
-        JSON.parse(await res.text());
-        return "up";
-    }
-    catch {
-        return "down";
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
 function printJson(io, payload) {
     io.log(JSON.stringify(payload, null, 2));
 }
@@ -304,15 +280,22 @@ async function resolveShowWaitRunId(parsed, cwd, io) {
     }
     return parsed.runId;
 }
+const MUTATING_SUBCOMMANDS = new Set([
+    "answer",
+    "feedback-decide",
+    "retry",
+    "resume",
+    "recover",
+    "abandon",
+    "rerun",
+]);
 export async function runRunsCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const projectRoot = options.projectRoot ?? cwd;
-    const isGitProject = options.isGitProject ?? false;
     const out = { ...defaultIo, ...options.io };
-    const env = options.env ?? process.env;
     const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY === true;
     const readStdin = options.readStdin ?? (() => readFileSync(0, "utf8"));
-    const probeHost = options.probeHost ?? defaultProbeHost;
+    const base = options.hostBaseUrl ?? hostBaseUrl();
+    const ensureService = options.ensureService ?? (() => ensureGlobalService());
     let parsed;
     try {
         parsed = parseRunsArgs(args);
@@ -331,39 +314,23 @@ export async function runRunsCommand(args, options = {}) {
     let resolvedStore = options.store;
     const getStore = () => {
         if (resolvedStore === undefined) {
-            resolvedStore = createRunStore({ rootDir: projectRoot });
+            resolvedStore = createRunStore({ rootDir: globalStageflowHome() });
         }
         return resolvedStore;
     };
     const mutatingIo = out;
-    const agent = await resolveGlobalOnlyAgentPort(projectRoot);
-    const buildManager = () => {
-        const store = getStore();
-        if (options.createManager)
-            return options.createManager(store);
-        const operatorCatalog = resolveOperatorCatalog({
-            flags: {},
-            env,
-            defaultCwd: cwd,
-        });
-        return new RunManager({
-            agent,
-            store,
-            cwd,
-            projectRoot,
-            isGitProject,
-            operatorCatalog,
-            executionMode: readStageExecutionMode(env, "process"),
-        });
-    };
-    const guardHost = async () => {
-        const status = await probeHost();
-        if (status === "up") {
-            out.error(`A Stageflow host is already running at ${hostBaseUrl()}. Use the operator console or MCP instead of mutating the store from the CLI.`);
+    if (MUTATING_SUBCOMMANDS.has(parsed.subcommand)) {
+        const ensured = await ensureService();
+        if (!ensured.ok) {
+            if (parsed.json) {
+                printJson(out, { error: ensured.message, reason: ensured.reason });
+            }
+            else {
+                out.error(ensured.message);
+            }
             return 1;
         }
-        return undefined;
-    };
+    }
     switch (parsed.subcommand) {
         case "list": {
             if (parsed.status === "waiting") {
@@ -527,9 +494,6 @@ export async function runRunsCommand(args, options = {}) {
             }
         }
         case "answer": {
-            const blocked = await guardHost();
-            if (blocked !== undefined)
-                return blocked;
             if (!parsed.runId) {
                 return usageError(out, "Missing --run");
             }
@@ -578,8 +542,7 @@ export async function runRunsCommand(args, options = {}) {
                 out.error(message);
                 return 1;
             }
-            const manager = buildManager();
-            const result = await manager.deliverAnswer(parsed.runId, parsed.stageId, answer);
+            const result = await httpDeliverAnswer(base, parsed.runId, parsed.stageId, parsedJson);
             if (!result.ok) {
                 const payload = { error: result.reason };
                 if (result.status !== undefined)
@@ -601,9 +564,6 @@ export async function runRunsCommand(args, options = {}) {
             return 0;
         }
         case "feedback-decide": {
-            const blocked = await guardHost();
-            if (blocked !== undefined)
-                return blocked;
             if (!parsed.runId) {
                 return usageError(out, "Missing --run");
             }
@@ -625,8 +585,7 @@ export async function runRunsCommand(args, options = {}) {
                 }
                 return 1;
             }
-            const manager = buildManager();
-            const result = await manager.decideFeedbackLoop(parsed.runId, parsed.stageId, {
+            const result = await httpDecideFeedbackLoop(base, parsed.runId, parsed.stageId, {
                 decision: parsed.decision,
                 ...(parsed.loopId !== undefined ? { loopId: parsed.loopId } : {}),
                 ...(parsed.reason !== undefined ? { reason: parsed.reason } : {}),
@@ -656,14 +615,10 @@ export async function runRunsCommand(args, options = {}) {
             return 0;
         }
         case "retry": {
-            const blocked = await guardHost();
-            if (blocked !== undefined)
-                return blocked;
             if (!parsed.runId || !parsed.stageId) {
                 return usageError(out, "Missing --run and/or --stage");
             }
-            const manager = buildManager();
-            const result = await manager.retryStageUntilStop(parsed.runId, parsed.stageId);
+            const result = await httpRetryStageUntilStop(base, parsed.runId, parsed.stageId);
             if (!result.ok) {
                 if (parsed.json) {
                     printJson(out, {
@@ -679,14 +634,10 @@ export async function runRunsCommand(args, options = {}) {
             return reportCliRun({ kind: "completion", result: result.pipeline }, { json: parsed.json, io: mutatingIo });
         }
         case "resume": {
-            const blocked = await guardHost();
-            if (blocked !== undefined)
-                return blocked;
             if (!parsed.runId || !parsed.stageId) {
                 return usageError(out, "Missing --run and/or --stage");
             }
-            const manager = buildManager();
-            const result = await manager.resumeTimedOutStage(parsed.runId, parsed.stageId);
+            const result = await httpResumeTimedOutStage(base, parsed.runId, parsed.stageId);
             if (!result.ok) {
                 if (parsed.json) {
                     printJson(out, {
@@ -713,18 +664,14 @@ export async function runRunsCommand(args, options = {}) {
             return 0;
         }
         case "recover": {
-            const blocked = await guardHost();
-            if (blocked !== undefined)
-                return blocked;
             if (!parsed.runId || !parsed.stageId) {
                 return usageError(out, "Missing --run and/or --stage");
             }
-            const manager = buildManager();
             if (parsed.stop) {
                 if (parsed.guidance !== undefined) {
                     return usageError(out, "--guidance cannot be used with --stop");
                 }
-                const result = await manager.stopManualRecovery(parsed.runId, parsed.stageId);
+                const result = await httpStopManualRecovery(base, parsed.runId, parsed.stageId);
                 if (!result.ok) {
                     if (parsed.json) {
                         printJson(out, { error: result.reason, status: result.status });
@@ -742,7 +689,7 @@ export async function runRunsCommand(args, options = {}) {
                 }
                 return 0;
             }
-            const result = await manager.recoverManualStageUntilStop(parsed.runId, parsed.stageId, parsed.guidance);
+            const result = await httpRecoverManualStageUntilStop(base, parsed.runId, parsed.stageId, parsed.guidance);
             if (!result.ok) {
                 if (parsed.json) {
                     printJson(out, { ...mapRetryStageFailure(result), status: result.status });
@@ -755,14 +702,10 @@ export async function runRunsCommand(args, options = {}) {
             return reportCliRun({ kind: "completion", result: result.pipeline }, { json: parsed.json, io: mutatingIo });
         }
         case "abandon": {
-            const blocked = await guardHost();
-            if (blocked !== undefined)
-                return blocked;
             if (!parsed.runId || !parsed.stageId) {
                 return usageError(out, "Missing --run and/or --stage");
             }
-            const manager = buildManager();
-            const result = await manager.abandonStage(parsed.runId, parsed.stageId);
+            const result = await httpAbandonStage(base, parsed.runId, parsed.stageId);
             if (!result.ok) {
                 const payload = { error: result.reason };
                 if (result.status !== undefined)
@@ -788,14 +731,10 @@ export async function runRunsCommand(args, options = {}) {
             return 0;
         }
         case "rerun": {
-            const blocked = await guardHost();
-            if (blocked !== undefined)
-                return blocked;
             if (!parsed.runId) {
                 return usageError(out, "Missing --run");
             }
-            const manager = buildManager();
-            const started = await manager.rerun(parsed.runId);
+            const started = await httpRerun(base, parsed.runId);
             if (!started.ok) {
                 return reportCliRun({ kind: "start-failure", started }, { json: parsed.json, io: mutatingIo });
             }

package/dist/cli.js

@@ -306,8 +306,6 @@ async function main(argv) {
         if (parsed.command === "run") {
             return runRunCommand(argv.slice(3), {
                 cwd: ctx.invocationCwd,
-                projectRoot: ctx.projectRoot,
-                isGitProject: ctx.isGitProject,
             });
         }
         if (parsed.command === "artifact") {
@@ -331,8 +329,6 @@ async function main(argv) {
         if (parsed.command === "runs") {
             return runRunsCommand(argv.slice(3), {
                 cwd: ctx.invocationCwd,
-                projectRoot: ctx.projectRoot,
-                isGitProject: ctx.isGitProject,
             });
         }
         if (parsed.command === "providers") {
@@ -344,7 +340,7 @@ async function main(argv) {
                 projectRoot: ctx.projectRoot,
             });
         }
-        const store = createRunStore({ rootDir: ctx.projectRoot });
+        const store = createRunStore({ rootDir: ctx.globalHome });
         const globalAgent = globalAgentBackendFromManifest(ctx.manifest);
         if (parsed.command === "ui") {
             const mcpStateless = resolveMcpStateless({

package/dist/config/describePipeline.d.ts

@@ -0,0 +1,26 @@
+import type { CloneMode, FeedbackLoopConfig, LoadedPipeline, PipelineForkConfig, PipelineNeedEdge, ResolvedPipelineStageNode, RouteIfPredicate } from "../types/pipeline.js";
+import type { StageGateKind } from "../types/stage.js";
+export type PipelineDescribeNeedEdge = {
+    id: string;
+    on: PipelineNeedEdge["on"];
+    if?: RouteIfPredicate;
+};
+export type PipelineDescribeNeeds = string | null | PipelineDescribeNeedEdge[];
+export type PipelineDescribeStage = {
+    id: string;
+    needs: PipelineDescribeNeeds;
+    fork?: PipelineForkConfig;
+    gate_kinds?: StageGateKind[];
+    clone_cap?: number;
+    clone_mode?: CloneMode;
+    feedback_loop?: FeedbackLoopConfig;
+    entry?: boolean;
+    replay_safe?: boolean;
+};
+export type PipelineDescribe = {
+    id: string;
+    path: string;
+    stages: PipelineDescribeStage[];
+};
+export declare function describePipelineNeeds(node: ResolvedPipelineStageNode): PipelineDescribeNeeds;
+export declare function describePipeline(loaded: LoadedPipeline): PipelineDescribe;

package/dist/config/describePipeline.js

@@ -0,0 +1,37 @@
+import { toPipelineNeeds } from "./pipelineNeeds.js";
+export function describePipelineNeeds(node) {
+    if (node.needsEdges.length === 0)
+        return node.needs;
+    const collapsed = toPipelineNeeds(node.needsEdges);
+    if (typeof collapsed === "string")
+        return collapsed;
+    return collapsed.map((edge) => ({
+        id: edge.id,
+        on: [...edge.on],
+        ...(edge.if !== undefined ? { if: edge.if } : {}),
+    }));
+}
+export function describePipeline(loaded) {
+    const gateById = new Map(loaded.stages.map((stage) => [stage.id, stage.gate_kinds]));
+    const stages = loaded.dag.nodes.map((node) => {
+        const gateKinds = gateById.get(node.id);
+        return {
+            id: node.id,
+            needs: describePipelineNeeds(node),
+            ...(node.fork !== undefined ? { fork: { ...node.fork } } : {}),
+            ...(node.clone_cap !== undefined ? { clone_cap: node.clone_cap } : {}),
+            ...(node.clone_mode !== undefined ? { clone_mode: node.clone_mode } : {}),
+            ...(node.feedback_loop !== undefined
+                ? { feedback_loop: { ...node.feedback_loop } }
+                : {}),
+            ...(node.entry !== undefined ? { entry: node.entry } : {}),
+            ...(node.replay_safe !== undefined ? { replay_safe: node.replay_safe } : {}),
+            ...(gateKinds !== undefined ? { gate_kinds: [...gateKinds] } : {}),
+        };
+    });
+    return {
+        id: loaded.pipeline.id,
+        path: loaded.pipelinePath,
+        stages,
+    };
+}

package/dist/config/loadPipeline.d.ts

@@ -1,8 +1,20 @@
-import type { LoadedPipeline } from "../types/pipeline.js";
+import type { InlinePipelineDefinition, LoadedPipeline } from "../types/pipeline.js";
 import { type LoadOutcome } from "./loadOutcome.js";
 export type { LoadedPipeline } from "../types/pipeline.js";
 export type { LoadIssue, LoadOutcome } from "./loadOutcome.js";
 export declare function resolvePipelinePath(pipelinePath: string, cwd: string): Promise<string>;
+/** Synthetic `pipelinePath` for a `LoadedPipeline` built from an inline object with no backing file. */
+export declare const INLINE_PIPELINE_PATH = "<inline>";
+export declare function loadPipelineFromObjectOutcome(raw: InlinePipelineDefinition, options?: {
+    cwd?: string;
+    projectRoot?: string;
+    requireIo?: boolean;
+}): Promise<LoadOutcome<LoadedPipeline>>;
+export declare function loadPipelineFromObject(raw: InlinePipelineDefinition, options?: {
+    cwd?: string;
+    projectRoot?: string;
+    requireIo?: boolean;
+}): Promise<LoadedPipeline>;
 export declare function loadPipelineOutcome(nameOrPath: string, options?: {
     cwd?: string;
     projectRoot?: string;

package/dist/config/loadPipeline.js

@@ -2,7 +2,7 @@ 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 { mergeInlinePipelineStages, mergePipelineStages, } from "./mergePipelineIncludes.js";
 import { normalizePipelineStageEntries, toWiringRefs, } from "./normalizePipelineStageEntry.js";
 import { loadStageFromObjectOutcome, loadStageOutcome, afterCompletionForStage } from "./loadStage.js";
 import { materializeStageModels } from "./materializeStageModels.js";
@@ -92,14 +92,44 @@ 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.`);
     }
 }
+/** Synthetic `pipelinePath` for a `LoadedPipeline` built from an inline object with no backing file. */
+export const INLINE_PIPELINE_PATH = "<inline>";
 async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd, requireIo = true) {
     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, model: pipelineModel, schemas: pipelineSchemas, warnings: mergeWarnings, } = mergeOutcome.value;
-    const ctx = { pipelineId, path: normalizedPipelinePath };
+    return buildLoadedPipelineFromMerge(mergeOutcome.value, {
+        projectRoot,
+        requireIo,
+        pipelinePath: normalizedPipelinePath,
+    });
+}
+export async function loadPipelineFromObjectOutcome(raw, options = {}) {
+    const projectRoot = options.projectRoot ?? options.cwd ?? process.cwd();
+    const requireIo = options.requireIo !== false;
+    const mergeOutcome = await mergeInlinePipelineStages(raw);
+    if (!mergeOutcome.ok) {
+        return loadFailure(mergeOutcome.issues);
+    }
+    return buildLoadedPipelineFromMerge(mergeOutcome.value, {
+        projectRoot,
+        requireIo,
+        pipelinePath: INLINE_PIPELINE_PATH,
+    });
+}
+export async function loadPipelineFromObject(raw, options = {}) {
+    const outcome = await loadPipelineFromObjectOutcome(raw, options);
+    if (!outcome.ok) {
+        throw new Error(outcome.issues[0].message);
+    }
+    return outcome.value;
+}
+async function buildLoadedPipelineFromMerge(merge, options) {
+    const { projectRoot, requireIo, pipelinePath } = options;
+    const { entries: rawEntries, pipelineId, agent: pipelineAgent, model: pipelineModel, schemas: pipelineSchemas, warnings: mergeWarnings, } = merge;
+    const ctx = { pipelineId, path: pipelinePath };
     const warnings = [...mergeWarnings];
     const normalizeOutcome = normalizePipelineStageEntries(rawEntries, ctx);
     if (!normalizeOutcome.ok) {
@@ -274,7 +304,7 @@ async function loadPipelineFromPath(pipelinePath, cwd, projectRoot = cwd, requir
         pipeline,
         stages: loadedStages,
         dag,
-        pipelinePath: normalizedPipelinePath,
+        pipelinePath,
         stageSources,
     }, warnings);
 }

package/dist/config/mergePipelineIncludes.d.ts

@@ -1,4 +1,5 @@
 import type { PayloadSchemaMap } from "../envelope/payloadSchema.js";
+import type { InlinePipelineDefinition } from "../types/pipeline.js";
 import { type LoadIssue, type LoadOutcome } from "./loadOutcome.js";
 export type RawMergedEntry = {
     raw: unknown;
@@ -12,3 +13,13 @@ export declare function mergePipelineStages(rootPath: string): Promise<LoadOutco
     schemas?: PayloadSchemaMap;
     warnings: LoadIssue[];
 }>>;
+/** Synthetic `declaringPath` for stage entries with no backing file. */
+export declare const INLINE_DECLARING_PATH = "<inline pipeline>";
+export declare function mergeInlinePipelineStages(raw: InlinePipelineDefinition): Promise<LoadOutcome<{
+    entries: RawMergedEntry[];
+    pipelineId: string;
+    agent?: string;
+    model?: string;
+    schemas?: PayloadSchemaMap;
+    warnings: LoadIssue[];
+}>>;

package/dist/config/mergePipelineIncludes.js

@@ -201,6 +201,81 @@ export async function mergePipelineStages(rootPath) {
         warnings,
     });
 }
+/** Synthetic `declaringPath` for stage entries with no backing file. */
+export const INLINE_DECLARING_PATH = "<inline pipeline>";
+export async function mergeInlinePipelineStages(raw) {
+    if (typeof raw.id !== "string" || !raw.id) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_shape",
+                message: `Invalid inline pipeline: id is required`,
+                category: "pipeline",
+            },
+        ]);
+    }
+    if (!Array.isArray(raw.stages) || raw.stages.length === 0) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_shape",
+                message: `Invalid inline pipeline ${raw.id}: stages must be non-empty`,
+                category: "pipeline",
+                pipelineId: raw.id,
+            },
+        ]);
+    }
+    const pipelineId = raw.id;
+    const agentField = parseAgentField(raw.agent);
+    if (!agentField.ok) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_agent",
+                message: `Invalid inline pipeline ${pipelineId}: ${agentField.message}`,
+                category: "pipeline",
+                pipelineId,
+            },
+        ]);
+    }
+    const agent = agentField.value;
+    const modelField = parseModelField(raw.model);
+    if (!modelField.ok) {
+        return loadFailure([
+            {
+                code: "pipeline.invalid_model",
+                message: `Invalid inline pipeline ${pipelineId}: ${modelField.message}`,
+                category: "pipeline",
+                pipelineId,
+            },
+        ]);
+    }
+    const model = modelField.value;
+    const schemasOutcome = parsePipelineSchemas(raw.schemas, "<inline pipeline>", pipelineId);
+    if (!schemasOutcome.ok)
+        return schemasOutcome;
+    const schemas = schemasOutcome.value;
+    const entries = [];
+    for (let index = 0; index < raw.stages.length; index++) {
+        const entry = raw.stages[index];
+        if (isPlainObject(entry) && typeof entry.uses === "string") {
+            return loadFailure([
+                {
+                    code: "pipeline.invalid_shape",
+                    message: `Invalid inline pipeline ${pipelineId}: stage entry at index ${index} has "uses" — inline pipelines cannot reference external stage files, all stage bodies must be inline`,
+                    category: "pipeline",
+                    pipelineId,
+                },
+            ]);
+        }
+        entries.push({ raw: entry, declaringPath: INLINE_DECLARING_PATH });
+    }
+    return loadSuccess({
+        entries,
+        pipelineId,
+        ...(agent !== undefined ? { agent } : {}),
+        ...(model !== undefined ? { model } : {}),
+        ...(schemas !== undefined ? { schemas } : {}),
+        warnings: [],
+    });
+}
 function parsePipelineSchemas(raw, absPath, pipelineId) {
     if (raw === undefined)
         return loadSuccess(undefined);

package/dist/config/validateCatalog.d.ts

@@ -1,4 +1,4 @@
-import type { LoadedPipeline } from "../types/pipeline.js";
+import type { InlinePipelineDefinition, LoadedPipeline } from "../types/pipeline.js";
 import type { LoadIssue } from "./loadOutcome.js";
 export type ValidationSeverity = "error" | "warning";
 export type ValidationCategory = "pipeline" | "stage" | "catalog" | "task";
@@ -50,7 +50,7 @@ export type LoadPipelineValidatedResult = {
     ok: false;
     findings: ValidationFinding[];
 };
-export declare function loadPipelineValidated(nameOrPath: string, options?: {
+export declare function loadPipelineValidated(nameOrPath: string | InlinePipelineDefinition, options?: {
     cwd?: string;
     projectRoot?: string;
     validateStages?: boolean;

package/dist/config/validateCatalog.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { loadPipelineOutcome, resolvePipelinePath } from "./loadPipeline.js";
+import { INLINE_PIPELINE_PATH, loadPipelineFromObjectOutcome, loadPipelineOutcome, resolvePipelinePath, } from "./loadPipeline.js";
 import { loadStageOutcome } from "./loadStage.js";
 import { loadTaskOutcome } from "./loadTask.js";
 import { readYamlObject } from "./readYamlObject.js";
@@ -241,23 +241,30 @@ async function runPipelineValidation(nameOrPath, options) {
     const { cwd, validateStages } = options;
     const projectRoot = options.projectRoot ?? cwd;
     let pipelinePath;
-    try {
-        pipelinePath = await resolvePipelinePath(nameOrPath, cwd);
+    let outcome;
+    if (typeof nameOrPath === "string") {
+        try {
+            pipelinePath = await resolvePipelinePath(nameOrPath, cwd);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                ok: false,
+                findings: findingsFromLoadIssues(cwd, path.resolve(cwd, nameOrPath), [
+                    {
+                        code: "pipeline.load_error",
+                        message,
+                        category: "pipeline",
+                    },
+                ]),
+            };
+        }
+        outcome = await loadPipelineOutcome(pipelinePath, { cwd, projectRoot });
+    }
+    else {
+        pipelinePath = path.resolve(cwd, INLINE_PIPELINE_PATH);
+        outcome = await loadPipelineFromObjectOutcome(nameOrPath, { cwd, projectRoot });
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            ok: false,
-            findings: findingsFromLoadIssues(cwd, path.resolve(cwd, nameOrPath), [
-                {
-                    code: "pipeline.load_error",
-                    message,
-                    category: "pipeline",
-                },
-            ]),
-        };
-    }
-    const outcome = await loadPipelineOutcome(pipelinePath, { cwd, projectRoot });
     const findings = [];
     if (!outcome.ok) {
         findings.push(...findingsFromLoadIssues(cwd, pipelinePath, outcome.issues));