feat(tui): show recipe step output and make it scrollable

Running a report-style recipe (stale-device-cleanup, compliance-report,
audit-*, etc.) from the TUI was hiding the actual data — only the
"Stale device scan complete. Review devices..." completion message
rendered, which is useless when the devices themselves aren't visible.

- Render each step's captured stdout inline below its status line on done
- Viewport-based scrolling (j/k/up/down, g/G, PgUp/PgDn, space) because
  altscreen mode disables terminal scrollback
- Scroll indicator shows position + range when content overflows
- Skipped steps omit the empty-output block

Also renames RecipeParamFormScreen.Title() from "Run: X" to "Configure:
X" so the breadcrumb no longer reads `... > Run: X > Run: X`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: juergen-kc

internal/tui/screen/recipe_list_test.go

@@ -82,7 +82,7 @@ func TestRecipeListScreen_EnterPushesParamForm(t *testing.T) {
 	// Recipes are sorted alphabetically in LoadAll, but our fake bypasses that;
 	// accept either as long as it's one of our recipes.
 	title := pushMsg.Screen.Title()
-	if title != "Run: security-audit" && title != "Run: onboard-user" {
+	if title != "Configure: security-audit" && title != "Configure: onboard-user" {
 		t.Errorf("unexpected pushed screen title %q", title)
 	}
 }

internal/tui/screen/recipe_param.go

@@ -51,7 +51,7 @@ func NewRecipeParamFormScreen(r *recipe.Recipe) *RecipeParamFormScreen {
 }
 
 func (s *RecipeParamFormScreen) Title() string {
-	return "Run: " + s.recipe.Name
+	return "Configure: " + s.recipe.Name
 }
 
 func (s *RecipeParamFormScreen) TextInputActive() bool {
@@ -153,7 +153,7 @@ func (s *RecipeParamFormScreen) submit() (tea.Model, tea.Cmd) {
 
 func (s *RecipeParamFormScreen) View() string {
 	var sb strings.Builder
-	sb.WriteString(style.Title.Render("Run: " + s.recipe.Name))
+	sb.WriteString(style.Title.Render("Configure: " + s.recipe.Name))
 	sb.WriteString("\n")
 
 	if s.recipe.Description != "" {

internal/tui/screen/recipe_param_test.go

@@ -12,7 +12,7 @@ import (
 func TestRecipeParamFormScreen_TitleIncludesRecipe(t *testing.T) {
 	r := &recipe.Recipe{Name: "onboard-user", Steps: []recipe.Step{{Name: "x", Command: "y"}}}
 	s := NewRecipeParamFormScreen(r)
-	if s.Title() != "Run: onboard-user" {
+	if s.Title() != "Configure: onboard-user" {
 		t.Errorf("Title = %q", s.Title())
 	}
 }
@@ -105,7 +105,7 @@ func TestRecipeParamFormScreen_SubmitPushesRunScreen(t *testing.T) {
 		t.Fatalf("expected PushScreenMsg, got %T", msg)
 	}
 	if !strings.HasPrefix(push.Screen.Title(), "Run: ") {
-		t.Errorf("pushed title = %q, want prefix 'Run: '", push.Screen.Title())
+		t.Errorf("pushed title = %q, want prefix 'Run: ' (the run screen, not the configure screen)", push.Screen.Title())
 	}
 }
 

internal/tui/screen/recipe_run.go

@@ -74,6 +74,10 @@ type RecipeRunScreen struct {
 
 	width  int
 	height int
+
+	// scrollOffset controls the first visible line of the scrollable body.
+	// Updated on j/k/up/down/page keys; clamped in clampScroll.
+	scrollOffset int
 }
 
 // NewRecipeRunScreen creates the run screen. When planMode is true, the screen
@@ -180,6 +184,30 @@ func (s *RecipeRunScreen) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if s.done {
 				return s, func() tea.Msg { return tui.PopScreenMsg{} }
 			}
+		case "j", "down":
+			s.scrollOffset++
+			return s, nil
+		case "k", "up":
+			s.scrollOffset--
+			if s.scrollOffset < 0 {
+				s.scrollOffset = 0
+			}
+			return s, nil
+		case "g":
+			s.scrollOffset = 0
+			return s, nil
+		case "G":
+			s.scrollOffset = 1 << 30 // clamped in View
+			return s, nil
+		case "pgdown", " ":
+			s.scrollOffset += s.viewportHeight()
+			return s, nil
+		case "pgup":
+			s.scrollOffset -= s.viewportHeight()
+			if s.scrollOffset < 0 {
+				s.scrollOffset = 0
+			}
+			return s, nil
 		}
 
 	case recipeLineMsg:
@@ -250,25 +278,43 @@ func RegisterTeaProgram(p interface{ Send(tea.Msg) }) {
 	teaProgramSend = p.Send
 }
 
-func (s *RecipeRunScreen) View() string {
-	var sb strings.Builder
+// viewportHeight returns how many lines are available for the scrollable
+// body (everything except the fixed title and footer rows).
+func (s *RecipeRunScreen) viewportHeight() int {
+	// Title + blank + footer = 3 lines; plus 1 for scroll indicator when needed.
+	reserved := 4
+	h := s.height - reserved
+	if h < 5 {
+		h = 5
+	}
+	return h
+}
 
+// buildBodyLines assembles the scrollable body: per-step status, step output,
+// final error/summary message. Returns a slice of already-styled lines.
+func (s *RecipeRunScreen) buildBodyLines() []string {
 	if s.planMode {
-		sb.WriteString(style.Title.Render("Plan: " + s.recipe.Name))
-		sb.WriteString("\n\n")
+		out := []string{}
 		if s.err != "" {
-			sb.WriteString(style.Error.Render("  " + s.err))
+			out = append(out, style.Error.Render("  "+s.err))
 		} else {
-			sb.WriteString(s.planText)
+			for _, line := range strings.Split(strings.TrimRight(s.planText, "\n"), "\n") {
+				out = append(out, line)
+			}
 		}
-		sb.WriteString("\n")
-		sb.WriteString(style.DimRow.Render("  enter: back  esc: back"))
-		return sb.String()
+		return out
 	}
 
-	sb.WriteString(style.Title.Render("Run: " + s.recipe.Name))
-	sb.WriteString("\n\n")
+	// Build a quick lookup from step name → captured output, available only
+	// after the recipe finishes (recipeDoneMsg populates s.result).
+	outputs := map[string]string{}
+	if s.result != nil {
+		for _, sr := range s.result.Steps {
+			outputs[sr.Name] = sr.Output
+		}
+	}
 
+	var lines []string
 	for _, st := range s.steps {
 		icon := "○"
 		lineStyle := style.DimRow
@@ -286,27 +332,99 @@ func (s *RecipeRunScreen) View() string {
 			icon = "✗"
 			lineStyle = style.Error
 		}
-		sb.WriteString(lineStyle.Render(fmt.Sprintf("  %s %s", icon, st.name)))
-		sb.WriteString("\n")
+		lines = append(lines, lineStyle.Render(fmt.Sprintf("  %s %s", icon, st.name)))
+
+		// Show captured output below the step line once available. Keep the
+		// "skipped" case output-free (engine doesn't produce output for
+		// skipped steps, and showing empty whitespace is just noise).
+		if out, ok := outputs[st.name]; ok && st.status != "skipped" {
+			for _, line := range strings.Split(strings.TrimRight(out, "\n"), "\n") {
+				if line == "" {
+					lines = append(lines, "")
+					continue
+				}
+				lines = append(lines, "      "+line)
+			}
+			if st.status == "done" || st.status == "failed" {
+				lines = append(lines, "")
+			}
+		}
 	}
 
-	sb.WriteString("\n")
-
 	if s.err != "" {
-		sb.WriteString(style.Error.Render("  " + s.err))
-		sb.WriteString("\n")
+		lines = append(lines, "")
+		lines = append(lines, style.Error.Render("  "+s.err))
 	}
 
 	if s.done && s.result != nil && s.result.Message != "" {
-		sb.WriteString(style.Category.Render("  " + s.result.Message))
+		lines = append(lines, "")
+		lines = append(lines, style.Category.Render("  "+s.result.Message))
+	}
+
+	return lines
+}
+
+// clampScroll constrains scrollOffset to [0, max(0, totalLines - viewport)].
+func (s *RecipeRunScreen) clampScroll(totalLines int) {
+	max := totalLines - s.viewportHeight()
+	if max < 0 {
+		max = 0
+	}
+	if s.scrollOffset > max {
+		s.scrollOffset = max
+	}
+	if s.scrollOffset < 0 {
+		s.scrollOffset = 0
+	}
+}
+
+func (s *RecipeRunScreen) View() string {
+	var sb strings.Builder
+
+	// Title.
+	if s.planMode {
+		sb.WriteString(style.Title.Render("Plan: " + s.recipe.Name))
+	} else {
+		sb.WriteString(style.Title.Render("Run: " + s.recipe.Name))
+	}
+	sb.WriteString("\n\n")
+
+	// Body (scrollable).
+	body := s.buildBodyLines()
+	s.clampScroll(len(body))
+
+	vh := s.viewportHeight()
+	start := s.scrollOffset
+	end := start + vh
+	if end > len(body) {
+		end = len(body)
+	}
+	for i := start; i < end; i++ {
+		sb.WriteString(body[i])
 		sb.WriteString("\n")
 	}
+	// Fill short bodies so footer doesn't jump.
+	for i := end - start; i < vh; i++ {
+		sb.WriteString("\n")
+	}
+
+	// Scroll indicator + keys footer.
+	scrollHint := ""
+	if len(body) > vh {
+		scrollHint = fmt.Sprintf("  [%d-%d of %d]  j/k: scroll  g/G: top/bottom", start+1, end, len(body))
+	}
 
+	var keys string
 	if s.done {
-		sb.WriteString(style.DimRow.Render("  enter: back  esc: back"))
+		keys = "enter: back  esc: back"
 	} else {
-		sb.WriteString(style.DimRow.Render("  esc: back (running in background)"))
+		keys = "esc: back (running in background)"
+	}
+	if scrollHint != "" {
+		sb.WriteString(style.DimRow.Render(scrollHint))
+		sb.WriteString("\n")
 	}
+	sb.WriteString(style.DimRow.Render("  " + keys))
 
 	return sb.String()
 }

internal/tui/screen/recipe_run_test.go

@@ -142,3 +142,104 @@ func TestRecipeRunScreen_DoneMsgSetsResult(t *testing.T) {
 		t.Errorf("view should show completion message; got:\n%s", view)
 	}
 }
+
+func TestRecipeRunScreen_ShowsStepOutput(t *testing.T) {
+	r := &recipe.Recipe{
+		Name: "audit",
+		Steps: []recipe.Step{
+			{Name: "list-devices", Command: "devices list -t"},
+		},
+	}
+	s := NewRecipeRunScreen(r, nil, false)
+	// Mark the step done and inject a done message with captured output.
+	s.steps[0].status = "done"
+	s.Update(tea.WindowSizeMsg{Width: 120, Height: 40})
+	s.Update(recipeDoneMsg{
+		result: &recipe.ExecutionResult{
+			Recipe: "audit",
+			Status: "success",
+			Steps: []recipe.StepResult{
+				{Name: "list-devices", Status: "success",
+					Output: "HOSTNAME  OS\nfoo       Mac\nbar       Windows\n"},
+			},
+			Message: "done",
+		},
+	})
+
+	view := s.View()
+	if !strings.Contains(view, "HOSTNAME") {
+		t.Errorf("view should contain captured output header 'HOSTNAME'; got:\n%s", view)
+	}
+	if !strings.Contains(view, "foo") || !strings.Contains(view, "bar") {
+		t.Errorf("view should contain output rows; got:\n%s", view)
+	}
+}
+
+func TestRecipeRunScreen_ScrollOffsetJKMoves(t *testing.T) {
+	// Build an output large enough to force scrolling.
+	var many []string
+	for i := 0; i < 50; i++ {
+		many = append(many, "line"+string(rune('A'+i%26)))
+	}
+	longOutput := strings.Join(many, "\n")
+
+	r := &recipe.Recipe{
+		Name:  "t",
+		Steps: []recipe.Step{{Name: "s", Command: "c"}},
+	}
+	s := NewRecipeRunScreen(r, nil, false)
+	s.steps[0].status = "done"
+	s.Update(tea.WindowSizeMsg{Width: 80, Height: 20}) // viewport ~16 lines
+	s.Update(recipeDoneMsg{
+		result: &recipe.ExecutionResult{
+			Recipe: "t",
+			Status: "success",
+			Steps:  []recipe.StepResult{{Name: "s", Status: "success", Output: longOutput}},
+		},
+	})
+
+	initial := s.scrollOffset
+	s.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
+	if s.scrollOffset != initial+1 {
+		t.Errorf("after j, scrollOffset = %d, want %d", s.scrollOffset, initial+1)
+	}
+	s.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
+	if s.scrollOffset != initial {
+		t.Errorf("after k, scrollOffset = %d, want %d", s.scrollOffset, initial)
+	}
+	// Scroll to bottom with G, then ensure offset is clamped (View calls clampScroll).
+	s.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("G")})
+	_ = s.View() // triggers clampScroll
+	if s.scrollOffset > 50 {
+		t.Errorf("scrollOffset after G+View should be clamped; got %d", s.scrollOffset)
+	}
+	// Back to top with g.
+	s.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("g")})
+	if s.scrollOffset != 0 {
+		t.Errorf("after g, scrollOffset = %d, want 0", s.scrollOffset)
+	}
+}
+
+func TestRecipeRunScreen_SkippedStepHasNoOutput(t *testing.T) {
+	r := &recipe.Recipe{
+		Name: "t",
+		Steps: []recipe.Step{
+			{Name: "conditional", Command: "c", When: "{{ .flag }}"},
+		},
+	}
+	s := NewRecipeRunScreen(r, nil, false)
+	s.steps[0].status = "skipped"
+	s.Update(tea.WindowSizeMsg{Width: 80, Height: 40})
+	s.Update(recipeDoneMsg{
+		result: &recipe.ExecutionResult{
+			Recipe: "t",
+			Status: "success",
+			Steps:  []recipe.StepResult{{Name: "conditional", Status: "skipped"}},
+		},
+	})
+
+	view := s.View()
+	if !strings.Contains(view, "conditional") {
+		t.Errorf("view should still list skipped step name; got:\n%s", view)
+	}
+}