stageflow 0.19.0 → 0.23.0

package/dist/mcp/tools.js

@@ -1,12 +1,16 @@
 import { z } from "zod";
 import { registerCatalogTools } from "./catalogTools.js";
 import { registerControlTools } from "./controlTools.js";
+import { registerProjectMcpTools } from "./projectMcpTools.js";
+import { registerProviderTools } from "./providerTools.js";
 import { textResult } from "./toolResults.js";
 import { DEFAULT_TIMEOUT_MS, waitRun } from "./waitRun.js";
 export function registerMcpTools(server, deps) {
     const { store } = deps;
     registerCatalogTools(server, deps);
     registerControlTools(server, deps);
+    registerProviderTools(server, deps);
+    registerProjectMcpTools(server, deps);
     server.registerTool("wait_run", {
         description: "Long-poll until a run is waiting for HITL input and/or terminal (succeeded/failed), or until timeout_ms. Default until=any wakes on waiting OR terminal. Abort cancels only this wait (not the run). Optional notifications/progress when the client supplies _meta.progressToken. Compose: wait_run → answer_gate → wait_run.",
         inputSchema: z.object({

package/dist/mcp/waitRun.js

@@ -1,3 +1,4 @@
+import { mapStoreLookupError } from "../server/operatorResults.js";
 import { projectRunForMcp } from "./projectRun.js";
 export const DEFAULT_TIMEOUT_MS = 60_000;
 export const MAX_TIMEOUT_MS = 240_000;
@@ -90,12 +91,11 @@ export async function waitRun(opts) {
             detail = await opts.store.readRun(opts.runId);
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            const notFound = /not found|no such|unknown run/i.test(message);
+            const mapped = mapStoreLookupError(err, { policy: "run" });
             return {
                 ok: false,
-                error: message,
-                status: notFound ? 404 : 500,
+                error: mapped.error,
+                status: mapped.status,
             };
         }
         const run = projectRunForMcp(detail);

package/dist/mcp/waitingGates.d.ts

@@ -9,5 +9,6 @@ export declare function projectWaitingGate(opts: {
 }): Record<string, unknown>;
 export declare function projectWaitingGates(store: RunStore, opts?: {
     runId?: string;
+    projectRoot?: string;
 }): Promise<Array<Record<string, unknown>>>;
 export {};

package/dist/mcp/waitingGates.js

@@ -83,8 +83,9 @@ export async function projectWaitingGates(store, opts) {
         return projectGatesForRun(detail, detail);
     }
     const summaries = await store.listRuns();
-    const waiting = summaries.filter((r) => (r.waiting_stage_ids !== undefined && r.waiting_stage_ids.length > 0) ||
-        r.waiting_stage_id !== undefined);
+    const waiting = summaries.filter((r) => (opts?.projectRoot === undefined || r.project_root === opts.projectRoot) &&
+        ((r.waiting_stage_ids !== undefined && r.waiting_stage_ids.length > 0) ||
+            r.waiting_stage_id !== undefined));
     const perRun = await Promise.all(waiting.map(async (summary) => {
         let detail;
         try {

package/dist/package-meta.d.ts

@@ -1,2 +1,2 @@
 export declare const PACKAGE_NAME = "stageflow";
-export declare const PACKAGE_VERSION = "0.19.0";
+export declare const PACKAGE_VERSION = "0.23.0";

package/dist/package-meta.js

@@ -1,2 +1,2 @@
 export const PACKAGE_NAME = "stageflow";
-export const PACKAGE_VERSION = "0.19.0";
+export const PACKAGE_VERSION = "0.23.0";

package/dist/projection/projectRun.d.ts

@@ -16,6 +16,8 @@ export type StageProjection = {
     artifacts: string[];
     last_at?: string;
     pending_prompt?: AskOperatorPrompt;
+    definition_id?: string;
+    cost_usd?: number;
 };
 export type RunProjection = {
     run_id: string;
@@ -40,6 +42,7 @@ export type RunProjection = {
     failed_reason?: RunSummary["failed_reason"];
     active_feedback_loop?: FeedbackLoopRecord;
     feedback_loops: FeedbackLoopHistory[];
+    total_cost_usd?: number;
 };
 export declare function projectRun(detail: RunDetail): RunProjection;
 export { projectRun as projectRunForMcp };

package/dist/projection/projectRun.js

@@ -44,6 +44,9 @@ export function projectRun(detail) {
         ...(detail.active_feedback_loop !== undefined
             ? { active_feedback_loop: detail.active_feedback_loop }
             : {}),
+        ...(detail.total_cost_usd !== undefined
+            ? { total_cost_usd: detail.total_cost_usd }
+            : {}),
         feedback_loops: detail.feedback_loops ?? [],
         stages: detail.stages.map((stage) => ({
             stage_id: stage.stage_id,
@@ -69,6 +72,10 @@ export function projectRun(detail) {
             ...(stage.pending_prompt
                 ? { pending_prompt: stage.pending_prompt }
                 : {}),
+            ...(stage.definition_id !== undefined
+                ? { definition_id: stage.definition_id }
+                : {}),
+            ...(stage.cost_usd !== undefined ? { cost_usd: stage.cost_usd } : {}),
         })),
     };
 }

package/dist/runstore/port.d.ts

@@ -327,12 +327,14 @@ export interface RunStore {
     writeEnvelope(runId: string, stageId: string, envelope: StageEnvelope, options?: {
         attempt?: number;
     }): Promise<void>;
-    readEnvelope(runId: string, stageId: string): Promise<StageEnvelope>;
+    readEnvelope(runId: string, stageId: string, attempt?: number): Promise<StageEnvelope>;
     appendStageEvent(runId: string, stageId: string, event: StageLogLine, options?: {
         attempt?: number;
     }): Promise<void>;
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
     listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
+    /** Every distinct non-empty project_root recorded across all runs. */
+    listProjectRoots(): Promise<string[]>;
     readRun(runId: string): Promise<RunDetail>;
     updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
     createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;

package/dist/runstore/sqlite/SqliteRunStore.d.ts

@@ -29,7 +29,7 @@ export declare class SqliteRunStore implements RunStore {
     writeEnvelope(runId: string, stageId: string, envelope: StageEnvelope, options?: {
         attempt?: number;
     }): Promise<void>;
-    readEnvelope(runId: string, stageId: string): Promise<StageEnvelope>;
+    readEnvelope(runId: string, stageId: string, attempt?: number): Promise<StageEnvelope>;
     private readEnvelopeFromDb;
     appendStageEvent(runId: string, stageId: string, event: StageLogLine, options?: {
         attempt?: number;
@@ -43,6 +43,7 @@ export declare class SqliteRunStore implements RunStore {
     private updateStageStatusDenorm;
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
     listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
+    listProjectRoots(): Promise<string[]>;
     readRun(runId: string): Promise<RunDetail>;
     createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;
     getFeedbackLoop(runId: string, loopId: string): Promise<FeedbackLoopRecord>;

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -606,8 +606,15 @@ export class SqliteRunStore {
         });
         await this.updateStageExecution(runId, stageId, attempt, { envelope });
     }
-    async readEnvelope(runId, stageId) {
+    async readEnvelope(runId, stageId, attempt) {
         await this.ready();
+        if (attempt !== undefined) {
+            const execution = await this.getStageExecution(runId, stageId, attempt);
+            if (execution.envelope != null) {
+                return execution.envelope;
+            }
+            throw new Error(`Envelope not found: ${runId}/${stageId}`);
+        }
         const execution = await this.getLatestStageExecution(runId, stageId);
         if (execution?.envelope != null) {
             return execution.envelope;
@@ -717,6 +724,13 @@ export class SqliteRunStore {
         }
         return summaries;
     }
+    async listProjectRoots() {
+        await this.ready();
+        const rows = this.db
+            .prepare(`SELECT DISTINCT project_root FROM runs WHERE project_root IS NOT NULL AND project_root != ''`)
+            .all();
+        return rows.map((row) => row.project_root);
+    }
     async readRun(runId) {
         await this.ready();
         const row = this.getRunRow(runId);

package/dist/runstore/workspaceLayout.d.ts

@@ -2,6 +2,7 @@ export { stageDir } from "./paths.js";
 export declare function guardStageId(stageId: string): void;
 export declare function attemptWorkspaceDir(workspaceDir: string, stageId: string, attempt: number): string;
 export declare function attemptLogPath(workspaceDir: string, stageId: string, attempt: number): string;
+export declare function attemptStreamLogPath(workspaceDir: string, stageId: string, attempt: number): string;
 export declare function attemptEnvelopePath(workspaceDir: string, stageId: string, attempt: number): string;
 export declare function attemptArtifactsDir(workspaceDir: string, stageId: string, attempt: number): string;
 export declare function attemptAgentDir(workspaceDir: string, stageId: string, attempt: number): string;

package/dist/runstore/workspaceLayout.js

@@ -21,6 +21,9 @@ export function attemptWorkspaceDir(workspaceDir, stageId, attempt) {
 export function attemptLogPath(workspaceDir, stageId, attempt) {
     return path.join(attemptWorkspaceDir(workspaceDir, stageId, attempt), "log.jsonl");
 }
+export function attemptStreamLogPath(workspaceDir, stageId, attempt) {
+    return path.join(attemptWorkspaceDir(workspaceDir, stageId, attempt), "stream.log");
+}
 export function attemptEnvelopePath(workspaceDir, stageId, attempt) {
     return path.join(attemptWorkspaceDir(workspaceDir, stageId, attempt), "envelope.json");
 }

package/dist/runtime/feedbackLoopCoordinator.d.ts

@@ -1,5 +1,5 @@
 import type { FeedbackLoopContext, StageSessionMode } from "../agent/port.js";
-import type { DeferredFeedbackSendBack, FeedbackLoopRecord, FeedbackReplayRecord, RunStore } from "../runstore/port.js";
+import type { DeferredFeedbackSendBack, FeedbackLoopRecord, FeedbackReplayRecord, FeedbackReplayStagePassStatus, RunStore } from "../runstore/port.js";
 import type { StageEnvelope } from "../types/envelope.js";
 import type { ResolvedPipelineDag, ResolvedPipelineStageNode } from "../types/pipeline.js";
 import type { FeedbackScheduleState } from "./feedbackLoopSchedule.js";
@@ -38,6 +38,14 @@ export type FeedbackSendBackRejected = {
 };
 export type FeedbackSendBackResult = FeedbackSendBackAccepted | FeedbackSendBackIdempotent | FeedbackSendBackWaitingForHuman | FeedbackSendBackRejected;
 export declare function terminalizeCurrentFeedbackReplay(store: RunStore, runId: string, loop: FeedbackLoopRecord, status: Extract<FeedbackReplayRecord["status"], "completed" | "failed" | "waiting_for_human">): Promise<void>;
+export declare function updateFeedbackReplaySourcePass(options: {
+    store: RunStore;
+    runId: string;
+    loop: FeedbackLoopRecord;
+    sourceStageId: string;
+    status: Extract<FeedbackReplayStagePassStatus, "waiting" | "succeeded" | "failed">;
+    envelope?: StageEnvelope;
+}): Promise<void>;
 export declare function acceptFeedbackSendBack(options: {
     store: RunStore;
     runId: string;

package/dist/runtime/feedbackLoopCoordinator.js

@@ -10,6 +10,33 @@ export async function terminalizeCurrentFeedbackReplay(store, runId, loop, statu
         return;
     await store.updateFeedbackReplay(runId, loop.current_replay_id, { status });
 }
+export async function updateFeedbackReplaySourcePass(options) {
+    const { store, runId, loop, sourceStageId, status, envelope } = options;
+    if (loop.current_replay_id === undefined)
+        return;
+    const passes = await store.listFeedbackReplayStagePasses(runId, loop.current_replay_id);
+    const sourcePass = passes.find((pass) => pass.stage_id === sourceStageId);
+    if (sourcePass === undefined)
+        return;
+    if (sourcePass.status === "succeeded")
+        return;
+    if (status === "waiting") {
+        await store.updateFeedbackReplayStagePass(runId, loop.current_replay_id, sourceStageId, { status: "waiting" });
+        return;
+    }
+    if (status === "succeeded") {
+        await store.updateFeedbackReplayStagePass(runId, loop.current_replay_id, sourceStageId, {
+            status: "succeeded",
+            finished_at: new Date().toISOString(),
+            ...(envelope !== undefined ? { emitted_envelope: envelope } : {}),
+        });
+        return;
+    }
+    await store.updateFeedbackReplayStagePass(runId, loop.current_replay_id, sourceStageId, {
+        status: "failed",
+        finished_at: new Date().toISOString(),
+    });
+}
 async function resolveResumeSessionAttempt(store, runId, loopId, stageId, fallbackAttempt) {
     const replays = await store.listFeedbackReplays(runId, loopId);
     for (const replay of replays) {
@@ -182,6 +209,13 @@ export async function acceptFeedbackSendBack(options) {
                 source_attempt: sourceAttempt,
             };
             await terminalizeCurrentFeedbackReplay(store, runId, loop, "waiting_for_human");
+            await updateFeedbackReplaySourcePass({
+                store,
+                runId,
+                loop,
+                sourceStageId: sourceNode.id,
+                status: "waiting",
+            });
             await store.updateFeedbackLoop(runId, loop.loop_id, {
                 state: "waiting_for_human",
                 deferred_send_back: deferred,
@@ -205,15 +239,14 @@ export async function acceptFeedbackSendBack(options) {
         };
     }
     if (loop.current_replay_id !== undefined) {
-        const currentPasses = await store.listFeedbackReplayStagePasses(runId, loop.current_replay_id);
-        const sourcePass = currentPasses.find((p) => p.stage_id === sourceNode.id);
-        if (sourcePass !== undefined && sourcePass.status !== "succeeded") {
-            await store.updateFeedbackReplayStagePass(runId, loop.current_replay_id, sourceNode.id, {
-                status: "succeeded",
-                finished_at: new Date().toISOString(),
-                emitted_envelope: envelope,
-            });
-        }
+        await updateFeedbackReplaySourcePass({
+            store,
+            runId,
+            loop,
+            sourceStageId: sourceNode.id,
+            status: "succeeded",
+            envelope,
+        });
         await store.updateFeedbackReplay(runId, loop.current_replay_id, {
             status: "completed",
         });
@@ -301,17 +334,14 @@ export async function markFeedbackLoopContinued(options) {
         (entry.state === "active" || entry.state === "waiting_for_human"));
     if (loop === undefined)
         return;
-    if (loop.current_replay_id !== undefined) {
-        const passes = await store.listFeedbackReplayStagePasses(runId, loop.current_replay_id);
-        const sourcePass = passes.find((p) => p.stage_id === sourceStageId);
-        if (sourcePass !== undefined && sourcePass.status !== "succeeded") {
-            await store.updateFeedbackReplayStagePass(runId, loop.current_replay_id, sourceStageId, {
-                status: "succeeded",
-                finished_at: new Date().toISOString(),
-                emitted_envelope: envelope,
-            });
-        }
-    }
+    await updateFeedbackReplaySourcePass({
+        store,
+        runId,
+        loop,
+        sourceStageId,
+        status: "succeeded",
+        envelope,
+    });
     await terminalizeCurrentFeedbackReplay(store, runId, loop, "completed");
     await store.updateFeedbackLoop(runId, loop.loop_id, {
         state: "continued",

package/dist/runtime/feedbackLoopDecision.js

@@ -1,7 +1,19 @@
-import { terminalizeCurrentFeedbackReplay } from "./feedbackLoopCoordinator.js";
+import { terminalizeCurrentFeedbackReplay, updateFeedbackReplaySourcePass, } from "./feedbackLoopCoordinator.js";
 import { createFeedbackScheduleState } from "./feedbackLoopSchedule.js";
 import { applySendBack, releaseHold, } from "./replayLifecycle.js";
 const DECISION_CONFLICT = "feedback loop decision conflict: no longer waiting_for_human";
+async function appendFeedbackLoopDecided(store, runId, loop, decision, reason) {
+    const latest = await store.getLatestStageExecution(runId, loop.source_stage_id);
+    const attempt = latest?.attempt;
+    const eventOptions = attempt !== undefined ? { attempt } : undefined;
+    const trimmed = reason?.trim();
+    await store.appendStageEvent(runId, loop.source_stage_id, {
+        event: "feedback_loop_decided",
+        decision,
+        loopId: loop.loop_id,
+        ...(trimmed ? { reason: trimmed } : {}),
+    }, eventOptions);
+}
 async function clearSourceWaiting(store, runId, sourceStageId, nextStatus, reason) {
     const latest = await store.getLatestStageExecution(runId, sourceStageId);
     const attempt = latest?.attempt;
@@ -96,6 +108,7 @@ export async function resolveFeedbackLoopDecision(options) {
                 reason: `${DECISION_CONFLICT} (loop=${loop.loop_id})`,
             };
         }
+        await appendFeedbackLoopDecided(store, runId, loop, "extend", options.reason);
         await clearSourceWaiting(store, runId, loop.source_stage_id, "succeeded");
         if (schedule === undefined) {
             const applied = await applySendBack({
@@ -168,8 +181,19 @@ export async function resolveFeedbackLoopDecision(options) {
                 reason: `${DECISION_CONFLICT} (loop=${loop.loop_id})`,
             };
         }
+        await appendFeedbackLoopDecided(store, runId, loop, "continue", options.reason);
         await terminalizeCurrentFeedbackReplay(store, runId, loop, "completed");
         await clearSourceWaiting(store, runId, loop.source_stage_id, "succeeded");
+        await updateFeedbackReplaySourcePass({
+            store,
+            runId,
+            loop,
+            sourceStageId: loop.source_stage_id,
+            status: "succeeded",
+            ...(deferred !== undefined
+                ? { envelope: deferred.feedback_envelope }
+                : {}),
+        });
         if (schedule !== undefined) {
             schedule.states.set(loop.source_stage_id, "succeeded");
             if (schedule.completedEnvelopes.get(loop.source_stage_id) === undefined &&
@@ -190,8 +214,16 @@ export async function resolveFeedbackLoopDecision(options) {
             reason: `${DECISION_CONFLICT} (loop=${loop.loop_id})`,
         };
     }
+    await appendFeedbackLoopDecided(store, runId, loop, "abandon", abandonReason);
     await terminalizeCurrentFeedbackReplay(store, runId, loop, "failed");
     await clearSourceWaiting(store, runId, loop.source_stage_id, "failed", abandonReason);
+    await updateFeedbackReplaySourcePass({
+        store,
+        runId,
+        loop,
+        sourceStageId: loop.source_stage_id,
+        status: "failed",
+    });
     if (schedule !== undefined) {
         schedule.states.set(loop.source_stage_id, "failed");
         releaseHold({ feedback: schedule.feedback });

package/dist/runtime/pipelineRunner.d.ts

@@ -3,7 +3,7 @@ import { type ValidationFinding } from "../config/validateCatalog.js";
 import type { RunStore } from "../runstore/port.js";
 import type { StageEnvelope } from "../types/envelope.js";
 import type { StageHitlController } from "./stageHitl.js";
-import type { LoadedPipeline } from "../types/pipeline.js";
+import type { InlinePipelineDefinition, LoadedPipeline } from "../types/pipeline.js";
 import type { TaskFile } from "../types/task.js";
 import { type StageExecutionMode } from "./stageConcurrency.js";
 import { StageProcessLauncher } from "./stageProcessLauncher.js";
@@ -57,7 +57,7 @@ export declare function runPipeline(options: {
     store: RunStore;
     taskPath?: string;
     taskYaml?: string;
-    pipeline: string;
+    pipeline: string | InlinePipelineDefinition;
     cwd?: string;
     projectRoot?: string;
     checkoutOverride?: string;
@@ -74,7 +74,7 @@ export declare function startPipeline(options: {
     store: RunStore;
     taskPath?: string;
     taskYaml?: string;
-    pipeline: string;
+    pipeline: string | InlinePipelineDefinition;
     cwd?: string;
     projectRoot?: string;
     checkoutOverride?: string;

package/dist/runtime/pipelineRunner.js

@@ -57,7 +57,9 @@ async function preparePipeline(options) {
         console.error(`${finding.code}: ${finding.message}`);
     }
     const checkoutRoot = await resolveAndValidateCheckout(task, options.checkoutOverride, options.cwd);
-    const pipelinePath = normalizeCatalogPath(loaded.pipelinePath);
+    const pipelinePath = typeof options.pipeline === "string"
+        ? normalizeCatalogPath(loaded.pipelinePath)
+        : undefined;
     const taskPath = options.taskPath
         ? normalizeCatalogPath(path.resolve(options.cwd, options.taskPath))
         : undefined;

package/dist/runtime/resumeReconstruct.js

@@ -33,12 +33,12 @@ export async function loadRunContext(store, runId, cwd) {
 }
 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);
         const attemptOpt = attemptCtx.eventOptions();
         const { meta, task, loaded } = await loadRunContext(store, runId, cwd);
+        const factoryCwd = meta.project_root ?? ctx.factoryCwd ?? cwd;
         const definitionId = definitionIdForInstance(meta.pipeline_dag, stageId);
         const stageIndex = loaded.stages.findIndex((s) => s.id === definitionId);
         if (stageIndex < 0) {
@@ -127,7 +127,7 @@ export async function reconstructAndContinue(ctx) {
                 run: { runId, workspaceDir },
                 agent,
                 store,
-                cwd,
+                cwd: factoryCwd,
                 projectRoot: factoryCwd,
                 checkoutRoot,
                 hitl: ctx.hitl,

package/dist/runtime/runManager.d.ts

@@ -1,4 +1,5 @@
 import type { AgentPort, OpaqueAnswer } from "../agent/port.js";
+import type { InlinePipelineDefinition } from "../types/pipeline.js";
 import { type RunStore } from "../runstore/port.js";
 import type { TaskFile } from "../types/task.js";
 import { type PipelineRunResult } from "./pipelineRunner.js";
@@ -125,7 +126,7 @@ export declare class RunManager {
     }>>;
     abandonStage(runId: string, stageId: string): Promise<AbandonStageResult>;
     startRun(input: StartTaskInput & {
-        pipeline: string;
+        pipeline: string | InlinePipelineDefinition;
         task?: string | TaskFile;
         checkoutOverride?: string;
         skipGates?: boolean;

package/dist/runtime/runManager.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { readFile, realpath } from "node:fs/promises";
 import path from "node:path";
+import { findProjectRoot } from "../project/findProjectRoot.js";
 import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
 import { loadRunContext } from "./resumeReconstruct.js";
 import { assertTimedOutStageEligible, reconstructTimedOutAndContinue, } from "./resumeTimedOut.js";
@@ -12,7 +13,7 @@ import { resolveFeedbackLoopDecision, } from "./feedbackLoopDecision.js";
 import { RunRetryCoordinator, readRetryRootWaitTimeoutMs, } from "./runRetryCoordinator.js";
 import { readMaxActiveStageProcesses, readMaxActiveStagesPerRun, readStageExecutionMode, } from "./stageConcurrency.js";
 import { StageProcessLauncher } from "./stageProcessLauncher.js";
-import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, projectSettingsContext, readMaxConcurrentFromContext, writeMaxConcurrentToContext, } from "./settingsFile.js";
+import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, readMaxConcurrentFromGlobal, writeMaxConcurrentToGlobal, } from "./settingsFile.js";
 import { StageHitlController, waitKey, } from "./stageHitl.js";
 import { resolveAndValidateCheckout, } from "./stageRoots.js";
 import { orchestrateAnswerResume } from "./answerResume.js";
@@ -94,10 +95,9 @@ export class RunManager {
         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 ??
-                readMaxConcurrentFromContext(settingsCtx) ??
+                readMaxConcurrentFromGlobal() ??
                 parseMaxConcurrent(process.env.STAGEFLOW_MAX_CONCURRENT_RUNS);
         this.maxActiveStagesPerRun = readMaxActiveStagesPerRun(process.env, options.maxActiveStagesPerRun);
         this.executionMode = readStageExecutionMode(process.env, options.executionMode);
@@ -119,7 +119,7 @@ export class RunManager {
             throw new Error(INVALID_SLOT_COUNT_MESSAGE);
         }
         this.maxConcurrent = parsed;
-        writeMaxConcurrentToContext(projectSettingsContext(this.cwd, this.projectRoot, this.isGitProject), parsed);
+        writeMaxConcurrentToGlobal(parsed);
         return this.getHealth();
     }
     getActiveCount() {
@@ -350,6 +350,11 @@ export class RunManager {
     }
     async startRun(input) {
         const cwd = this.options.cwd ?? process.cwd();
+        // An inline pipeline has no filesystem anchor to derive a project root from.
+        const derivedProjectRoot = typeof input.pipeline === "string"
+            ? (findProjectRoot(path.dirname(path.resolve(cwd, input.pipeline))) ??
+                this.projectRoot)
+            : this.projectRoot;
         let resolved;
         try {
             resolved = resolveStartTaskInput(input, cwd);
@@ -384,7 +389,7 @@ export class RunManager {
             gitSha: input.gitSha,
             ciPrUrl: input.ciPrUrl,
             ciJobUrl: input.ciJobUrl,
-        }, undefined, resolved.kind === "path" ? resolved.taskPath : undefined);
+        }, derivedProjectRoot, resolved.kind === "path" ? resolved.taskPath : undefined);
     }
     async rerun(runId) {
         const cwd = this.options.cwd ?? process.cwd();
@@ -456,6 +461,7 @@ export class RunManager {
         }
         const insertedForResume = !wasActive;
         try {
+            const runProjectRoot = detail.project_root ?? this.projectRoot;
             const done = reconstructTimedOutAndContinue({
                 runId,
                 stageId,
@@ -463,9 +469,9 @@ export class RunManager {
                 store: this.options.store,
                 hitl: this.hitl,
                 executionMode: this.executionMode,
-                cwd: this.cwd,
+                cwd: runProjectRoot,
                 maxActiveStagesPerRun: this.maxActiveStagesPerRun,
-                factoryCwd: this.projectRoot,
+                factoryCwd: runProjectRoot,
                 ...(this.stageProcessLauncher !== undefined
                     ? { stageProcessLauncher: this.stageProcessLauncher }
                     : {}),
@@ -585,6 +591,7 @@ export class RunManager {
             };
         }
         try {
+            let meta;
             let orchestrationConflict = this.active.has(runId) &&
                 !this.attachedWaiting.has(waitKey(runId, stageId));
             if (!this.retryCoordinator.isActive(runId)) {
@@ -607,7 +614,7 @@ export class RunManager {
                 let detail;
                 try {
                     detail = await this.options.store.readRun(runId);
-                    await this.options.store.readRunMeta(runId);
+                    meta = await this.options.store.readRunMeta(runId);
                 }
                 catch {
                     this.retryInFlight.delete(retryKey);
@@ -626,12 +633,21 @@ export class RunManager {
                     }
                 }
             }
+            if (meta === undefined) {
+                try {
+                    meta = await this.options.store.readRunMeta(runId);
+                }
+                catch {
+                    this.retryInFlight.delete(retryKey);
+                    return { ok: false, reason: `Run not found: ${runId}`, status: 404 };
+                }
+            }
             const result = await this.retryCoordinator.retryStage({
                 runId,
                 stageId,
                 store: this.options.store,
                 agent: this.options.agent,
-                cwd: this.cwd,
+                cwd: meta.project_root ?? this.projectRoot,
                 operatorCatalog: this.options.operatorCatalog,
                 maxActiveStagesPerRun: this.maxActiveStagesPerRun,
                 executionMode: this.executionMode,
@@ -980,6 +996,7 @@ export class RunManager {
                 };
             }
             const { meta, task, loaded } = await loadRunContext(this.options.store, runId, this.cwd);
+            const runProjectRoot = meta.project_root ?? this.projectRoot;
             const done = runPipelineDag({
                 prepared: {
                     task,
@@ -990,8 +1007,8 @@ export class RunManager {
                     },
                     agent: this.options.agent,
                     store: this.options.store,
-                    cwd: this.cwd,
-                    projectRoot: this.projectRoot,
+                    cwd: runProjectRoot,
+                    projectRoot: runProjectRoot,
                     checkoutRoot: meta.checkout_root,
                     hitl: this.hitl,
                     operatorCatalog: this.options.operatorCatalog,
@@ -1041,10 +1058,12 @@ export class RunManager {
         const sessionFilePath = resumeSessionFilePath(workspaceDir, stageId, attempt);
         const eventOptions = { attempt };
         try {
+            const runMeta = await store.readRunMeta(runId);
+            const runProjectRoot = runMeta.project_root ?? this.projectRoot;
             const launchResult = await launcher.launch({
                 runId,
                 stageId,
-                rootDir: this.projectRoot,
+                rootDir: runProjectRoot,
                 mode: "resume",
                 resumeAnswer: opaqueAnswer,
                 attempt,
@@ -1079,8 +1098,8 @@ export class RunManager {
                     run: { runId, workspaceDir: store.getWorkspaceDir(runId) },
                     agent: this.options.agent,
                     store,
-                    cwd: this.cwd,
-                    projectRoot: this.projectRoot,
+                    cwd: meta.project_root ?? this.projectRoot,
+                    projectRoot: meta.project_root ?? this.projectRoot,
                     checkoutRoot: meta.checkout_root,
                     hitl: this.hitl,
                     operatorCatalog: this.options.operatorCatalog,
@@ -1277,6 +1296,7 @@ export class RunManager {
             return false;
         }
         try {
+            const runProjectRoot = meta.project_root ?? this.projectRoot;
             const { meta: loadedMeta, task, loaded, workspaceDir } = await loadRunContext(this.options.store, runId, this.cwd);
             const promise = runPipelineDag({
                 prepared: {
@@ -1285,8 +1305,8 @@ export class RunManager {
                     run: { runId, workspaceDir },
                     agent: this.options.agent,
                     store: this.options.store,
-                    cwd: this.cwd,
-                    projectRoot: this.projectRoot,
+                    cwd: runProjectRoot,
+                    projectRoot: runProjectRoot,
                     checkoutRoot: loadedMeta.checkout_root,
                     hitl: this.hitl,
                     operatorCatalog: this.options.operatorCatalog,

package/dist/runtime/settingsFile.d.ts

@@ -23,6 +23,8 @@ export declare function readMaxConcurrentFromContext(ctx: ProjectContext): numbe
 export declare function readMaxConcurrentFromFile(cwd: string): number | undefined;
 export declare function writeMaxConcurrentToContext(ctx: ProjectContext, maxConcurrent: number): void;
 export declare function writeMaxConcurrentToFile(cwd: string, maxConcurrent: number): void;
+export declare function readMaxConcurrentFromGlobal(): number | undefined;
+export declare function writeMaxConcurrentToGlobal(maxConcurrent: number): void;
 export declare function readCredentialSourceFromFile(cwd: string): CredentialSource | undefined;
 export declare function writeCredentialSourceToContext(ctx: ProjectContext, credentialSource: CredentialSource): void;
 export declare function writeCredentialSourceToFile(cwd: string, credentialSource: CredentialSource): void;