feat(runner): real-time step feedback — pre-step indicator, progress ticker, timeout warning (#100)

Three-layer feedback system so test runs no longer look stale:

Layer 1 — Pre-step indicator (verbose mode)
  Prints '→ step description' immediately before each step runs.
  On TTY: result line (✓/✗) overwrites the arrow line in place via ANSI
  cursor-up + erase (clean single-line-per-step output).
  On non-TTY: both lines appended (CI-friendly, nothing hidden).

Layer 2 — Progress ticker (all modes)
  runStepTicker goroutine fires every 5s while a step is running.
  Prints '⏱ step... (Ns)' so the user knows something is happening.
  Goroutine exits immediately when step finishes; fast steps (< 5s)
  produce no ticker output.

Layer 3 — 80% timeout warning (all modes)
  One-time '⚠ step still running — Ns elapsed, Ns timeout' warning
  when elapsed >= 80% of the step's context deadline. Gives time to
  react before a timeout occurs.

Non-verbose TTY status line
  Without --verbose: a faint \r-overwriting status shows the current
  step while it runs, then is cleared. No output on non-TTY (CI clean).

Implementation:
  reporter.go: isTTY detection via os.ModeCharDevice (no new deps),
    6 testable helpers (printStep*W accept io.Writer + bool),
    6 public wrappers (PrintStep*) called from executor.go
  executor.go: runStep now calls PrintStepBefore/PrintCurrentStep before
    the dispatch switch, spawns runStepTicker goroutine, stops it via
    close(stop)+<-done after the switch, then calls PrintStepAfterN
  Goroutine sync: close(stopTicker) → <-tickerDone guarantees ticker
    has exited before extraLines.Load() or result print runs (no race)

Tests: 21 new tests in step_feedback_test.go (package runner, internal)
  covering TTY detection, all print helpers, ticker no-output-for-fast-
  steps, tick-after-interval, 80%-warning, ctx-cancel exit, warning-once

Author: pbertsch

CHANGELOG.md

@@ -6,6 +6,15 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.2] - 2026-05-09
+
+### Added
+- **Real-time step feedback** — the runner now emits progress during test execution instead of staying silent until a step completes:
+  - **Pre-step indicator** (verbose mode): prints `→ step description` immediately before each step runs. On a TTY the line is overwritten in place by the `✓/✗` result when the step finishes (clean single-line-per-step output). On non-TTY (CI) both lines are appended.
+  - **Progress ticker** (all modes): a goroutine fires every 5 seconds while a step is still running and prints `⏱ step... (Ns)`. Stops immediately when the step completes — fast steps produce no ticker output.
+  - **Timeout warning** (all modes): when a step has consumed ≥ 80% of its context deadline, a one-time `⚠ step still running — Ns elapsed, Ns timeout` warning is printed. Gives time to react before the step times out.
+  - **Non-verbose TTY status line**: even without `--verbose`, a faint `\r`-overwriting status line shows the current step name while it runs and is cleared when it finishes. No output on non-TTY so CI logs stay clean.
+
 ## [0.9.1] - 2026-05-09
 
 ### Added

docs/wiki/Home.md

@@ -18,7 +18,7 @@ Welcome to the FlutterProbe wiki. This documentation covers architecture details
 
 ## Project Status
 
-FlutterProbe is in active development. Current version: **0.9.1**.
+FlutterProbe is in active development. Current version: **0.9.2**.
 
 ### Repository Structure
 

internal/runner/executor.go

