ui: GitHub-Actions-style detail page, sub-steps, mini-tile run-view

Reshapes the detail page into a run-view: hybrid horizontal pipeline
+ expanded active-step pane with sub-steps, a per-step log pane with
line-numbered permalinks and client-side search, and a runs-history
sidebar that navigates via ?run=N. Default step is server-picked
(running → failed → Reporting) so the operator lands on the thing
that's moving.

Adds a sub_steps table + SSE topic (substep-{run}-{stage}-{ordinal})
so per-disk and per-pass work (SMART, CPUStress CPU/RAM, Storage,
GPU) is visible in the UI instead of buried in stage summary JSON.
Agent emits sub-step reports from existing per-iteration loops.

Dashboard tiles become a mini run-view with a 9-dot step strip so
the operator reads run health across the whole grid at a glance.
Register page gets the same card shell + button styling.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

internal/api/agent_handlers.go

@@ -37,6 +37,7 @@ type Agent struct {
 	Hosts           *store.Hosts
 	Runs            *store.Runs
 	Stages          *store.Stages
+	SubSteps        *store.SubSteps
 	Artifacts       *store.Artifacts
 	SpecDiffs       *store.SpecDiffs
 	Measurements    *store.Measurements
@@ -386,12 +387,30 @@ func (a *Agent) Log(w http.ResponseWriter, r *http.Request) {
 // DefaultStageOrder); Passed drives StageCompleted vs StageFailed.
 // Inventory is optional and only set when kind == "Inventory" — the
 // orchestrator persists it as an artifact and feeds it to spec.Diff.
+//
+// SubSteps is agent-authored granular rows (CPU/Memory pass, per-disk
+// SMART, per-device GPU, …). Empty for stages with no natural
+// breakdown. Persisted after the mismatch guard fires; per-row SSE is
+// emitted at the same time so the detail pane can surface them without
+// a full page reload.
 type StageResult struct {
-	Stage     string          `json:"stage"`
-	Passed    bool            `json:"passed"`
-	Summary   json.RawMessage `json:"summary,omitempty"`
-	Inventory *spec.Inventory `json:"inventory,omitempty"`
-	Message   string          `json:"message,omitempty"`
+	Stage     string              `json:"stage"`
+	Passed    bool                `json:"passed"`
+	Summary   json.RawMessage     `json:"summary,omitempty"`
+	Inventory *spec.Inventory     `json:"inventory,omitempty"`
+	Message   string              `json:"message,omitempty"`
+	SubSteps  []SubStepResultLine `json:"sub_steps,omitempty"`
+}
+
+// SubStepResultLine is one entry in StageResult.SubSteps. Ordinal is
+// assigned from slice index server-side; the agent doesn't set it.
+type SubStepResultLine struct {
+	Name        string          `json:"name"`
+	Passed      bool            `json:"passed"`
+	Skipped     bool            `json:"skipped,omitempty"`
+	StartedAt   string          `json:"started_at,omitempty"`
+	CompletedAt string          `json:"completed_at,omitempty"`
+	Summary     json.RawMessage `json:"summary,omitempty"`
 }
 
 // Result receives a stage's outcome. Flow:
@@ -470,6 +489,12 @@ func (a *Agent) Result(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Agent-authored sub-steps: persist in slice order (ordinal = index)
+	// and fan out a per-row SSE event each so the detail pane shows them
+	// without a reload. Best-effort — a persistence error is logged but
+	// doesn't fail the whole /result.
+	a.persistSubSteps(r.Context(), runID, body.Stage, body.SubSteps)
+
 	// Inventory-specific: persist artifact + compute spec diff.
 	if body.Stage == "Inventory" && body.Inventory != nil {
 		if err := a.persistInventory(r, run, body.Inventory); err != nil {
@@ -531,6 +556,65 @@ func (a *Agent) Result(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, map[string]any{"ok": true, "next_state": string(next)})
 }
 
+// persistSubSteps writes each reported sub-step as a row keyed by
+// (runID, stage, ordinal) where ordinal is the slice index, then emits
+// a per-row SSE event so an open detail page updates without a reload.
+// Silently no-ops when SubSteps is unwired (tests that don't supply a
+// store) or the slice is empty.
+func (a *Agent) persistSubSteps(ctx context.Context, runID int64, stage string, lines []SubStepResultLine) {
+	if a.SubSteps == nil || len(lines) == 0 {
+		return
+	}
+	for i, line := range lines {
+		state := model.StagePassed
+		switch {
+		case line.Skipped:
+			state = model.StageSkipped
+		case !line.Passed:
+			state = model.StageFailed
+		}
+		started := parseResultTime(line.StartedAt)
+		completed := parseResultTime(line.CompletedAt)
+		summaryJSON := ""
+		if len(line.Summary) > 0 {
+			summaryJSON = string(line.Summary)
+		}
+		ss := model.SubStep{
+			RunID:       runID,
+			StageName:   stage,
+			Ordinal:     i,
+			Name:        line.Name,
+			State:       state,
+			StartedAt:   started,
+			CompletedAt: completed,
+			SummaryJSON: summaryJSON,
+		}
+		if err := a.SubSteps.Upsert(ctx, ss); err != nil {
+			log.Printf("substep upsert run=%d stage=%s ord=%d: %v", runID, stage, i, err)
+			continue
+		}
+		if a.Runner != nil {
+			a.Runner.PublishSubStepUpdate(ctx, ss)
+		}
+	}
+}
+
+// parseResultTime tolerates RFC3339 / RFC3339Nano and returns nil for
+// empty or unparseable values so a missing timestamp doesn't block the
+// persist path.
+func parseResultTime(s string) *time.Time {
+	if s == "" {
+		return nil
+	}
+	if t, err := time.Parse(time.RFC3339Nano, s); err == nil {
+		return &t
+	}
+	if t, err := time.Parse(time.RFC3339, s); err == nil {
+		return &t
+	}
+	return nil
+}
+
 func (a *Agent) persistInventory(r *http.Request, run *model.Run, inv *spec.Inventory) error {
 	dir := filepath.Join(a.ArtifactsDir, fmt.Sprintf("run-%d", run.ID))
 	if err := os.MkdirAll(dir, 0o755); err != nil {