stageflow 0.3.0 → 0.9.0

package/dist/runstore/pipelineDagSnapshot.js

@@ -1,3 +1,4 @@
+import { mintCloneInstanceIds } from "./stageInstanceId.js";
 export function buildPipelineDagSnapshotFromLoaded(loaded) {
     const gate_kinds = {};
     for (const stage of loaded.stages) {
@@ -7,7 +8,10 @@ export function buildPipelineDagSnapshotFromLoaded(loaded) {
     }
     return {
         stage_ids: [...loaded.pipeline.stages],
-        nodes: loaded.dag.nodes,
+        nodes: loaded.dag.nodes.map((node) => ({
+            ...node,
+            definition_id: node.id,
+        })),
         roots: loaded.dag.roots,
         childrenOf: loaded.dag.childrenOf,
         ...(Object.keys(gate_kinds).length > 0 ? { gate_kinds } : {}),
@@ -19,6 +23,7 @@ export function linearCompatDagSnapshot(stageIds) {
         needs: index === 0 ? null : stageIds[index - 1],
         ancestors: index === 0 ? [] : stageIds.slice(0, index),
         stageIndex: index,
+        definition_id: id,
     }));
     const childrenOf = {};
     for (let i = 1; i < stageIds.length; i++) {
@@ -41,3 +46,87 @@ export function parsePipelineDagSnapshot(raw) {
         return null;
     return raw;
 }
+export function instancesOfDefinition(snapshot, catalogId) {
+    const nodeById = new Map(snapshot.nodes.map((n) => [n.id, n]));
+    return snapshot.stage_ids.filter((id) => {
+        const node = nodeById.get(id);
+        return (node?.definition_id ?? node?.id) === catalogId;
+    });
+}
+export function appendCloneInstances(snapshot, input) {
+    const { catalogId, predecessorId, count } = input;
+    if (!snapshot.stage_ids.includes(catalogId)) {
+        throw new Error(`catalog stage "${catalogId}" is not in the run DAG snapshot`);
+    }
+    const predNode = snapshot.nodes.find((n) => n.id === predecessorId);
+    if (!predNode) {
+        throw new Error(`predecessor "${predecessorId}" is not in the run DAG snapshot`);
+    }
+    const instanceIds = mintCloneInstanceIds(catalogId, count);
+    for (const id of instanceIds) {
+        if (snapshot.stage_ids.includes(id) ||
+            snapshot.nodes.some((n) => n.id === id)) {
+            throw new Error(`instance id "${id}" already exists in the run DAG snapshot`);
+        }
+    }
+    const catalogNode = snapshot.nodes.find((n) => n.id === catalogId);
+    if (!catalogNode) {
+        throw new Error(`catalog stage "${catalogId}" is not in the run DAG snapshot`);
+    }
+    const catalogIdx = snapshot.stage_ids.indexOf(catalogId);
+    const stage_ids = [
+        ...snapshot.stage_ids.slice(0, catalogIdx),
+        ...instanceIds,
+        ...snapshot.stage_ids.slice(catalogIdx + 1),
+    ];
+    const instanceNodes = instanceIds.map((id) => ({
+        id,
+        definition_id: catalogId,
+        needs: predecessorId,
+        ancestors: [...predNode.ancestors, predecessorId],
+        stageIndex: 0,
+        ...(catalogNode.fork !== undefined ? { fork: catalogNode.fork } : {}),
+    }));
+    const remaining = new Map(snapshot.nodes
+        .filter((n) => n.id !== catalogId)
+        .map((n) => [n.id, n]));
+    const minted = new Map(instanceNodes.map((n) => [n.id, n]));
+    const nodes = stage_ids.map((id, index) => {
+        const node = minted.get(id) ?? remaining.get(id);
+        if (!node) {
+            throw new Error(`missing node for "${id}" after clone fan-out`);
+        }
+        return { ...node, stageIndex: index };
+    });
+    const childrenOf = {};
+    for (const [key, children] of Object.entries(snapshot.childrenOf)) {
+        childrenOf[key] = [...children];
+    }
+    const predChildren = childrenOf[predecessorId] ?? [];
+    const predIdx = predChildren.indexOf(catalogId);
+    childrenOf[predecessorId] =
+        predIdx === -1
+            ? [...predChildren, ...instanceIds]
+            : [
+                ...predChildren.slice(0, predIdx),
+                ...instanceIds,
+                ...predChildren.slice(predIdx + 1),
+            ];
+    const definitionParent = catalogNode.needs;
+    if (definitionParent && definitionParent !== predecessorId) {
+        const parentChildren = childrenOf[definitionParent] ?? [];
+        childrenOf[definitionParent] = parentChildren.filter((id) => id !== catalogId);
+        if (childrenOf[definitionParent].length === 0) {
+            delete childrenOf[definitionParent];
+        }
+    }
+    return {
+        snapshot: {
+            ...snapshot,
+            stage_ids,
+            nodes,
+            childrenOf,
+        },
+        instanceIds,
+    };
+}

package/dist/runstore/port.d.ts

@@ -18,6 +18,7 @@ export type PipelineTrackNode = {
     blocked_by?: string[];
     gate_kinds?: StageGateKind[];
     attempt_count?: number;
+    definition_id?: string;
 };
 export type PipelineTrackEdge = {
     from: string;
@@ -55,7 +56,8 @@ export type StageLogEvent = StageLogLine & {
 };
 export type StageSnapshot = {
     stage_id: string;
-    status: "pending" | "running" | "waiting_for_input" | "succeeded" | "failed";
+    definition_id?: string;
+    status: "pending" | "running" | "waiting_for_input" | "succeeded" | "failed" | "skipped";
     events: StageLogEvent[];
     envelope: StageEnvelope | null;
     artifacts: string[];
@@ -82,6 +84,7 @@ export type CompactStage = {
     id: string;
     status: StageSnapshot["status"];
     attempt_count: number;
+    definition_id?: string;
 };
 export type RunSummary = {
     run_id: string;
@@ -125,6 +128,13 @@ export type CreateRunInput = {
     taskPath?: string;
     projectRoot?: string;
 };
+export type ListRunsFilter = {
+    status?: RunStatus;
+    /** ISO timestamp; keep runs with created_at >= since */
+    since?: string;
+    /** Match pipeline_id or pipeline_path */
+    pipeline?: string;
+};
 /**
  * Persistence port for pipeline run state.
  * Call sites should prefer CreatedRun.workspaceDir from createRun over
@@ -154,8 +164,9 @@ export interface RunStore {
         attempt?: number;
     }): Promise<void>;
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
-    listRuns(): Promise<RunSummary[]>;
+    listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
     readRun(runId: string): Promise<RunDetail>;
+    updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
 }
 export declare function stageStatusFromEvents(events: StageLogEvent[]): StageSnapshot["status"];
 export declare function deriveStatusFromStages(stages: StageSnapshot[]): RunStatus;

package/dist/runstore/port.js

@@ -9,6 +9,8 @@ export function stageStatusFromEvents(events) {
             status = "succeeded";
         if (ev.event === "failed")
             status = "failed";
+        if (ev.event === "skipped")
+            status = "skipped";
     }
     return status;
 }
@@ -17,8 +19,9 @@ export function deriveStatusFromStages(stages) {
         return "created";
     if (stages.some((s) => s.status === "failed"))
         return "failed";
-    if (stages.every((s) => s.status === "succeeded"))
+    if (stages.every((s) => s.status === "succeeded" || s.status === "skipped")) {
         return "succeeded";
+    }
     if (stages.some((s) => s.status === "running" ||
         s.status === "waiting_for_input" ||
         s.status === "succeeded")) {

package/dist/runstore/runProjection.d.ts

@@ -1,6 +1,6 @@
 import type { RunDetail, RunMeta, RunPipelineDagSnapshot, RunSummary, StageSnapshot } from "./port.js";
 export { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
-export declare function overlayPlannedStages(stageIds: string[], snapshots: StageSnapshot[]): StageSnapshot[];
+export declare function overlayPlannedStages(stageIds: string[], snapshots: StageSnapshot[], dag?: Pick<RunPipelineDagSnapshot, "nodes"> | null): StageSnapshot[];
 export declare function orderStageSnapshots(stageIds: string[], snapshots: StageSnapshot[]): StageSnapshot[];
 export declare function projectRunSummary(meta: RunMeta, stages: StageSnapshot[]): RunSummary;
 export declare function projectRunDetail(meta: RunMeta, stages: StageSnapshot[], task_yaml: string, dagSnapshot?: RunPipelineDagSnapshot | null): RunDetail;

package/dist/runstore/runProjection.js

@@ -3,9 +3,19 @@ import { linearCompatDagSnapshot } from "./pipelineDagSnapshot.js";
 import { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
 import { buildPipelineTrack } from "./trackProjection.js";
 export { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
-export function overlayPlannedStages(stageIds, snapshots) {
+export function overlayPlannedStages(stageIds, snapshots, dag) {
     const byId = new Map(snapshots.map((s) => [s.stage_id, s]));
-    return stageIds.map((id) => byId.get(id) ?? syntheticPendingSnapshot(id));
+    const nodeById = new Map((dag?.nodes ?? []).map((n) => [n.id, n]));
+    return stageIds.map((id) => {
+        const node = nodeById.get(id);
+        const definitionId = node?.definition_id ?? node?.id;
+        const existing = byId.get(id);
+        const base = existing ?? syntheticPendingSnapshot(id, definitionId);
+        if (definitionId === undefined || base.definition_id === definitionId) {
+            return base;
+        }
+        return { ...base, definition_id: definitionId };
+    });
 }
 export function orderStageSnapshots(stageIds, snapshots) {
     return overlayPlannedStages(stageIds, snapshots);
@@ -15,6 +25,7 @@ function compactStages(stages) {
         id: s.stage_id,
         status: s.status,
         attempt_count: s.attempt_count,
+        ...(s.definition_id !== undefined ? { definition_id: s.definition_id } : {}),
     }));
 }
 function waitingSummaryFromPrompt(prompt) {
@@ -93,7 +104,7 @@ export function projectRunSummary(meta, stages) {
 }
 export function projectRunDetail(meta, stages, task_yaml, dagSnapshot) {
     const ordered = dagSnapshot
-        ? overlayPlannedStages(dagSnapshot.stage_ids, stages)
+        ? overlayPlannedStages(dagSnapshot.stage_ids, stages, dagSnapshot)
         : stages;
     const summary = projectRunSummary(meta, ordered);
     const snapshot = dagSnapshot ??

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

@@ -1,6 +1,6 @@
 import type { StageEnvelope } from "../../types/envelope.js";
 import type { StageLogLine } from "../../agent/activity.js";
-import { type CreateRunInput, type CreatedRun, type RunDetail, type RunMeta, type RunStatus, type RunStore, type RunSummary, type StageExecution, type StageExecutionPatch, type StageLogEvent } from "../port.js";
+import { type CreateRunInput, type CreatedRun, type ListRunsFilter, type RunDetail, type RunMeta, type RunPipelineDagSnapshot, type RunStatus, type RunStore, type RunSummary, type StageExecution, type StageExecutionPatch, type StageLogEvent } from "../port.js";
 export declare class SqliteRunStore implements RunStore {
     private readonly storeRoot;
     private readonly db;
@@ -11,6 +11,7 @@ export declare class SqliteRunStore implements RunStore {
     getWorkspaceDir(runId: string): string;
     createRun(input: CreateRunInput): Promise<CreatedRun>;
     updateRunStatus(runId: string, status: RunStatus): Promise<void>;
+    updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
     readRunMeta(runId: string): Promise<RunMeta>;
     readTaskYaml(runId: string): Promise<string>;
     ensureStageWorkspace(runId: string, stageId: string): Promise<void>;
@@ -37,7 +38,7 @@ export declare class SqliteRunStore implements RunStore {
      */
     private updateStageStatusDenorm;
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
-    listRuns(): Promise<RunSummary[]>;
+    listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
     readRun(runId: string): Promise<RunDetail>;
     private readPipelineDagSnapshotFromRow;
     private runMetaFromRow;

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -174,6 +174,19 @@ export class SqliteRunStore {
             throw new Error(`Run not found: ${runId}`);
         }
     }
+    async updatePipelineDag(runId, dag) {
+        await this.ready();
+        const result = this.db
+            .prepare(`UPDATE runs SET pipeline_dag_json = @pipeline_dag_json, updated_at = @updated_at WHERE run_id = @run_id`)
+            .run({
+            run_id: runId,
+            pipeline_dag_json: JSON.stringify(dag),
+            updated_at: new Date().toISOString(),
+        });
+        if (result.changes === 0) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+    }
     async readRunMeta(runId) {
         await this.ready();
         return this.runMetaFromRow(this.getRunRow(runId));
@@ -411,12 +424,29 @@ export class SqliteRunStore {
         await this.ready();
         return this.loadEvents(runId, stageId, attempt);
     }
-    async listRuns() {
+    async listRuns(filter) {
         await this.ready();
+        const clauses = [];
+        const params = [];
+        if (filter?.status !== undefined) {
+            clauses.push("status = ?");
+            params.push(filter.status);
+        }
+        if (filter?.since !== undefined) {
+            clauses.push("created_at >= ?");
+            params.push(filter.since);
+        }
+        if (filter?.pipeline !== undefined && filter.pipeline.trim().length > 0) {
+            const pipeline = filter.pipeline.trim();
+            const normalized = normalizeCatalogPath(pipeline);
+            clauses.push("(pipeline_id = ? OR pipeline_path = ? OR pipeline_path = ?)");
+            params.push(pipeline, pipeline, normalized);
+        }
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
         const rows = this.db
             .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root
-         FROM runs ORDER BY created_at DESC`)
-            .all();
+         FROM runs ${where} ORDER BY created_at DESC`)
+            .all(...params);
         const summaries = [];
         for (const row of rows) {
             const dagSnapshot = this.readPipelineDagSnapshotFromRow(row);
@@ -438,6 +468,7 @@ export class SqliteRunStore {
         return parsePipelineDagSnapshot(JSON.parse(row.pipeline_dag_json));
     }
     runMetaFromRow(row) {
+        const pipeline_dag = this.readPipelineDagSnapshotFromRow(row);
         return {
             run_id: row.run_id,
             pipeline_id: row.pipeline_id,
@@ -452,6 +483,7 @@ export class SqliteRunStore {
             ...(row.pipeline_path != null ? { pipeline_path: row.pipeline_path } : {}),
             ...(row.task_path != null ? { task_path: row.task_path } : {}),
             ...(row.project_root != null ? { project_root: row.project_root } : {}),
+            ...(pipeline_dag ? { pipeline_dag } : {}),
         };
     }
     getRunRow(runId) {

package/dist/runstore/stageInstanceId.d.ts

@@ -0,0 +1,4 @@
+import type { RunPipelineDagSnapshot } from "./port.js";
+export declare function mintCloneInstanceId(catalogId: string, n: number): string;
+export declare function mintCloneInstanceIds(catalogId: string, count: number): string[];
+export declare function definitionIdForInstance(snapshot: RunPipelineDagSnapshot | null | undefined, instanceId: string): string;

package/dist/runstore/stageInstanceId.js

@@ -0,0 +1,23 @@
+import { guardStageId } from "./workspaceLayout.js";
+function guardPositiveInteger(n, label) {
+    if (!Number.isInteger(n) || n < 1) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+}
+export function mintCloneInstanceId(catalogId, n) {
+    guardPositiveInteger(n, "n");
+    guardStageId(catalogId);
+    const instanceId = `${catalogId}~${n}`;
+    guardStageId(instanceId);
+    return instanceId;
+}
+export function mintCloneInstanceIds(catalogId, count) {
+    guardPositiveInteger(count, "count");
+    return Array.from({ length: count }, (_, i) => mintCloneInstanceId(catalogId, i + 1));
+}
+export function definitionIdForInstance(snapshot, instanceId) {
+    const node = snapshot?.nodes.find((n) => n.id === instanceId);
+    if (!node)
+        return instanceId;
+    return node.definition_id ?? node.id;
+}

package/dist/runstore/syntheticStageSnapshot.d.ts

@@ -1,2 +1,2 @@
 import type { StageSnapshot } from "./port.js";
-export declare function syntheticPendingSnapshot(stageId: string): StageSnapshot;
+export declare function syntheticPendingSnapshot(stageId: string, definitionId?: string): StageSnapshot;

package/dist/runstore/syntheticStageSnapshot.js

@@ -1,4 +1,4 @@
-export function syntheticPendingSnapshot(stageId) {
+export function syntheticPendingSnapshot(stageId, definitionId) {
     return {
         stage_id: stageId,
         status: "pending",
@@ -6,5 +6,6 @@ export function syntheticPendingSnapshot(stageId) {
         envelope: null,
         artifacts: [],
         attempt_count: 1,
+        ...(definitionId !== undefined ? { definition_id: definitionId } : {}),
     };
 }

package/dist/runstore/trackProjection.js

@@ -1,10 +1,14 @@
-import { linearCompatDagSnapshot } from "./pipelineDagSnapshot.js";
+import { instancesOfDefinition, linearCompatDagSnapshot, } from "./pipelineDagSnapshot.js";
 function stageStarted(stage) {
     return stage.events.some((e) => e.event === "started" || e.event === "resumed");
 }
 function runHalted(stages) {
     return stages.some((s) => s.status === "failed");
 }
+function predecessorIds(dag, needs) {
+    const preds = instancesOfDefinition(dag, needs);
+    return preds.length > 0 ? preds : [needs];
+}
 function computeLayers(dag) {
     const layers = new Map();
     const nodeById = new Map(dag.nodes.map((n) => [n.id, n]));
@@ -17,7 +21,8 @@ function computeLayers(dag) {
             layers.set(id, 0);
             return 0;
         }
-        const l = layerFor(node.needs) + 1;
+        const fromIds = predecessorIds(dag, node.needs);
+        const l = Math.max(...fromIds.map(layerFor)) + 1;
         layers.set(id, l);
         return l;
     }
@@ -32,6 +37,8 @@ function deriveReadiness(stage, dag, snapshotsById, halted) {
         return { readiness: "succeeded" };
     if (status === "failed")
         return { readiness: "failed" };
+    if (status === "skipped")
+        return { readiness: "skipped" };
     if (status === "running")
         return { readiness: "running" };
     if (status === "waiting_for_input")
@@ -42,9 +49,13 @@ function deriveReadiness(stage, dag, snapshotsById, halted) {
     const node = dag.nodes.find((n) => n.id === stage.stage_id);
     const need = node?.needs;
     if (need) {
-        const predecessor = snapshotsById.get(need);
-        if (!predecessor || predecessor.status !== "succeeded") {
-            return { readiness: "blocked", blocked_by: [need] };
+        const fromIds = predecessorIds(dag, need);
+        const unresolved = fromIds.filter((id) => {
+            const predecessor = snapshotsById.get(id);
+            return !predecessor || predecessor.status !== "succeeded";
+        });
+        if (unresolved.length > 0) {
+            return { readiness: "blocked", blocked_by: unresolved };
         }
     }
     return { readiness: "ready" };
@@ -63,6 +74,7 @@ export function buildPipelineTrack(input) {
         }
         const node = dag.nodes.find((n) => n.id === stageId);
         const { readiness, blocked_by } = deriveReadiness(stage, dag, snapshotsById, halted);
+        const definitionId = node?.definition_id ?? stage.definition_id ?? stageId;
         const trackNode = {
             stage_id: stageId,
             status: stage.status,
@@ -70,10 +82,11 @@ export function buildPipelineTrack(input) {
             layer: layers.get(stageId) ?? 0,
             layer_order: node?.stageIndex ?? dag.stage_ids.indexOf(stageId),
             attempt_count: stage.attempt_count,
+            definition_id: definitionId,
         };
         if (blocked_by?.length)
             trackNode.blocked_by = blocked_by;
-        const gateKinds = dag.gate_kinds?.[stageId];
+        const gateKinds = dag.gate_kinds?.[definitionId] ?? dag.gate_kinds?.[stageId];
         if (gateKinds?.length)
             trackNode.gate_kinds = gateKinds;
         return trackNode;
@@ -82,13 +95,16 @@ export function buildPipelineTrack(input) {
     for (const node of dag.nodes) {
         if (!node.needs)
             continue;
-        const fromStage = snapshotsById.get(node.needs);
-        const edge = { from: node.needs, to: node.id };
-        if (fromStage?.status === "succeeded" &&
-            fromStage.envelope?.summary) {
-            edge.envelope_summary = fromStage.envelope.summary;
+        const fromIds = predecessorIds(dag, node.needs);
+        for (const fromId of fromIds) {
+            const fromStage = snapshotsById.get(fromId);
+            const edge = { from: fromId, to: node.id };
+            if (fromStage?.status === "succeeded" &&
+                fromStage.envelope?.summary) {
+                edge.envelope_summary = fromStage.envelope.summary;
+            }
+            edges.push(edge);
         }
-        edges.push(edge);
     }
     return { nodes, edges };
 }

package/dist/runstore/workspaceLayout.d.ts

@@ -1,4 +1,5 @@
 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 attemptEnvelopePath(workspaceDir: string, stageId: string, attempt: number): string;

package/dist/runstore/workspaceLayout.js

@@ -1,7 +1,7 @@
 import { access, lstat, mkdir, readdir, realpath } from "node:fs/promises";
 import path from "node:path";
 export { stageDir } from "./paths.js";
-function guardStageId(stageId) {
+export function guardStageId(stageId) {
     if (stageId.includes("..") ||
         stageId.includes("/") ||
         stageId.includes("\\")) {

package/dist/runtime/cloneSchedule.d.ts

@@ -0,0 +1,18 @@
+import type { RunPipelineDagSnapshot } 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 isCloneInstance(dag: ResolvedPipelineDag, stageId: string): boolean;
+export declare function sequentialLaterCloneIds(dag: ResolvedPipelineDag, stageId: string, completedEnvelopes: Map<string, StageEnvelope>): string[];
+export declare function cloneFanoutConflict(dag: ResolvedPipelineDag, envelope: StageEnvelope): string | undefined;
+export declare function protectedClonableChildIds(dag: ResolvedPipelineDag, predecessorId: string, envelope: StageEnvelope): Set<string>;
+export declare function cloneRetryDownstream(dag: ResolvedPipelineDag, stageIds: string[]): Set<string>;
+export declare function cloneFailureContinuesSchedule(dag: ResolvedPipelineDag, stageId: string, completedEnvelopes: Map<string, StageEnvelope>): boolean;
+export declare function cloneFailFastSkipIds(dag: ResolvedPipelineDag, stageId: string, completedEnvelopes: Map<string, StageEnvelope>): string[];
+export declare function cloneScheduleAllowsRun(dag: ResolvedPipelineDag, stageId: string, states: Map<string, StageScheduleState>, completedEnvelopes: Map<string, StageEnvelope>): boolean;
+export type ApplyCloneForksResult = {
+    dag: RunPipelineDagSnapshot;
+    skippedIds: string[];
+};
+export declare function applyCloneForksToSchedule(dag: ResolvedPipelineDag, predecessorId: string, envelope: StageEnvelope, states: Map<string, StageScheduleState>): ApplyCloneForksResult;
+export declare function applyCloneForksFromEnvelopes(dag: ResolvedPipelineDag, states: Map<string, StageScheduleState>, completedEnvelopes: Map<string, StageEnvelope>): ApplyCloneForksResult;