stageflow 0.18.0 → 0.23.0

package/dist/mcp/tailStreamLog.js

@@ -0,0 +1,28 @@
+import { readFile } from "node:fs/promises";
+import { parseStreamLogHeader } from "../runtime/stageStreamLog.js";
+/** Read new content from a stage's stream.log since a caller's last cursor. */
+export async function readStreamLogTail(streamLogPath, sinceOffset) {
+    let raw;
+    try {
+        raw = await readFile(streamLogPath);
+    }
+    catch {
+        return { text: "", nextOffset: 0 };
+    }
+    const { base, headerLength } = parseStreamLogHeader(raw);
+    const contentBytes = raw.subarray(headerLength);
+    const eof = base + contentBytes.length;
+    if (sinceOffset === undefined || sinceOffset < base) {
+        const truncated = sinceOffset !== undefined && sinceOffset < base;
+        return {
+            text: contentBytes.toString("utf8"),
+            nextOffset: eof,
+            ...(truncated ? { truncated: true, earliestOffset: base } : {}),
+        };
+    }
+    if (sinceOffset >= eof) {
+        return { text: "", nextOffset: eof };
+    }
+    const slice = contentBytes.subarray(sinceOffset - base);
+    return { text: slice.toString("utf8"), nextOffset: eof };
+}

package/dist/mcp/toolResults.d.ts

@@ -5,3 +5,20 @@ export declare function textResult(data: unknown, isError?: boolean): {
     }[];
     isError?: boolean | undefined;
 };
+export declare function imageResult(mimeType: string, bytes: Buffer, identity: {
+    runId: string;
+    path: string;
+    mimeType: string;
+}): {
+    content: ({
+        type: "image";
+        mimeType: string;
+        data: string;
+        text?: undefined;
+    } | {
+        mimeType?: undefined;
+        data?: undefined;
+        type: "text";
+        text: string;
+    })[];
+};

package/dist/mcp/toolResults.js

@@ -4,3 +4,18 @@ export function textResult(data, isError = false) {
         ...(isError ? { isError: true } : {}),
     };
 }
+export function imageResult(mimeType, bytes, identity) {
+    return {
+        content: [
+            {
+                type: "image",
+                mimeType,
+                data: bytes.toString("base64"),
+            },
+            {
+                type: "text",
+                text: JSON.stringify(identity, null, 2),
+            },
+        ],
+    };
+}

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.18.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.18.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/port.js

@@ -12,6 +12,8 @@ export function stageStatusFromEvents(events) {
             status = "failed";
         if (ev.event === "skipped")
             status = "skipped";
+        if (ev.event === "reopened")
+            status = "pending";
     }
     return status;
 }

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/forkGeneration.d.ts

@@ -63,6 +63,10 @@ export declare function selectActiveInput(options: {
     needsStageId: string;
     scheduleOverride?: ReadonlyMap<string, ReadonlySet<string>>;
 }): Promise<ActiveCohort>;
