Host detail page + pipeline timeline

Click a tile to open /hosts/{id} — the canonical control surface per
host. Timeline renders every pre-stage, stage, and terminal node in
order, with the current one pulsing, failed ones flagged, and
downstream ones dimmed as skipped. Detail page shows summary, hold
card (when holding), all action buttons, spec diffs, a full-height
log pane, and a collapsed expected-spec YAML.

Tile slims to name, last-seen, status, and one primary action; a
CSS-overlay <a> makes the whole card clickable while buttons stay
receptive via z-index.

Runner.publishTileUpdate now also emits pipeline-{runID} fragments,
and CompleteStage wraps Stages.CompleteByName so stage completions
advance the timeline live — without this the dots only moved on
state transitions.

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

internal/api/ui_handlers.go

@@ -26,6 +26,8 @@ import (
 type UI struct {
 	Hosts     *store.Hosts
 	Runs      *store.Runs
+	Stages    *store.Stages
+	SpecDiffs *store.SpecDiffs
 	Artifacts *store.Artifacts
 	EventHub  *events.Hub
 	Runner    *orchestrator.Runner
@@ -74,6 +76,51 @@ func (u *UI) Dashboard(w http.ResponseWriter, r *http.Request) {
 	_ = templates.Dashboard(tiles).Render(r.Context(), w)
 }
 
+// HostDetail renders the per-host page: breadcrumb, summary, pipeline
+// timeline, hold card, action row, spec diffs, log pane, meta. Same
+// enrichment path as Dashboard for tile data; additionally reads stage
+// rows + spec diffs for the latest run to populate the timeline and
+// diff list.
+func (u *UI) HostDetail(w http.ResponseWriter, r *http.Request) {
+	idStr := chi.URLParam(r, "id")
+	id, err := strconv.ParseInt(idStr, 10, 64)
+	if err != nil {
+		http.Error(w, "bad host id", http.StatusBadRequest)
+		return
+	}
+	host, err := u.Hosts.Get(r.Context(), id)
+	if err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			http.NotFound(w, r)
+			return
+		}
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	latest, err := u.Runs.LatestForHost(r.Context(), id)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	var stages []model.Stage
+	var diffs []model.SpecDiff
+	if latest != nil {
+		if u.Stages != nil {
+			stages, _ = u.Stages.ListForRun(r.Context(), latest.ID)
+		}
+		if u.SpecDiffs != nil {
+			diffs, _ = u.SpecDiffs.ListForRun(r.Context(), latest.ID)
+		}
+	}
+	t := u.Tiles.Build(r.Context(), *host, latest)
+	data := templates.HostDetailData{
+		Tile:      t,
+		Stages:    stages,
+		SpecDiffs: diffs,
+	}
+	_ = templates.HostDetail(data).Render(r.Context(), w)
+}
+
 // StartRun creates a new Run for the host, issues an agent token, and
 // transitions Registered→Queued. The dispatcher goroutine picks it up
 // and fires WoL.