stageflow 0.8.0 → 0.12.0

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -59,6 +59,7 @@ CREATE TABLE IF NOT EXISTS stage_executions (
   stage_id TEXT NOT NULL,
   attempt INTEGER NOT NULL,
   status TEXT NOT NULL,
+  verification_outcome TEXT NOT NULL DEFAULT 'not_run',
   started_at TEXT,
   finished_at TEXT,
   envelope_json TEXT,
@@ -69,6 +70,46 @@ CREATE INDEX IF NOT EXISTS idx_stage_executions_run_stage
   ON stage_executions (run_id, stage_id, attempt);
 `);
 }
+function ensureStageExecutionVerificationOutcomeColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(stage_executions)`)
+        .all();
+    if (!cols.some((c) => c.name === "verification_outcome")) {
+        db.exec(`ALTER TABLE stage_executions ADD COLUMN verification_outcome TEXT NOT NULL DEFAULT 'not_run'`);
+    }
+}
+function backfillVerificationOutcomes(db) {
+    db.exec(`
+UPDATE stage_executions
+SET verification_outcome = CASE
+  WHEN status = 'succeeded'
+    AND EXISTS (
+      SELECT 1 FROM verification_check_results AS check_result
+      WHERE check_result.run_id = stage_executions.run_id
+        AND check_result.stage_id = stage_executions.stage_id
+        AND check_result.attempt = stage_executions.attempt
+    )
+    AND NOT EXISTS (
+      SELECT 1 FROM verification_check_results AS check_result
+      WHERE check_result.run_id = stage_executions.run_id
+        AND check_result.stage_id = stage_executions.stage_id
+        AND check_result.attempt = stage_executions.attempt
+        AND check_result.status != 'passed'
+    )
+    THEN 'passed'
+  WHEN status = 'failed'
+    AND EXISTS (
+      SELECT 1 FROM verification_check_results AS check_result
+      WHERE check_result.run_id = stage_executions.run_id
+        AND check_result.stage_id = stage_executions.stage_id
+        AND check_result.attempt = stage_executions.attempt
+    )
+    THEN 'failed'
+  ELSE verification_outcome
+END
+WHERE verification_outcome = 'not_run';
+`);
+}
 function ensureStageEventsAttemptColumn(db) {
     const cols = db
         .prepare(`PRAGMA table_info(stage_events)`)
@@ -81,12 +122,63 @@ CREATE INDEX IF NOT EXISTS idx_stage_events_run_stage_attempt_at
 `);
     }
 }
+function ensureVerificationCheckResultsTable(db) {
+    db.exec(`
+CREATE TABLE IF NOT EXISTS verification_check_results (
+  run_id TEXT NOT NULL,
+  stage_id TEXT NOT NULL,
+  attempt INTEGER NOT NULL,
+  check_id TEXT NOT NULL,
+  check_type TEXT NOT NULL,
+  status TEXT NOT NULL,
+  started_at TEXT,
+  finished_at TEXT,
+  evidence_json TEXT,
+  PRIMARY KEY (run_id, stage_id, attempt, check_id),
+  FOREIGN KEY (run_id, stage_id, attempt)
+    REFERENCES stage_executions(run_id, stage_id, attempt)
+);
+CREATE INDEX IF NOT EXISTS idx_verification_check_results_execution
+  ON verification_check_results (run_id, stage_id, attempt, check_id);
+`);
+}
+function ensureFeedbackReplayStagePassEnvelopeColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(feedback_replay_stage_passes)`)
+        .all();
+    if (cols.length === 0)
+        return;
+    if (!cols.some((c) => c.name === "emitted_envelope_json")) {
+        db.exec(`ALTER TABLE feedback_replay_stage_passes ADD COLUMN emitted_envelope_json TEXT`);
+    }
+}
+function ensureFeedbackReplayStagePassSessionOriginColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(feedback_replay_stage_passes)`)
+        .all();
+    if (cols.length === 0)
+        return;
+    if (!cols.some((c) => c.name === "session_origin_attempt")) {
+        db.exec(`ALTER TABLE feedback_replay_stage_passes ADD COLUMN session_origin_attempt INTEGER`);
+    }
+}
+function ensureFeedbackLoopDeferredSendBackColumn(db) {
+    const cols = db
+        .prepare(`PRAGMA table_info(feedback_loops)`)
+        .all();
+    if (cols.length === 0)
+        return;
+    if (!cols.some((c) => c.name === "deferred_send_back_json")) {
+        db.exec(`ALTER TABLE feedback_loops ADD COLUMN deferred_send_back_json TEXT`);
+    }
+}
 function executionFromRow(row) {
     return {
         run_id: row.run_id,
         stage_id: row.stage_id,
         attempt: row.attempt,
         status: row.status,
+        verification_outcome: row.verification_outcome ?? "not_run",
         ...(row.started_at != null ? { started_at: row.started_at } : {}),
         ...(row.finished_at != null ? { finished_at: row.finished_at } : {}),
         envelope: row.envelope_json
@@ -94,6 +186,95 @@ function executionFromRow(row) {
             : null,
     };
 }
+function verificationCheckResultFromRow(row) {
+    return {
+        run_id: row.run_id,
+        stage_id: row.stage_id,
+        attempt: row.attempt,
+        check_id: row.check_id,
+        check_type: row.check_type,
+        status: row.status,
+        ...(row.started_at != null ? { started_at: row.started_at } : {}),
+        ...(row.finished_at != null ? { finished_at: row.finished_at } : {}),
+        ...(row.evidence_json != null
+            ? { evidence: JSON.parse(row.evidence_json) }
+            : {}),
+    };
+}
+function feedbackLoopFromRow(row) {
+    return {
+        run_id: row.run_id,
+        loop_id: row.loop_id,
+        source_stage_id: row.source_stage_id,
+        source_attempt: row.source_attempt,
+        policy: JSON.parse(row.policy_json),
+        state: row.state,
+        ...(row.current_replay_id != null
+            ? { current_replay_id: row.current_replay_id }
+            : {}),
+        ...(row.current_replay_number != null
+            ? { current_replay_number: row.current_replay_number }
+            : {}),
+        ...(row.deferred_send_back_json != null
+            ? {
+                deferred_send_back: JSON.parse(row.deferred_send_back_json),
+            }
+            : {}),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+function feedbackReplayFromRow(row) {
+    return {
+        run_id: row.run_id,
+        replay_id: row.replay_id,
+        loop_id: row.loop_id,
+        source_stage_id: row.source_stage_id,
+        source_attempt: row.source_attempt,
+        target_stage_id: row.target_stage_id,
+        replay_number: row.replay_number,
+        max_replays: row.max_replays,
+        replay_session: row.replay_session,
+        route_stage_ids: JSON.parse(row.route_stage_ids_json),
+        feedback_envelope: JSON.parse(row.feedback_envelope_json),
+        status: row.status,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+function feedbackReplayStagePassFromRow(row) {
+    return {
+        run_id: row.run_id,
+        replay_id: row.replay_id,
+        stage_id: row.stage_id,
+        stage_attempt: row.stage_attempt,
+        ...(row.session_origin_attempt != null
+            ? { session_origin_attempt: row.session_origin_attempt }
+            : {}),
+        session_mode: row.session_mode,
+        status: row.status,
+        ...(row.started_at != null ? { started_at: row.started_at } : {}),
+        ...(row.finished_at != null ? { finished_at: row.finished_at } : {}),
+        ...(row.emitted_envelope_json != null
+            ? {
+                emitted_envelope: JSON.parse(row.emitted_envelope_json),
+            }
+            : {}),
+    };
+}
+function forkGenerationFromRow(row) {
+    return {
+        run_id: row.run_id,
+        generation_id: row.generation_id,
+        ...(row.replay_id != null ? { replay_id: row.replay_id } : {}),
+        fork_parent_stage_id: row.fork_parent_stage_id,
+        generation_number: row.generation_number,
+        clone_stage_ids: JSON.parse(row.clone_stage_ids_json),
+        status: row.status,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
 export class SqliteRunStore {
     storeRoot;
     db;
@@ -110,7 +291,13 @@ export class SqliteRunStore {
         ensurePipelineDagColumn(this.db);
         ensureRunLocatorColumns(this.db);
         ensureStageExecutionsTable(this.db);
+        ensureStageExecutionVerificationOutcomeColumn(this.db);
         ensureStageEventsAttemptColumn(this.db);
+        ensureVerificationCheckResultsTable(this.db);
+        ensureFeedbackReplayStagePassEnvelopeColumn(this.db);
+        ensureFeedbackReplayStagePassSessionOriginColumn(this.db);
+        ensureFeedbackLoopDeferredSendBackColumn(this.db);
+        backfillVerificationOutcomes(this.db);
         this.migratePromise = importDiskRunsIfEmpty(this.db, storeRoot).then(() => undefined);
     }
     /** Await one-shot disk import before catalog reads (create paths also wait). */
@@ -235,16 +422,17 @@ export class SqliteRunStore {
                 .get(runId, stageId);
             const attempt = (maxRow?.max_attempt ?? 0) + 1;
             this.db
-                .prepare(`INSERT INTO stage_executions (run_id, stage_id, attempt, status)
-           VALUES (@run_id, @stage_id, @attempt, @status)`)
+                .prepare(`INSERT INTO stage_executions (run_id, stage_id, attempt, status, verification_outcome)
+           VALUES (@run_id, @stage_id, @attempt, @status, @verification_outcome)`)
                 .run({
                 run_id: runId,
                 stage_id: stageId,
                 attempt,
                 status: "pending",
+                verification_outcome: "not_run",
             });
             const row = this.db
-                .prepare(`SELECT run_id, stage_id, attempt, status, started_at, finished_at, envelope_json
+                .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
            FROM stage_executions
            WHERE run_id = ? AND stage_id = ? AND attempt = ?`)
                 .get(runId, stageId, attempt);
@@ -254,7 +442,7 @@ export class SqliteRunStore {
     async listStageExecutions(runId, stageId) {
         await this.ready();
         const rows = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, started_at, finished_at, envelope_json
+            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ?
          ORDER BY attempt ASC`)
