stageflow 0.9.0 → 0.12.0

package/dist/runstore/port.d.ts

@@ -1,12 +1,14 @@
 import type { StageLogLine } from "../agent/activity.js";
 import type { AskOperatorPrompt } from "../tools/askOperator.js";
 import type { StageEnvelope } from "../types/envelope.js";
-import type { ResolvedPipelineDag } from "../types/pipeline.js";
+import type { FeedbackLoopConfig, ResolvedPipelineDag } from "../types/pipeline.js";
+import type { CompletionCheck } from "../types/completion.js";
 import type { StageGateKind } from "../types/stage.js";
 export type RunStatus = "created" | "running" | "succeeded" | "failed";
 export type RunPipelineDagSnapshot = ResolvedPipelineDag & {
     stage_ids: string[];
     gate_kinds?: Record<string, StageGateKind[]>;
+    clone_input_schema?: Record<string, unknown>;
 };
 export type StageReadiness = "blocked" | "ready" | "running" | "waiting" | "succeeded" | "failed" | "skipped";
 export type PipelineTrackNode = {
@@ -19,6 +21,9 @@ export type PipelineTrackNode = {
     gate_kinds?: StageGateKind[];
     attempt_count?: number;
     definition_id?: string;
+    feedback_loop?: {
+        target: string;
+    };
 };
 export type PipelineTrackEdge = {
     from: string;
@@ -70,16 +75,145 @@ export type StageExecution = {
     stage_id: string;
     attempt: number;
     status: StageSnapshot["status"];
+    verification_outcome: VerificationOutcome;
     started_at?: string;
     finished_at?: string;
     envelope: StageEnvelope | null;
 };
 export type StageExecutionPatch = {
     status?: StageSnapshot["status"];
+    verification_outcome?: VerificationOutcome;
     started_at?: string;
     finished_at?: string;
     envelope?: StageEnvelope | null;
 };
+/** The durable disposition of completion verification for one stage attempt. */
+export type VerificationOutcome = "not_run" | "passed" | "failed" | "error";
+/** The lifecycle state of one independently-run completion check. */
+export type VerificationCheckStatus = "pending" | "running" | "passed" | "failed" | "skipped";
+/**
+ * Durable evidence for one check in one stage execution attempt.
+ *
+ * `evidence` is intentionally JSON-shaped: each checker owns its evidence
+ * schema (for example, command output metadata or an artifact digest), while
+ * the run store preserves it without privileging a particular checker.
+ */
+export type VerificationCheckResult = {
+    run_id: string;
+    stage_id: string;
+    attempt: number;
+    check_id: string;
+    check_type: CompletionCheck["type"];
+    status: VerificationCheckStatus;
+    started_at?: string;
+    finished_at?: string;
+    evidence?: Record<string, unknown>;
+};
+/** Input for creating or updating a verification-check lifecycle record. */
+export type VerificationCheckResultPatch = {
+    check_id: string;
+    check_type: CompletionCheck["type"];
+    status: VerificationCheckStatus;
+    started_at?: string;
+    finished_at?: string;
+    evidence?: Record<string, unknown>;
+};
+/** Durable lifecycle for one source-owned feedback-loop policy in a run. */
+export type FeedbackLoopState = "active" | "waiting_for_human" | "continued" | "abandoned" | "completed";
+/** Durable lifecycle for one accepted send-back through a feedback loop. */
+export type FeedbackReplayStatus = "scheduled" | "active" | "waiting_for_human" | "completed" | "failed" | "superseded";
+/** Lifecycle for one persistent stage's pass within a feedback replay. */
+export type FeedbackReplayStagePassStatus = "pending" | "running" | "waiting" | "succeeded" | "failed" | "superseded";
+/** Active/history state for a dynamic clone cohort created by a fork parent. */
+export type ForkGenerationStatus = "active" | "completed" | "superseded";
+/** Deferred over-limit send_back awaiting a human feedback-loop decision. */
+export type DeferredFeedbackSendBack = {
+    target: string;
+    feedback_envelope: StageEnvelope;
+    source_attempt: number;
+};
+export type FeedbackLoopRecord = {
+    run_id: string;
+    loop_id: string;
+    source_stage_id: string;
+    source_attempt: number;
+    policy: FeedbackLoopConfig;
+    state: FeedbackLoopState;
+    current_replay_id?: string;
+    current_replay_number?: number;
+    deferred_send_back?: DeferredFeedbackSendBack;
+    created_at: string;
+    updated_at: string;
+};
+export type FeedbackReplayRecord = {
+    run_id: string;
+    replay_id: string;
+    loop_id: string;
+    source_stage_id: string;
+    source_attempt: number;
+    target_stage_id: string;
+    /** One-based accepted send-back count for this loop. */
+    replay_number: number;
+    max_replays: number;
+    replay_session: FeedbackLoopConfig["replay_session"];
+    route_stage_ids: string[];
+    feedback_envelope: StageEnvelope;
+    status: FeedbackReplayStatus;
+    created_at: string;
+    updated_at: string;
+};
+export type FeedbackReplayStagePassRecord = {
+    run_id: string;
+    replay_id: string;
+    stage_id: string;
+    /** Execution attempt whose session this pass resumes or newly creates. */
+    stage_attempt: number;
+    /** Immutable attempt whose Pi session resume targets; never rebound. */
+    session_origin_attempt?: number;
+    session_mode: FeedbackLoopConfig["replay_session"];
+    status: FeedbackReplayStagePassStatus;
+    started_at?: string;
+    finished_at?: string;
+    emitted_envelope?: StageEnvelope;
+};
+export type ForkGenerationRecord = {
+    run_id: string;
+    generation_id: string;
+    /** Undefined for an initial fan-out that is not part of a replay. */
+    replay_id?: string;
+    fork_parent_stage_id: string;
+    generation_number: number;
+    clone_stage_ids: string[];
+    status: ForkGenerationStatus;
+    created_at: string;
+    updated_at: string;
+};
+export type CreateFeedbackLoopInput = Omit<FeedbackLoopRecord, "run_id" | "state" | "current_replay_id" | "current_replay_number" | "created_at" | "updated_at"> & {
+    state?: FeedbackLoopState;
+};
+export type FeedbackLoopPatch = Partial<Pick<FeedbackLoopRecord, "state" | "current_replay_id" | "current_replay_number" | "policy">> & {
+    /** Set to clear a previously deferred send_back. */
+    deferred_send_back?: DeferredFeedbackSendBack | null;
+};
+export type CreateFeedbackReplayInput = Omit<FeedbackReplayRecord, "run_id" | "status" | "created_at" | "updated_at"> & {
+    status?: FeedbackReplayStatus;
+};
+export type FeedbackReplayPatch = Partial<Pick<FeedbackReplayRecord, "status">>;
+export type CreateFeedbackReplayStagePassInput = Omit<FeedbackReplayStagePassRecord, "run_id" | "status" | "started_at" | "finished_at" | "emitted_envelope"> & {
+    status?: FeedbackReplayStagePassStatus;
+    started_at?: string;
+    finished_at?: string;
+    emitted_envelope?: StageEnvelope;
+};
+export type FeedbackReplayStagePassPatch = Partial<Pick<FeedbackReplayStagePassRecord, "status" | "stage_attempt">> & {
+    started_at?: string | null;
+    finished_at?: string | null;
+    emitted_envelope?: StageEnvelope | null;
+};
+export type CreateForkGenerationInput = Omit<ForkGenerationRecord, "run_id" | "status" | "created_at" | "updated_at"> & {
+    status?: ForkGenerationStatus;
+};
+export type ForkGenerationPatch = Partial<Pick<ForkGenerationRecord, "status">>;
 export type CompactStage = {
     id: string;
     status: StageSnapshot["status"];
@@ -103,17 +237,31 @@ export type RunSummary = {
     waiting_stage_ids?: string[];
     /** Short prompt text for Today triage; omitted when not waiting. */
     waiting_summary?: string;
-    waiting_kind?: AskOperatorPrompt["kind"];
+    waiting_kind?: AskOperatorPrompt["kind"] | "feedback_loop_decision";
     waiting_prompt_id?: string;
     waiting_artifacts?: string[];
     waiting_questions?: string[];
     failed_stage_id?: string;
     failed_reason?: string;
+    /** The active loop, when a run is currently replaying or awaiting a decision. */
+    active_feedback_loop?: FeedbackLoopRecord;
 };
 export type RunDetail = Omit<RunSummary, "stages"> & {
     task_yaml: string;
     stages: StageSnapshot[];
     pipeline_track: PipelineTrackProjection;
+    /** Append-only feedback-loop and replay history, ordered by creation. */
+    feedback_loops: FeedbackLoopHistory[];
+};
+export type FeedbackLoopHistory = {
+    loop: FeedbackLoopRecord;
+    replays: Array<{
+        replay: FeedbackReplayRecord;
+        stage_passes: FeedbackReplayStagePassRecord[];
+        fork_generations: ForkGenerationRecord[];
+    }>;
+    /** Fork cohorts not associated with a replay, for example the first pass. */
+    fork_generations: ForkGenerationRecord[];
 };
 export type CreateRunInput = {
     pipelineId: string;
@@ -156,6 +304,15 @@ export interface RunStore {
     countStageAttempts(runId: string, stageId: string): Promise<number>;
     getStageExecution(runId: string, stageId: string, attempt: number): Promise<StageExecution>;
     updateStageExecution(runId: string, stageId: string, attempt: number, patch: StageExecutionPatch): Promise<void>;
+    /** Create or update evidence for one check in a stage execution attempt. */
+    upsertVerificationCheckResult(runId: string, stageId: string, result: VerificationCheckResultPatch, options?: {
+        attempt?: number;
+    }): Promise<void>;
+    /**
+     * List verification evidence in write order. Without an attempt, returns all
+     * attempts for the stage; callers may pass an attempt to inspect one retry.
+     */
+    listVerificationCheckResults(runId: string, stageId: string, attempt?: number): Promise<VerificationCheckResult[]>;
     writeEnvelope(runId: string, stageId: string, envelope: StageEnvelope, options?: {
         attempt?: number;
     }): Promise<void>;
@@ -167,6 +324,31 @@ export interface RunStore {
     listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
     readRun(runId: string): Promise<RunDetail>;
     updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
+    createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;
+    getFeedbackLoop(runId: string, loopId: string): Promise<FeedbackLoopRecord>;
+    listFeedbackLoops(runId: string): Promise<FeedbackLoopRecord[]>;
+    /**
+     * Patch a feedback loop. When `expectedState` is set, the update is conditional
+     * (CAS): returns false if the row exists but state does not match.
+     * Throws if the loop is missing.
+     */
+    updateFeedbackLoop(runId: string, loopId: string, patch: FeedbackLoopPatch, options?: {
+        expectedState?: FeedbackLoopState;
+    }): Promise<boolean>;
+    createFeedbackReplay(runId: string, input: CreateFeedbackReplayInput): Promise<FeedbackReplayRecord>;
+    getFeedbackReplay(runId: string, replayId: string): Promise<FeedbackReplayRecord>;
+    listFeedbackReplays(runId: string, loopId: string): Promise<FeedbackReplayRecord[]>;
+    updateFeedbackReplay(runId: string, replayId: string, patch: FeedbackReplayPatch): Promise<void>;
+    createFeedbackReplayStagePass(runId: string, input: CreateFeedbackReplayStagePassInput): Promise<FeedbackReplayStagePassRecord>;
+    listFeedbackReplayStagePasses(runId: string, replayId: string): Promise<FeedbackReplayStagePassRecord[]>;
+    updateFeedbackReplayStagePass(runId: string, replayId: string, stageId: string, patch: FeedbackReplayStagePassPatch): Promise<void>;
+    createForkGeneration(runId: string, input: CreateForkGenerationInput): Promise<ForkGenerationRecord>;
+    listForkGenerations(runId: string, options?: {
+        replayId?: string;
+        forkParentStageId?: string;
+    }): Promise<ForkGenerationRecord[]>;
+    updateForkGeneration(runId: string, generationId: string, patch: ForkGenerationPatch): Promise<void>;
 }
 export declare function stageStatusFromEvents(events: StageLogEvent[]): StageSnapshot["status"];
-export declare function deriveStatusFromStages(stages: StageSnapshot[]): RunStatus;
+export declare function findUnhandledFailedStage(stages: StageSnapshot[], dag?: Pick<RunPipelineDagSnapshot, "nodes"> | null): StageSnapshot | undefined;
+export declare function deriveStatusFromStages(stages: StageSnapshot[], dag?: Pick<RunPipelineDagSnapshot, "nodes"> | null): RunStatus;

package/dist/runstore/port.js

@@ -1,3 +1,4 @@
+import { predecessorEdges } from "../config/pipelineNeeds.js";
 export function stageStatusFromEvents(events) {
     let status = "pending";
     for (const ev of events) {
@@ -14,12 +15,50 @@ export function stageStatusFromEvents(events) {
     }
     return status;
 }
-export function deriveStatusFromStages(stages) {
+function definitionIdForStage(dag, stageId, snapshotsById) {
+    const snap = snapshotsById.get(stageId);
+    if (snap?.definition_id)
+        return snap.definition_id;
+    const node = dag.nodes.find((n) => n.id === stageId);
+    return node?.definition_id ?? stageId;
+}
+function failureAcceptedByJoin(dag, failedId, snapshotsById) {
+    const defId = definitionIdForStage(dag, failedId, snapshotsById);
+    for (const node of dag.nodes) {
+        const edge = predecessorEdges(node).find((item) => item.id === failedId || item.id === defId);
+        if (!edge?.on.includes("failed"))
+            continue;
+        const join = snapshotsById.get(node.id);
+        if (join && join.status !== "skipped")
+            return true;
+    }
+    return false;
+}
+export function findUnhandledFailedStage(stages, dag) {
+    const byId = new Map(stages.map((s) => [s.stage_id, s]));
+    return stages.find((stage) => {
+        if (stage.status !== "failed")
+            return false;
+        if (!dag)
+            return true;
+        return !failureAcceptedByJoin(dag, stage.stage_id, byId);
+    });
+}
+function stageResolvedForSuccess(stage, dag, byId) {
+    if (stage.status === "succeeded" || stage.status === "skipped")
+        return true;
+    if (stage.status === "failed" && dag) {
+        return failureAcceptedByJoin(dag, stage.stage_id, byId);
+    }
+    return false;
+}
+export function deriveStatusFromStages(stages, dag) {
     if (stages.length === 0)
         return "created";
-    if (stages.some((s) => s.status === "failed"))
+    if (findUnhandledFailedStage(stages, dag))
         return "failed";
-    if (stages.every((s) => s.status === "succeeded" || s.status === "skipped")) {
+    const byId = new Map(stages.map((s) => [s.stage_id, s]));
+    if (stages.every((s) => stageResolvedForSuccess(s, dag, byId))) {
         return "succeeded";
     }
     if (stages.some((s) => s.status === "running" ||

package/dist/runstore/runProjection.d.ts

@@ -1,6 +1,10 @@
-import type { RunDetail, RunMeta, RunPipelineDagSnapshot, RunSummary, StageSnapshot } from "./port.js";
+import type { FeedbackLoopHistory, FeedbackLoopRecord, RunDetail, RunMeta, RunPipelineDagSnapshot, RunSummary, StageSnapshot } from "./port.js";
 export { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
+export type FeedbackProjectionInput = {
+    feedback_loops?: FeedbackLoopHistory[];
+    active_feedback_loop?: FeedbackLoopRecord;
+};
 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;
+export declare function projectRunSummary(meta: RunMeta, stages: StageSnapshot[], feedback?: Pick<FeedbackProjectionInput, "active_feedback_loop">): RunSummary;
+export declare function projectRunDetail(meta: RunMeta, stages: StageSnapshot[], task_yaml: string, dagSnapshot?: RunPipelineDagSnapshot | null, feedback?: FeedbackProjectionInput): RunDetail;

package/dist/runstore/runProjection.js

@@ -1,4 +1,4 @@
-import { deriveStatusFromStages } from "./port.js";
+import { deriveStatusFromStages, findUnhandledFailedStage } from "./port.js";
 import { linearCompatDagSnapshot } from "./pipelineDagSnapshot.js";
 import { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
 import { buildPipelineTrack } from "./trackProjection.js";
@@ -61,8 +61,8 @@ function waitingFieldsFromStages(stages) {
     }
     return fields;
 }
-function failedFieldsFromStages(stages) {
-    const failed = stages.find((s) => s.status === "failed");
+function failedFieldsFromStages(stages, dag) {
+    const failed = findUnhandledFailedStage(stages, dag);
     if (!failed)
         return {};
     let failed_reason;
@@ -75,10 +75,10 @@ function failedFieldsFromStages(stages) {
         ...(failed_reason !== undefined ? { failed_reason } : {}),
     };
 }
-function resolveListedStatus(stages, meta) {
+function resolveListedStatus(stages, meta, dag) {
     if (stages.length === 0)
         return meta.status ?? "created";
-    const derived = deriveStatusFromStages(stages);
+    const derived = deriveStatusFromStages(stages, dag);
     if (meta.status === "succeeded" && derived === "running") {
         const hasActiveStage = stages.some((s) => s.status === "running" || s.status === "waiting_for_input");
         if (!hasActiveStage)
@@ -86,7 +86,18 @@ function resolveListedStatus(stages, meta) {
     }
     return derived;
 }
-export function projectRunSummary(meta, stages) {
+export function projectRunSummary(meta, stages, feedback) {
+    const dag = meta.pipeline_dag;
+    const waiting = waitingFieldsFromStages(stages);
+    if (feedback?.active_feedback_loop?.state === "waiting_for_human" &&
+        waiting.waiting_stage_id !== undefined &&
+        waiting.waiting_kind === undefined) {
+        waiting.waiting_kind = "feedback_loop_decision";
+        if (waiting.waiting_summary === undefined || waiting.waiting_summary === "Waiting for input") {
+            waiting.waiting_summary =
+                "Feedback loop limit reached — extend, continue, or abandon";
+        }
+    }
     return {
         run_id: meta.run_id,
         pipeline_id: meta.pipeline_id,
@@ -94,21 +105,24 @@ export function projectRunSummary(meta, stages) {
         ...(meta.pipeline_path !== undefined ? { pipeline_path: meta.pipeline_path } : {}),
         ...(meta.task_path !== undefined ? { task_path: meta.task_path } : {}),
         ...(meta.project_root !== undefined ? { project_root: meta.project_root } : {}),
-        status: resolveListedStatus(stages, meta),
+        status: resolveListedStatus(stages, meta, dag),
         created_at: meta.created_at,
         updated_at: meta.updated_at,
         stages: compactStages(stages),
-        ...waitingFieldsFromStages(stages),
-        ...failedFieldsFromStages(stages),
+        ...waiting,
+        ...failedFieldsFromStages(stages, dag),
+        ...(feedback?.active_feedback_loop !== undefined
+            ? { active_feedback_loop: feedback.active_feedback_loop }
+            : {}),
     };
 }
-export function projectRunDetail(meta, stages, task_yaml, dagSnapshot) {
-    const ordered = dagSnapshot
-        ? overlayPlannedStages(dagSnapshot.stage_ids, stages, dagSnapshot)
+export function projectRunDetail(meta, stages, task_yaml, dagSnapshot, feedback) {
+    const dag = dagSnapshot ?? meta.pipeline_dag ?? null;
+    const ordered = dag
+        ? overlayPlannedStages(dag.stage_ids, stages, dag)
         : stages;
-    const summary = projectRunSummary(meta, ordered);
-    const snapshot = dagSnapshot ??
-        linearCompatDagSnapshot(ordered.map((s) => s.stage_id));
+    const summary = projectRunSummary(dag ? { ...meta, pipeline_dag: dag } : meta, ordered, { active_feedback_loop: feedback?.active_feedback_loop });
+    const snapshot = dag ?? linearCompatDagSnapshot(ordered.map((s) => s.stage_id));
     const pipeline_track = buildPipelineTrack({
         dagSnapshot: snapshot,
         stages: ordered,
@@ -119,5 +133,6 @@ export function projectRunDetail(meta, stages, task_yaml, dagSnapshot) {
         task_yaml,
         stages: ordered,
         pipeline_track,
+        feedback_loops: feedback?.feedback_loops ?? [],
     };
 }

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 ListRunsFilter, type RunDetail, type RunMeta, type RunPipelineDagSnapshot, type RunStatus, type RunStore, type RunSummary, type StageExecution, type StageExecutionPatch, type StageLogEvent } from "../port.js";
+import { type CreateFeedbackLoopInput, type CreateFeedbackReplayInput, type CreateFeedbackReplayStagePassInput, type CreateForkGenerationInput, type CreateRunInput, type CreatedRun, type FeedbackLoopPatch, type FeedbackLoopRecord, type FeedbackLoopState, type FeedbackReplayPatch, type FeedbackReplayRecord, type FeedbackReplayStagePassPatch, type FeedbackReplayStagePassRecord, type ForkGenerationPatch, type ForkGenerationRecord, type ListRunsFilter, type RunDetail, type RunMeta, type RunPipelineDagSnapshot, type RunStatus, type RunStore, type RunSummary, type StageExecution, type StageExecutionPatch, type StageLogEvent, type VerificationCheckResult, type VerificationCheckResultPatch } from "../port.js";
 export declare class SqliteRunStore implements RunStore {
     private readonly storeRoot;
     private readonly db;
@@ -22,6 +22,10 @@ export declare class SqliteRunStore implements RunStore {
     countStageAttempts(runId: string, stageId: string): Promise<number>;
     getStageExecution(runId: string, stageId: string, attempt: number): Promise<StageExecution>;
     updateStageExecution(runId: string, stageId: string, attempt: number, patch: StageExecutionPatch): Promise<void>;
+    upsertVerificationCheckResult(runId: string, stageId: string, result: VerificationCheckResultPatch, options?: {
+        attempt?: number;
+    }): Promise<void>;
+    listVerificationCheckResults(runId: string, stageId: string, attempt?: number): Promise<VerificationCheckResult[]>;
     writeEnvelope(runId: string, stageId: string, envelope: StageEnvelope, options?: {
         attempt?: number;
     }): Promise<void>;
@@ -40,6 +44,26 @@ export declare class SqliteRunStore implements RunStore {
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
     listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
     readRun(runId: string): Promise<RunDetail>;
+    createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;
+    getFeedbackLoop(runId: string, loopId: string): Promise<FeedbackLoopRecord>;
+    listFeedbackLoops(runId: string): Promise<FeedbackLoopRecord[]>;
+    updateFeedbackLoop(runId: string, loopId: string, patch: FeedbackLoopPatch, options?: {
+        expectedState?: FeedbackLoopState;
+    }): Promise<boolean>;
+    createFeedbackReplay(runId: string, input: CreateFeedbackReplayInput): Promise<FeedbackReplayRecord>;
+    getFeedbackReplay(runId: string, replayId: string): Promise<FeedbackReplayRecord>;
+    listFeedbackReplays(runId: string, loopId: string): Promise<FeedbackReplayRecord[]>;
+    updateFeedbackReplay(runId: string, replayId: string, patch: FeedbackReplayPatch): Promise<void>;
+    createFeedbackReplayStagePass(runId: string, input: CreateFeedbackReplayStagePassInput): Promise<FeedbackReplayStagePassRecord>;
+    listFeedbackReplayStagePasses(runId: string, replayId: string): Promise<FeedbackReplayStagePassRecord[]>;
+    updateFeedbackReplayStagePass(runId: string, replayId: string, stageId: string, patch: FeedbackReplayStagePassPatch): Promise<void>;
+    createForkGeneration(runId: string, input: CreateForkGenerationInput): Promise<ForkGenerationRecord>;
+    listForkGenerations(runId: string, options?: {
+        replayId?: string;
+        forkParentStageId?: string;
+    }): Promise<ForkGenerationRecord[]>;
+    updateForkGeneration(runId: string, generationId: string, patch: ForkGenerationPatch): Promise<void>;
+    private loadFeedbackLoopHistory;
     private readPipelineDagSnapshotFromRow;
     private runMetaFromRow;
     private getRunRow;