relay-flow 0.2.9-alpha → 0.2.10-alpha

package/internal/execution/projection/projection.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 	"strings"
 	"sync"
@@ -117,6 +118,7 @@ CREATE TABLE IF NOT EXISTS relay_runs (
     workflow TEXT NOT NULL,
     ticket_id TEXT NOT NULL,
     ticket_key TEXT NOT NULL,
+    created_at DATETIME,
     state TEXT NOT NULL,
     current_node TEXT,
     current_node_visit_id TEXT,
@@ -158,6 +160,28 @@ CREATE TABLE IF NOT EXISTS relay_node_sessions (
     PRIMARY KEY (run_id, node, session_id),
     FOREIGN KEY (run_id) REFERENCES relay_runs(id) ON DELETE CASCADE
 );
+CREATE TABLE IF NOT EXISTS relay_run_steps (
+    run_id TEXT NOT NULL,
+    sequence INTEGER NOT NULL,
+    node TEXT NOT NULL,
+    node_visit_id TEXT,
+    node_type TEXT,
+    parent_sequence INTEGER,
+    depth INTEGER,
+    status TEXT NOT NULL,
+    started_at DATETIME,
+    finished_at DATETIME,
+    duration_ns INTEGER,
+    message TEXT,
+    selected_route TEXT,
+    runtime TEXT,
+    resource TEXT,
+    PRIMARY KEY (run_id, sequence),
+    FOREIGN KEY (run_id) REFERENCES relay_runs(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS relay_run_steps_run_order ON relay_run_steps (run_id, sequence);
+CREATE UNIQUE INDEX IF NOT EXISTS relay_run_steps_run_visit ON relay_run_steps (run_id, node_visit_id)
+    WHERE node_visit_id IS NOT NULL AND node_visit_id <> '';
 `
 
 func (p *RunProjection) migrate() error {
@@ -170,6 +194,7 @@ func (p *RunProjection) migrate() error {
 		"retry_error":    "TEXT",
 		"retry_attempt":  "INTEGER",
 		"next_retry_at":  "DATETIME",
+		"created_at":     "DATETIME",
 	} {
 		var count int
 		if err := p.DB.QueryRow(`SELECT COUNT(1) FROM pragma_table_info('relay_runs') WHERE name = ?`, name).Scan(&count); err != nil {
@@ -190,10 +215,24 @@ func (p *RunProjection) migrate() error {
 	if _, err := p.DB.Exec(`UPDATE relay_runs SET attempt_id = 1 WHERE attempt_id IS NULL OR attempt_id = 0`); err != nil {
 		return err
 	}
+	for name, definition := range map[string]string{
+		"parent_sequence": "INTEGER",
+		"depth":           "INTEGER",
+	} {
+		var count int
+		if err := p.DB.QueryRow(`SELECT COUNT(1) FROM pragma_table_info('relay_run_steps') WHERE name = ?`, name).Scan(&count); err != nil {
+			return err
+		}
+		if count == 0 {
+			if _, err := p.DB.Exec(`ALTER TABLE relay_run_steps ADD COLUMN ` + name + ` ` + definition); err != nil {
+				return err
+			}
+		}
+	}
 	return nil
 }
 
-var errRunNotFound = errors.New("run not found")
+var errRunNotFound = run.ErrNotFound
 var errNodeRuntimeNotFound = errors.New("node runtime not found")
 
 // IsNotFound reports a missing projection row.
@@ -209,24 +248,86 @@ func (p *RunProjection) insertStart(ctx context.Context, s run.Start, now time.T
 		attemptID = 1
 	}
 	_, err := p.DB.ExecContext(ctx, `
-		INSERT INTO relay_runs (id, logical_run_id, attempt_id, repo, workflow, ticket_id, ticket_key, state, started_at, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		INSERT INTO relay_runs (id, logical_run_id, attempt_id, repo, workflow, ticket_id, ticket_key, created_at, state, started_at, updated_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 		ON CONFLICT(id) DO NOTHING`,
 		string(s.ID), string(logicalID), int64(attemptID), s.Repo, s.Workflow.Name, s.Ticket.ID, s.Ticket.Key,
-		string(run.StateStarting), now, now)
+		now, string(run.StateStarting), now, now)
 	return err
 }
 
 func (p *RunProjection) updateState(ctx context.Context, id run.ID, state run.State, lastErr string, finished *time.Time) error {
 	terminal := state == run.StateCompleted || state == run.StateCanceled
+	now := time.Now().UTC()
 	_, err := p.DB.ExecContext(ctx, `
 		UPDATE relay_runs SET state = ?, last_error = ?, updated_at = ?, finished_at = COALESCE(?, finished_at),
 			retry_error = CASE WHEN ? THEN NULL ELSE retry_error END,
 			retry_attempt = CASE WHEN ? THEN NULL ELSE retry_attempt END,
 			next_retry_at = CASE WHEN ? THEN NULL ELSE next_retry_at END
 		WHERE id = ?`,
-		string(state), lastErr, time.Now().UTC(), finished, terminal, terminal, terminal, string(id))
-	return err
+		string(state), lastErr, now, finished, terminal, terminal, terminal, string(id))
+	if err != nil {
+		return err
+	}
+	// Keep the derived timeline useful during retries and cancellation without
+	// making it an execution authority. Identify one active row first; a
+	// repeated terminal update with no active row is a no-op for the timeline.
+	stepStatus := stepStatusForRunState(state)
+	if stepStatus == "" {
+		return nil
+	}
+	var sequence int64
+	var startedAt sql.NullTime
+	lookupErr := p.DB.QueryRowContext(ctx, `
+		SELECT sequence, started_at FROM relay_run_steps
+		WHERE run_id = ? AND status IN ('running', 'waiting', 'blocked')
+		ORDER BY sequence DESC LIMIT 1`, string(id)).Scan(&sequence, &startedAt)
+	if errors.Is(lookupErr, sql.ErrNoRows) {
+		return nil
+	}
+	if lookupErr != nil {
+		// relay_run_steps is display/cache data. The authoritative relay_runs
+		// state update above has already succeeded and must not be retried just
+		// because this optional projection is unavailable.
+		slog.Warn("step projection state lookup unavailable", "runID", string(id), "state", state, "error", lookupErr)
+		return nil
+	}
+	var stepFinished any
+	if terminal {
+		if finished != nil {
+			stepFinished = *finished
+		} else {
+			stepFinished = now
+		}
+	}
+	result, err := p.DB.ExecContext(ctx, `
+		UPDATE relay_run_steps SET status = ?, message = CASE WHEN ? <> '' THEN ? ELSE message END,
+			finished_at = CASE WHEN ? THEN COALESCE(finished_at, ?) ELSE finished_at END
+		WHERE run_id = ? AND sequence = ? AND status IN ('running', 'waiting', 'blocked')`,
+		stepStatus, lastErr, lastErr, terminal, stepFinished,
+		string(id), sequence)
+	if err != nil {
+		slog.Warn("step projection state update unavailable", "runID", string(id), "state", state, "error", err)
+		return nil
+	}
+	updated, err := result.RowsAffected()
+	if err != nil || updated != 1 {
+		return nil
+	}
+	if terminal && startedAt.Valid {
+		endAt := now
+		if finished != nil {
+			endAt = *finished
+		}
+		duration := endAt.Sub(startedAt.Time)
+		if duration < 0 {
+			duration = 0
+		}
+		if _, durationErr := p.DB.ExecContext(ctx, `UPDATE relay_run_steps SET duration_ns = ? WHERE run_id = ? AND sequence = ?`, int64(duration), string(id), sequence); durationErr != nil {
+			slog.Warn("step projection duration update unavailable", "runID", string(id), "state", state, "error", durationErr)
+		}
+	}
+	return nil
 }
 
 func (p *RunProjection) updateRetry(ctx context.Context, id run.ID, status *run.RetryStatus) error {
@@ -271,6 +372,169 @@ func (p *RunProjection) updateNode(ctx context.Context, id run.ID, state run.Sta
 	return tx.Commit()
 }
 
+func stepStatusForRunState(state run.State) string {
+	switch state {
+	case run.StateRunning:
+		return string(run.StepRunning)
+	case run.StateWaiting:
+		return string(run.StepWaiting)
+	case run.StateBlocked:
+		return string(run.StepBlocked)
+	case run.StateCompleted:
+		return string(run.StepSucceeded)
+	case run.StateCanceled:
+		return string(run.StepCanceled)
+	default:
+		return ""
+	}
+}
+
+// upsertStep records one display row idempotently. The durable executor calls
+// this at existing lifecycle boundaries; no route or report decision reads
+// this table.
+func (p *RunProjection) upsertStep(ctx context.Context, step run.StepEntry) error {
+	if step.RunID == "" {
+		return fmt.Errorf("step projection requires a run id")
+	}
+	if step.Node == "" {
+		return fmt.Errorf("step projection requires a node")
+	}
+	if step.Status == "" {
+		return fmt.Errorf("step projection requires a status")
+	}
+	var startedAt, finishedAt any
+	if step.StartedAt != nil && !step.StartedAt.IsZero() {
+		startedAt = step.StartedAt.UTC()
+	}
+	if step.FinishedAt != nil && !step.FinishedAt.IsZero() {
+		finishedAt = step.FinishedAt.UTC()
+	}
+	_, err := p.DB.ExecContext(ctx, `
+		INSERT INTO relay_run_steps
+			(run_id, sequence, node, node_visit_id, node_type, parent_sequence, depth, status, started_at, finished_at,
+			 duration_ns, message, selected_route, runtime, resource)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(run_id, sequence) DO UPDATE SET
+			node = excluded.node,
+			node_visit_id = COALESCE(NULLIF(excluded.node_visit_id, ''), relay_run_steps.node_visit_id),
+			node_type = COALESCE(NULLIF(excluded.node_type, ''), relay_run_steps.node_type),
+			parent_sequence = CASE WHEN excluded.parent_sequence <> 0 THEN excluded.parent_sequence ELSE relay_run_steps.parent_sequence END,
+			depth = CASE WHEN excluded.depth <> 0 THEN excluded.depth ELSE relay_run_steps.depth END,
+			status = CASE
+				WHEN relay_run_steps.status IN ('succeeded', 'failed', 'canceled') THEN relay_run_steps.status
+				WHEN relay_run_steps.status = 'blocked' AND excluded.status IN ('pending', 'running', 'waiting') THEN relay_run_steps.status
+				WHEN relay_run_steps.status = 'waiting' AND excluded.status IN ('pending', 'running') THEN relay_run_steps.status
+				WHEN relay_run_steps.status = 'running' AND excluded.status = 'pending' THEN relay_run_steps.status
+				ELSE excluded.status
+			END,
+			started_at = COALESCE(relay_run_steps.started_at, excluded.started_at),
+			finished_at = CASE
+				WHEN relay_run_steps.status IN ('succeeded', 'failed', 'canceled') THEN relay_run_steps.finished_at
+				ELSE COALESCE(excluded.finished_at, relay_run_steps.finished_at)
+			END,
+			duration_ns = CASE
+				WHEN relay_run_steps.status IN ('succeeded', 'failed', 'canceled') THEN relay_run_steps.duration_ns
+				WHEN excluded.duration_ns <> 0 THEN excluded.duration_ns
+				WHEN excluded.finished_at IS NOT NULL AND COALESCE(relay_run_steps.started_at, excluded.started_at) IS NOT NULL
+					THEN CAST((julianday(excluded.finished_at) - julianday(COALESCE(relay_run_steps.started_at, excluded.started_at))) * 86400000000000 AS INTEGER)
+				ELSE relay_run_steps.duration_ns
+			END,
+			message = CASE WHEN relay_run_steps.status IN ('succeeded', 'failed', 'canceled') THEN relay_run_steps.message ELSE COALESCE(NULLIF(excluded.message, ''), relay_run_steps.message) END,
+			selected_route = CASE WHEN relay_run_steps.status IN ('succeeded', 'failed', 'canceled') THEN relay_run_steps.selected_route ELSE COALESCE(NULLIF(excluded.selected_route, ''), relay_run_steps.selected_route) END,
+			runtime = COALESCE(NULLIF(excluded.runtime, ''), relay_run_steps.runtime),
+			resource = COALESCE(NULLIF(excluded.resource, ''), relay_run_steps.resource)`,
+		string(step.RunID), step.Sequence, step.Node, nullableString(string(step.NodeVisitID)),
+		nullableString(step.NodeType), step.ParentSequence, step.Depth, string(step.Status), startedAt, finishedAt,
+		durationNanos(step), nullableString(step.Message), nullableString(step.Route),
+		nullableString(step.Runtime), nullableString(step.Resource))
+	return err
+}
+
+func durationNanos(step run.StepEntry) any {
+	if step.Duration != 0 {
+		return int64(step.Duration)
+	}
+	if step.StartedAt != nil && step.FinishedAt != nil {
+		duration := step.FinishedAt.Sub(*step.StartedAt)
+		if duration < 0 {
+			duration = 0
+		}
+		return int64(duration)
+	}
+	if step.DurationKnown {
+		return int64(0)
+	}
+	return nil
+}
+
+func (p *RunProjection) listSteps(ctx context.Context, id run.ID) ([]run.StepEntry, error) {
+	rows, err := p.DB.QueryContext(ctx, `
+		SELECT run_id, sequence, node, node_visit_id, node_type, parent_sequence, depth, status,
+			started_at, finished_at, duration_ns, message, selected_route, runtime, resource
+		FROM relay_run_steps WHERE run_id = ? ORDER BY sequence`, string(id))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	steps := make([]run.StepEntry, 0)
+	for rows.Next() {
+		var step run.StepEntry
+		var visit, nodeType, message, route, runtime, resource sql.NullString
+		var started, finished sql.NullTime
+		var duration, parentSequence, depth sql.NullInt64
+		if err := rows.Scan(&step.RunID, &step.Sequence, &step.Node, &visit, &nodeType,
+			&parentSequence, &depth, &step.Status, &started, &finished, &duration,
+			&message, &route, &runtime, &resource); err != nil {
+			return nil, err
+		}
+		step.NodeVisitID = run.NodeVisitID(visit.String)
+		if parentSequence.Valid {
+			step.ParentSequence = parentSequence.Int64
+		}
+		if depth.Valid {
+			step.Depth = int(depth.Int64)
+		}
+		step.NodeType, step.Message, step.Route = nodeType.String, message.String, route.String
+		step.Runtime, step.Resource = runtime.String, resource.String
+		if started.Valid {
+			t := started.Time.UTC()
+			step.StartedAt = &t
+		}
+		if finished.Valid {
+			t := finished.Time.UTC()
+			step.FinishedAt = &t
+		}
+		if duration.Valid {
+			step.Duration = time.Duration(duration.Int64)
+			step.DurationKnown = true
+		}
+		steps = append(steps, step)
+	}
+	return steps, rows.Err()
+}
+
+func (p *RunProjection) getDetail(ctx context.Context, id run.ID) (run.RunDetail, error) {
+	base, err := p.get(ctx, id)
+	if err != nil {
+		return run.RunDetail{}, err
+	}
+	detail := run.NewRunDetail(base)
+	var created sql.NullTime
+	if err := p.DB.QueryRowContext(ctx, `SELECT created_at FROM relay_runs WHERE id = ?`, string(id)).Scan(&created); err != nil {
+		return run.RunDetail{}, err
+	}
+	if created.Valid {
+		createdAt := created.Time.UTC()
+		detail.CreatedAt = &createdAt
+	}
+	detail.Steps, err = p.listSteps(ctx, id)
+	if err != nil {
+		return run.RunDetail{}, err
+	}
+	detail.DeriveInspectionFields(time.Now().UTC())
+	return detail, nil
+}
+
 func (p *RunProjection) getNodeRuntime(ctx context.Context, id run.ID, node string) (NodeRuntime, error) {
 	var rt NodeRuntime
 	var terminalID, sessionID sql.NullString
@@ -610,6 +874,10 @@ func (p *RunProjection) sweepRetention(ctx context.Context, olderThan time.Time)
 			tx.Rollback()
 			return ids, err
 		}
+		if _, err := tx.ExecContext(ctx, `DELETE FROM relay_run_steps WHERE run_id = ?`, id); err != nil {
+			tx.Rollback()
+			return ids, err
+		}
 		if _, err := tx.ExecContext(ctx, `DELETE FROM relay_runs WHERE id = ?`, id); err != nil {
 			tx.Rollback()
 			return ids, err
@@ -649,6 +917,22 @@ func (p *RunProjection) UpdateNode(ctx context.Context, id run.ID, state run.Sta
 	return p.updateNode(ctx, id, state, node, visit)
 }
 
+// UpsertStep records or updates one display-only execution step.
+func (p *RunProjection) UpsertStep(ctx context.Context, step run.StepEntry) error {
+	return p.upsertStep(ctx, step)
+}
+
+// ListSteps returns the ordered display-only execution timeline for a run.
+func (p *RunProjection) ListSteps(ctx context.Context, id run.ID) ([]run.StepEntry, error) {
+	return p.listSteps(ctx, id)
+}
+
+// GetDetail returns a run and its derived inspection data in one query
+// boundary. The result never drives durable execution.
+func (p *RunProjection) GetDetail(ctx context.Context, id run.ID) (run.RunDetail, error) {
+	return p.getDetail(ctx, id)
+}
+
 // GetNodeRuntime returns one node's persisted runtime binding.
 func (p *RunProjection) GetNodeRuntime(ctx context.Context, id run.ID, node string) (NodeRuntime, error) {
 	return p.getNodeRuntime(ctx, id, node)

package/internal/execution/projection/projection_test.go

@@ -80,6 +80,7 @@ func TestSharedProjectionSchemaAndQueries(t *testing.T) {
 		"relay_node_runtime",
 		"relay_node_sessions",
 		"relay_processed_reports",
+		"relay_run_steps",
 		"relay_runs",
 	}
 	if len(tables) != len(wantTables) {
@@ -209,8 +210,8 @@ func TestProjectionImplementationIsSharedByExecutorModes(t *testing.T) {
 			if err := db.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name LIKE 'relay_%'`).Scan(&count); err != nil {
 				t.Fatal(err)
 			}
-			if count != 5 {
-				t.Fatalf("relay schema table count = %d, want five shared tables", count)
+			if count != 6 {
+				t.Fatalf("relay schema table count = %d, want six shared tables", count)
 			}
 			if err := p.InsertStart(context.Background(), projectionStart(run.ID("run-"+mode), "PAY-"+mode), time.Now().UTC()); err != nil {
 				t.Fatalf("insert %s run through shared projection: %v", mode, err)

package/internal/execution/temporal/activities.go

@@ -411,6 +411,15 @@ func (a *Activities) CompleteMailbox(ctx context.Context, w run.Work, mailbox ta
 
 // Projection activities: idempotent read-model updates.
 
+func (a *Activities) ProjectionUpsertStep(ctx context.Context, step run.StepEntry) error {
+	if err := a.Runs.UpsertStep(ctx, step); err != nil {
+		// Step detail is a cache. Never let a display-projection failure block
+		// route selection, report acceptance, or durable graph progression.
+		slog.Warn("step projection unavailable", "runID", string(step.RunID), "node", step.Node, "sequence", step.Sequence, "error", err)
+	}
+	return nil
+}
+
 func (a *Activities) ProjectionUpdateNode(ctx context.Context, id run.ID, state run.State, node string, visit run.NodeVisitID) error {
 	return a.Runs.UpdateNode(ctx, id, state, node, visit)
 }

package/internal/execution/temporal/engine.go

@@ -362,6 +362,19 @@ func (e *Engine) GetRun(ctx context.Context, id run.ID) (run.Run, error) {
 func (e *Engine) FindRunByTicket(ctx context.Context, ticket string) (run.Run, error) {
 	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 only contribute explicit pending display rows. The
+	// derived projection is never consulted by Temporal workflow code.
+	if wf, wfErr := e.workflowFromHistory(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/temporal/interpreter.go

@@ -42,6 +42,7 @@ const (
 	activityComment                     = "Comment"
 	activityCompleteMailbox             = "CompleteMailbox"
 	activityProjectionUpdateNodeRuntime = "ProjectionUpdateNodeRuntimeVisit"
+	activityProjectionUpsertStep        = "ProjectionUpsertStep"
 	activityProjectionRecordReport      = "ProjectionRecordProcessedReport"
 	activityProjectionUpdateNode        = "ProjectionUpdateNode"
 	activityProjectionUpdateState       = "ProjectionUpdateState"
@@ -72,6 +73,7 @@ type NodeRuntimeBinding struct {
 type RunStateSnapshot struct {
 	Run             run.Run              `json:"run"`
 	RuntimeBindings []NodeRuntimeBinding `json:"runtimeBindings"`
+	Steps           []run.StepEntry      `json:"steps"`
 }
 
 type ReportStateQuery struct {
@@ -89,6 +91,7 @@ type workflowState struct {
 	run       run.Run
 	bindings  map[string]NodeRuntimeBinding
 	processed map[string]bool
+	steps     []run.StepEntry
 }
 
 func (s *workflowState) snapshot() RunStateSnapshot {
@@ -101,7 +104,53 @@ func (s *workflowState) snapshot() RunStateSnapshot {
 	for _, node := range keys {
 		bindings = append(bindings, s.bindings[node])
 	}
-	return RunStateSnapshot{Run: s.run, RuntimeBindings: bindings}
+	steps := append([]run.StepEntry(nil), s.steps...)
+	return RunStateSnapshot{Run: s.run, RuntimeBindings: bindings, Steps: steps}
+}
+
+func (s *workflowState) upsertStep(step run.StepEntry) {
+	for i := range s.steps {
+		if s.steps[i].Sequence == step.Sequence {
+			previous := s.steps[i]
+			if step.StartedAt == nil {
+				step.StartedAt = previous.StartedAt
+			}
+			if step.FinishedAt == nil {
+				step.FinishedAt = previous.FinishedAt
+			}
+			if step.Duration == 0 {
+				step.Duration = previous.Duration
+			}
+			if step.Message == "" {
+				step.Message = previous.Message
+			}
+			if step.Route == "" {
+				step.Route = previous.Route
+			}
+			if step.Runtime == "" {
+				step.Runtime = previous.Runtime
+			}
+			s.steps[i] = step
+			return
+		}
+	}
+	s.steps = append(s.steps, step)
+	sort.Slice(s.steps, func(i, j int) bool { return s.steps[i].Sequence < s.steps[j].Sequence })
+}
+
+func (s *workflowState) updateLatestStep(status run.StepStatus, message string) {
+	for i := len(s.steps) - 1; i >= 0; i-- {
+		if s.steps[i].Status != run.StepRunning && s.steps[i].Status != run.StepWaiting && s.steps[i].Status != run.StepBlocked {
+			continue
+		}
+		step := s.steps[i]
+		step.Status = status
+		if message != "" {
+			step.Message = message
+		}
+		s.upsertStep(step)
+		return
+	}
 }
 
 var temporalActivityOptions = temporalworkflow.ActivityOptions{
@@ -254,6 +303,23 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		return err
 	}
 
+	// The timeline is a derived display projection. Sequence is deterministic
+	// for Temporal replay and is never consulted for routing.
+	stepSequence := int64(0)
+	target, err := wf.StartTarget()
+	if err != nil {
+		return err
+	}
+	startStarted := temporalworkflow.Now(ctx).UTC()
+	startStep := run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: "start", NodeType: "lifecycle",
+		Status: run.StepRunning, StartedAt: &startStarted, Depth: 1}
+	if _, err := retryActivity(ctx, state, work, "start", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, startStep)
+	}); err != nil {
+		return err
+	}
+	state.upsertStep(startStep)
+
 	startNode := wf.Nodes["start"]
 	if _, err := retryActivity(ctx, state, work, "start", func() (struct{}, error) {
 		return executeActivity[struct{}](ctx, activityApplyTaskConfig, work, "start", (*task.Mailbox)(nil), mergeTaskConfig(wf.TaskConfig, startNode.TaskConfig))
@@ -265,12 +331,19 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 	}); err != nil {
 		return err
 	}
-	target, err := wf.StartTarget()
-	if err != nil {
+	startFinished := temporalworkflow.Now(ctx).UTC()
+	startStep.Status, startStep.FinishedAt, startStep.Route = run.StepSucceeded, &startFinished, target
+	startStep.StartedAt = &startStarted
+	if _, err := retryActivity(ctx, state, work, "start", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, startStep)
+	}); err != nil {
 		return err
 	}
+	state.upsertStep(startStep)
 
 	current := target
+	lastStepByNode := map[string]int64{}
+	lastDepthByNode := map[string]int{}
 	for current != "end" {
 		node := wf.Nodes[current]
 		var visitID identity.NodeVisitID
@@ -280,6 +353,26 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 			return err
 		}
 		visit := run.NodeVisitID(visitID)
+		stepSequence++
+		stepParent := int64(0)
+		stepDepth := 1
+		if previous, ok := lastStepByNode[current]; ok {
+			stepParent = previous
+			stepDepth = lastDepthByNode[current] + 1
+		}
+		stepStarted := temporalworkflow.Now(ctx).UTC()
+		step := run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: current,
+			NodeVisitID: visit, NodeType: string(node.Type), Status: run.StepRunning,
+			StartedAt: &stepStarted, ParentSequence: stepParent, Depth: stepDepth, Runtime: node.Agent}
+		if _, err := retryActivity(ctx, state, work, current, func() (struct{}, error) {
+			return executeActivity[struct{}](ctx, activityProjectionUpsertStep, step)
+		}); err != nil {
+			return err
+		}
+		state.upsertStep(step)
+		lastStepByNode[current] = stepSequence
+		lastDepthByNode[current] = stepDepth
+
 		runtime, err := retryActivity(ctx, state, work, current, func() (NodeRuntime, error) {
 			return executeActivity[NodeRuntime](ctx, activityLoadNodeRuntime, start.ID, current)
 		})
@@ -347,6 +440,7 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		}
 		state.run.State = run.StateWaiting
 		state.run.UpdatedAt = temporalworkflow.Now(ctx)
+		state.updateLatestStep(run.StepWaiting, "waiting")
 
 		reportCh := temporalworkflow.GetSignalChannel(ctx, reportSignalName)
 		reconcileCh := temporalworkflow.GetSignalChannel(ctx, reconcileSignalName)
@@ -417,6 +511,20 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		}); err != nil {
 			return err
 		}
+		stepStatus := run.StepSucceeded
+		stepMessage := accepted.Report.Summary.Completed
+		if accepted.Report.Status == domainworkflow.OutcomeFailure {
+			stepStatus = run.StepFailed
+			stepMessage = accepted.Report.Summary.IssuesDiscovered
+		}
+		stepFinished := temporalworkflow.Now(ctx).UTC()
+		step.Status, step.FinishedAt, step.Message, step.Route = stepStatus, &stepFinished, stepMessage, accepted.Report.NextStep
+		if _, err := retryActivity(ctx, state, work, current, func() (struct{}, error) {
+			return executeActivity[struct{}](ctx, activityProjectionUpsertStep, step)
+		}); err != nil {
+			return err
+		}
+		state.upsertStep(step)
 
 		if _, err := retryActivity(ctx, state, work, current, func() (struct{}, error) {
 			return executeActivity[struct{}](ctx, activityComment, start.Repo, run.CommentWork{
@@ -463,6 +571,17 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		current = next
 	}
 
+	stepSequence++
+	endStarted := temporalworkflow.Now(ctx).UTC()
+	endStep := run.StepEntry{RunID: start.ID, Sequence: stepSequence, Node: "end", NodeType: "lifecycle",
+		Status: run.StepRunning, StartedAt: &endStarted, Depth: 1}
+	if _, err := retryActivity(ctx, state, work, "end", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, endStep)
+	}); err != nil {
+		return err
+	}
+	state.upsertStep(endStep)
+
 	endNode := wf.Nodes["end"]
 	if _, err := retryActivity(ctx, state, work, "end", func() (struct{}, error) {
 		return executeActivity[struct{}](ctx, activityApplyTaskConfig, work, "end", (*task.Mailbox)(nil), mergeTaskConfig(wf.TaskConfig, endNode.TaskConfig))
@@ -494,6 +613,13 @@ func runGraph(ctx temporalworkflow.Context, start run.Start, state *workflowStat
 		}
 	}
 	now := temporalworkflow.Now(ctx).UTC()
+	endStep.Status, endStep.FinishedAt = run.StepSucceeded, &now
+	if _, err := retryActivity(ctx, state, work, "end", func() (struct{}, error) {
+		return executeActivity[struct{}](ctx, activityProjectionUpsertStep, endStep)
+	}); err != nil {
+		return err
+	}
+	state.upsertStep(endStep)
 	if _, err := retryActivity(ctx, state, work, "", func() (struct{}, error) {
 		return executeActivity[struct{}](ctx, activityProjectionUpdateState, start.ID, run.StateCompleted, "", &now)
 	}); err != nil {
@@ -566,6 +692,7 @@ func retryActivity[T any](ctx temporalworkflow.Context, state *workflowState, wo
 					return zero, stateErr
 				}
 				state.run.State = run.StateWaiting
+				state.updateLatestStep(run.StepWaiting, "waiting")
 			}
 			return result, nil
 		}
@@ -580,6 +707,7 @@ func retryActivity[T any](ctx temporalworkflow.Context, state *workflowState, wo
 			failure.Message = blockedMessage(work, node, failure.Message)
 			blocked = true
 			state.run.State = run.StateBlocked
+			state.updateLatestStep(run.StepBlocked, failure.Message)
 			if _, stateErr := retryProjectionActivity(ctx, state, work, node, func() (struct{}, error) {
 				return executeActivity[struct{}](ctx, activityProjectionUpdateState, work.RunID, run.StateBlocked, failure.Message, (*time.Time)(nil))
 			}); stateErr != nil {