+export declare function forkCohortMapsFromStore(store: Pick<RunStore, "listForkGenerations">, runId: string): Promise<{
+    supersededCloneIds: Set<string>;
+    cohortByForkParent: Map<string, Set<string>>;
+}>;
 export declare function filterJoinInputs(allInstanceIds: readonly string[], cohort: ActiveCohort): string[];
 export declare function filterJoinInstanceIds(allInstanceIds: readonly string[], activeCloneIds: Set<string> | null): string[];
 /**

package/dist/runtime/forkGeneration.js

@@ -251,6 +251,22 @@ export async function selectActiveInput(options) {
     }
     return activeCohortForParent(options.store, options.runId, forkParentId);
 }
+export async function forkCohortMapsFromStore(store, runId) {
+    const gens = await store.listForkGenerations(runId);
+    const supersededCloneIds = new Set();
+    const cohortByForkParent = new Map();
+    for (const gen of gens) {
+        if (gen.status === "superseded") {
+            for (const id of gen.clone_stage_ids) {
+                supersededCloneIds.add(id);
+            }
+        }
+        else if (gen.status === "active") {
+            cohortByForkParent.set(gen.fork_parent_stage_id, new Set(gen.clone_stage_ids));
+        }
+    }
+    return { supersededCloneIds, cohortByForkParent };
+}
 export function filterJoinInputs(allInstanceIds, cohort) {
     if (cohort.kind === "untracked")
         return [...allInstanceIds];

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/pipelineScheduler.js

@@ -4,7 +4,8 @@ import { definitionIdForInstance } from "../runstore/stageInstanceId.js";
 import { cloneFailureContinuesSchedule, cloneRetryDownstream, cloneFailFastSkipIds, cloneScheduleAllowsRun, failureIsAccepted, isCloneInstance, mint, protectedClonableChildIds, sequentialLaterCloneIds, skipRejectedNeedDependents, } from "./cloneSchedule.js";
 import { buildCompletedEnvelopesFromRun, buildStageConfigById, } from "./envelopeRouting.js";
 import { classifyInboundAfterSuccess, isEagerSingleParentIfSkip, joinAllowsRun, pickStalledJoinSkips, } from "./joinReadiness.js";
-import { forkChoicePreservesReplaySource, mintCohortForFanout, } from "./forkGeneration.js";
+import { reopenRunnableSkippedStages, persistReopenedStages } from "./reopenSkipped.js";
+import { forkChoicePreservesReplaySource, forkCohortMapsFromStore, mintCohortForFanout, } from "./forkGeneration.js";
 import { activeReplayId, activeSourceStageId, applySendBack, createReplaySchedule, hydrateFromStore, isHeld, launchAttemptFor, launchFor, noteActiveCohort, onContinued, onRouteStageFailed, onRouteStageRunning, onRouteStageSucceeded, rebindRouteAttempts, resolveDecision, } from "./replayLifecycle.js";
 import { WAIT_WITHOUT_WORKER_DISPATCH } from "./answerResume.js";
 import { runStage, isRunStageWaiting } from "./stageRunner.js";
@@ -65,6 +66,7 @@ export async function hydrateScheduleFromStore(store, runId, dag, executionMode
             continue;
         schedulingHalted = true;
     }
+    await reopenRunnableSkippedStages(store, runId, resolvedDag, states, completedEnvelopes);
     return {
         states,
         completedEnvelopes,
@@ -85,15 +87,20 @@ export async function hydrateScheduleForRetryRoots(store, runId, dag, retryStage
         }
     }
     const retryRootSet = new Set(retryStageIds);
+    const { supersededCloneIds } = await forkCohortMapsFromStore(store, runId);
     const states = new Map();
     for (const node of resolvedDag.nodes) {
         states.set(node.id, "pending");
     }
     const overrides = new Map();
     for (const rootId of retryStageIds) {
+        if (supersededCloneIds.has(rootId))
+            continue;
         overrides.set(rootId, "pending");
     }
     for (const id of downstream) {
+        if (supersededCloneIds.has(id))
+            continue;
         overrides.set(id, "pending");
     }
     for (const snap of runDetail.stages) {
@@ -104,6 +111,20 @@ export async function hydrateScheduleForRetryRoots(store, runId, dag, retryStage
             completedEnvelopes.delete(id);
         }
     }
+    const skippedToReopen = [];
+    const skipStates = new Map();
+    for (const snap of runDetail.stages) {
+        const id = snap.stage_id;
+        if (supersededCloneIds.has(id))
+            continue;
+        if (snap.status !== "skipped")
+            continue;
+        if (!retryRootSet.has(id) && !downstream.has(id))
+            continue;
+        skippedToReopen.push(id);
+        skipStates.set(id, "skipped");
+    }
+    await persistReopenedStages(store, runId, skippedToReopen, skipStates);
     return {
         states,
         completedEnvelopes,
@@ -752,6 +773,7 @@ export async function runPipelineDag(options) {
                 await persistSkipPending(childId);
             }
         }
+        await reopenRunnableSkippedStages(store, run.runId, dag, states, completedEnvelopes);
     };
     const handlePostSuccessError = async (stageId, reason) => {
         if (states.get(stageId) === "succeeded") {

package/dist/runtime/reopenSkipped.d.ts

@@ -0,0 +1,13 @@
+import type { RunStore } from "../runstore/port.js";
+import type { StageEnvelope } from "../types/envelope.js";
+import type { ResolvedPipelineDag } from "../types/pipeline.js";
+import type { StageScheduleState } from "./pipelineScheduler.js";
+export declare function isUnchosenForkChild(dag: ResolvedPipelineDag, stageId: string, envelopes: Map<string, StageEnvelope>): boolean;
+export declare function eventsShowStarted(events: ReadonlyArray<{
+    event: string;
+}>): boolean;
+export declare function shouldReopenSkippedStage(dag: ResolvedPipelineDag, stageId: string, states: Map<string, StageScheduleState>, envelopes: Map<string, StageEnvelope>, hasStarted: boolean, options?: {
+    supersededCloneIds?: ReadonlySet<string>;
+}): boolean;
+export declare function persistReopenedStages(store: Pick<RunStore, "appendStageEvent">, runId: string, stageIds: Iterable<string>, states: Map<string, StageScheduleState>): Promise<void>;
+export declare function reopenRunnableSkippedStages(store: Pick<RunStore, "appendStageEvent" | "listStageEvents" | "listForkGenerations">, runId: string, dag: ResolvedPipelineDag, states: Map<string, StageScheduleState>, envelopes: Map<string, StageEnvelope>): Promise<void>;