relay-flow 0.2.9-alpha → 0.2.11-alpha

package/internal/execution/goworkflows/engine.go

@@ -211,6 +211,7 @@ func (e *Engine) registerActivities() error {
 		a.CompleteMailbox,
 		a.ProjectionUpdateNodeRuntimeVisit,
 		a.ProjectionRecordProcessedReport,
+		a.ProjectionUpsertStep,
 		a.ProjectionUpdateNode,
 		a.ProjectionUpdateState,
 		a.ProjectionUpdateRetry,
@@ -502,6 +503,20 @@ func (e *Engine) FindRunByTicket(ctx context.Context, ticket string) (run.Run, e
 	return e.runs.findByTicket(ctx, ticket)
 }
 
+func (e *Engine) GetRunDetail(ctx context.Context, id run.ID) (run.RunDetail, error) {
+	detail, err := e.runs.getDetail(ctx, id)
+	if err != nil {
+		return run.RunDetail{}, err
+	}
+	// Static definitions are used only to add explicit pending display rows;
+	// the projection remains a cache and never influences execution.
+	if wf, wfErr := e.workflowOf(ctx, id); wfErr == nil {
+		detail.AddPendingNodes(*wf)
+		detail.DeriveInspectionFields(time.Now().UTC())
+	}
+	return detail, nil
+}
+
 func (e *Engine) ListRuns(ctx context.Context, filter run.Filter) ([]run.Run, error) {
 	return e.runs.list(ctx, filter)
 }

package/internal/execution/goworkflows/interpreter.go

@@ -142,6 +142,23 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 		return err
 	}
 
+	// The step timeline is a derived display projection. Its sequence is
+	// deterministic for replay and is never consulted for routing.
+	stepSequence := int64(0)
+	target, err := wf.StartTarget()
+	if err != nil {
+		return err
+	}
+	startStarted := goworkflow.Now(ctx).UTC()
+	if _, err := retryLoop(ctx, start.ID, a, work, "start",
+		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+			return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.ProjectionUpsertStep,
+				run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: "start", NodeType: "lifecycle",
+					Status: run.StepRunning, StartedAt: &startStarted, Depth: 1})
+		}); err != nil {
+		return err
+	}
+
 	// Process the reserved start taskConfig (parent target).
 	startNode := wf.Nodes["start"]
 	if _, err := retryLoop(ctx, start.ID, a, work, "start",
@@ -160,13 +177,21 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 		return err
 	}
 
-	target, err := wf.StartTarget()
-	if err != nil {
+	startFinished := goworkflow.Now(ctx).UTC()
+	if _, err := retryLoop(ctx, start.ID, a, work, "start",
+		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+			return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.ProjectionUpsertStep,
+				run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: "start", NodeType: "lifecycle",
+					Status: run.StepSucceeded, StartedAt: &startStarted, FinishedAt: &startFinished,
+					Route: target, Depth: 1})
+		}); err != nil {
 		return err
 	}
 
 	current := target
 	seenReportIDs := map[string]bool{}
+	lastStepByNode := map[string]int64{}
+	lastDepthByNode := map[string]int{}
 	for current != "end" {
 		node := wf.Nodes[current]
 
@@ -178,6 +203,27 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 			return err
 		}
 		visitID := run.NodeVisitID(visit)
+		stepSequence++
+		stepParent := int64(0)
+		stepDepth := 1
+		if previous, ok := lastStepByNode[current]; ok {
+			stepParent = previous
+			stepDepth = lastDepthByNode[current] + 1
+		}
+		stepStarted := goworkflow.Now(ctx).UTC()
+		if _, err := retryLoop(ctx, start.ID, a, work, current,
+			func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+				return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.ProjectionUpsertStep,
+					run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: current,
+						NodeVisitID: visitID, NodeType: string(node.Type), Status: run.StepRunning,
+						StartedAt: &stepStarted, ParentSequence: stepParent, Depth: stepDepth,
+						Runtime: node.Agent})
+			}); err != nil {
+			return err
+		}
+		lastStepByNode[current] = stepSequence
+		lastDepthByNode[current] = stepDepth
+
 		runtime, err := retryLoop(ctx, start.ID, a, work, current,
 			func(ctx2 goworkflow.Context) goworkflow.Future[NodeRuntime] {
 				return goworkflow.ExecuteActivity[NodeRuntime](ctx2, noNativeRetries,
@@ -328,6 +374,23 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 			}); err != nil {
 			return err
 		}
+		stepStatus := run.StepSucceeded
+		stepMessage := report.Summary.Completed
+		if report.Status == workflow.OutcomeFailure {
+			stepStatus = run.StepFailed
+			stepMessage = report.Summary.IssuesDiscovered
+		}
+		stepFinished := goworkflow.Now(ctx).UTC()
+		if _, err := retryLoop(ctx, start.ID, a, work, current,
+			func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+				return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.ProjectionUpsertStep,
+					run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: current,
+						NodeVisitID: visitID, NodeType: string(node.Type), Status: stepStatus,
+						StartedAt: &stepStarted, FinishedAt: &stepFinished, Message: stepMessage,
+						Route: report.NextStep, Runtime: node.Agent, ParentSequence: stepParent, Depth: stepDepth})
+			}); err != nil {
+			return err
+		}
 
 		// Ordered transition: summary -> feedback (selected next only) ->
 		// complete current -> process next node.