@@ -124,8 +124,28 @@ func (e *Executor) runStep(ctx context.Context, step parser.Step) error {
 
 	start := time.Now()
 	desc := e.stepDescription(step)
-	var err error
 
+	// Real-time feedback: print the step description before it runs.
+	if desc != "" {
+		if e.verbose {
+			PrintStepBefore(e.depth, desc)
+		} else {
+			PrintCurrentStep(desc)
+		}
+	}
+
+	// Launch a ticker goroutine that prints progress lines every 5 seconds for
+	// slow steps. It also emits a one-time warning at 80% of the step timeout.
+	// The goroutine is always started when there's a description — it exits
+	// immediately via <-stopTicker if the step finishes fast (< 5s).
+	var extraLines atomic.Int32
+	stopTicker := make(chan struct{})
+	tickerDone := make(chan struct{})
+	if desc != "" {
+		go runStepTicker(stepCtx, desc, e.depth, 5*time.Second, stopTicker, tickerDone, &extraLines)
+	}
+
+	var err error
 	switch s := step.(type) {
 	case parser.ActionStep:
 		err = e.runAction(stepCtx, s)
@@ -181,19 +201,76 @@ func (e *Executor) runStep(ctx context.Context, step parser.Step) error {
 		}
 	}
 
-	if e.verbose && desc != "" {
+	// Stop the ticker goroutine and wait for it to fully exit before reading
+	// extraLines or printing the result — this eliminates any output race.
+	if desc != "" {
+		close(stopTicker)
+		<-tickerDone
+	}
+
+	if desc != "" {
 		elapsed := time.Since(start)
-		indent := strings.Repeat("  ", e.depth)
-		status := "\033[32m✓\033[0m"
-		if err != nil {
-			status = "\033[31m✗\033[0m"
+		if e.verbose {
+			PrintStepAfterN(e.depth, desc, elapsed, err, int(extraLines.Load()))
+		} else {
+			ClearCurrentStep()
 		}
-		fmt.Printf("    %s%s %s \033[2m(%.1fs)\033[0m\n", indent, status, desc, elapsed.Seconds())
 	}
 
 	return err
 }
 
+// runStepTicker is run in a goroutine by runStep. It emits ⏱ progress lines
+// every tickInterval for slow steps and a one-time ⚠ warning at 80% of the
+// step's context deadline. It exits when stop is closed or ctx is cancelled.
+func runStepTicker(
+	ctx context.Context,
+	desc string,
+	depth int,
+	tickInterval time.Duration,
+	stop <-chan struct{},
+	done chan<- struct{},
+	extraLines *atomic.Int32,
+) {
+	defer close(done)
+
+	ticker := time.NewTicker(tickInterval)
+	defer ticker.Stop()
+
+	goroutineStart := time.Now()
+	warnPrinted := false
+
+	// Derive the total step timeout from the context deadline so we can emit
+	// the 80% warning at the right moment.
+	var timeoutDur time.Duration
+	if deadline, ok := ctx.Deadline(); ok {
+		timeoutDur = deadline.Sub(goroutineStart)
+	}
+
+	for {
+		select {
+		case <-stop:
+			return
+		case <-ctx.Done():
+			return
+		case t := <-ticker.C:
+			elapsed := t.Sub(goroutineStart)
+			PrintStepTick(depth, desc, elapsed)
+			extraLines.Add(1)
+
+			// Emit the 80% warning exactly once, after the threshold is crossed.
+			if !warnPrinted && timeoutDur > 0 {
+				threshold := time.Duration(float64(timeoutDur) * 0.80)
+				if elapsed >= threshold {
+					PrintStepWarning(depth, desc, elapsed, timeoutDur)
+					extraLines.Add(1)
+					warnPrinted = true
+				}
+			}
+		}
+	}
+}
+
 // stepDescription returns a human-readable description of the step.
 func (e *Executor) stepDescription(step parser.Step) string {
 	switch s := step.(type) {

internal/runner/reporter.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -357,3 +358,118 @@ func AllPassed(results []TestResult) bool {
 	}
 	return true
 }
+
+// ---- Real-time step feedback ----
+
+// isTTY reports whether os.Stdout is an interactive terminal. The result is
+// computed once (via sync.OnceValue) and cached — no repeated syscalls.
+// Returns false in CI pipes, when stdout is redirected to a file, etc.
+var isTTY = sync.OnceValue(func() bool {
+	fi, err := os.Stdout.Stat()
+	if err != nil {
+		return false
+	}
+	return fi.Mode()&os.ModeCharDevice != 0
+})
+
+// printStepBeforeW writes the "→ desc" pre-step line to w.
+// On a TTY the line will be overwritten by printStepAfterNW (when tickLines==0).
+func printStepBeforeW(w io.Writer, _ bool, depth int, desc string) {
+	if desc == "" {
+		return
+	}
+	indent := strings.Repeat("  ", depth)
+	fmt.Fprintf(w, "    %s\033[2m→\033[0m  %s\n", indent, desc)
+}
+
+// printStepAfterNW writes the ✓/✗ result line.
+// On a TTY with no tick lines printed below the "→" line, it moves the cursor
+// up one line and overwrites in place (clean single-line-per-step output).
+// When tickLines > 0 the "→" line has scrolled above the tick lines, so we
+// just append — attempting to erase N lines is more fragile than helpful.
+// On non-TTY output is always appended.
+func printStepAfterNW(w io.Writer, tty bool, depth int, desc string, elapsed time.Duration, err error, tickLines int) {
+	if desc == "" {
+		return
+	}
+	indent := strings.Repeat("  ", depth)
+	status := "\033[32m✓\033[0m"
+	if err != nil {
+		status = "\033[31m✗\033[0m"
+	}
+	line := fmt.Sprintf("    %s%s %s \033[2m(%.1fs)\033[0m", indent, status, desc, elapsed.Seconds())
+	if tty && tickLines == 0 {
+		// Cursor up one line, carriage return, erase to EOL, then print result.
+		fmt.Fprintf(w, "\033[1A\r\033[K%s\n", line)
+	} else {
+		fmt.Fprintln(w, line)
+	}
+}
+
+// printStepTickW writes a ⏱ progress line showing elapsed time.
+func printStepTickW(w io.Writer, depth int, desc string, elapsed time.Duration) {
+	indent := strings.Repeat("  ", depth)
+	fmt.Fprintf(w, "    %s\033[33m⏱\033[0m  %s... \033[2m(%ds)\033[0m\n",
+		indent, desc, int(elapsed.Seconds()))
+}
+
+// printStepWarningW writes a one-time ⚠ warning when a step is near its timeout.
+func printStepWarningW(w io.Writer, depth int, desc string, elapsed, timeout time.Duration) {
+	indent := strings.Repeat("  ", depth)
+	fmt.Fprintf(w, "    %s\033[33m⚠\033[0m  %s still running — %ds elapsed, %ds timeout\n",
+		indent, desc, int(elapsed.Seconds()), int(timeout.Seconds()))
+}
+
+// printCurrentStepW writes a transient \r-overwriting status line in non-verbose
+// mode. On non-TTY this is a no-op so CI output stays clean.
+func printCurrentStepW(w io.Writer, tty bool, desc string) {
+	if !tty || desc == "" {
+		return
+	}
+	const maxW = 80
+	label := "  \033[2m" + desc + "\033[0m"
+	// Pad to maxW so previous (longer) status is fully erased.
+	fmt.Fprintf(w, "\r%-*s", maxW, label)
+}
+
+// clearCurrentStepW erases the transient status line written by printCurrentStepW.
+func clearCurrentStepW(w io.Writer, tty bool) {
+	if !tty {
+		return
+	}
+	fmt.Fprintf(w, "\r%*s\r", 80, "")
+}
+
+// Public wrappers — called from executor.go. Each delegates to the testable
+// helper with os.Stdout and the cached isTTY result.
+
+// PrintStepBefore prints the "→ desc" line before a step runs (verbose mode).
+func PrintStepBefore(depth int, desc string) {
+	printStepBeforeW(os.Stdout, isTTY(), depth, desc)
+}
+
+// PrintStepAfterN prints the ✓/✗ result line after a step finishes.
+// tickLines is the number of ⏱/⚠ lines printed below the "→" line.
+func PrintStepAfterN(depth int, desc string, elapsed time.Duration, err error, tickLines int) {
+	printStepAfterNW(os.Stdout, isTTY(), depth, desc, elapsed, err, tickLines)
+}
+
+// PrintStepTick prints a ⏱ progress line during a long-running step.
+func PrintStepTick(depth int, desc string, elapsed time.Duration) {
+	printStepTickW(os.Stdout, depth, desc, elapsed)
+}
+
+// PrintStepWarning prints a one-time ⚠ warning when a step is near its timeout.
+func PrintStepWarning(depth int, desc string, elapsed, timeout time.Duration) {
+	printStepWarningW(os.Stdout, depth, desc, elapsed, timeout)
+}
+
+// PrintCurrentStep prints a transient \r-based status line (non-verbose, TTY only).
+func PrintCurrentStep(desc string) {
+	printCurrentStepW(os.Stdout, isTTY(), desc)
+}
+
+// ClearCurrentStep erases the transient status line (non-verbose, TTY only).
+func ClearCurrentStep() {
+	clearCurrentStepW(os.Stdout, isTTY())
+}