stageflow 0.2.0 → 0.8.0

package/dist/runtime/pipelineScheduler.js

@@ -1,8 +1,25 @@
-import { collectDownstreamClosure, collectDownstreamStageIds, } from "./dagTraversal.js";
+import { normalizeForkChoice } from "../envelope/forkChoice.js";
+import { buildPipelineDagSnapshotFromLoaded } from "../runstore/pipelineDagSnapshot.js";
+import { definitionIdForInstance } from "../runstore/stageInstanceId.js";
+import { applyCloneForksFromEnvelopes, applyCloneForksToSchedule, cloneFailureContinuesSchedule, cloneFanoutConflict, cloneRetryDownstream, cloneFailFastSkipIds, cloneScheduleAllowsRun, isCloneInstance, protectedClonableChildIds, sequentialLaterCloneIds, } from "./cloneSchedule.js";
+import { collectDownstreamStageIds } from "./dagTraversal.js";
 import { buildCompletedEnvelopesFromRun, buildStageConfigById, } from "./envelopeRouting.js";
 import { WAIT_WITHOUT_WORKER_DISPATCH } from "./answerResume.js";
 import { runStage, isRunStageWaiting } from "./stageRunner.js";
 import { attemptContext } from "./stageAttemptContext.js";
+function asDagSnapshot(dag) {
+    const snapshot = dag;
+    if (Array.isArray(snapshot.stage_ids))
+        return snapshot;
+    return {
+        ...dag,
+        stage_ids: dag.nodes.map((n) => n.id),
+    };
+}
+export { applyCloneForksFromEnvelopes, applyCloneForksToSchedule, };
+function synthesizedFailureEnvelope(reason) {
+    return { status: "failure", summary: reason, artifacts: [] };
+}
 export function snapshotToScheduleState(snap, overrides, stageId, executionMode) {
     const override = overrides.get(stageId);
     if (override !== undefined)
@@ -16,23 +33,28 @@ export function snapshotToScheduleState(snap, overrides, stageId, executionMode)
             return "active";
         case "waiting_for_input":
             return executionMode === "process" ? "waiting" : "active";
+        case "skipped":
+            return "skipped";
         default:
             return "pending";
     }
 }
 export async function hydrateScheduleFromStore(store, runId, dag, executionMode = "process") {
+    const runDetail = await store.readRun(runId);
+    const meta = await store.readRunMeta(runId);
+    const resolvedDag = meta.pipeline_dag ?? asDagSnapshot(dag);
     const states = new Map();
-    for (const node of dag.nodes) {
+    for (const node of resolvedDag.nodes) {
         states.set(node.id, "pending");
     }
-    const runDetail = await store.readRun(runId);
-    const completedEnvelopes = await buildCompletedEnvelopesFromRun(store, runId, runDetail.stages);
+    const completedEnvelopes = await buildCompletedEnvelopesFromRun(store, runId, runDetail.stages, resolvedDag);
     let schedulingHalted = false;
     const overrides = new Map();
     for (const snap of runDetail.stages) {
         const state = snapshotToScheduleState(snap, overrides, snap.stage_id, executionMode);
         states.set(snap.stage_id, state);
-        if (state === "failed") {
+        if (state === "failed" &&
+            !cloneFailureContinuesSchedule(resolvedDag, snap.stage_id, completedEnvelopes)) {
             schedulingHalted = true;
         }
     }
@@ -41,15 +63,23 @@ export async function hydrateScheduleFromStore(store, runId, dag, executionMode
         completedEnvelopes,
         schedulingHalted,
         firstFailureReason: undefined,
+        dag: resolvedDag,
     };
 }
 export async function hydrateScheduleForRetryRoots(store, runId, dag, retryStageIds) {
     const runDetail = await store.readRun(runId);
-    const downstream = collectDownstreamClosure(dag, retryStageIds);
+    const meta = await store.readRunMeta(runId);
+    const resolvedDag = meta.pipeline_dag ?? asDagSnapshot(dag);
+    const completedEnvelopes = await buildCompletedEnvelopesFromRun(store, runId, runDetail.stages, resolvedDag);
+    const downstream = cloneRetryDownstream(resolvedDag, retryStageIds);
+    for (const rootId of retryStageIds) {
+        for (const id of sequentialLaterCloneIds(resolvedDag, rootId, completedEnvelopes)) {
+            downstream.add(id);
+        }
+    }
     const retryRootSet = new Set(retryStageIds);
-    const completedEnvelopes = await buildCompletedEnvelopesFromRun(store, runId, runDetail.stages);
     const states = new Map();
-    for (const node of dag.nodes) {
+    for (const node of resolvedDag.nodes) {
         states.set(node.id, "pending");
     }
     const overrides = new Map();
@@ -72,6 +102,7 @@ export async function hydrateScheduleForRetryRoots(store, runId, dag, retryStage
         completedEnvelopes,
         schedulingHalted: false,
         firstFailureReason: undefined,
+        dag: resolvedDag,
     };
 }
 export async function hydrateScheduleForRetry(store, runId, dag, retryStageId) {
@@ -79,7 +110,8 @@ export async function hydrateScheduleForRetry(store, runId, dag, retryStageId) {
 }
 export async function resumeRun(options) {
     const { prepared, resumeFromStageId, initialPrior } = options;
-    const dag = prepared.loaded.dag;
+    const meta = await prepared.store.readRunMeta(prepared.run.runId);
+    const dag = meta.pipeline_dag ?? buildPipelineDagSnapshotFromLoaded(prepared.loaded);
     const downstream = dag.childrenOf[resumeFromStageId];
     if (downstream?.length) {
         return runPipelineDag(options);
@@ -104,7 +136,10 @@ 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,
@@ -120,7 +155,7 @@ export async function resumeRun(options) {
 }
 export async function retryRun(options) {
     const { prepared, retryRoots } = options;
-    const hydrated = await hydrateScheduleForRetryRoots(prepared.store, prepared.run.runId, prepared.loaded.dag, [...retryRoots.keys()]);
+    const hydrated = await hydrateScheduleForRetryRoots(prepared.store, prepared.run.runId, buildPipelineDagSnapshotFromLoaded(prepared.loaded), [...retryRoots.keys()]);
     return runPipelineDag({
         prepared: options.prepared,
         maxActiveStagesPerRun: options.maxActiveStagesPerRun,
@@ -133,10 +168,42 @@ 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 (options?.protectedIds?.has(childId))
+            continue;
+        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]);
+    const downstream = cloneRetryDownstream(dag, [stageId]);
     const resetIds = new Set([stageId, ...downstream]);
+    for (const id of sequentialLaterCloneIds(dag, stageId, completedEnvelopes)) {
+        resetIds.add(id);
+    }
     for (const id of resetIds) {
         const state = states.get(id);
         if (state === "active" || state === "succeeded") {
@@ -190,27 +257,28 @@ function sortRunnableIds(dag, ids) {
     const indexById = new Map(dag.nodes.map((node) => [node.id, node.stageIndex]));
     return ids.slice().sort((a, b) => (indexById.get(a) ?? 0) - (indexById.get(b) ?? 0));
 }
-function isRunnable(dag, stageId, states, schedulingHalted) {
+function isRunnable(dag, stageId, states, schedulingHalted, completedEnvelopes) {
     if (schedulingHalted)
         return false;
     const state = states.get(stageId);
     if (state !== "pending")
         return false;
-    const node = dag.nodes.find((n) => n.id === stageId);
-    if (!node)
-        return false;
-    if (node.needs === null)
-        return true;
-    return states.get(node.needs) === "succeeded";
+    return cloneScheduleAllowsRun(dag, stageId, states, completedEnvelopes);
 }
 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 dag = loaded.dag;
+    const { agent, task, loaded, run, store, checkoutRoot, hitl, cwd, projectRoot, } = prepared;
+    const factoryCwd = projectRoot ?? cwd ?? process.cwd();
+    const fallbackDag = buildPipelineDagSnapshotFromLoaded(loaded);
+    let { states, completedEnvelopes, schedulingHalted, firstFailureReason, dag: hydratedDag, } = options.initialSchedule ??
+        (await hydrateScheduleFromStore(store, run.runId, fallbackDag, executionMode));
+    let dag = hydratedDag ?? fallbackDag;
+    if (hydratedDag === undefined) {
+        const meta = await store.readRunMeta(run.runId);
+        dag = meta.pipeline_dag ?? fallbackDag;
+    }
     const stageById = buildStageConfigById(loaded);
-    let { states, completedEnvelopes, schedulingHalted, firstFailureReason } = options.initialSchedule ??
-        (await hydrateScheduleFromStore(store, run.runId, dag, executionMode));
     const retryContext = options.retryContext;
     const resolveLaunchAttempt = async (stageId) => {
         if (retryContext) {
@@ -260,6 +328,14 @@ export async function runPipelineDag(options) {
             }
         }
     }
+    applyForkSkipsFromEnvelopes(dag, states, completedEnvelopes);
+    {
+        const applied = applyCloneForksFromEnvelopes(dag, states, completedEnvelopes);
+        if (applied.dag !== dag) {
+            await store.updatePipelineDag(run.runId, applied.dag);
+        }
+        dag = applied.dag;
+    }
     let activeCount = 0;
     const inFlight = new Set();
     const notifyRetryRootTerminal = (stageId, outcome) => {
@@ -270,6 +346,20 @@ export async function runPipelineDag(options) {
             return;
         options.onRetryRootTerminal?.(stageId, attempt, outcome);
     };
+    const persistSkipPending = async (id) => {
+        if (states.get(id) !== "pending")
+            return;
+        states.set(id, "skipped");
+        notifyRetryRootTerminal(id, "skipped");
+        await store.appendStageEvent(run.runId, id, { event: "skipped" });
+    };
+    for (const [stageId, state] of states) {
+        if (state !== "failed")
+            continue;
+        for (const id of cloneFailFastSkipIds(dag, stageId, completedEnvelopes)) {
+            await persistSkipPending(id);
+        }
+    }
     const markSkippedPending = () => {
         for (const node of dag.nodes) {
             if (states.get(node.id) === "pending") {
@@ -300,9 +390,41 @@ export async function runPipelineDag(options) {
             });
         });
     };
-    const onStageFailure = async (stageId, reason) => {
+    const recordCloneFailureEnvelope = async (stageId, reason, envelope) => {
+        if (!isCloneInstance(dag, stageId)) {
+            if (envelope !== undefined) {
+                completedEnvelopes.set(stageId, envelope);
+            }
+            return;
+        }
+        const failureEnvelope = envelope ??
+            completedEnvelopes.get(stageId) ??
+            synthesizedFailureEnvelope(reason);
+        completedEnvelopes.set(stageId, failureEnvelope);
+        if (envelope === undefined) {
+            try {
+                await store.writeEnvelope(run.runId, stageId, failureEnvelope);
+            }
+            catch {
+            }
+        }
+    };
+    const onStageFailure = async (stageId, reason, envelope) => {
         states.set(stageId, "failed");
         notifyRetryRootTerminal(stageId, "failed");
+        await recordCloneFailureEnvelope(stageId, reason, envelope);
+        if (cloneFailureContinuesSchedule(dag, stageId, completedEnvelopes)) {
+            if (firstFailureReason === undefined) {
+                firstFailureReason = reason;
+            }
+            for (const id of cloneFailFastSkipIds(dag, stageId, completedEnvelopes)) {
+                await persistSkipPending(id);
+            }
+            if (retryContext) {
+                drainRetryMutations();
+            }
+            return;
+        }
         if (retryContext) {
             markBranchDownstreamSkipped(stageId);
             drainRetryMutations();
@@ -319,13 +441,59 @@ export async function runPipelineDag(options) {
             firstFailureReason = reason;
         }
     };
-    const onStageSuccess = (stageId, envelope) => {
+    const onStageSuccess = async (stageId, envelope) => {
+        const conflict = cloneFanoutConflict(dag, envelope);
+        if (conflict !== undefined) {
+            await store.appendStageEvent(run.runId, stageId, {
+                event: "failed",
+                reason: conflict,
+            });
+            await onStageFailure(stageId, conflict);
+            return;
+        }
         states.set(stageId, "succeeded");
         completedEnvelopes.set(stageId, envelope);
         notifyRetryRootTerminal(stageId, "succeeded");
+        const node = dag.nodes.find((n) => n.id === stageId);
+        const protectedIds = protectedClonableChildIds(dag, stageId, envelope);
+        if (node?.fork) {
+            const chosen = normalizeForkChoice(envelope.fork_choice, "stored");
+            const skippedIds = [];
+            applyForkChoiceToSchedule(dag, stageId, chosen, states, {
+                protectedIds,
+                onSkip: (id) => {
+                    notifyRetryRootTerminal(id, "skipped");
+                    skippedIds.push(id);
+                },
+            });
+            for (const id of skippedIds) {
+                await store.appendStageEvent(run.runId, id, { event: "skipped" });
+            }
+        }
+        const applied = applyCloneForksToSchedule(dag, stageId, envelope, states);
+        const dagChanged = applied.dag !== dag;
+        dag = applied.dag;
+        if (dagChanged) {
+            await store.updatePipelineDag(run.runId, dag);
+        }
+        for (const id of applied.skippedIds) {
+            notifyRetryRootTerminal(id, "skipped");
+            await store.appendStageEvent(run.runId, id, { event: "skipped" });
+        }
+    };
+    const handlePostSuccessError = async (stageId, reason) => {
+        if (states.get(stageId) === "succeeded") {
+            completedEnvelopes.delete(stageId);
+            await store.appendStageEvent(run.runId, stageId, {
+                event: "failed",
+                reason,
+            });
+        }
+        await onStageFailure(stageId, reason);
     };
     const launchStage = async (stageId) => {
-        const stage = stageById.get(stageId);
+        const definitionId = definitionIdForInstance(dag, stageId);
+        const stage = stageById.get(definitionId);
         if (!stage) {
             await onStageFailure(stageId, `stage config missing for "${stageId}"`);
             return;
@@ -341,7 +509,7 @@ 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 }
@@ -351,11 +519,11 @@ export async function runPipelineDag(options) {
             if (launchResult.type === "succeeded") {
                 try {
                     const envelope = await store.readEnvelope(run.runId, stageId);
-                    onStageSuccess(stageId, envelope);
+                    await onStageSuccess(stageId, envelope);
                 }
-                catch {
-                    states.set(stageId, "succeeded");
-                    notifyRetryRootTerminal(stageId, "succeeded");
+                catch (err) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    await handlePostSuccessError(stageId, reason);
                 }
                 return;
             }
@@ -371,13 +539,14 @@ export async function runPipelineDag(options) {
             store,
             runId: run.runId,
             stage,
+            stageId,
             task,
             dag,
             checkoutRoot,
             workspaceDir: run.workspaceDir,
             hitl,
             attemptCtx,
-            factoryCwd: cwd,
+            factoryCwd,
             operatorCatalog: prepared.operatorCatalog,
             completedEnvelopes,
             skipGates: prepared.skipGates,
@@ -387,11 +556,17 @@ export async function runPipelineDag(options) {
             return;
         }
         if (!result.ok) {
-            await onStageFailure(stageId, result.reason ?? "stage failed");
+            await onStageFailure(stageId, result.reason ?? "stage failed", result.envelope);
             return;
         }
         if (result.envelope) {
-            onStageSuccess(stageId, result.envelope);
+            try {
+                await onStageSuccess(stageId, result.envelope);
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                await handlePostSuccessError(stageId, reason);
+            }
         }
         else {
             states.set(stageId, "succeeded");
@@ -412,7 +587,7 @@ export async function runPipelineDag(options) {
     const pickRunnable = () => {
         const ids = [];
         for (const node of dag.nodes) {
-            if (isRunnable(dag, node.id, states, schedulingHalted)) {
+            if (isRunnable(dag, node.id, states, schedulingHalted, completedEnvelopes)) {
                 ids.push(node.id);
             }
         }
@@ -485,7 +660,10 @@ export async function runPipelineDag(options) {
             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");
@@ -498,9 +676,7 @@ export async function runPipelineDag(options) {
             reason: firstFailureReason ?? "pipeline incomplete",
         };
     }
-    if (retryContext === undefined) {
-        await store.updateRunStatus(run.runId, "succeeded");
-    }
+    await store.updateRunStatus(run.runId, "succeeded");
     return {
         ok: true,
         outcome: "succeeded",

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,10 @@
 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 { definitionIdForInstance } from "../runstore/stageInstanceId.js";
 import { WAIT_WITHOUT_WORKER_DISPATCH } from "./answerResume.js";
 import { resumeRun } from "./pipelineScheduler.js";
 import { buildStageRoots, withResolvedAuthPath } from "./stageRoots.js";
@@ -10,20 +13,34 @@ 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);
         const attemptOpt = attemptCtx.eventOptions();
         const { meta, task, loaded } = await loadRunContext(store, runId, cwd);
-        const stageIndex = loaded.stages.findIndex((s) => s.id === stageId);
+        const definitionId = definitionIdForInstance(meta.pipeline_dag, stageId);
+        const stageIndex = loaded.stages.findIndex((s) => s.id === definitionId);
         if (stageIndex < 0) {
             const reason = `Stage ${stageId} not in pipeline ${meta.pipeline_id}`;
             await store.appendStageEvent(runId, stageId, {
@@ -34,9 +51,10 @@ export async function reconstructAndContinue(ctx) {
             return { ok: false, reason };
         }
         const stage = loaded.stages[stageIndex];
+        const dag = meta.pipeline_dag ?? loaded.dag;
         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)) {
@@ -53,11 +71,12 @@ export async function reconstructAndContinue(ctx) {
             store,
             runId,
             stage,
+            stageId,
             task,
-            dag: loaded.dag,
+            dag,
             checkoutRoot,
             workspaceDir,
-            factoryCwd: cwd,
+            factoryCwd,
             attemptCtx,
             operatorCatalog: ctx.operatorCatalog,
             onActivity: (event) => {
@@ -78,15 +97,16 @@ export async function reconstructAndContinue(ctx) {
             store,
             runId,
             stage,
+            stageId,
             task,
-            dag: loaded.dag,
+            dag,
             checkoutRoot,
             workspaceDir,
             hitl: ctx.hitl,
             skipStarted: true,
             existingHandle: opened.handle,
             attemptCtx,
-            factoryCwd: cwd,
+            factoryCwd,
             operatorCatalog: ctx.operatorCatalog,
         });
         if (isRunStageWaiting(result)) {
@@ -108,6 +128,7 @@ export async function reconstructAndContinue(ctx) {
                 agent,
                 store,
                 cwd,
+                projectRoot: factoryCwd,
                 checkoutRoot,
                 hitl: ctx.hitl,
                 operatorCatalog: ctx.operatorCatalog,

package/dist/runtime/runChangeBus.d.ts

@@ -0,0 +1,18 @@
+import type { RunStore } from "../runstore/port.js";
+export type RunChangeKind = "created" | "status" | "waiting";
+export type RunChangeEvent = {
+    runId: string;
+    kind: RunChangeKind;
+};
+type RunChangeListener = (event: RunChangeEvent) => void;
+export declare class RunChangeBus {
+    private readonly listeners;
+    on(listener: RunChangeListener): () => void;
+    off(listener: RunChangeListener): void;
+    emit(event: RunChangeEvent): void;
+}
+export declare function createRunChangeBus(): RunChangeBus;
+export declare function isRunStoreWrapped(store: RunStore): boolean;
+export declare function getRunChangeBusFromWrappedStore(store: RunStore): RunChangeBus | undefined;
+export declare function wrapRunStoreWithChangeBus(store: RunStore, bus: RunChangeBus): RunStore;
+export {};