@@ -389,7 +452,19 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 	}
 
 	// end: apply end task config, then optional runner cleanup, then mark
-	// the run completed.
+	// the run completed. Record the lifecycle row before setup so a lost
+	// terminal upsert can still be finalized by the authoritative completed
+	// state update.
+	stepSequence++
+	endStarted := goworkflow.Now(ctx).UTC()
+	endStep := run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: "end", NodeType: "lifecycle",
+		Status: run.StepRunning, StartedAt: &endStarted, Depth: 1}
+	if _, err := retryLoop(ctx, start.ID, a, work, "end",
+		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+			return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.ProjectionUpsertStep, endStep)
+		}); err != nil {
+		return err
+	}
 	endNode := wf.Nodes["end"]
 	if _, err := retryLoop(ctx, start.ID, a, work, "end",
 		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
@@ -424,6 +499,14 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 			return err
 		}
 	}
+	endFinished := goworkflow.Now(ctx).UTC()
+	endStep.Status, endStep.FinishedAt = run.StepSucceeded, &endFinished
+	if _, err := retryLoop(ctx, start.ID, a, work, "end",
+		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+			return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries, a.ProjectionUpsertStep, endStep)
+		}); err != nil {
+		return err
+	}
 	if _, err := retryLoop(ctx, start.ID, a, work, "",
 		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
 			now := goworkflow.Now(ctx).UTC()

package/internal/execution/goworkflows/projection.go

@@ -54,6 +54,18 @@ func (p *RunProjection) updateNode(ctx context.Context, id run.ID, state run.Sta
 	return p.shared().UpdateNode(ctx, id, state, node, visit)
 }
 
+func (p *RunProjection) upsertStep(ctx context.Context, step run.StepEntry) error {
+	return p.shared().UpsertStep(ctx, step)
+}
+
+func (p *RunProjection) listSteps(ctx context.Context, id run.ID) ([]run.StepEntry, error) {
+	return p.shared().ListSteps(ctx, id)
+}
+
+func (p *RunProjection) getDetail(ctx context.Context, id run.ID) (run.RunDetail, error) {
+	return p.shared().GetDetail(ctx, id)
+}
+
 func (p *RunProjection) getNodeRuntime(ctx context.Context, id run.ID, node string) (NodeRuntime, error) {
 	return p.shared().GetNodeRuntime(ctx, id, node)
 }
@@ -102,6 +114,10 @@ func (p *RunProjection) get(ctx context.Context, id run.ID) (run.Run, error) {
 	return p.shared().Get(ctx, id)
 }
 
+func (p *RunProjection) detail(ctx context.Context, id run.ID) (run.RunDetail, error) {
+	return p.getDetail(ctx, id)
+}
+
 func (p *RunProjection) findByTicket(ctx context.Context, ticket string) (run.Run, error) {
 	return p.shared().FindByTicket(ctx, ticket)
 }

package/internal/execution/projection/detail_test.go

@@ -0,0 +1,259 @@
+package projection_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/rajpopat27/relay-flow/internal/run"
+)
+
+func TestLegacyNullCreationAndDurationRemainUnavailable(t *testing.T) {
+	ctx := context.Background()
+	p, db := openProjection(t)
+	now := time.Now().UTC()
+	if _, err := db.Exec(`INSERT INTO relay_runs (id, repo, workflow, ticket_id, ticket_key, state, started_at, updated_at) VALUES (?, 'repo', 'workflow', 'T-LEGACY', 'T-LEGACY', 'waiting', ?, ?)`, "legacy-null", now, now); err != nil {
+		t.Fatal(err)
+	}
+	detail, err := p.GetDetail(ctx, "legacy-null")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if detail.CreatedAt != nil {
+		t.Fatalf("legacy CreatedAt = %v, want nil", detail.CreatedAt)
+	}
+	if err := p.UpsertStep(ctx, run.StepEntry{RunID: "legacy-null", Sequence: 1, Node: "coding", Status: run.StepRunning}); err != nil {
+		t.Fatal(err)
+	}
+	steps, err := p.ListSteps(ctx, "legacy-null")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(steps) != 1 || steps[0].DurationKnown {
+		t.Fatalf("legacy unknown duration = %#v", steps)
+	}
+}
+
+func TestStepProjectionIsIdempotentAndDerivesDetail(t *testing.T) {
+	ctx := context.Background()
+	p, _ := openProjection(t)
+	start := projectionStart("detail-run", "PAY-DETAIL")
+	started := time.Now().UTC().Add(-2 * time.Minute)
+	if err := p.InsertStart(ctx, start, started); err != nil {
+		t.Fatal(err)
+	}
+	finished := started.Add(time.Minute)
+	step := run.StepEntry{
+		RunID: start.ID, Sequence: 1, Node: "coding", NodeVisitID: "visit-1", NodeType: "agent",
+		Status: run.StepSucceeded, StartedAt: &started, FinishedAt: &finished,
+		Message: "report accepted", Route: "end", Runtime: "coder", Resource: "harness",
+	}
+	if err := p.UpsertStep(ctx, step); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpsertStep(ctx, step); err != nil {
+		t.Fatal(err)
+	}
+	steps, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(steps) != 1 || steps[0].NodeVisitID != step.NodeVisitID || steps[0].Route != "end" || steps[0].Duration <= 0 {
+		t.Fatalf("steps = %#v", steps)
+	}
+	detail, err := p.GetDetail(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if detail.Progress.Completed != 1 || detail.Progress.Total != 1 || detail.ResourcesDuration.Harness <= 0 {
+		t.Fatalf("detail = %#v", detail)
+	}
+	if detail.Conditions.Completed {
+		t.Fatal("starting run was reported completed")
+	}
+}
+
+func TestStepUpsertDoesNotRegressTerminalVisit(t *testing.T) {
+	ctx := context.Background()
+	p, _ := openProjection(t)
+	start := projectionStart("monotonic-run", "PAY-MONOTONIC")
+	if err := p.InsertStart(ctx, start, time.Now().UTC()); err != nil {
+		t.Fatal(err)
+	}
+	finished := time.Now().UTC()
+	terminal := run.StepEntry{RunID: start.ID, Sequence: 1, Node: "coding", NodeVisitID: "visit-1", Status: run.StepSucceeded, FinishedAt: &finished, Message: "accepted", Route: "end"}
+	if err := p.UpsertStep(ctx, terminal); err != nil {
+		t.Fatal(err)
+	}
+	stale := terminal
+	stale.Status, stale.Message, stale.Route = run.StepRunning, "stale retry", "coding"
+	if err := p.UpsertStep(ctx, stale); err != nil {
+		t.Fatal(err)
+	}
+	steps, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(steps) != 1 || steps[0].Status != run.StepSucceeded || steps[0].Message != "accepted" || steps[0].Route != "end" {
+		t.Fatalf("stale write regressed terminal step: %#v", steps)
+	}
+}
+
+func TestBranchLoopVisitsRemainDistinctAndNested(t *testing.T) {
+	ctx := context.Background()
+	p, _ := openProjection(t)
+	start := projectionStart("branch-loop", "PAY-BRANCH")
+	if err := p.InsertStart(ctx, start, time.Now().UTC()); err != nil {
+		t.Fatal(err)
+	}
+	steps := []run.StepEntry{
+		{RunID: start.ID, Sequence: 1, Node: "coding", NodeVisitID: "visit-coding-1", Status: run.StepSucceeded, Depth: 1},
+		{RunID: start.ID, Sequence: 2, Node: "review", NodeVisitID: "visit-review-1", Status: run.StepSucceeded, Depth: 1},
+		{RunID: start.ID, Sequence: 3, Node: "coding", NodeVisitID: "visit-coding-2", ParentSequence: 1, Status: run.StepWaiting, Depth: 2},
+	}
+	for _, step := range steps {
+		if err := p.UpsertStep(ctx, step); err != nil {
+			t.Fatal(err)
+		}
+	}
+	got, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != len(steps) || got[2].NodeVisitID != "visit-coding-2" || got[2].ParentSequence != 1 || got[2].Depth != 2 {
+		t.Fatalf("branch/loop steps = %#v", got)
+	}
+}
+
+func TestStepProjectionFailureDoesNotBlockAuthoritativeRunState(t *testing.T) {
+	ctx := context.Background()
+	p, db := openProjection(t)
+	start := projectionStart("projection-failure", "PAY-PROJECTION")
+	if err := p.InsertStart(ctx, start, time.Now().UTC()); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec(`DROP TABLE relay_run_steps`); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpdateState(ctx, start.ID, run.StateWaiting, "", nil); err != nil {
+		t.Fatalf("authoritative state update failed with missing display table: %v", err)
+	}
+	got, err := p.Get(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.State != run.StateWaiting {
+		t.Fatalf("state = %s, want waiting", got.State)
+	}
+}
+
+func TestTerminalStepTimingIsStableAcrossLaterRunFinalization(t *testing.T) {
+	ctx := context.Background()
+	p, _ := openProjection(t)
+	start := projectionStart("stable-terminal", "PAY-STABLE")
+	t0 := time.Now().UTC().Add(-2 * time.Minute)
+	t1 := t0.Add(20 * time.Second)
+	if err := p.InsertStart(ctx, start, t0); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpsertStep(ctx, run.StepEntry{RunID: start.ID, Sequence: 1, Node: "coding", Status: run.StepSucceeded, StartedAt: &t0, FinishedAt: &t1}); err != nil {
+		t.Fatal(err)
+	}
+	before, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(before) != 1 || before[0].FinishedAt == nil || before[0].Duration <= 0 {
+		t.Fatalf("initial terminal step = %#v", before)
+	}
+	finished := t1.Add(time.Minute)
+	if err := p.UpdateState(ctx, start.ID, run.StateCanceled, "canceled", &finished); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpdateState(ctx, start.ID, run.StateCanceled, "canceled", &finished); err != nil {
+		t.Fatal(err)
+	}
+	after, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(after) != 1 || !after[0].FinishedAt.Equal(*before[0].FinishedAt) || after[0].Duration != before[0].Duration {
+		t.Fatalf("terminal timing changed after run finalization: before=%#v after=%#v", before, after)
+	}
+}
+
+func TestCompletedRunFinalizesActiveStepWhenFinalUpsertIsMissing(t *testing.T) {
+	ctx := context.Background()
+	p, _ := openProjection(t)
+	start := projectionStart("complete-detail", "PAY-COMPLETE-DETAIL")
+	started := time.Now().UTC().Add(-time.Minute)
+	if err := p.InsertStart(ctx, start, started); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpsertStep(ctx, run.StepEntry{RunID: start.ID, Sequence: 1, Node: "end", Status: run.StepRunning, StartedAt: &started}); err != nil {
+		t.Fatal(err)
+	}
+	finished := time.Now().UTC()
+	if err := p.UpdateState(ctx, start.ID, run.StateCompleted, "", &finished); err != nil {
+		t.Fatal(err)
+	}
+	steps, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(steps) != 1 || steps[0].Status != run.StepSucceeded || steps[0].FinishedAt == nil || steps[0].Duration <= 0 {
+		t.Fatalf("completed step = %#v", steps)
+	}
+}
+
+func TestCanceledRunFinalizesCurrentStepTiming(t *testing.T) {
+	ctx := context.Background()
+	p, _ := openProjection(t)
+	start := projectionStart("cancel-detail", "PAY-CANCEL-DETAIL")
+	started := time.Now().UTC().Add(-time.Minute)
+	if err := p.InsertStart(ctx, start, started); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpsertStep(ctx, run.StepEntry{RunID: start.ID, Sequence: 1, Node: "coding", Status: run.StepRunning, StartedAt: &started}); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpdateState(ctx, start.ID, run.StateCanceling, "operator canceled", nil); err != nil {
+		t.Fatal(err)
+	}
+	finished := time.Now().UTC()
+	if err := p.UpdateState(ctx, start.ID, run.StateCanceled, "operator canceled", &finished); err != nil {
+		t.Fatal(err)
+	}
+	steps, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(steps) != 1 || steps[0].Status != run.StepCanceled || steps[0].FinishedAt == nil || steps[0].Duration <= 0 {
+		t.Fatalf("canceled step = %#v", steps)
+	}
+}
+
+func TestSetupConflictMarksCurrentStepBlocked(t *testing.T) {
+	ctx := context.Background()
+	p, _ := openProjection(t)
+	start := projectionStart("setup-conflict", "PAY-SETUP")
+	if err := p.InsertStart(ctx, start, time.Now().UTC()); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpsertStep(ctx, run.StepEntry{RunID: start.ID, Sequence: 1, Node: "coding", Status: run.StepRunning}); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.UpdateState(ctx, start.ID, run.StateBlocked, "runner setup conflict", nil); err != nil {
+		t.Fatal(err)
+	}
+	steps, err := p.ListSteps(ctx, start.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(steps) != 1 || steps[0].Status != run.StepBlocked || steps[0].Message != "runner setup conflict" {
+		t.Fatalf("blocked setup step = %#v", steps)
+	}
+	if steps[0].DurationKnown {
+		t.Fatal("unknown setup duration was fabricated as known")
+	}
+}