stageflow 0.9.0 → 0.13.0

package/dist/runtime/completionCheckRunner.js

@@ -0,0 +1,365 @@
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+import { assertEnvelopePayload } from "../envelope/payloadSchema.js";
+const MAX_COMMAND_OUTPUT_BYTES = 64 * 1024;
+function captureOutput(chunks, chunk, currentSize) {
+    const remaining = MAX_COMMAND_OUTPUT_BYTES - currentSize;
+    if (remaining <= 0)
+        return currentSize;
+    const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, remaining);
+    chunks.push(accepted);
+    return currentSize + accepted.byteLength;
+}
+/** Default Node implementation; callers may substitute a sandboxed executor. */
+export const nodeCommandExecutor = {
+    async run(input) {
+        return new Promise((resolve) => {
+            let stdoutSize = 0;
+            let stderrSize = 0;
+            const stdout = [];
+            const stderr = [];
+            let timedOut = false;
+            let settled = false;
+            let timeout;
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                resolve(result);
+            };
+            let child;
+            try {
+                child = spawn(input.command, {
+                    cwd: input.cwd,
+                    shell: true,
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+            }
+            catch (error) {
+                finish({
+                    exit_code: null,
+                    stdout: "",
+                    stderr: "",
+                    timed_out: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return;
+            }
+            child.stdout?.on("data", (data) => {
+                stdoutSize = captureOutput(stdout, Buffer.from(data), stdoutSize);
+            });
+            child.stderr?.on("data", (data) => {
+                stderrSize = captureOutput(stderr, Buffer.from(data), stderrSize);
+            });
+            child.once("error", (error) => {
+                finish({
+                    exit_code: null,
+                    stdout: Buffer.concat(stdout).toString("utf8"),
+                    stderr: Buffer.concat(stderr).toString("utf8"),
+                    timed_out: timedOut,
+                    error: error.message,
+                });
+            });
+            child.once("close", (code) => {
+                finish({
+                    exit_code: code,
+                    stdout: Buffer.concat(stdout).toString("utf8"),
+                    stderr: Buffer.concat(stderr).toString("utf8"),
+                    timed_out: timedOut,
+                });
+            });
+            if (input.timeout_ms !== undefined) {
+                timeout = setTimeout(() => {
+                    timedOut = true;
+                    child.kill("SIGTERM");
+                }, input.timeout_ms);
+            }
+        });
+    },
+};
+function result(check, outcome, evidence, message) {
+    return {
+        check_id: check.id,
+        check_type: check.type,
+        outcome,
+        ...(message !== undefined ? { message } : {}),
+        evidence,
+    };
+}
+function resolveCommandCwd(check, base) {
+    return check.cwd === undefined ? base : path.resolve(base, check.cwd);
+}
+async function runCommandCheck(check, input) {
+    const base = input.commandWorkingDirectory;
+    if (base === undefined) {
+        return result(check, "error", { kind: "command", command: check.run, exit_code: null, stdout: "", stderr: "", timed_out: false }, "command check requires commandWorkingDirectory");
+    }
+    const cwd = resolveCommandCwd(check, base);
+    const executor = input.commandExecutor ?? nodeCommandExecutor;
+    try {
+        const execution = await executor.run({ command: check.run, cwd, timeout_ms: check.timeout_ms });
+        const evidence = {
+            kind: "command",
+            command: check.run,
+            cwd,
+            exit_code: execution.exit_code,
+            stdout: execution.stdout,
+            stderr: execution.stderr,
+            timed_out: execution.timed_out,
+            ...(execution.error !== undefined ? { error: execution.error } : {}),
+        };
+        if (execution.timed_out)
+            return result(check, "failed", evidence, "command timed out");
+        if (execution.error !== undefined)
+            return result(check, "error", evidence, execution.error);
+        if (execution.exit_code !== 0)
+            return result(check, "failed", evidence, `command exited with code ${execution.exit_code ?? "unknown"}`);
+        return result(check, "passed", evidence);
+    }
+    catch (error) {
+        return result(check, "error", { kind: "command", command: check.run, cwd, exit_code: null, stdout: "", stderr: "", timed_out: false }, error instanceof Error ? error.message : String(error));
+    }
+}
+async function inspectArtifact(artifactsDir, relativePath) {
+    const target = path.resolve(artifactsDir, relativePath);
+    const relative = path.relative(artifactsDir, target);
+    if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        return { kind: "artifact", path: relativePath, exists: false, file_type: "missing" };
+    }
+    try {
+        // lstat every component rather than just the target: lstat(target) follows
+        // a symlink in a parent directory, which could otherwise prove a file that
+        // lives outside the attempt artifact root.
+        const segments = relative.split(path.sep).filter((segment) => segment !== "");
+        let current = artifactsDir;
+        let stats;
+        for (const segment of segments) {
+            current = path.join(current, segment);
+            stats = await lstat(current);
+            if (stats.isSymbolicLink()) {
+                return { kind: "artifact", path: relativePath, exists: true, file_type: "symlink" };
+            }
+            if (current !== target && !stats.isDirectory()) {
+                return { kind: "artifact", path: relativePath, exists: true, file_type: "other" };
+            }
+        }
+        if (stats === undefined) {
+            return { kind: "artifact", path: relativePath, exists: false, file_type: "missing" };
+        }
+        if (stats.isSymbolicLink()) {
+            return { kind: "artifact", path: relativePath, exists: true, file_type: "symlink" };
+        }
+        if (stats.isDirectory()) {
+            return { kind: "artifact", path: relativePath, exists: true, file_type: "directory" };
+        }
+        if (!stats.isFile()) {
+            return { kind: "artifact", path: relativePath, exists: true, file_type: "other" };
+        }
+        const content = await readFile(target);
+        return {
+            kind: "artifact",
+            path: relativePath,
+            exists: true,
+            file_type: "file",
+            size_bytes: stats.size,
+            sha256: createHash("sha256").update(content).digest("hex"),
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { kind: "artifact", path: relativePath, exists: false, file_type: "missing" };
+        }
+        throw error;
+    }
+}
+async function runArtifactCheck(check, input) {
+    try {
+        const evidence = await inspectArtifact(input.artifactsDir, check.path);
+        if (evidence.file_type !== "file") {
+            return result(check, "failed", evidence, `artifact is ${evidence.file_type}`);
+        }
+        if (check.nonempty === true && evidence.size_bytes === 0) {
+            return result(check, "failed", evidence, "artifact is empty");
+        }
+        return result(check, "passed", evidence);
+    }
+    catch (error) {
+        return result(check, "error", { kind: "artifact", path: check.path, exists: false, file_type: "missing" }, error instanceof Error ? error.message : String(error));
+    }
+}
+function runPayloadSchemaCheck(check, input) {
+    const evidence = {
+        kind: "payload_schema",
+        schema_declared: input.payloadSchema !== undefined,
+        payload_present: input.envelope.payload !== undefined,
+    };
+    if (input.payloadSchema === undefined) {
+        evidence.validation_error = "stage does not declare payload_schema";
+        return result(check, "error", evidence, evidence.validation_error);
+    }
+    try {
+        assertEnvelopePayload(input.envelope, input.payloadSchema);
+        return result(check, "passed", evidence);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        evidence.validation_error = message;
+        return result(check, "failed", evidence, message);
+    }
+}
+async function runGateCheck(check, input) {
+    const baseEvidence = { kind: "gate", gate_kind: check.kind, decisions: [] };
+    if (!input.gates) {
+        return result(check, "error", baseEvidence, "gate check requires a gate decision provider");
+    }
+    try {
+        const decisions = [...(await input.gates.listDecisions(check.kind))]
+            .filter((decision) => decision.kind === check.kind)
+            .sort((a, b) => (a.prompt_id ?? "").localeCompare(b.prompt_id ?? "") || a.status.localeCompare(b.status));
+        const evidence = { ...baseEvidence, decisions };
+        const accepted = decisions.some((decision) => decision.status === "accepted");
+        const answered = decisions.some((decision) => decision.status === "answered");
+        const passes = check.kind === "confirm" ? accepted : accepted || answered;
+        return passes
+            ? result(check, "passed", evidence)
+            : result(check, "failed", evidence, `no accepted ${check.kind} gate decision`);
+    }
+    catch (error) {
+        return result(check, "error", baseEvidence, error instanceof Error ? error.message : String(error));
+    }
+}
+function normalizeCheckoutPath(value) {
+    const normalized = path.posix.normalize(value.replaceAll("\\", "/"));
+    if (normalized === "." || normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+        return undefined;
+    }
+    return normalized;
+}
+function claimedPaths(payload, fields) {
+    if (fields === undefined)
+        return { paths: [], invalid: [] };
+    const paths = [];
+    const invalid = [];
+    for (const field of fields) {
+        const value = payload?.[field];
+        if (!Array.isArray(value)) {
+            invalid.push(field);
+            continue;
+        }
+        for (const candidate of value) {
+            if (typeof candidate !== "string") {
+                invalid.push(field);
+                continue;
+            }
+            const normalized = normalizeCheckoutPath(candidate);
+            if (normalized === undefined)
+                invalid.push(candidate);
+            else
+                paths.push(normalized);
+        }
+    }
+    return { paths: [...new Set(paths)].sort(), invalid: [...new Set(invalid)].sort() };
+}
+async function runCheckoutChangesCheck(check, input) {
+    const empty = { kind: "checkout_changes", changes: [] };
+    if (input.checkoutError !== undefined) {
+        return result(check, "error", empty, input.checkoutError);
+    }
+    if (!input.checkout || !input.checkoutBefore) {
+        return result(check, "error", empty, "checkout check requires a before snapshot and checkout capability");
+    }
+    try {
+        const rawChanges = await input.checkout.changesSince(input.checkoutBefore);
+        const changes = [...rawChanges]
+            .map((change) => ({ ...change, path: normalizeCheckoutPath(change.path) }))
+            .filter((change) => change.path !== undefined)
+            .sort((a, b) => a.path.localeCompare(b.path) || a.status.localeCompare(b.status));
+        const { paths, invalid } = claimedPaths(input.envelope.payload, check.path_fields);
+        const changedPaths = [...new Set(changes.map((change) => change.path))];
+        const evidence = {
+            kind: "checkout_changes",
+            changes,
+            ...(check.path_fields !== undefined ? { claimed_paths: paths } : {}),
+        };
+        if (changes.length === 0)
+            return result(check, "failed", evidence, "checkout has no changes from this attempt");
+        if (invalid.length > 0)
+            return result(check, "failed", evidence, `invalid claimed checkout paths: ${invalid.join(", ")}`);
+        if (check.path_fields !== undefined) {
+            const claimed = new Set(paths);
+            const actual = new Set(changedPaths);
+            const missing = paths.filter((item) => !actual.has(item));
+            const unclaimed = changedPaths.filter((item) => !claimed.has(item));
+            if (missing.length > 0)
+                evidence.missing_claimed_paths = missing;
+            if (unclaimed.length > 0)
+                evidence.unclaimed_changed_paths = unclaimed;
+            if (missing.length > 0 || unclaimed.length > 0) {
+                return result(check, "failed", evidence, "claimed checkout paths do not match observed changes");
+            }
+        }
+        return result(check, "passed", evidence);
+    }
+    catch (error) {
+        return result(check, "error", empty, error instanceof Error ? error.message : String(error));
+    }
+}
+function runChecklistCheck(check, input) {
+    const attestation = input.checklistAttestations?.find((item) => item.check_id === check.id);
+    const attested = [...new Set(attestation?.items ?? [])].sort();
+    const expected = [...check.items].sort();
+    const attestedSet = new Set(attested);
+    const expectedSet = new Set(expected);
+    const evidence = {
+        kind: "checklist",
+        expected_items: expected,
+        attested_items: attested,
+        missing_items: expected.filter((item) => !attestedSet.has(item)),
+        unexpected_items: attested.filter((item) => !expectedSet.has(item)),
+    };
+    if (evidence.missing_items.length > 0 || evidence.unexpected_items.length > 0) {
+        return result(check, "failed", evidence, "checklist attestation does not match required items");
+    }
+    return result(check, "passed", evidence);
+}
+async function runCheck(check, input) {
+    switch (check.type) {
+        case "command":
+            return runCommandCheck(check, input);
+        case "artifact":
+            return runArtifactCheck(check, input);
+        case "payload_schema":
+            return runPayloadSchemaCheck(check, input);
+        case "gate":
+            return runGateCheck(check, input);
+        case "checkout_changes":
+            return runCheckoutChangesCheck(check, input);
+        case "checklist":
+            return runChecklistCheck(check, input);
+    }
+}
+/**
+ * Run every completion check in declaration order. A failed check never throws
+ * or prevents later checks from producing their own repair evidence.
+ */
+export async function runCompletionContract(input) {
+    const checks = [];
+    for (const check of input.contract.checks) {
+        await input.onCheckStart?.(check);
+        const completed = await runCheck(check, input);
+        await input.onCheckComplete?.(completed);
+        checks.push(completed);
+    }
+    const failedCheckIds = checks
+        .filter((check) => check.outcome !== "passed")
+        .map((check) => check.check_id);
+    return {
+        outcome: failedCheckIds.length === 0 ? "passed" : "failed",
+        checks,
+        failed_check_ids: failedCheckIds,
+    };
+}

package/dist/runtime/completionCheckoutBaseline.d.ts

@@ -0,0 +1,3 @@
+import type { CheckoutSnapshot } from "./completionCheckRunner.js";
+export declare function readCompletionCheckoutBaseline(workspaceDir: string, stageId: string, attempt: number): Promise<CheckoutSnapshot | undefined>;
+export declare function writeCompletionCheckoutBaseline(workspaceDir: string, stageId: string, attempt: number, snapshot: CheckoutSnapshot): Promise<void>;

package/dist/runtime/completionCheckoutBaseline.js

@@ -0,0 +1,44 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { attemptWorkspaceDir } from "../runstore/workspaceLayout.js";
+function baselinePath(workspaceDir, stageId, attempt) {
+    return path.join(attemptWorkspaceDir(workspaceDir, stageId, attempt), "completion-checkout-before.json");
+}
+function parseSnapshot(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = value.entries;
+    if (!Array.isArray(entries))
+        return undefined;
+    if (!entries.every((entry) => entry !== null &&
+        typeof entry === "object" &&
+        typeof entry.path === "string" &&
+        typeof entry.fingerprint === "string")) {
+        return undefined;
+    }
+    return {
+        entries: entries.map((entry) => ({
+            path: entry.path,
+            fingerprint: entry.fingerprint,
+        })),
+    };
+}
+export async function readCompletionCheckoutBaseline(workspaceDir, stageId, attempt) {
+    try {
+        const raw = await readFile(baselinePath(workspaceDir, stageId, attempt), "utf8");
+        return parseSnapshot(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new Error("completion checkout baseline is unreadable");
+    }
+}
+export async function writeCompletionCheckoutBaseline(workspaceDir, stageId, attempt, snapshot) {
+    const target = baselinePath(workspaceDir, stageId, attempt);
+    await mkdir(path.dirname(target), { recursive: true });
+    const temporary = `${target}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(snapshot)}\n`, "utf8");
+    await rename(temporary, target);
+}

package/dist/runtime/envelopeRouting.d.ts

@@ -1,5 +1,5 @@
 import type { RunStore, StageSnapshot } from "../runstore/port.js";
-import type { StageEnvelope } from "../types/envelope.js";
+import type { StageEnvelope, TerminalEnvelope } from "../types/envelope.js";
 import type { LoadedPipeline, ResolvedPipelineDag } from "../types/pipeline.js";
 import type { StageConfig } from "../types/stage.js";
 export declare function buildCompletedEnvelopesFromRun(store: RunStore, runId: string, stages?: StageSnapshot[], dag?: ResolvedPipelineDag): Promise<Map<string, StageEnvelope>>;
@@ -8,14 +8,21 @@ export type ResolvePriorEnvelopeResult = {
     ok: true;
     prior: StageEnvelope | null;
     joinPriors?: StageEnvelope[];
+    priorEnvelopesByStage?: Record<string, TerminalEnvelope | TerminalEnvelope[]>;
 } | {
     ok: false;
     reason: string;
 };
-export declare function resolvePriorEnvelope(options: {
+type ResolvePriorEnvelopeOptions = {
     dag: ResolvedPipelineDag;
     stageId: string;
     completedEnvelopes: Map<string, StageEnvelope>;
     store?: RunStore;
     runId?: string;
-}): Promise<ResolvePriorEnvelopeResult>;
+    stages?: StageSnapshot[];
+    /** When set (including null), skips store lookup for active fork generation. */
+    activeCloneIds?: Set<string> | null;
+    scheduleOverride?: ReadonlyMap<string, ReadonlySet<string>>;
+};
+export declare function resolvePriorEnvelope(options: ResolvePriorEnvelopeOptions): Promise<ResolvePriorEnvelopeResult>;
+export {};

package/dist/runtime/envelopeRouting.js

@@ -1,5 +1,7 @@
+import { predecessorEdges } from "../config/pipelineNeeds.js";
 import { instancesOfDefinition, } from "../runstore/pipelineDagSnapshot.js";
 import { definitionIdForInstance } from "../runstore/stageInstanceId.js";
+import { activeCohortFromCloneIds, filterJoinInputs, selectActiveInput, } from "./forkGeneration.js";
 function definitionInstances(dag, catalogId) {
     const snapshot = dag;
     if (Array.isArray(snapshot.stage_ids)) {
@@ -7,6 +9,20 @@ function definitionInstances(dag, catalogId) {
     }
     return dag.nodes.some((n) => n.id === catalogId) ? [catalogId] : [];
 }
+async function resolveActiveCohortForNeeds(dag, needsId, store, runId, activeCloneIds, scheduleOverride) {
+    if (activeCloneIds !== undefined) {
+        return activeCohortFromCloneIds(activeCloneIds);
+    }
+    if (store === undefined || runId === undefined)
+        return { kind: "untracked" };
+    return selectActiveInput({
+        store,
+        runId,
+        dag,
+        needsStageId: needsId,
+        ...(scheduleOverride !== undefined ? { scheduleOverride } : {}),
+    });
+}
 export async function buildCompletedEnvelopesFromRun(store, runId, stages, dag) {
     const completedEnvelopes = new Map();
     const snapshotStages = stages ?? (await store.readRun(runId)).stages;
@@ -43,6 +59,123 @@ export function buildStageConfigById(loaded) {
 function dagNode(dag, stageId) {
     return dag.nodes.find((node) => node.id === stageId);
 }
+const SYNTHETIC_SKIPPED_TERMINAL = {
+    status: "skipped",
+    summary: "stage was skipped",
+    artifacts: [],
+};
+function mintedCloneInstances(dag, parentId) {
+    return definitionInstances(dag, parentId).filter((id) => id !== parentId);
+}
+function isClonableParent(dag, parentId) {
+    const node = dagNode(dag, parentId);
+    return node?.clonable === true || mintedCloneInstances(dag, parentId).length > 0;
+}
+function failureReasonFromSnapshot(snap) {
+    let reason = "stage failed";
+    if (snap === undefined)
+        return reason;
+    for (const ev of snap.events) {
+        if (ev.event === "failed" && typeof ev.reason === "string" && ev.reason) {
+            reason = ev.reason;
+        }
+    }
+    return reason;
+}
+async function loadStageSnapshots(options) {
+    if (options.stages !== undefined)
+        return options.stages;
+    if (options.store !== undefined && options.runId !== undefined) {
+        return (await options.store.readRun(options.runId)).stages;
+    }
+    return [];
+}
+async function readCachedEnvelope(options, snapshots, stageId) {
+    const fromMap = options.completedEnvelopes.get(stageId);
+    if (fromMap !== undefined)
+        return structuredClone(fromMap);
+    const snap = snapshots.get(stageId);
+    if (snap?.envelope)
+        return structuredClone(snap.envelope);
+    if (options.store !== undefined && options.runId !== undefined) {
+        try {
+            return structuredClone(await options.store.readEnvelope(options.runId, stageId));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+async function terminalForPersistedStage(options, snapshots, stageId) {
+    const snap = snapshots.get(stageId);
+    if (snap?.status === "skipped") {
+        return { ok: true, value: { ...SYNTHETIC_SKIPPED_TERMINAL } };
+    }
+    if (snap?.status === "failed") {
+        const envelope = await readCachedEnvelope(options, snapshots, stageId);
+        if (envelope?.status === "failure") {
+            return { ok: true, value: envelope };
+        }
+        return {
+            ok: true,
+            value: {
+                status: "failure",
+                summary: failureReasonFromSnapshot(snap),
+                artifacts: [],
+            },
+        };
+    }
+    if (snap?.status === "succeeded") {
+        const envelope = await readCachedEnvelope(options, snapshots, stageId);
+        if (envelope === undefined) {
+            return {
+                ok: false,
+                reason: `missing envelope for upstream stage "${stageId}"`,
+            };
+        }
+        return { ok: true, value: envelope };
+    }
+    return {
+        ok: false,
+        reason: `missing envelope for upstream stage "${stageId}"`,
+    };
+}
+async function resolveGenericJoinPriors(options, node) {
+    const snapshots = new Map((await loadStageSnapshots(options)).map((snap) => [snap.stage_id, snap]));
+    const priorEnvelopesByStage = {};
+    for (const edge of predecessorEdges(node)) {
+        const parentId = edge.id;
+        if (isClonableParent(options.dag, parentId)) {
+            const minted = mintedCloneInstances(options.dag, parentId);
+            if (minted.length > 0) {
+                const list = [];
+                for (const id of minted) {
+                    const terminal = await terminalForPersistedStage(options, snapshots, id);
+                    if (!terminal.ok)
+                        return terminal;
+                    list.push(terminal.value);
+                }
+                priorEnvelopesByStage[parentId] = list;
+                continue;
+            }
+            if (snapshots.get(parentId)?.status === "skipped") {
+                priorEnvelopesByStage[parentId] = [];
+                continue;
+            }
+            const once = await terminalForPersistedStage(options, snapshots, parentId);
+            if (!once.ok)
+                return once;
+            priorEnvelopesByStage[parentId] = [once.value];
+            continue;
+        }
+        const terminal = await terminalForPersistedStage(options, snapshots, parentId);
+        if (!terminal.ok)
+            return terminal;
+        priorEnvelopesByStage[parentId] = terminal.value;
+    }
+    return { ok: true, prior: null, priorEnvelopesByStage };
+}
 export async function resolvePriorEnvelope(options) {
     const node = dagNode(options.dag, options.stageId);
     if (!node) {
@@ -51,11 +184,18 @@ export async function resolvePriorEnvelope(options) {
             reason: `stage "${options.stageId}" not in pipeline DAG`,
         };
     }
-    if (node.needs === null) {
+    const edges = predecessorEdges(node);
+    if (edges.length === 0) {
         return { ok: true, prior: null };
     }
-    const joinInstances = definitionInstances(options.dag, node.needs);
-    if (joinInstances.length > 1) {
+    if (edges.length >= 2) {
+        return resolveGenericJoinPriors(options, node);
+    }
+    const parentId = typeof node.needs === "string" && node.needs ? node.needs : edges[0].id;
+    const allJoinInstances = definitionInstances(options.dag, parentId);
+    if (allJoinInstances.length > 1) {
+        const cohort = await resolveActiveCohortForNeeds(options.dag, parentId, options.store, options.runId, options.activeCloneIds, options.scheduleOverride);
+        const joinInstances = filterJoinInputs(allJoinInstances, cohort);
         const joinPriors = [];
         for (const id of joinInstances) {
             const fromMap = options.completedEnvelopes.get(id);
@@ -83,7 +223,6 @@ export async function resolvePriorEnvelope(options) {
         }
         return { ok: true, prior: null, joinPriors };
     }
-    const parentId = node.needs;
     const fromMap = options.completedEnvelopes.get(parentId);
     let parent = fromMap;
     if (parent === undefined && options.store !== undefined && options.runId !== undefined) {
@@ -108,7 +247,9 @@ export async function resolvePriorEnvelope(options) {
             return { ok: true, prior: structuredClone(item.envelope) };
         }
         if (item.action === "fanout") {
-            const instanceIds = definitionInstances(options.dag, item.successor_id);
+            const allInstanceIds = definitionInstances(options.dag, item.successor_id);
+            const cohort = await resolveActiveCohortForNeeds(options.dag, item.successor_id, options.store, options.runId, options.activeCloneIds, options.scheduleOverride);
+            const instanceIds = filterJoinInputs(allInstanceIds, cohort);
             const index = instanceIds.indexOf(options.stageId);
             if (index >= 0) {
                 const clone = item.clones[index];