@@ -264,7 +452,7 @@ export class SqliteRunStore {
     async getLatestStageExecution(runId, stageId) {
         await this.ready();
         const row = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, started_at, finished_at, envelope_json
+            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ?
          ORDER BY attempt DESC
@@ -283,7 +471,7 @@ export class SqliteRunStore {
     async getStageExecution(runId, stageId, attempt) {
         await this.ready();
         const row = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, started_at, finished_at, envelope_json
+            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ? AND attempt = ?`)
             .get(runId, stageId, attempt);
@@ -304,6 +492,10 @@ export class SqliteRunStore {
             sets.push("status = @status");
             params.status = patch.status;
         }
+        if (patch.verification_outcome !== undefined) {
+            sets.push("verification_outcome = @verification_outcome");
+            params.verification_outcome = patch.verification_outcome;
+        }
         if (patch.started_at !== undefined) {
             sets.push("started_at = @started_at");
             params.started_at = patch.started_at;
@@ -327,6 +519,50 @@ export class SqliteRunStore {
             throw new Error(`Stage execution not found: ${runId}/${stageId} attempt ${attempt}`);
         }
     }
+    async upsertVerificationCheckResult(runId, stageId, result, options) {
+        await this.ready();
+        const attempt = options?.attempt ?? 1;
+        await this.getStageExecution(runId, stageId, attempt);
+        this.db
+            .prepare(`INSERT INTO verification_check_results
+          (run_id, stage_id, attempt, check_id, check_type, status, started_at, finished_at, evidence_json)
+         VALUES
+          (@run_id, @stage_id, @attempt, @check_id, @check_type, @status, @started_at, @finished_at, @evidence_json)
+         ON CONFLICT(run_id, stage_id, attempt, check_id) DO UPDATE SET
+          check_type = excluded.check_type,
+          status = excluded.status,
+          started_at = COALESCE(excluded.started_at, verification_check_results.started_at),
+          finished_at = COALESCE(excluded.finished_at, verification_check_results.finished_at),
+          evidence_json = COALESCE(excluded.evidence_json, verification_check_results.evidence_json)`)
+            .run({
+            run_id: runId,
+            stage_id: stageId,
+            attempt,
+            check_id: result.check_id,
+            check_type: result.check_type,
+            status: result.status,
+            started_at: result.started_at ?? null,
+            finished_at: result.finished_at ?? null,
+            evidence_json: result.evidence !== undefined ? JSON.stringify(result.evidence) : null,
+        });
+    }
+    async listVerificationCheckResults(runId, stageId, attempt) {
+        await this.ready();
+        const rows = attempt === undefined
+            ? this.db
+                .prepare(`SELECT run_id, stage_id, attempt, check_id, check_type, status, started_at, finished_at, evidence_json
+             FROM verification_check_results
+             WHERE run_id = ? AND stage_id = ?
+             ORDER BY attempt ASC, rowid ASC`)
+                .all(runId, stageId)
+            : this.db
+                .prepare(`SELECT run_id, stage_id, attempt, check_id, check_type, status, started_at, finished_at, evidence_json
+             FROM verification_check_results
+             WHERE run_id = ? AND stage_id = ? AND attempt = ?
+             ORDER BY rowid ASC`)
+                .all(runId, stageId, attempt);
+        return rows.map(verificationCheckResultFromRow);
+    }
     async writeEnvelope(runId, stageId, envelope, options) {
         const attempt = options?.attempt ?? 1;
         await this.ensureAttemptWorkspace(runId, stageId, attempt);
@@ -451,7 +687,10 @@ export class SqliteRunStore {
         for (const row of rows) {
             const dagSnapshot = this.readPipelineDagSnapshotFromRow(row);
             const stages = await this.loadStageSnapshots(row.run_id, dagSnapshot?.stage_ids);
-            summaries.push(projectRunSummary(this.runMetaFromRow(row), stages));
+            const { active } = await this.loadFeedbackLoopHistory(row.run_id);
+            summaries.push(projectRunSummary(this.runMetaFromRow(row), stages, {
+                active_feedback_loop: active,
+            }));
         }
         return summaries;
     }
@@ -460,7 +699,386 @@ export class SqliteRunStore {
         const row = this.getRunRow(runId);
         const dagSnapshot = this.readPipelineDagSnapshotFromRow(row);
         const stages = await this.loadStageSnapshots(runId, dagSnapshot?.stage_ids);
-        return projectRunDetail(this.runMetaFromRow(row), stages, row.task_yaml, dagSnapshot);
+        const { history, active } = await this.loadFeedbackLoopHistory(runId);
+        return projectRunDetail(this.runMetaFromRow(row), stages, row.task_yaml, dagSnapshot, {
+            feedback_loops: history,
+            active_feedback_loop: active,
+        });
+    }
+    async createFeedbackLoop(runId, input) {
+        await this.ready();
+        this.getRunRow(runId);
+        const now = new Date().toISOString();
+        const state = input.state ?? "active";
+        this.db
+            .prepare(`INSERT INTO feedback_loops
+          (run_id, loop_id, source_stage_id, source_attempt, policy_json, state,
+           current_replay_id, current_replay_number, created_at, updated_at)
+         VALUES
+          (@run_id, @loop_id, @source_stage_id, @source_attempt, @policy_json, @state,
+           NULL, NULL, @created_at, @updated_at)`)
+            .run({
+            run_id: runId,
+            loop_id: input.loop_id,
+            source_stage_id: input.source_stage_id,
+            source_attempt: input.source_attempt,
+            policy_json: JSON.stringify(input.policy),
+            state,
+            created_at: now,
+            updated_at: now,
+        });
+        return this.getFeedbackLoop(runId, input.loop_id);
+    }
+    async getFeedbackLoop(runId, loopId) {
+        await this.ready();
+        const row = this.db
+            .prepare(`SELECT run_id, loop_id, source_stage_id, source_attempt, policy_json, state,
+                current_replay_id, current_replay_number, deferred_send_back_json,
+                created_at, updated_at
+         FROM feedback_loops WHERE run_id = ? AND loop_id = ?`)
+            .get(runId, loopId);
+        if (!row) {
+            throw new Error(`Feedback loop not found: ${runId}/${loopId}`);
+        }
+        return feedbackLoopFromRow(row);
+    }
+    async listFeedbackLoops(runId) {
+        await this.ready();
+        this.getRunRow(runId);
+        const rows = this.db
+            .prepare(`SELECT run_id, loop_id, source_stage_id, source_attempt, policy_json, state,
+                current_replay_id, current_replay_number, deferred_send_back_json,
+                created_at, updated_at
+         FROM feedback_loops WHERE run_id = ? ORDER BY created_at ASC`)
+            .all(runId);
+        return rows.map(feedbackLoopFromRow);
+    }
+    async updateFeedbackLoop(runId, loopId, patch, options) {
+        await this.ready();
+        const sets = ["updated_at = @updated_at"];
+        const params = {
+            run_id: runId,
+            loop_id: loopId,
+            updated_at: new Date().toISOString(),
+        };
+        if (patch.state !== undefined) {
+            sets.push("state = @state");
+            params.state = patch.state;
+        }
+        if (patch.current_replay_id !== undefined) {
+            sets.push("current_replay_id = @current_replay_id");
+            params.current_replay_id = patch.current_replay_id;
+        }
+        if (patch.current_replay_number !== undefined) {
+            sets.push("current_replay_number = @current_replay_number");
+            params.current_replay_number = patch.current_replay_number;
+        }
+        if (patch.policy !== undefined) {
+            sets.push("policy_json = @policy_json");
+            params.policy_json = JSON.stringify(patch.policy);
+        }
+        if (patch.deferred_send_back !== undefined) {
+            sets.push("deferred_send_back_json = @deferred_send_back_json");
+            params.deferred_send_back_json =
+                patch.deferred_send_back === null
+                    ? null
+                    : JSON.stringify(patch.deferred_send_back);
+        }
+        const whereParts = ["run_id = @run_id", "loop_id = @loop_id"];
+        if (options?.expectedState !== undefined) {
+            whereParts.push("state = @expected_state");
+            params.expected_state = options.expectedState;
+        }
+        const result = this.db
+            .prepare(`UPDATE feedback_loops SET ${sets.join(", ")}
+         WHERE ${whereParts.join(" AND ")}`)
+            .run(params);
+        if (result.changes === 0) {
+            if (options?.expectedState !== undefined) {
+                const exists = this.db
+                    .prepare(`SELECT 1 AS ok FROM feedback_loops WHERE run_id = ? AND loop_id = ?`)
+                    .get(runId, loopId);
+                if (exists === undefined) {
+                    throw new Error(`Feedback loop not found: ${runId}/${loopId}`);
+                }
+                return false;
+            }
+            throw new Error(`Feedback loop not found: ${runId}/${loopId}`);
+        }
+        return true;
+    }
+    async createFeedbackReplay(runId, input) {
+        await this.ready();
+        await this.getFeedbackLoop(runId, input.loop_id);
+        const now = new Date().toISOString();
+        const status = input.status ?? "scheduled";
+        this.db
+            .prepare(`INSERT INTO feedback_replays
+          (run_id, replay_id, loop_id, source_stage_id, source_attempt, target_stage_id,
+           replay_number, max_replays, replay_session, route_stage_ids_json,
+           feedback_envelope_json, status, created_at, updated_at)
+         VALUES
+          (@run_id, @replay_id, @loop_id, @source_stage_id, @source_attempt, @target_stage_id,
+           @replay_number, @max_replays, @replay_session, @route_stage_ids_json,
+           @feedback_envelope_json, @status, @created_at, @updated_at)`)
+            .run({
+            run_id: runId,
+            replay_id: input.replay_id,
+            loop_id: input.loop_id,
+            source_stage_id: input.source_stage_id,
+            source_attempt: input.source_attempt,
+            target_stage_id: input.target_stage_id,
+            replay_number: input.replay_number,
+            max_replays: input.max_replays,
+            replay_session: input.replay_session,
+            route_stage_ids_json: JSON.stringify(input.route_stage_ids),
+            feedback_envelope_json: JSON.stringify(input.feedback_envelope),
+            status,
+            created_at: now,
+            updated_at: now,
+        });
+        return this.getFeedbackReplay(runId, input.replay_id);
+    }
+    async getFeedbackReplay(runId, replayId) {
+        await this.ready();
+        const row = this.db
+            .prepare(`SELECT run_id, replay_id, loop_id, source_stage_id, source_attempt, target_stage_id,
+                replay_number, max_replays, replay_session, route_stage_ids_json,
+                feedback_envelope_json, status, created_at, updated_at
+         FROM feedback_replays WHERE run_id = ? AND replay_id = ?`)
+            .get(runId, replayId);
+        if (!row) {
+            throw new Error(`Feedback replay not found: ${runId}/${replayId}`);
+        }
+        return feedbackReplayFromRow(row);
+    }
+    async listFeedbackReplays(runId, loopId) {
+        await this.ready();
+        await this.getFeedbackLoop(runId, loopId);
+        const rows = this.db
+            .prepare(`SELECT run_id, replay_id, loop_id, source_stage_id, source_attempt, target_stage_id,
+                replay_number, max_replays, replay_session, route_stage_ids_json,
+                feedback_envelope_json, status, created_at, updated_at
+         FROM feedback_replays
+         WHERE run_id = ? AND loop_id = ?
+         ORDER BY replay_number ASC`)
+            .all(runId, loopId);
+        return rows.map(feedbackReplayFromRow);
+    }
+    async updateFeedbackReplay(runId, replayId, patch) {
+        await this.ready();
+        const sets = ["updated_at = @updated_at"];
+        const params = {
+            run_id: runId,
+            replay_id: replayId,
+            updated_at: new Date().toISOString(),
+        };
+        if (patch.status !== undefined) {
+            sets.push("status = @status");
+            params.status = patch.status;
+        }
+        const result = this.db
+            .prepare(`UPDATE feedback_replays SET ${sets.join(", ")}
+         WHERE run_id = @run_id AND replay_id = @replay_id`)
+            .run(params);
+        if (result.changes === 0) {
+            throw new Error(`Feedback replay not found: ${runId}/${replayId}`);
+        }
+    }
+    async createFeedbackReplayStagePass(runId, input) {
+        await this.ready();
+        await this.getFeedbackReplay(runId, input.replay_id);
+        const status = input.status ?? "pending";
+        this.db
+            .prepare(`INSERT INTO feedback_replay_stage_passes
+          (run_id, replay_id, stage_id, stage_attempt, session_origin_attempt,
+           session_mode, status, started_at, finished_at, emitted_envelope_json)
+         VALUES
+          (@run_id, @replay_id, @stage_id, @stage_attempt, @session_origin_attempt,
+           @session_mode, @status, @started_at, @finished_at, @emitted_envelope_json)`)
+            .run({
+            run_id: runId,
+            replay_id: input.replay_id,
+            stage_id: input.stage_id,
+            stage_attempt: input.stage_attempt,
+            session_origin_attempt: input.session_origin_attempt ?? null,
+            session_mode: input.session_mode,
+            status,
+            started_at: input.started_at ?? null,
+            finished_at: input.finished_at ?? null,
+            emitted_envelope_json: input.emitted_envelope !== undefined
+                ? JSON.stringify(input.emitted_envelope)
+                : null,
+        });
+        const row = this.db
+            .prepare(`SELECT run_id, replay_id, stage_id, stage_attempt, session_origin_attempt,
+                session_mode, status, started_at, finished_at, emitted_envelope_json
+         FROM feedback_replay_stage_passes
+         WHERE run_id = ? AND replay_id = ? AND stage_id = ?`)
+            .get(runId, input.replay_id, input.stage_id);
+        return feedbackReplayStagePassFromRow(row);
+    }
+    async listFeedbackReplayStagePasses(runId, replayId) {
+        await this.ready();
+        await this.getFeedbackReplay(runId, replayId);
+        const rows = this.db
+            .prepare(`SELECT run_id, replay_id, stage_id, stage_attempt, session_origin_attempt,
+                session_mode, status, started_at, finished_at, emitted_envelope_json
+         FROM feedback_replay_stage_passes
+         WHERE run_id = ? AND replay_id = ?
+         ORDER BY stage_id ASC`)
+            .all(runId, replayId);
+        return rows.map(feedbackReplayStagePassFromRow);
+    }
+    async updateFeedbackReplayStagePass(runId, replayId, stageId, patch) {
+        await this.ready();
+        const sets = [];
+        const params = {
+            run_id: runId,
+            replay_id: replayId,
+            stage_id: stageId,
+        };
+        if (patch.status !== undefined) {
+            sets.push("status = @status");
+            params.status = patch.status;
+        }
+        if (patch.stage_attempt !== undefined) {
+            sets.push("stage_attempt = @stage_attempt");
+            params.stage_attempt = patch.stage_attempt;
+        }
+        if (patch.started_at !== undefined) {
+            sets.push("started_at = @started_at");
+            params.started_at = patch.started_at;
+        }
+        if (patch.finished_at !== undefined) {
+            sets.push("finished_at = @finished_at");
+            params.finished_at = patch.finished_at;
+        }
+        if (patch.emitted_envelope !== undefined) {
+            sets.push("emitted_envelope_json = @emitted_envelope_json");
+            params.emitted_envelope_json =
+                patch.emitted_envelope === null
+                    ? null
+                    : JSON.stringify(patch.emitted_envelope);
+        }
+        if (sets.length === 0)
+            return;
+        const result = this.db
+            .prepare(`UPDATE feedback_replay_stage_passes SET ${sets.join(", ")}
+         WHERE run_id = @run_id AND replay_id = @replay_id AND stage_id = @stage_id`)
+            .run(params);
+        if (result.changes === 0) {
+            throw new Error(`Feedback replay stage pass not found: ${runId}/${replayId}/${stageId}`);
+        }
+    }
+    async createForkGeneration(runId, input) {
+        await this.ready();
+        this.getRunRow(runId);
+        if (input.replay_id !== undefined) {
+            await this.getFeedbackReplay(runId, input.replay_id);
+        }
+        const now = new Date().toISOString();
+        const status = input.status ?? "active";
+        this.db
+            .prepare(`INSERT INTO fork_generations
+          (run_id, generation_id, replay_id, fork_parent_stage_id, generation_number,
+           clone_stage_ids_json, status, created_at, updated_at)
+         VALUES
+          (@run_id, @generation_id, @replay_id, @fork_parent_stage_id, @generation_number,
+           @clone_stage_ids_json, @status, @created_at, @updated_at)`)
+            .run({
+            run_id: runId,
+            generation_id: input.generation_id,
+            replay_id: input.replay_id ?? null,
+            fork_parent_stage_id: input.fork_parent_stage_id,
+            generation_number: input.generation_number,
+            clone_stage_ids_json: JSON.stringify(input.clone_stage_ids),
+            status,
+            created_at: now,
+            updated_at: now,
+        });
+        const row = this.db
+            .prepare(`SELECT run_id, generation_id, replay_id, fork_parent_stage_id, generation_number,
+                clone_stage_ids_json, status, created_at, updated_at
+         FROM fork_generations WHERE run_id = ? AND generation_id = ?`)
+            .get(runId, input.generation_id);
+        return forkGenerationFromRow(row);
+    }
+    async listForkGenerations(runId, options) {
+        await this.ready();
+        this.getRunRow(runId);
+        const clauses = ["run_id = ?"];
+        const params = [runId];
+        if (options?.replayId !== undefined) {
+            clauses.push("replay_id = ?");
+            params.push(options.replayId);
+        }
+        if (options?.forkParentStageId !== undefined) {
+            clauses.push("fork_parent_stage_id = ?");
+            params.push(options.forkParentStageId);
+        }
+        const rows = this.db
+            .prepare(`SELECT run_id, generation_id, replay_id, fork_parent_stage_id, generation_number,
+                clone_stage_ids_json, status, created_at, updated_at
+         FROM fork_generations
+         WHERE ${clauses.join(" AND ")}
+         ORDER BY created_at ASC`)
+            .all(...params);
+        return rows.map(forkGenerationFromRow);
+    }
+    async updateForkGeneration(runId, generationId, patch) {
+        await this.ready();
+        const sets = ["updated_at = @updated_at"];
+        const params = {
+            run_id: runId,
+            generation_id: generationId,
+            updated_at: new Date().toISOString(),
+        };
+        if (patch.status !== undefined) {
+            sets.push("status = @status");
+            params.status = patch.status;
+        }
+        const result = this.db
+            .prepare(`UPDATE fork_generations SET ${sets.join(", ")}
+         WHERE run_id = @run_id AND generation_id = @generation_id`)
+            .run(params);
+        if (result.changes === 0) {
+            throw new Error(`Fork generation not found: ${runId}/${generationId}`);
+        }
+    }
+    async loadFeedbackLoopHistory(runId) {
+        const loops = await this.listFeedbackLoops(runId);
+        const allForkGens = await this.listForkGenerations(runId);
+        const nullReplayGens = allForkGens.filter((g) => g.replay_id == null);
+        const history = [];
+        for (const loop of loops) {
+            const replays = await this.listFeedbackReplays(runId, loop.loop_id);
+            const replayEntries = [];
+            for (const replay of replays) {
+                const stage_passes = await this.listFeedbackReplayStagePasses(runId, replay.replay_id);
+                const fork_generations = allForkGens.filter((g) => g.replay_id === replay.replay_id);
+                replayEntries.push({ replay, stage_passes, fork_generations });
+            }
+            history.push({
+                loop,
+                replays: replayEntries,
+                fork_generations: nullReplayGens,
+            });
+        }
+        const activeCandidates = loops.filter((l) => l.state === "active" || l.state === "waiting_for_human");
+        let active;
+        if (activeCandidates.length > 0) {
+            active = [...activeCandidates].sort((a, b) => {
+                const byUpdated = b.updated_at.localeCompare(a.updated_at);
+                if (byUpdated !== 0)
+                    return byUpdated;
+                return b.created_at.localeCompare(a.created_at);
+            })[0];
+        }
+        return {
+            history,
+            ...(active !== undefined ? { active } : {}),
+        };
     }
     readPipelineDagSnapshotFromRow(row) {
         if (!row.pipeline_dag_json)