stageflow 0.1.0 → 0.3.0

package/dist/runtime/pipelineRunner.js

@@ -1,10 +1,11 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { loadPipelineValidated } from "../config/loadPipeline.js";
+import { loadPipelineValidated } from "../config/validateCatalog.js";
 import { loadTaskFromYaml } from "../config/loadTask.js";
 import { buildValidationResult } from "../config/validateCatalog.js";
 import { resolveAndValidateCheckout } from "./stageRoots.js";
 import { buildPipelineDagSnapshotFromLoaded } from "../runstore/pipelineDagSnapshot.js";
+import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
 import { runPipelineDag } from "./pipelineScheduler.js";
 import { readMaxActiveStagesPerRun, readStageExecutionMode, } from "./stageConcurrency.js";
 import { StageProcessLauncher } from "./stageProcessLauncher.js";
@@ -41,12 +42,23 @@ async function preparePipeline(options) {
     const label = options.taskPath ?? "task.yaml";
     const task = loadTaskFromYaml(taskYaml, `task file ${label}`);
     const checkoutRoot = await resolveAndValidateCheckout(task, options.checkoutOverride, options.cwd);
+    const pipelinePath = normalizeCatalogPath(loaded.pipelinePath);
+    const taskPath = options.taskPath
+        ? normalizeCatalogPath(path.resolve(options.cwd, options.taskPath))
+        : undefined;
+    const projectRoot = normalizeCatalogPath(options.projectRoot ?? options.cwd);
     const run = await options.store.createRun({
         pipelineId: loaded.pipeline.id,
         taskYaml,
         taskId: task.id,
         checkoutRoot,
+        gitSha: options.gitSha,
+        ciPrUrl: options.ciPrUrl,
+        ciJobUrl: options.ciJobUrl,
         pipelineDag: buildPipelineDagSnapshotFromLoaded(loaded),
+        pipelinePath,
+        taskPath,
+        projectRoot,
     });
     const executionMode = readStageExecutionMode(process.env, options.executionMode);
     const stageProcessLauncher = resolveStageProcessLauncher(executionMode, options.stageProcessLauncher);
@@ -57,11 +69,13 @@ async function preparePipeline(options) {
         agent: options.agent,
         store: options.store,
         cwd: options.cwd,
+        projectRoot: options.projectRoot ?? options.cwd,
         checkoutRoot,
         hitl: options.hitl,
         executionMode,
         stageProcessLauncher,
         operatorCatalog: options.operatorCatalog,
+        skipGates: options.skipGates,
     };
 }
 export async function executeStages(prepared, options) {
@@ -82,6 +96,7 @@ export async function executeStages(prepared, options) {
 }
 export async function runPipeline(options) {
     const cwd = options.cwd ?? process.cwd();
+    const projectRoot = options.projectRoot ?? cwd;
     const prepared = await preparePipeline({
         agent: options.agent,
         store: options.store,
@@ -89,11 +104,13 @@ export async function runPipeline(options) {
         taskYaml: options.taskYaml,
         pipeline: options.pipeline,
         cwd,
+        projectRoot,
         checkoutOverride: options.checkoutOverride,
         hitl: options.hitl,
         executionMode: options.executionMode,
         stageProcessLauncher: options.stageProcessLauncher,
         operatorCatalog: options.operatorCatalog,
+        skipGates: options.skipGates,
     });
     return executeStages(prepared, {
         maxActiveStagesPerRun: options.maxActiveStagesPerRun,
@@ -104,6 +121,7 @@ export async function runPipeline(options) {
 /** Create the run immediately, then execute stages in the returned promise. */
 export async function startPipeline(options) {
     const cwd = options.cwd ?? process.cwd();
+    const projectRoot = options.projectRoot ?? cwd;
     const prepared = await preparePipeline({
         agent: options.agent,
         store: options.store,
@@ -111,11 +129,16 @@ export async function startPipeline(options) {
         taskYaml: options.taskYaml,
         pipeline: options.pipeline,
         cwd,
+        projectRoot,
         checkoutOverride: options.checkoutOverride,
+        gitSha: options.gitSha,
+        ciPrUrl: options.ciPrUrl,
+        ciJobUrl: options.ciJobUrl,
         hitl: options.hitl,
         executionMode: options.executionMode,
         stageProcessLauncher: options.stageProcessLauncher,
         operatorCatalog: options.operatorCatalog,
+        skipGates: options.skipGates,
     });
     const done = executeStages(prepared, {
         maxActiveStagesPerRun: options.maxActiveStagesPerRun,
@@ -125,6 +148,7 @@ export async function startPipeline(options) {
         await prepared.store.updateRunStatus(prepared.run.runId, "failed").catch(() => undefined);
         return {
             ok: false,
+            outcome: "failed",
             runDir: prepared.run.workspaceDir,
             runId: prepared.run.runId,
             reason: err instanceof Error ? err.message : String(err),

package/dist/runtime/pipelineScheduler.d.ts

@@ -18,9 +18,11 @@ type SchedulerPreparedPipeline = {
     agent: AgentPort;
     store: RunStore;
     cwd: string;
+    projectRoot?: string;
     checkoutRoot?: string;
     hitl?: StageHitlController;
     operatorCatalog?: OperatorCatalog;
+    skipGates?: boolean;
 };
 export type { SchedulerPreparedPipeline };
 type RetryContext = {
@@ -85,6 +87,7 @@ export type RetryRunOptions = {
     onRetryRootTerminal?: OnRetryRootTerminal;
 };
 export declare function retryRun(options: RetryRunOptions): Promise<PipelineRunResult>;
+export declare function applyForkSkipsFromEnvelopes(dag: ResolvedPipelineDag, states: Map<string, StageScheduleState>, completedEnvelopes: Map<string, StageEnvelope>): void;
 export declare function applyRetryRootDelta(dag: ResolvedPipelineDag, states: Map<string, StageScheduleState>, completedEnvelopes: Map<string, StageEnvelope>, retryRoots: Map<string, number>, stageId: string, attempt: number, clearSchedulingHalt?: () => void): void;
 export declare function hasWorkOutsideBranch(dag: ResolvedPipelineDag, branchRootId: string, states: Map<string, StageScheduleState>, ctx?: HasWorkOutsideBranchContext): boolean;
 export declare function runPipelineDag(options: RunPipelineDagOptions): Promise<PipelineRunResult>;

package/dist/runtime/pipelineScheduler.js

@@ -1,3 +1,4 @@
+import { normalizeForkChoice } from "../envelope/forkChoice.js";
 import { collectDownstreamClosure, collectDownstreamStageIds, } from "./dagTraversal.js";
 import { buildCompletedEnvelopesFromRun, buildStageConfigById, } from "./envelopeRouting.js";
 import { WAIT_WITHOUT_WORKER_DISPATCH } from "./answerResume.js";
@@ -93,7 +94,8 @@ export async function resumeRun(options) {
     const hasActive = [...hydrated.states.values()].some((s) => s === "active");
     if (hasActive) {
         return {
-            ok: true,
+            ok: false,
+            outcome: "waiting",
             runDir: prepared.run.workspaceDir,
             runId: prepared.run.runId,
         };
@@ -103,10 +105,14 @@ export async function resumeRun(options) {
         return state !== undefined && terminalState(state);
     });
     if (allTerminal) {
-        const allSucceeded = dag.nodes.every((node) => hydrated.states.get(node.id) === "succeeded");
+        const allSucceeded = dag.nodes.every((node) => {
+            const s = hydrated.states.get(node.id);
+            return s === "succeeded" || s === "skipped";
+        });
         await prepared.store.updateRunStatus(prepared.run.runId, allSucceeded ? "succeeded" : "failed");
         return {
             ok: allSucceeded,
+            outcome: allSucceeded ? "succeeded" : "failed",
             runDir: prepared.run.workspaceDir,
             runId: prepared.run.runId,
             ...(allSucceeded
@@ -131,6 +137,33 @@ export async function retryRun(options) {
         onRetryRootTerminal: options.onRetryRootTerminal,
     });
 }
+function applyForkChoiceToSchedule(dag, forkStageId, chosen, states, options) {
+    const skipPending = (stageId) => {
+        if (states.get(stageId) === "pending") {
+            states.set(stageId, "skipped");
+            options?.onSkip?.(stageId);
+        }
+    };
+    for (const childId of dag.childrenOf[forkStageId] ?? []) {
+        if (!chosen.has(childId)) {
+            skipPending(childId);
+            for (const desc of collectDownstreamStageIds(dag, childId)) {
+                skipPending(desc);
+            }
+        }
+    }
+}
+export function applyForkSkipsFromEnvelopes(dag, states, completedEnvelopes) {
+    for (const node of dag.nodes) {
+        if (!node.fork)
+            continue;
+        const envelope = completedEnvelopes.get(node.id);
+        if (!envelope)
+            continue;
+        const chosen = normalizeForkChoice(envelope.fork_choice, "stored");
+        applyForkChoiceToSchedule(dag, node.id, chosen, states);
+    }
+}
 export function applyRetryRootDelta(dag, states, completedEnvelopes, retryRoots, stageId, attempt, clearSchedulingHalt) {
     retryRoots.set(stageId, attempt);
     const downstream = collectDownstreamClosure(dag, [stageId]);
@@ -204,7 +237,8 @@ function isRunnable(dag, stageId, states, schedulingHalted) {
 export async function runPipelineDag(options) {
     const { prepared, maxActiveStagesPerRun } = options;
     const executionMode = options.executionMode ?? "process";
-    const { agent, task, loaded, run, store, checkoutRoot, hitl, cwd, } = prepared;
+    const { agent, task, loaded, run, store, checkoutRoot, hitl, cwd, projectRoot, } = prepared;
+    const factoryCwd = projectRoot ?? cwd ?? process.cwd();
     const dag = loaded.dag;
     const stageById = buildStageConfigById(loaded);
     let { states, completedEnvelopes, schedulingHalted, firstFailureReason } = options.initialSchedule ??
@@ -258,6 +292,7 @@ export async function runPipelineDag(options) {
             }
         }
     }
+    applyForkSkipsFromEnvelopes(dag, states, completedEnvelopes);
     let activeCount = 0;
     const inFlight = new Set();
     const notifyRetryRootTerminal = (stageId, outcome) => {
@@ -321,6 +356,13 @@ export async function runPipelineDag(options) {
         states.set(stageId, "succeeded");
         completedEnvelopes.set(stageId, envelope);
         notifyRetryRootTerminal(stageId, "succeeded");
+        const node = dag.nodes.find((n) => n.id === stageId);
+        if (node?.fork) {
+            const chosen = normalizeForkChoice(envelope.fork_choice, "stored");
+            applyForkChoiceToSchedule(dag, stageId, chosen, states, {
+                onSkip: (id) => notifyRetryRootTerminal(id, "skipped"),
+            });
+        }
     };
     const launchStage = async (stageId) => {
         const stage = stageById.get(stageId);
@@ -339,20 +381,20 @@ export async function runPipelineDag(options) {
             const launchResult = await launcher.launch({
                 runId: run.runId,
                 stageId,
-                rootDir: cwd,
+                rootDir: factoryCwd,
                 attempt,
                 ...(prepared.operatorCatalog !== undefined
                     ? { operatorCatalog: prepared.operatorCatalog }
                     : {}),
+                ...(prepared.skipGates ? { skipGates: true } : {}),
             });
             if (launchResult.type === "succeeded") {
                 try {
                     const envelope = await store.readEnvelope(run.runId, stageId);
                     onStageSuccess(stageId, envelope);
                 }
-                catch {
-                    states.set(stageId, "succeeded");
-                    notifyRetryRootTerminal(stageId, "succeeded");
+                catch (err) {
+                    await onStageFailure(stageId, err instanceof Error ? err.message : String(err));
                 }
                 return;
             }
@@ -374,9 +416,10 @@ export async function runPipelineDag(options) {
             workspaceDir: run.workspaceDir,
             hitl,
             attemptCtx,
-            factoryCwd: cwd,
+            factoryCwd,
             operatorCatalog: prepared.operatorCatalog,
             completedEnvelopes,
+            skipGates: prepared.skipGates,
         });
         if (isRunStageWaiting(result)) {
             await onStageFailure(stageId, WAIT_WITHOUT_WORKER_DISPATCH);
@@ -461,7 +504,12 @@ export async function runPipelineDag(options) {
     }
     const hasWaiting = [...states.values()].some((s) => s === "waiting");
     if (hasWaiting && !schedulingHalted) {
-        return { ok: true, runDir: run.workspaceDir, runId: run.runId };
+        return {
+            ok: false,
+            outcome: "waiting",
+            runDir: run.workspaceDir,
+            runId: run.runId,
+        };
     }
     if (schedulingHalted) {
         markSkippedPending();
@@ -470,25 +518,33 @@ export async function runPipelineDag(options) {
         }
         return {
             ok: false,
+            outcome: "failed",
             runDir: run.workspaceDir,
             runId: run.runId,
             reason: firstFailureReason,
         };
     }
-    const allSucceeded = dag.nodes.every((node) => states.get(node.id) === "succeeded");
+    const allSucceeded = dag.nodes.every((node) => {
+        const s = states.get(node.id);
+        return s === "succeeded" || s === "skipped";
+    });
     if (!allSucceeded) {
         if (retryContext === undefined) {
             await store.updateRunStatus(run.runId, "failed");
         }
         return {
             ok: false,
+            outcome: "failed",
             runDir: run.workspaceDir,
             runId: run.runId,
             reason: firstFailureReason ?? "pipeline incomplete",
         };
     }
-    if (retryContext === undefined) {
-        await store.updateRunStatus(run.runId, "succeeded");
-    }
-    return { ok: true, runDir: run.workspaceDir, runId: run.runId };
+    await store.updateRunStatus(run.runId, "succeeded");
+    return {
+        ok: true,
+        outcome: "succeeded",
+        runDir: run.workspaceDir,
+        runId: run.runId,
+    };
 }

package/dist/runtime/reloadRunCatalog.d.ts

@@ -0,0 +1,5 @@
+import type { RunMeta } from "../runstore/port.js";
+import type { LoadedPipeline } from "../types/pipeline.js";
+import type { TaskFile } from "../types/task.js";
+export declare function reloadPipelineForRun(meta: RunMeta): Promise<LoadedPipeline>;
+export declare function reloadTaskForRun(meta: RunMeta): Promise<TaskFile>;

package/dist/runtime/reloadRunCatalog.js

@@ -0,0 +1,44 @@
+import { access } from "node:fs/promises";
+import { loadPipeline } from "../config/loadPipeline.js";
+import { loadTask } from "../config/loadTask.js";
+import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
+function missingLocator(field, runId) {
+    throw new Error(`Run ${runId} is missing ${field}; reload requires stored catalog locators.`);
+}
+function requireProjectRoot(meta) {
+    if (!meta.project_root) {
+        missingLocator("project_root", meta.run_id);
+    }
+    return normalizeCatalogPath(meta.project_root);
+}
+function requirePipelinePath(meta) {
+    if (!meta.pipeline_path) {
+        missingLocator("pipeline_path", meta.run_id);
+    }
+    return normalizeCatalogPath(meta.pipeline_path);
+}
+function requireTaskPath(meta) {
+    if (!meta.task_path) {
+        missingLocator("task_path", meta.run_id);
+    }
+    return normalizeCatalogPath(meta.task_path);
+}
+async function assertCatalogFileExists(filePath, label) {
+    try {
+        await access(filePath);
+    }
+    catch {
+        throw new Error(`${label} not found at stored path: ${filePath}`);
+    }
+}
+export async function reloadPipelineForRun(meta) {
+    const projectRoot = requireProjectRoot(meta);
+    const pipelinePath = requirePipelinePath(meta);
+    await assertCatalogFileExists(pipelinePath, "Pipeline");
+    return loadPipeline(pipelinePath, { cwd: projectRoot });
+}
+export async function reloadTaskForRun(meta) {
+    const taskPath = requireTaskPath(meta);
+    await assertCatalogFileExists(taskPath, "Task");
+    return loadTask(taskPath);
+}

package/dist/runtime/resumeReconstruct.d.ts

@@ -16,6 +16,7 @@ export type PreparedResumeContext = {
     executionMode: StageExecutionMode;
     stageProcessLauncher?: StageProcessLauncher;
     cwd: string;
+    factoryCwd?: string;
     maxActiveStagesPerRun: number;
     operatorCatalog?: OperatorCatalog;
 };

package/dist/runtime/resumeReconstruct.js

@@ -1,7 +1,9 @@
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { fakeHitlResumePath } from "../agent/fakeAgent.js";
-import { loadPipeline } from "../config/loadPipeline.js";
 import { loadTaskFromYaml } from "../config/loadTask.js";
+import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
+import { reloadPipelineForRun, reloadTaskForRun, } from "./reloadRunCatalog.js";
 import { WAIT_WITHOUT_WORKER_DISPATCH } from "./answerResume.js";
 import { resumeRun } from "./pipelineScheduler.js";
 import { buildStageRoots, withResolvedAuthPath } from "./stageRoots.js";
@@ -10,14 +12,27 @@ import { attemptContext } from "./stageAttemptContext.js";
 import { openStageAttempt, } from "./stageAttemptBootstrap.js";
 export async function loadRunContext(store, runId, cwd) {
     const meta = await store.readRunMeta(runId);
-    const taskYaml = await store.readTaskYaml(runId);
-    const task = loadTaskFromYaml(taskYaml, `run ${runId} task`);
-    const loaded = await loadPipeline(meta.pipeline_id, { cwd });
+    const reloadMeta = {
+        ...meta,
+        project_root: meta.project_root ?? normalizeCatalogPath(cwd),
+    };
+    const loaded = await reloadPipelineForRun(reloadMeta);
+    let taskYaml;
+    let task;
+    if (meta.task_path) {
+        task = await reloadTaskForRun(meta);
+        taskYaml = await readFile(normalizeCatalogPath(meta.task_path), "utf8");
+    }
+    else {
+        taskYaml = await store.readTaskYaml(runId);
+        task = loadTaskFromYaml(taskYaml, `run ${runId} task`);
+    }
     const workspaceDir = store.getWorkspaceDir(runId);
     return { meta, taskYaml, task, loaded, workspaceDir };
 }
 export async function reconstructAndContinue(ctx) {
     const { runId, stageId, opaqueAnswer, agent, store, cwd } = ctx;
+    const factoryCwd = ctx.factoryCwd ?? cwd;
     try {
         const latestExecution = await store.getLatestStageExecution(runId, stageId);
         const attemptCtx = attemptContext(latestExecution?.attempt ?? 1);
@@ -36,7 +51,7 @@ export async function reconstructAndContinue(ctx) {
         const stage = loaded.stages[stageIndex];
         const workspaceDir = store.getWorkspaceDir(runId);
         const checkoutRoot = meta.checkout_root;
-        const roots = withResolvedAuthPath(buildStageRoots(workspaceDir, stageId, checkoutRoot, attemptCtx), cwd);
+        const roots = withResolvedAuthPath(buildStageRoots(workspaceDir, stageId, checkoutRoot, attemptCtx), factoryCwd);
         const fakeResume = fakeHitlResumePath(roots, stageId);
         const piSession = attemptCtx.sessionPath(workspaceDir, stageId);
         if (!existsSync(fakeResume) && !existsSync(piSession)) {
@@ -57,7 +72,7 @@ export async function reconstructAndContinue(ctx) {
             dag: loaded.dag,
             checkoutRoot,
             workspaceDir,
-            factoryCwd: cwd,
+            factoryCwd,
             attemptCtx,
             operatorCatalog: ctx.operatorCatalog,
             onActivity: (event) => {
@@ -86,7 +101,7 @@ export async function reconstructAndContinue(ctx) {
             skipStarted: true,
             existingHandle: opened.handle,
             attemptCtx,
-            factoryCwd: cwd,
+            factoryCwd,
             operatorCatalog: ctx.operatorCatalog,
         });
         if (isRunStageWaiting(result)) {
@@ -108,6 +123,7 @@ export async function reconstructAndContinue(ctx) {
                 agent,
                 store,
                 cwd,
+                projectRoot: factoryCwd,
                 checkoutRoot,
                 hitl: ctx.hitl,
                 operatorCatalog: ctx.operatorCatalog,
@@ -118,9 +134,10 @@ export async function reconstructAndContinue(ctx) {
             executionMode: ctx.executionMode,
             stageProcessLauncher: ctx.stageProcessLauncher,
         });
-        return rest.ok
-            ? { ok: true }
-            : { ok: false, reason: rest.reason };
+        if (rest.outcome === "failed") {
+            return { ok: false, reason: rest.reason };
+        }
+        return { ok: true };
     }
     catch (err) {
         const reason = err instanceof Error

package/dist/runtime/runManager.d.ts

@@ -61,10 +61,14 @@ export declare class RunManager {
     private readonly retryCoordinator;
     private readonly retryTracking;
     private readonly cwd;
+    private readonly projectRoot;
+    private readonly isGitProject;
     constructor(options: {
         agent: AgentPort;
         store: RunStore;
         cwd?: string;
+        projectRoot?: string;
+        isGitProject?: boolean;
         operatorCatalog?: OperatorCatalog;
         seams?: HitlSeams;
         maxConcurrent?: number;
@@ -100,6 +104,10 @@ export declare class RunManager {
         pipeline: string;
         task?: string | TaskFile;
         checkoutOverride?: string;
+        skipGates?: boolean;
+        gitSha?: string;
+        ciPrUrl?: string;
+        ciJobUrl?: string;
     }): Promise<StartRunResult>;
     rerun(runId: string): Promise<StartRunResult>;
     retryStage(runId: string, stageId: string): Promise<RetryStageResult>;

package/dist/runtime/runManager.js

@@ -1,14 +1,15 @@
 import { randomUUID } from "node:crypto";
 import { readFile, realpath } from "node:fs/promises";
 import path from "node:path";
-import { loadPipeline } from "../config/loadPipeline.js";
+import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
+import { loadRunContext } from "./resumeReconstruct.js";
 import { loadTaskFromYaml } from "../config/loadTask.js";
 import { PipelineValidationError, startPipeline, } from "./pipelineRunner.js";
 import { resumeRun } from "./pipelineScheduler.js";
 import { RunRetryCoordinator, } from "./runRetryCoordinator.js";
 import { readMaxActiveStageProcesses, readMaxActiveStagesPerRun, readStageExecutionMode, } from "./stageConcurrency.js";
 import { StageProcessLauncher } from "./stageProcessLauncher.js";
-import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, readMaxConcurrentFromFile, writeMaxConcurrentToFile, } from "./settingsFile.js";
+import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, projectSettingsContext, readMaxConcurrentFromContext, writeMaxConcurrentToContext, } from "./settingsFile.js";
 import { StageHitlController, waitKey, } from "./stageHitl.js";
 import { resolveAndValidateCheckout, } from "./stageRoots.js";
 import { orchestrateAnswerResume } from "./answerResume.js";
@@ -79,12 +80,17 @@ export class RunManager {
         },
     };
     cwd;
+    projectRoot;
+    isGitProject;
     constructor(options) {
         this.options = options;
         this.cwd = options.cwd ?? process.cwd();
+        this.projectRoot = options.projectRoot ?? this.cwd;
+        this.isGitProject = options.isGitProject ?? false;
+        const settingsCtx = projectSettingsContext(this.cwd, this.projectRoot, this.isGitProject);
         this.maxConcurrent =
             options.maxConcurrent ??
-                readMaxConcurrentFromFile(this.cwd) ??
+                readMaxConcurrentFromContext(settingsCtx) ??
                 parseMaxConcurrent(process.env.STAGEFLOW_MAX_CONCURRENT_RUNS);
         this.maxActiveStagesPerRun = readMaxActiveStagesPerRun(process.env, options.maxActiveStagesPerRun);
         this.executionMode = readStageExecutionMode(process.env, options.executionMode);
@@ -106,7 +112,7 @@ export class RunManager {
             throw new Error(INVALID_SLOT_COUNT_MESSAGE);
         }
         this.maxConcurrent = parsed;
-        writeMaxConcurrentToFile(this.cwd, parsed);
+        writeMaxConcurrentToContext(projectSettingsContext(this.cwd, this.projectRoot, this.isGitProject), parsed);
         return this.getHealth();
     }
     getActiveCount() {
@@ -347,21 +353,40 @@ export class RunManager {
                 status: 400,
             };
         }
-        return this.reserveAndStartPipeline(taskYaml, input.pipeline, `task file ${label}`, cwd, input.checkoutOverride);
+        return this.reserveAndStartPipeline(taskYaml, input.pipeline, `task file ${label}`, cwd, input.checkoutOverride, input.skipGates, {
+            gitSha: input.gitSha,
+            ciPrUrl: input.ciPrUrl,
+            ciJobUrl: input.ciJobUrl,
+        });
     }
     async rerun(runId) {
         const cwd = this.options.cwd ?? process.cwd();
-        let pipelineId;
+        let pipeline;
         let taskYaml;
+        let rerunCwd = cwd;
+        let rerunProjectRoot;
         try {
             const meta = await this.options.store.readRunMeta(runId);
-            pipelineId = meta.pipeline_id;
+            if (!meta.pipeline_path) {
+                return {
+                    ok: false,
+                    reason: `Run ${runId} is missing pipeline_path; re-run requires stored catalog locators.`,
+                    status: 400,
+                };
+            }
+            pipeline = normalizeCatalogPath(meta.pipeline_path);
+            rerunCwd = meta.project_root
+                ? normalizeCatalogPath(meta.project_root)
+                : cwd;
+            rerunProjectRoot = meta.project_root
+                ? normalizeCatalogPath(meta.project_root)
+                : undefined;
             taskYaml = await this.options.store.readTaskYaml(runId);
         }
         catch {
             return { ok: false, reason: `Run not found: ${runId}`, status: 404 };
         }
-        return this.reserveAndStartPipeline(taskYaml, pipelineId, `run ${runId} task`, cwd);
+        return this.reserveAndStartPipeline(taskYaml, pipeline, `run ${runId} task`, rerunCwd, undefined, undefined, undefined, rerunProjectRoot);
     }
     async retryStage(runId, stageId) {
         const retryKey = waitKey(runId, stageId);
@@ -485,7 +510,6 @@ export class RunManager {
         }
     }
     async resumeViaSubprocess(runId, stageId, opaqueAnswer) {
-        const cwd = this.options.cwd ?? process.cwd();
         const store = this.options.store;
         const launcher = this.stageProcessLauncher;
         if (!launcher) {
@@ -500,7 +524,7 @@ export class RunManager {
             const launchResult = await launcher.launch({
                 runId,
                 stageId,
-                rootDir: cwd,
+                rootDir: this.projectRoot,
                 mode: "resume",
                 resumeAnswer: opaqueAnswer,
                 attempt,
@@ -527,10 +551,7 @@ export class RunManager {
             catch {
                 // downstream resume may read envelope from store
             }
-            const meta = await store.readRunMeta(runId);
-            const taskYaml = await store.readTaskYaml(runId);
-            const task = loadTaskFromYaml(taskYaml, `run ${runId} task`);
-            const loaded = await loadPipeline(meta.pipeline_id, { cwd });
+            const { meta, task, loaded } = await loadRunContext(store, runId, this.cwd);
             const rest = await resumeRun({
                 prepared: {
                     task,
@@ -538,7 +559,8 @@ export class RunManager {
                     run: { runId, workspaceDir: store.getWorkspaceDir(runId) },
                     agent: this.options.agent,
                     store,
-                    cwd,
+                    cwd: this.cwd,
+                    projectRoot: this.projectRoot,
                     checkoutRoot: meta.checkout_root,
                     hitl: this.hitl,
                     operatorCatalog: this.options.operatorCatalog,
@@ -549,7 +571,10 @@ export class RunManager {
                 executionMode: this.executionMode,
                 stageProcessLauncher: launcher,
             });
-            return rest.ok ? { ok: true } : { ok: false, reason: rest.reason };
+            if (rest.outcome === "failed") {
+                return { ok: false, reason: rest.reason };
+            }
+            return { ok: true };
         }
         catch (err) {
             const reason = err instanceof Error
@@ -583,6 +608,7 @@ export class RunManager {
                 executionMode: this.executionMode,
                 stageProcessLauncher: this.stageProcessLauncher,
                 cwd: this.cwd,
+                factoryCwd: this.projectRoot,
                 maxActiveStagesPerRun: this.maxActiveStagesPerRun,
                 operatorCatalog: this.options.operatorCatalog,
             });
@@ -591,7 +617,7 @@ export class RunManager {
             this.attachedWaiting.delete(`${runId}\0${stageId}`);
         }
     }
-    async reserveAndStartPipeline(taskYaml, pipelineId, taskLabel, cwd, checkoutOverride) {
+    async reserveAndStartPipeline(taskYaml, pipeline, taskLabel, cwd, checkoutOverride, skipGates, ciIdentity, projectRoot) {
         let checkoutKey;
         try {
             const task = loadTaskFromYaml(taskYaml, taskLabel);
@@ -616,14 +642,19 @@ export class RunManager {
                 agent: this.options.agent,
                 store: this.options.store,
                 taskYaml,
-                pipeline: pipelineId,
+                pipeline,
                 cwd,
+                projectRoot: projectRoot ?? this.projectRoot,
                 checkoutOverride,
+                gitSha: ciIdentity?.gitSha,
+                ciPrUrl: ciIdentity?.ciPrUrl,
+                ciJobUrl: ciIdentity?.ciJobUrl,
                 hitl: this.hitl,
                 maxActiveStagesPerRun: this.maxActiveStagesPerRun,
                 executionMode: this.executionMode,
                 stageProcessLauncher: this.stageProcessLauncher,
                 operatorCatalog: this.options.operatorCatalog,
+                skipGates,
             });
             this.track(reserved.provisionalId, started.runId, started.done);
             return { ok: true, runId: started.runId, done: started.done };