stageflow 0.8.0 → 0.12.0

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;