stageflow 0.15.0 → 0.18.0

package/dist/runtime/forkGeneration.js

@@ -10,22 +10,35 @@ function asDagSnapshot(dag) {
         stage_ids: dag.nodes.map((n) => n.id),
     };
 }
-/** Persistent route stages that fan out to clonable successors (or already have instances). */
+function nodeById(dag, id) {
+    return dag.nodes.find((n) => n.id === id);
+}
+function isCloneEmitter(node) {
+    return node?.clone_array_field !== undefined;
+}
+function isMintedCloneInstance(node) {
+    return (node !== undefined &&
+        node.definition_id !== undefined &&
+        node.definition_id !== node.id);
+}
+function parentIsCloneEmitter(dag, node) {
+    if (node?.needs === null || node?.needs === undefined)
+        return false;
+    return isCloneEmitter(nodeById(dag, node.needs));
+}
+/** Persistent route stages that fan out to Clone Chain children (or already have instances). */
 export function routeRelatedForkParentIds(dag, routeStageIds) {
     const routeSet = new Set(routeStageIds);
     const parents = new Set();
     const snapshot = asDagSnapshot(dag);
     for (const stageId of routeStageIds) {
-        for (const childId of dag.childrenOf[stageId] ?? []) {
-            const child = dag.nodes.find((n) => n.id === childId);
-            if (child?.clonable === true) {
-                parents.add(stageId);
-            }
+        if (isCloneEmitter(nodeById(dag, stageId))) {
+            parents.add(stageId);
         }
     }
     for (const stageId of routeStageIds) {
-        const node = dag.nodes.find((n) => n.id === stageId);
-        if (node?.clonable === true && node.needs !== null) {
+        const node = nodeById(dag, stageId);
+        if (node !== undefined && parentIsCloneEmitter(dag, node) && node.needs !== null) {
             parents.add(node.needs);
         }
     }
@@ -38,24 +51,25 @@ export function routeRelatedForkParentIds(dag, routeStageIds) {
         }
     }
     for (const stageId of routeStageIds) {
-        const node = dag.nodes.find((n) => n.id === stageId);
-        if (node?.clonable !== true)
+        const node = nodeById(dag, stageId);
+        if (!parentIsCloneEmitter(dag, node) || isMintedCloneInstance(node))
             continue;
         const instances = instancesOfDefinition(snapshot, stageId).filter((id) => id !== stageId);
-        if (instances.length > 0 && node.needs !== null) {
+        if (instances.length > 0 && node !== undefined && node.needs !== null) {
             parents.add(node.needs);
         }
     }
     return [...parents];
 }
-/** Clone instance ids currently under clonable successors of a fork parent. */
+/** Clone instance ids currently under Clone Chain children of a fork parent. */
 export function cloneInstanceIdsForForkParent(dag, forkParentStageId) {
     const snapshot = asDagSnapshot(dag);
     const ids = [];
     const seen = new Set();
+    const parentIsEmitter = isCloneEmitter(nodeById(dag, forkParentStageId));
     for (const childId of dag.childrenOf[forkParentStageId] ?? []) {
-        const child = dag.nodes.find((n) => n.id === childId);
-        if (child?.clonable === true) {
+        const child = nodeById(dag, childId);
+        if (parentIsEmitter && !isMintedCloneInstance(child)) {
             for (const id of instancesOfDefinition(snapshot, childId)) {
                 if (id === childId)
                     continue;
@@ -264,7 +278,7 @@ export function forkChoicePreservesReplaySource(dag, chosen, sourceStageId) {
             return true;
         }
         const child = dag.nodes.find((n) => n.id === childId);
-        if (child?.clonable === true) {
+        if (parentIsCloneEmitter(dag, child) && !isMintedCloneInstance(child)) {
             const snapshot = asDagSnapshot(dag);
             for (const instanceId of instancesOfDefinition(snapshot, childId)) {
                 if (instanceId === childId)

package/dist/runtime/joinReadiness.d.ts

@@ -0,0 +1,16 @@
+import type { StageEnvelope } from "../types/envelope.js";
+import type { PipelineNeedEdge, ResolvedPipelineDag, ResolvedPipelineStageNode } from "../types/pipeline.js";
+import type { StageScheduleState } from "./pipelineScheduler.js";
+import { type RouteIfEval } from "./routeIfEval.js";
+export declare function expandJoinParent(dag: ResolvedPipelineDag, catalogParentId: string): string[];
+export declare function inboundEdgeFired(edge: PipelineNeedEdge, parentId: string, states: Map<string, StageScheduleState>, envelopes: Map<string, StageEnvelope>): boolean;
+export declare function joinAllowsRun(dag: ResolvedPipelineDag, stageId: string, states: Map<string, StageScheduleState>, envelopes: Map<string, StageEnvelope>): boolean;
+export type InboundAfterSuccess = RouteIfEval | "ungated";
+export declare function classifyInboundAfterSuccess(node: Pick<ResolvedPipelineStageNode, "needs" | "needsEdges">, parentId: string, payload: Record<string, unknown> | undefined): InboundAfterSuccess;
+export declare function isEagerSingleParentIfSkip(node: Pick<ResolvedPipelineStageNode, "needs" | "needsEdges">, parentId: string, payload: Record<string, unknown> | undefined): boolean;
+/**
+ * Finds pending multi-parent joins that cannot run once every parent is
+ * terminal: all-skipped, or all-succeeded with an inbound `if` miss.
+ * A failed parent is not a stalled skip — that join stays pending.
+ */
+export declare function pickStalledJoinSkips(dag: ResolvedPipelineDag, states: Map<string, StageScheduleState>, completedEnvelopes?: Map<string, StageEnvelope>): string[];

package/dist/runtime/joinReadiness.js

@@ -0,0 +1,156 @@
+import { isNeedTerminalState, predecessorEdges } from "../config/pipelineNeeds.js";
+import { instancesOfDefinition } from "../runstore/pipelineDagSnapshot.js";
+import { evaluateRouteIf } from "./routeIfEval.js";
+function definitionInstances(dag, catalogId) {
+    const snapshot = dag;
+    if (Array.isArray(snapshot.stage_ids)) {
+        return instancesOfDefinition(snapshot, catalogId);
+    }
+    return dag.nodes.some((n) => n.id === catalogId) ? [catalogId] : [];
+}
+export function expandJoinParent(dag, catalogParentId) {
+    const minted = definitionInstances(dag, catalogParentId).filter((id) => id !== catalogParentId);
+    return minted.length > 0 ? minted : [catalogParentId];
+}
+function expandJoinParents(dag, edges) {
+    const ids = [];
+    for (const edge of edges) {
+        ids.push(...expandJoinParent(dag, edge.id));
+    }
+    return ids;
+}
+function joinParentDisposition(dag, edges, states) {
+    const instances = expandJoinParents(dag, edges);
+    if (instances.length === 0)
+        return undefined;
+    let hasFailed = false;
+    let hasSucceeded = false;
+    let hasSkipped = false;
+    for (const id of instances) {
+        const state = states.get(id);
+        if (!isNeedTerminalState(state)) {
+            return { allTerminal: false };
+        }
+        if (state === "failed")
+            hasFailed = true;
+        if (state === "succeeded")
+            hasSucceeded = true;
+        if (state === "skipped")
+            hasSkipped = true;
+    }
+    return { allTerminal: true, hasFailed, hasSucceeded, hasSkipped };
+}
+export function inboundEdgeFired(edge, parentId, states, envelopes) {
+    if (edge.if === undefined)
+        return true;
+    if (states.get(parentId) !== "succeeded")
+        return false;
+    return evaluateRouteIf(edge.if, envelopes.get(parentId)?.payload) === "fire";
+}
+function inboundEdgeMissed(edge, parentId, envelopes) {
+    if (edge.if === undefined)
+        return false;
+    return evaluateRouteIf(edge.if, envelopes.get(parentId)?.payload) === "miss";
+}
+function everySucceededInboundEdgeFired(dag, edges, states, envelopes) {
+    for (const edge of edges) {
+        for (const id of expandJoinParent(dag, edge.id)) {
+            if (!inboundEdgeFired(edge, id, states, envelopes))
+                return false;
+        }
+    }
+    return true;
+}
+function anySucceededInboundEdgeMissed(dag, edges, envelopes) {
+    for (const edge of edges) {
+        for (const id of expandJoinParent(dag, edge.id)) {
+            if (inboundEdgeMissed(edge, id, envelopes))
+                return true;
+        }
+    }
+    return false;
+}
+function multiParentJoinAllowsRun(dag, node, states, envelopes) {
+    const edges = predecessorEdges(node);
+    if (expandJoinParents(dag, edges).length < 2)
+        return false;
+    const disposition = joinParentDisposition(dag, edges, states);
+    if (disposition === undefined || !disposition.allTerminal)
+        return false;
+    if (disposition.hasFailed)
+        return false;
+    if (!disposition.hasSucceeded)
+        return false;
+    if (!disposition.hasSkipped) {
+        return everySucceededInboundEdgeFired(dag, edges, states, envelopes);
+    }
+    return true;
+}
+/**
+ * A multi-parent join whose parents are all terminal, none failed, and
+ * either every parent skipped, or every parent succeeded but an inbound
+ * `if` missed. Those joins cannot run, so the scheduler force-skips them.
+ * A failed parent is not stalled: the join stays pending. A still-running
+ * parent is not stalled either.
+ */
+function isStalledMultiParentJoin(dag, node, states, envelopes) {
+    const edges = predecessorEdges(node);
+    if (edges.length <= 1)
+        return false;
+    const disposition = joinParentDisposition(dag, edges, states);
+    if (disposition === undefined || !disposition.allTerminal)
+        return false;
+    if (disposition.hasFailed)
+        return false;
+    if (!disposition.hasSucceeded)
+        return true;
+    if (disposition.hasSkipped)
+        return false;
+    return anySucceededInboundEdgeMissed(dag, edges, envelopes);
+}
+export function joinAllowsRun(dag, stageId, states, envelopes) {
+    const node = dag.nodes.find((n) => n.id === stageId);
+    if (!node)
+        return false;
+    const edges = predecessorEdges(node);
+    if (edges.length === 0)
+        return true;
+    if (expandJoinParents(dag, edges).length >= 2) {
+        return multiParentJoinAllowsRun(dag, node, states, envelopes);
+    }
+    const edge = edges[0];
+    const parentNeedId = typeof node.needs === "string" && node.needs ? node.needs : edge.id;
+    const parentId = expandJoinParent(dag, parentNeedId)[0];
+    if (states.get(parentId) !== "succeeded")
+        return false;
+    if (edge.if === undefined)
+        return true;
+    return inboundEdgeFired(edge, parentId, states, envelopes);
+}
+export function classifyInboundAfterSuccess(node, parentId, payload) {
+    const inbound = predecessorEdges(node).find((edge) => edge.id === parentId);
+    if (inbound?.if === undefined)
+        return "ungated";
+    return evaluateRouteIf(inbound.if, payload);
+}
+export function isEagerSingleParentIfSkip(node, parentId, payload) {
+    if (predecessorEdges(node).length !== 1)
+        return false;
+    return classifyInboundAfterSuccess(node, parentId, payload) === "miss";
+}
+/**
+ * Finds pending multi-parent joins that cannot run once every parent is
+ * terminal: all-skipped, or all-succeeded with an inbound `if` miss.
+ * A failed parent is not a stalled skip — that join stays pending.
+ */
+export function pickStalledJoinSkips(dag, states, completedEnvelopes = new Map()) {
+    const ids = [];
+    for (const node of dag.nodes) {
+        if (states.get(node.id) !== "pending")
+            continue;
+        if (isStalledMultiParentJoin(dag, node, states, completedEnvelopes)) {
+            ids.push(node.id);
+        }
+    }
+    return ids;
+}

package/dist/runtime/pipelineScheduler.d.ts

@@ -3,7 +3,6 @@ import type { RunPipelineDagSnapshot, RunStore, StageSnapshot } from "../runstor
 import type { StageEnvelope } from "../types/envelope.js";
 import type { LoadedPipeline, ResolvedPipelineDag } from "../types/pipeline.js";
 import type { TaskFile } from "../types/task.js";
-import { applyCloneForksFromEnvelopes, applyCloneForksToSchedule } from "./cloneSchedule.js";
 import type { FeedbackLoopDecisionInput, ResolveFeedbackLoopDecisionResult } from "./feedbackLoopDecision.js";
 import type { PipelineRunResult } from "./pipelineRunner.js";
 import type { StageProcessLauncher } from "./stageProcessLauncher.js";
@@ -49,8 +48,6 @@ export type HydratedSchedule = {
     firstFailureReason: string | undefined;
     dag?: RunPipelineDagSnapshot;
 };
-export { applyCloneForksFromEnvelopes, applyCloneForksToSchedule, };
-export type { ApplyCloneForksResult } from "./cloneSchedule.js";
 export declare function snapshotToScheduleState(snap: {
     status: StageSnapshot["status"];
 }, overrides: ReadonlyMap<string, StageScheduleState>, stageId: string, executionMode?: StageExecutionMode): StageScheduleState;

package/dist/runtime/pipelineScheduler.js

@@ -1,14 +1,14 @@
 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, failureIsAccepted, isCloneInstance, protectedClonableChildIds, sequentialLaterCloneIds, skipRejectedNeedDependents, } from "./cloneSchedule.js";
+import { cloneFailureContinuesSchedule, cloneRetryDownstream, cloneFailFastSkipIds, cloneScheduleAllowsRun, failureIsAccepted, isCloneInstance, mint, protectedClonableChildIds, sequentialLaterCloneIds, skipRejectedNeedDependents, } from "./cloneSchedule.js";
 import { buildCompletedEnvelopesFromRun, buildStageConfigById, } from "./envelopeRouting.js";
-import { activeCohortFromCloneIds, forkChoicePreservesReplaySource, forkParentForNeedsStage, mintCohortForFanout, } from "./forkGeneration.js";
-import { activeReplayId, activeSourceStageId, applySendBack, cohortOverrideMap, createReplaySchedule, hydrateFromStore, isHeld, launchAttemptFor, launchFor, noteActiveCohort, onContinued, onRouteStageFailed, onRouteStageRunning, onRouteStageSucceeded, rebindRouteAttempts, resolveDecision, } from "./replayLifecycle.js";
+import { classifyInboundAfterSuccess, isEagerSingleParentIfSkip, joinAllowsRun, pickStalledJoinSkips, } from "./joinReadiness.js";
+import { forkChoicePreservesReplaySource, 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";
 import { attemptContext, resumeSessionFilePath } from "./stageAttemptContext.js";
-const EMPTY_RETRY_DOWNSTREAM = new Set();
 function asDagSnapshot(dag) {
     const snapshot = dag;
     if (Array.isArray(snapshot.stage_ids))
@@ -18,7 +18,6 @@ function asDagSnapshot(dag) {
         stage_ids: dag.nodes.map((n) => n.id),
     };
 }
-export { applyCloneForksFromEnvelopes, applyCloneForksToSchedule, };
 function synthesizedFailureEnvelope(reason) {
     return { status: "failure", summary: reason, artifacts: [] };
 }
@@ -284,21 +283,9 @@ function isRunnable(dag, stageId, states, schedulingHalted, completedEnvelopes,
     const state = states.get(stageId);
     if (state !== "pending")
         return false;
-    return cloneScheduleAllowsRun(dag, stageId, states, completedEnvelopes, {
-        activeCohortForNeeds: (needsId) => {
-            const override = feedback !== undefined ? cohortOverrideMap(feedback) : undefined;
-            if (override === undefined || override.size === 0) {
-                return { kind: "untracked" };
-            }
-            const forkParentId = forkParentForNeedsStage(dag, needsId);
-            if (forkParentId === null)
-                return { kind: "untracked" };
-            const tracked = override.get(forkParentId);
-            if (tracked === undefined)
-                return { kind: "untracked" };
-            return activeCohortFromCloneIds(tracked);
-        },
-    });
+    if (!joinAllowsRun(dag, stageId, states, completedEnvelopes))
+        return false;
+    return cloneScheduleAllowsRun(dag, stageId, states, completedEnvelopes);
 }
 export function hydratedScheduleHasRunnableWork(hydrated) {
     if (hydrated.schedulingHalted)
@@ -403,13 +390,6 @@ 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 launchedIds = new Set();
@@ -442,6 +422,28 @@ export async function runPipelineDag(options) {
         await store.appendStageEvent(run.runId, id, { event: "skipped" });
         await persistSkipRejected(id, "skipped");
     };
+    /**
+     * Finalizes multi-parent (implicit-AND) join nodes that are permanently
+     * stuck in `pending`: every predecessor edge has reached a terminal state,
+     * but `joinAllowsRun` still can't be satisfied, and terminal
+     * states never change back. `shouldSkipForObservedNeed` deliberately
+     * refuses to decide these nodes from a single resolving parent (see its
+     * comment in cloneSchedule.ts), so this is the only place their fate gets
+     * sealed -- once we're sure every sibling has actually settled. Runs once
+     * per scheduler tick; loops until a pass finds nothing new, so a chain of
+     * stalled joins settles within a single tick rather than one per ~25ms
+     * poll.
+     */
+    const applyStalledJoinSkips = async () => {
+        for (;;) {
+            const ids = pickStalledJoinSkips(dag, states, completedEnvelopes);
+            if (ids.length === 0)
+                return;
+            for (const id of ids) {
+                await persistSkipPending(id);
+            }
+        }
+    };
     for (const [stageId, state] of states) {
         if (state !== "failed")
             continue;
@@ -569,22 +571,33 @@ export async function runPipelineDag(options) {
         }
     };
     const onStageSuccess = async (stageId, envelope) => {
-        const retryDownstreamIds = retryContext
-            ? cloneRetryDownstream(dag, [...retryContext.retryRoots.keys()])
-            : EMPTY_RETRY_DOWNSTREAM;
-        const forceFreshCloneIds = activeReplayId(feedbackSchedule) !== undefined;
-        const conflict = cloneFanoutConflict(dag, envelope, states, retryDownstreamIds, { forceFreshCloneIds });
-        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 minted = mint(dag, stageId, envelope);
+        if (minted.kind === "error") {
+            await handlePostSuccessError(stageId, minted.reason);
+            return;
+        }
+        if (minted.kind === "minted") {
+            dag = minted.dag;
+            await store.updatePipelineDag(run.runId, dag);
+            states.delete(minted.catalogChildId);
+            for (const id of minted.instanceIds) {
+                states.set(id, "pending");
+            }
+            const replayId = activeReplayId(feedbackSchedule);
+            if (replayId !== undefined) {
+                noteActiveCohort(feedbackSchedule, stageId, minted.instanceIds);
+                await mintCohortForFanout({
+                    store,
+                    runId: run.runId,
+                    replayId,
+                    forkParent: stageId,
+                    cloneStageIds: minted.instanceIds,
+                });
+            }
+        }
         const feedbackAction = envelope.feedback_loop;
         if (feedbackAction?.action === "send_back") {
             const node = dag.nodes.find((n) => n.id === stageId);
@@ -699,6 +712,18 @@ export async function runPipelineDag(options) {
                 return;
             }
             const skippedIds = [];
+            // applyForkChoiceToSchedule (and everything it calls, including
+            // skipRejectedNeedDependents in cloneSchedule.ts) is fully synchronous
+            // -- no `await` anywhere in that call chain. So by the time this call
+            // returns, `states` already reflects every one of this stage's
+            // unchosen children as terminal, atomically, before the persistence
+            // loop below runs its first `await`. A downstream multi-parent join
+            // (see pickStalledJoinSkips) that depends on several of these children
+            // therefore always decides off fully-consistent in-memory state, even
+            // though its own `stage_events` row can end up persisted *between*
+            // two of these sequential appendStageEvent calls below (this loop) --
+            // that interleaving is only a SQLite write-ordering artifact, not a
+            // sign the join decided early.
             applyForkChoiceToSchedule(dag, stageId, chosen, states, {
                 protectedIds,
                 onSkip: (id) => {
@@ -710,31 +735,21 @@ export async function runPipelineDag(options) {
                 await store.appendStageEvent(run.runId, id, { event: "skipped" });
             }
         }
-        const applied = applyCloneForksToSchedule(dag, stageId, envelope, states, {
-            forceFreshCloneIds,
-        });
-        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" });
-        }
-        if (applied.mintedBySuccessor !== undefined) {
-            for (const [, cloneStageIds] of applied.mintedBySuccessor) {
-                if (cloneStageIds.length === 0)
-                    continue;
-                const replayId = activeReplayId(feedbackSchedule);
-                await mintCohortForFanout({
-                    store,
-                    runId: run.runId,
-                    ...(replayId !== undefined ? { replayId } : {}),
-                    forkParent: stageId,
-                    cloneStageIds,
-                });
-                noteActiveCohort(feedbackSchedule, stageId, cloneStageIds);
+        const childIds = dag.childrenOf[stageId] ?? [];
+        for (const childId of childIds) {
+            const child = dag.nodes.find((node) => node.id === childId);
+            if (!child)
+                continue;
+            const result = classifyInboundAfterSuccess(child, stageId, envelope.payload);
+            if (result === "missing_field") {
+                schedulingHalted = true;
+                if (firstFailureReason === undefined) {
+                    firstFailureReason = `stage "${stageId}": route if field missing from payload`;
+                }
+                return;
+            }
+            if (isEagerSingleParentIfSkip(child, stageId, envelope.payload)) {
+                await persistSkipPending(childId);
             }
         }
     };
@@ -891,6 +906,7 @@ export async function runPipelineDag(options) {
     };
     while (!allTerminal()) {
         drainRetryMutations();
+        await applyStalledJoinSkips();
         if (options.onLoopTick !== undefined) {
             await options.onLoopTick();
         }

package/dist/runtime/routeIfEval.d.ts

@@ -0,0 +1,3 @@
+import type { RouteIfPredicate } from "../types/pipeline.js";
+export type RouteIfEval = "fire" | "miss" | "missing_field";
+export declare function evaluateRouteIf(predicate: RouteIfPredicate, payload: Record<string, unknown> | undefined): RouteIfEval;

package/dist/runtime/routeIfEval.js

@@ -0,0 +1,94 @@
+const NUMERIC_OPS = new Set(["gt", "gte", "lt", "lte"]);
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+}
+function isRouteIfLeaf(predicate) {
+    return "op" in predicate && predicate.op !== undefined && typeof predicate.field === "string";
+}
+function readPayloadPath(payload, field) {
+    if (payload === undefined)
+        return { ok: false };
+    const segments = field.split(".");
+    let current = payload;
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (!isPlainObject(current) || !hasOwn(current, segment)) {
+            return { ok: false };
+        }
+        current = current[segment];
+        if (i < segments.length - 1 && !isPlainObject(current)) {
+            return { ok: false };
+        }
+    }
+    return { ok: true, value: current };
+}
+function compareLeaf(op, actual, expected) {
+    if (op === "eq")
+        return actual === expected ? "fire" : "miss";
+    if (op === "ne")
+        return actual !== expected ? "fire" : "miss";
+    if (NUMERIC_OPS.has(op)) {
+        if (typeof actual !== "number" || !Number.isFinite(actual))
+            return "miss";
+        if (typeof expected !== "number" || !Number.isFinite(expected))
+            return "miss";
+        if (op === "gt")
+            return actual > expected ? "fire" : "miss";
+        if (op === "gte")
+            return actual >= expected ? "fire" : "miss";
+        if (op === "lt")
+            return actual < expected ? "fire" : "miss";
+        if (op === "lte")
+            return actual <= expected ? "fire" : "miss";
+    }
+    if (op === "in") {
+        if (!Array.isArray(expected))
+            return "miss";
+        return expected.includes(actual) ? "fire" : "miss";
+    }
+    if (op === "not_in") {
+        if (!Array.isArray(expected))
+            return "miss";
+        return expected.includes(actual) ? "miss" : "fire";
+    }
+    return "miss";
+}
+export function evaluateRouteIf(predicate, payload) {
+    if ("all" in predicate && predicate.all !== undefined) {
+        let anyMiss = false;
+        for (const child of predicate.all) {
+            const result = evaluateRouteIf(child, payload);
+            if (result === "missing_field")
+                return "missing_field";
+            if (result === "miss")
+                anyMiss = true;
+        }
+        return anyMiss ? "miss" : "fire";
+    }
+    if ("any" in predicate && predicate.any !== undefined) {
+        let anyFire = false;
+        for (const child of predicate.any) {
+            const result = evaluateRouteIf(child, payload);
+            if (result === "missing_field")
+                return "missing_field";
+            if (result === "fire")
+                anyFire = true;
+        }
+        return anyFire ? "fire" : "miss";
+    }
+    if ("not" in predicate && predicate.not !== undefined) {
+        const result = evaluateRouteIf(predicate.not, payload);
+        if (result === "missing_field")
+            return "missing_field";
+        return result === "fire" ? "miss" : "fire";
+    }
+    if (!isRouteIfLeaf(predicate))
+        return "missing_field";
+    const read = readPayloadPath(payload, predicate.field);
+    if (!read.ok)
+        return "missing_field";
+    return compareLeaf(predicate.op, read.value, predicate.value);
+}

package/dist/runtime/runRetryCoordinator.js

@@ -25,10 +25,6 @@ export function succeededStageRetryBlocker(stageSnap) {
         stageSnap.definition_id !== stageSnap.stage_id) {
         return `Cannot re-run a succeeded clone instance stage (stage=${stageSnap.stage_id}, definition=${stageSnap.definition_id}): clone instances are created by upstream fan-out and cannot be rebuilt in place. Use rerun to start a new run.`;
     }
-    const forks = stageSnap.envelope?.clone_forks;
-    if (Array.isArray(forks) && forks.length > 0) {
-        return `Cannot re-run a succeeded clonable-fanout stage (stage=${stageSnap.stage_id}): its envelope declared clone_forks and existing clone instances cannot be pruned. Use rerun to start a new run.`;
-    }
     if (stageSnap.envelope?.fork_choice !== undefined) {
         return `Cannot re-run a succeeded fork stage (stage=${stageSnap.stage_id}): its envelope recorded a fork_choice and skipped branches cannot be restored. Use rerun to start a new run.`;
     }