From 34939edd0e77e27e478e4928d0cd5fdd29ae6b06 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Tue, 20 Oct 2026 18:21:24 +0100 Subject: [PATCH] Render run list miniatures from compact per-stage route evidence --- docs/cli.md | 11 ++ internal/pipeline/run_graph_evidence_test.go | 121 +++++++++++++++++++ internal/pipeline/runs.go | 69 ++++++++++- internal/protocol/runevents.go | 13 +- internal/protocol/runs.go | 25 +++- internal/server/run_graph_events_test.go | 79 ++++++++++++ internal/server/runevents.go | 5 + web/PARITY.md | 23 ++-- web/lists.css | 2 +- web/src/miniGraph.js | 21 ++-- web/src/runEvents.js | 33 ++++- web/test/miniGraph-events.test.mjs | 35 ++++++ web/test/miniGraph.test.mjs | 32 ++++- web/test/miniatures-browser.mjs | 72 +++++++++-- 14 files changed, 501 insertions(+), 40 deletions(-) create mode 100644 internal/pipeline/run_graph_evidence_test.go create mode 100644 internal/server/run_graph_events_test.go create mode 100644 web/test/miniGraph-events.test.mjs diff --git a/docs/cli.md b/docs/cli.md index 0a82fb2d..6d1c35d2 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -543,6 +543,17 @@ rapid changes are coalesced to at most a few frames per second per run. once-per-second poll: the Android app consumes these pushes instead, while the TUI still polls in this release. +Run-list summaries and subscribe snapshots additionally carry compact +`graph_evidence: {complete: true, visits: [...]}`. Each visit contains only +`sequence`, `stage`, `status`, `outcome` and `target`: the last visit of each +stage and each distinct taken route, ordered by sequence. Repeated loops do not +grow the summary indefinitely, and private step inputs, outputs, transcripts +and diagnostics are excluded from this projection. Live `run_event.graph_visits` +preserves changed visits across coalescing (unlike the single latest `step`). +Clients merge these by sequence and retain last-stage/distinct-route evidence. +Missing evidence from an older peer means unknown, not that every stage shares +the overall run result. These fields are additive; older peers ignore them. + In the run inspector, `n`/`p` select the next/previous recorded execution visit, including repeated visits in loops, from any pane. Selection stops at the last visit or overview; it does not wrap. The selected stage has a full-row highlight; diff --git a/internal/pipeline/run_graph_evidence_test.go b/internal/pipeline/run_graph_evidence_test.go new file mode 100644 index 00000000..9957a81b --- /dev/null +++ b/internal/pipeline/run_graph_evidence_test.go @@ -0,0 +1,121 @@ +package pipeline + +import ( + "context" + "database/sql" + "encoding/json" + "fmt" + "path/filepath" + "strings" + "testing" +) + +type graphQueryCounter struct { + *sql.DB + calls int +} + +func (q *graphQueryCounter) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error) { + q.calls++ + if len(args) > 100 { + return nil, fmt.Errorf("unbounded batch: %d", len(args)) + } + for _, private := range []string{"input_json", "output_json", "transcript", "diagnostic", "session_id"} { + if strings.Contains(query, private) { + return nil, fmt.Errorf("private projection: %s", private) + } + } + return q.DB.QueryContext(ctx, query, args...) +} + +func TestRunGraphEvidenceBatchesCompactsAndReopens(t *testing.T) { + ctx := context.Background() + path := filepath.Join(t.TempDir(), "evidence.db") + store, err := Open(path) + if err != nil { + t.Fatal(err) + } + defer func() { store.Close() }() + if _, err := store.Submit(ctx, "graph", Template([]string{"a", "b", "c", "never"}, true)); err != nil { + t.Fatal(err) + } + pipelines, _ := store.List(ctx) + definition, _ := store.Get(ctx, pipelines[0].ID, 1) + var first int64 + // Cross two batch boundaries, retaining the complete empty evidence of queued + // runs. A single connection also catches accidental nested detail reads. + store.db.SetMaxOpenConns(1) + for i := 0; i < 205; i++ { + id, _, err := store.CreateRun(ctx, definition, fmt.Sprintf("graph-%d", i), "workspace", false, nil, nil) + if err != nil { + t.Fatal(err) + } + if i == 0 { + first = id + } + } + tx, err := store.db.BeginTx(ctx, nil) + if err != nil { + t.Fatal(err) + } + for sequence := 1; sequence <= 200; sequence++ { + stage, status, outcome, target := "a", "completed", "success", "b" + if sequence == 198 { + stage, target = "b", "c" + } + if sequence == 199 { + stage, outcome, target = "c", "retry", "a" + } + if sequence == 200 { + status, outcome, target = "failed", "", "" + } + _, err := tx.ExecContext(ctx, `INSERT INTO run_steps(run_id,sequence,stage_key,status,outcome,target,input_json,output_json,diagnostic,transcript) VALUES(?,?,?,?,?,?,'{"secret":"PRIVATE-INPUT"}','{}','PRIVATE-DIAGNOSTIC','PRIVATE-TRANSCRIPT')`, first, sequence, stage, status, outcome, target) + if err != nil { + t.Fatal(err) + } + } + if err := tx.Commit(); err != nil { + t.Fatal(err) + } + // No new table or column migration is required: projection works after an + // existing database is closed and reopened, including historical rows. + if err := store.Close(); err != nil { + t.Fatal(err) + } + store, err = Open(path) + if err != nil { + t.Fatal(err) + } + runs, err := store.ListRuns(ctx) + if err != nil { + t.Fatal(err) + } + if len(runs) != 205 { + t.Fatal(len(runs)) + } + counter := &graphQueryCounter{DB: store.db} + if err := loadRunGraphEvidence(ctx, counter, runs); err != nil { + t.Fatal(err) + } + if counter.calls != 3 { + t.Fatalf("graph projection made %d queries for 205 runs; want 3, not N+1", counter.calls) + } + for _, run := range runs { + if run.GraphEvidence == nil || !run.GraphEvidence.Complete { + t.Fatalf("missing complete evidence: %+v", run) + } + if run.ID != first && len(run.GraphEvidence.Visits) != 0 { + t.Fatal("fabricated queued visit") + } + if run.ID == first { + visits := run.GraphEvidence.Visits + if len(visits) != 4 || visits[0].Sequence != 197 || visits[3].Sequence != 200 || visits[3].Status != "failed" { + t.Fatalf("lost latest stage or loop routes: %+v", visits) + } + encoded, _ := json.Marshal(run.GraphEvidence) + if strings.Contains(string(encoded), "PRIVATE") || strings.Contains(string(encoded), "input") || strings.Contains(string(encoded), "diagnostic") { + t.Fatal(string(encoded)) + } + } + } +} diff --git a/internal/pipeline/runs.go b/internal/pipeline/runs.go index bf642dda..cdca8705 100644 --- a/internal/pipeline/runs.go +++ b/internal/pipeline/runs.go @@ -6,6 +6,7 @@ import ( "database/sql" "encoding/json" "fmt" + "strings" "git.a-wan.net/alan/pipelines/internal/protocol" ) @@ -43,7 +44,12 @@ func scanRun(row interface{ Scan(...any) error }, r *protocol.RunSummary) error } func (s *Store) ListRuns(ctx context.Context) ([]protocol.RunSummary, error) { - rows, err := s.db.QueryContext(ctx, runSelect+" ORDER BY r.id DESC") + tx, err := s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true}) + if err != nil { + return nil, err + } + defer tx.Rollback() + rows, err := tx.QueryContext(ctx, runSelect+" ORDER BY r.id DESC") if err != nil { return nil, err } @@ -56,7 +62,66 @@ func (s *Store) ListRuns(ctx context.Context) ([]protocol.RunSummary, error) { } items = append(items, r) } - return items, rows.Err() + if err := rows.Err(); err != nil { + return nil, err + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := loadRunGraphEvidence(ctx, tx, items); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return items, nil +} + +// One projection query per bounded batch, not a GetRun per row. Window ranks +// collapse arbitrarily long loops while preserving every distinct taken route +// and the last status of each stage. Only the five public graph facts are read. +type runGraphQuerier interface { + QueryContext(context.Context, string, ...any) (*sql.Rows, error) +} + +func loadRunGraphEvidence(ctx context.Context, tx runGraphQuerier, runs []protocol.RunSummary) error { + const batchSize = 100 + for start := 0; start < len(runs); start += batchSize { + end := min(start+batchSize, len(runs)) + args := make([]any, 0, end-start) + byID := make(map[int64]*protocol.RunGraphEvidence, end-start) + for i := start; i < end; i++ { + evidence := &protocol.RunGraphEvidence{Complete: true, Visits: []protocol.RunGraphVisit{}} + runs[i].GraphEvidence = evidence + byID[runs[i].ID] = evidence + args = append(args, runs[i].ID) + } + rows, err := tx.QueryContext(ctx, `WITH visits AS ( +SELECT run_id,sequence,stage_key,status,outcome,target, +ROW_NUMBER() OVER (PARTITION BY run_id,stage_key ORDER BY sequence DESC) AS stage_rank, +ROW_NUMBER() OVER (PARTITION BY run_id,stage_key,outcome,target ORDER BY sequence DESC) AS route_rank +FROM run_steps WHERE run_id IN (`+strings.TrimSuffix(strings.Repeat("?,", len(args)), ",")+`)) +SELECT run_id,sequence,stage_key,status,outcome,target FROM visits +WHERE stage_rank=1 OR (route_rank=1 AND outcome<>'' AND target<>'') ORDER BY run_id,sequence`, args...) + if err != nil { + return err + } + for rows.Next() { + var id int64 + var visit protocol.RunGraphVisit + if err := rows.Scan(&id, &visit.Sequence, &visit.Stage, &visit.Status, &visit.Outcome, &visit.Target); err != nil { + rows.Close() + return err + } + byID[id].Visits = append(byID[id].Visits, visit) + } + err = rows.Err() + rows.Close() + if err != nil { + return err + } + } + return nil } func (s *Store) RunByKey(ctx context.Context, key string) (int64, error) { diff --git a/internal/protocol/runevents.go b/internal/protocol/runevents.go index 49dac46c..32921b8b 100644 --- a/internal/protocol/runevents.go +++ b/internal/protocol/runevents.go @@ -15,7 +15,8 @@ const ( // RunEventFrame is the server-pushed run_event delta. It carries only the values // that changed, never the whole run: the run's identity, status, outcome, current -// stage, completed-step count and timestamps, plus at most one changed step. +// stage, completed-step count and timestamps, plus the latest changed step and +// compact routing facts for all changed visits preserved during coalescing. // Every field is optional so an older peer ignores what it does not know and a // client can fold the frame into its cached run. // @@ -24,9 +25,13 @@ const ( // from the frame instead of re-reading the whole list. They repeat on every // frame (pipeline identity never changes mid-run). type RunEventFrame struct { - NotifyMode string `json:"notify_mode,omitempty"` - RunID int64 `json:"run_id"` - Workspace string `json:"workspace,omitempty"` + // GraphEvidence seeds a complete compact snapshot; GraphVisits preserves + // changed visits even when Step is replaced during frame coalescing. + GraphEvidence *RunGraphEvidence `json:"graph_evidence,omitempty"` + GraphVisits []RunGraphVisit `json:"graph_visits,omitempty"` + NotifyMode string `json:"notify_mode,omitempty"` + RunID int64 `json:"run_id"` + Workspace string `json:"workspace,omitempty"` // PipelineID, Name, Title and Version identify the run's pipeline and its // operator-facing title, so a new run's row can be built without a fetch. PipelineID int64 `json:"pipeline_id,omitempty"` diff --git a/internal/protocol/runs.go b/internal/protocol/runs.go index 9c34ff12..ac337dd7 100644 --- a/internal/protocol/runs.go +++ b/internal/protocol/runs.go @@ -134,10 +134,11 @@ type SessionExportRecovery struct { } type RunSummary struct { - NotifyMode string `json:"notify_mode,omitempty"` - ID int64 `json:"id"` - PipelineID int64 `json:"pipeline_id"` - Name string `json:"name"` + GraphEvidence *RunGraphEvidence `json:"graph_evidence,omitempty"` + NotifyMode string `json:"notify_mode,omitempty"` + ID int64 `json:"id"` + PipelineID int64 `json:"pipeline_id"` + Name string `json:"name"` // Title is the operator-facing, bounded single-line description of what the // run is for, generated from its prompt. It is never empty for a new run; // historical rows predating the title column may omit it. @@ -165,6 +166,22 @@ type RunSummary struct { OutputFormat string `json:"output_format,omitempty"` } +// RunGraphVisit contains only routing and lifecycle facts, never private step +// inputs, outputs, diagnostics, sessions or transcripts. Repeated loop visits +// are compacted to the latest stage visit and the latest visit of each route. +type RunGraphVisit struct { + Sequence int `json:"sequence"` + Stage string `json:"stage"` + Status string `json:"status"` + Outcome string `json:"outcome"` + Target string `json:"target"` +} + +type RunGraphEvidence struct { + Complete bool `json:"complete"` + Visits []RunGraphVisit `json:"visits"` +} + // Label is the operator-facing name of a run: the generated Title when the // server stored one, otherwise the pipeline Name (historical rows predate // titles). It is the single definition shared by the CLI and TUI. diff --git a/internal/server/run_graph_events_test.go b/internal/server/run_graph_events_test.go new file mode 100644 index 00000000..ceeb3123 --- /dev/null +++ b/internal/server/run_graph_events_test.go @@ -0,0 +1,79 @@ +package server + +import ( + "context" + "encoding/json" + "git.a-wan.net/alan/pipelines/internal/protocol" + "strings" + "testing" + "time" +) + +func TestGraphEvidenceSubscribeSnapshot(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + store, handler, ids := eventStore(t, ctx, "a", "b", "c") + definition, err := store.Get(ctx, ids[0], 1) + if err != nil { + t.Fatal(err) + } + id, _, err := store.CreateRun(ctx, definition, "graph-snapshot", "workspace", false, nil, nil) + if err != nil { + t.Fatal(err) + } + for index, key := range []string{"a", "b", "c"} { + sequence := index + 1 + if err := store.BeginStep(ctx, id, sequence, key, map[string]any{"prompt": "PRIVATE-PROMPT"}); err != nil { + t.Fatal(err) + } + status, outcome, target := "completed", "success", "b" + if key == "b" { + target = "c" + } + if key == "c" { + status, outcome, target = "failed", "", "" + } + if err := store.FinishStep(ctx, id, protocol.RunStep{Sequence: sequence, Status: status, Outcome: outcome, Target: target, Transcript: "PRIVATE-TRANSCRIPT"}); err != nil { + t.Fatal(err) + } + } + hub := newRunEventHub() + defer hub.unsubscribeClient("snapshot-test") + var messages []protocol.Message + if !handleRunEvents(protocol.Message{Type: protocol.Subscribe}, hub, handler.runner, "snapshot-test", func(message protocol.Message) error { messages = append(messages, message); return nil }) { + t.Fatal("unhandled subscribe") + } + if len(messages) != 2 || messages[0].RunEvent == nil || messages[1].Type != protocol.Subscribe { + t.Fatalf("snapshot/ack: %+v", messages) + } + evidence := messages[0].RunEvent.GraphEvidence + if evidence == nil || !evidence.Complete || len(evidence.Visits) != 3 || evidence.Visits[2].Status != "failed" { + t.Fatalf("missing persisted graph evidence: %+v", evidence) + } + encoded, _ := json.Marshal(messages[0]) + if strings.Contains(string(encoded), "PRIVATE") { + t.Fatal(string(encoded)) + } +} + +func TestCoalescedGraphVisitsRetainEveryStage(t *testing.T) { + hub := newRunEventHub() + hub.interval = time.Hour + sub := hub.subscribe("graph-test", "", nil, func(protocol.Message) error { return nil }) + defer sub.close() + // Hold subsequent frames in the coalescer without relying on wall-clock races. + hub.emit(protocol.RunEventFrame{RunID: 1, Status: "running"}, false) + for sequence, stage := range []string{"a", "b", "c"} { + hub.emit(protocol.RunEventFrame{RunID: 1, Step: &protocol.RunStepDelta{Sequence: sequence + 1, Stage: stage, Status: "completed", Outcome: "success", Target: "next", Diagnostic: "PRIVATE"}}, false) + } + hub.mu.Lock() + pending := hub.runs[1].pending + hub.stopTimerLocked(hub.runs[1]) + hub.mu.Unlock() + if pending == nil || len(pending.GraphVisits) != 3 || pending.Step.Stage != "c" { + t.Fatalf("coalescing lost evidence: %+v", pending) + } + if pending.GraphVisits[0].Stage != "a" || pending.GraphVisits[1].Stage != "b" { + t.Fatal(pending.GraphVisits) + } +} diff --git a/internal/server/runevents.go b/internal/server/runevents.go index 350064f7..0dcbcf2c 100644 --- a/internal/server/runevents.go +++ b/internal/server/runevents.go @@ -173,6 +173,9 @@ func (h *runEventHub) remove(sub *runSubscription) { // A terminal transition flushes any pending delta first, then the terminal frame // immediately, so a client always observes the final state as its own frame. func (h *runEventHub) emit(frame protocol.RunEventFrame, terminal bool) { + if step := frame.Step; step != nil { + frame.GraphVisits = append(frame.GraphVisits, protocol.RunGraphVisit{Sequence: step.Sequence, Stage: step.Stage, Status: step.Status, Outcome: step.Outcome, Target: step.Target}) + } if h == nil || frame.RunID <= 0 { return } @@ -470,6 +473,7 @@ func mergeRunEventFrame(into, in *protocol.RunEventFrame) { if in.Step != nil { into.Step = in.Step } + into.GraphVisits = append(into.GraphVisits, in.GraphVisits...) } // handleRunEvents dispatches one subscribe/unsubscribe request and reports @@ -505,6 +509,7 @@ func handleRunEvents(request protocol.Message, events *runEventHub, runs *runner continue } frame := protocol.RunEventFrame{ + GraphEvidence: summary.GraphEvidence, NotifyMode: summary.NotifyMode, RunID: summary.ID, Workspace: summary.Workspace, diff --git a/web/PARITY.md b/web/PARITY.md index 84b5e558..2d6e51dd 100644 --- a/web/PARITY.md +++ b/web/PARITY.md @@ -11,18 +11,27 @@ Status legend: `todo` · `partial` (some of it works) · `done` (working + captu ### List miniature follow-up (2026-10-20) Workflow and run miniatures now share the existing graph layout, right-aligned -inside their SVG as well as their row, with a 6px extra trailing inset. Runs use -the shared status palette; recorded visits/routes override the aggregate tint, -and known untaken branches are hollow/dashed. With summaries only, the tint is -the **run status**, not a claim that every stage executed. Topology comes from +inside their SVG as well as their row, with a 6px extra trailing inset. Run LIST +nodes now use each stage's last visit: success green, failure red, running +accent, waiting amber and queued a distinct muted tint. Unvisited/unknown nodes +are neutral hollow/dashed; **no aggregate run-status tint is inherited**. +Taken edges use recorded outcome/target routes, including loops and branches. +The additive `graph_evidence` summary projection reads only five routing/status +fields from `run_steps`, compacts repeated loops, and batches 100 run IDs per +query (not N detail fetches). Subscribe snapshots seed the same evidence; +coalesced live frames preserve every changed visit in `graph_visits` and the +client maintains last-stage/distinct-route evidence without a detail fetch. +Older summaries remain honestly unknown. Topology comes from the run's own graph, an exact-version pipeline summary, or one cached `get_pipeline(id, version)` read per endpoint/version (never `get_run` per row, -never a fallback to latest). Unavailable graphs stay absent. No server changes. +never a fallback to latest). Unavailable graphs stay absent. No schema migration +or new private input/output/transcript payload is needed. Scratch browser extension `test/miniatures-browser.mjs` verifies 390/420/1100px -alignment, distinct status colors, wrapped titles, separate applied filters and +alignment, two successful stages before failure plus never-visited branches, +waiting/running/queued states, legacy unknown evidence, wrapped titles, separate applied filters and no document overflow; captures and `geometry.json` are in -`/private/var/folders/jp/q0qvjyg54fl_c5vhhk1ylz2m0000gn/T/opencode/status-miniature-captures/`. +`/private/var/folders/jp/q0qvjyg54fl_c5vhhk1ylz2m0000gn/T/opencode/per-stage-run-miniatures-captures/`. These are deterministic fixture captures, not a new live-server parity claim. Collapsed desktop navigation additionally gives Expand its own 40px flow slot diff --git a/web/lists.css b/web/lists.css index 9a879a7c..dd91d60b 100644 --- a/web/lists.css +++ b/web/lists.css @@ -435,7 +435,7 @@ .pipeline-mini-node { fill: currentColor; opacity: 0.55; } .run-mini .pipeline-mini-node { opacity: 0.85; } .run-mini .pipeline-mini-edge { opacity: 0.8; } -.run-mini .mini-untaken { color: var(--muted); opacity: 0.4; stroke-dasharray: 2 2; } +.run-mini .mini-untaken { color: var(--color-muted); opacity: 0.4; stroke-dasharray: 2 2; } .run-mini .pipeline-mini-node.mini-untaken { fill: none; stroke: currentColor; stroke-width: 1; } .row.selected .pipeline-mini { color: var(--color-accent); } .row:hover .pipeline-mini { color: var(--color-text); } diff --git a/web/src/miniGraph.js b/web/src/miniGraph.js index 29af70fd..54ddb876 100644 --- a/web/src/miniGraph.js +++ b/web/src/miniGraph.js @@ -10,6 +10,8 @@ const NS = "http://www.w3.org/2000/svg"; const STATUSES = new Set(["succeeded", "failed", "running", "waiting", "queued", "interrupted", "canceled", "blocked", "skipped"]); export function miniatureColor(status) { + if (status === "waiting") return "var(--warn)"; + if (status === "running") return "var(--accent)"; return `var(--status-${STATUSES.has(status) ? status : "unknown"})`; } @@ -20,20 +22,22 @@ export function miniatureModel(graph, run = null) { edges: Object.fromEntries(Object.entries(stage.edges ?? {}).filter(([, target]) => keys.has(target))), })) }; const layout = layoutGraph(shape, METRICS); - const evidence = run && Array.isArray(run.steps) ? runGraphState(run) : null; - const visits = new Map((run?.steps ?? []).map((step) => [step.stage, step])); + const steps = Array.isArray(run?.steps) ? run.steps : run?.graph_evidence?.visits; + const evidence = Array.isArray(steps) ? runGraphState({ ...run, steps }) : null; + const visits = new Map((steps ?? []).map((step) => [step.stage, step])); return { ...layout, evidence: evidence != null, + complete: Array.isArray(run?.steps) || run?.graph_evidence?.complete === true, nodes: layout.nodes.map((node) => { const step = visits.get(node.key); // A recorded current stage is evidence even in a compact list summary. const current = run?.executing && run.current_stage === node.key; - const status = current ? run.status : step?.status; + const status = step?.status ?? (current ? run.status : null); const color = status === "completed" ? edgeStrokeColor(step.outcome) : status ? miniatureColor(status) : null; return { ...node, color, - untaken: evidence != null && !step && !current }; + untaken: Boolean(run) && !step && !current }; }), edges: layout.edges.map((edge) => ({ ...edge, - untaken: evidence != null && !edgeIsExecuted(edge, evidence), + untaken: Boolean(run) && (!evidence || !edgeIsExecuted(edge, evidence)), color: evidence && edgeIsExecuted(edge, evidence) ? edgeStrokeColor(edge.outcome) : null, })), }; @@ -53,6 +57,7 @@ export function renderMiniGraph(graph, run = null) { if (edge.points.length < 2) continue; const line = document.createElementNS(NS, "polyline"); line.setAttribute("class", `pipeline-mini-edge${edge.untaken ? " mini-untaken" : ""}`); + line.setAttribute("data-route", `${edge.source}:${edge.outcome}:${edge.target}`); line.setAttribute("points", edge.points.map((p) => `${p.x},${p.y}`).join(" ")); if (edge.color) line.style.color = edge.color; svg.append(line); @@ -60,14 +65,16 @@ export function renderMiniGraph(graph, run = null) { for (const node of model.nodes) { const rect = document.createElementNS(NS, "rect"); rect.setAttribute("class", `pipeline-mini-node${node.untaken ? " mini-untaken" : ""}`); + rect.setAttribute("data-stage", node.key); for (const key of ["x", "y", "width", "height"]) rect.setAttribute(key, String(node[key])); rect.setAttribute("rx", "3"); if (node.color) rect.style.color = node.color; svg.append(rect); } const wrap = h("span", { class: `pipeline-mini${run ? " run-mini" : ""}`, - "aria-hidden": "true", "data-evidence": model.evidence ? "visits" : "summary" }, svg); - if (run) wrap.style.color = miniatureColor(run.status); + "aria-hidden": "true", "data-evidence": model.evidence ? model.complete ? "visits" : "partial" : "unknown" }, svg); + // Unknown/unvisited graph elements must never inherit the aggregate result. + if (run) wrap.style.color = "var(--color-muted)"; return wrap; } diff --git a/web/src/runEvents.js b/web/src/runEvents.js index e0dc4f38..6ca55f3a 100644 --- a/web/src/runEvents.js +++ b/web/src/runEvents.js @@ -215,7 +215,10 @@ function applyRunStateFields(current, frame) { cancel_requested: before.cancel_requested || frame.cancel_requested === true, cleanup_unconfirmed: before.cleanup_unconfirmed || frame.cleanup_unconfirmed === true, }; + // Detail already maintains full visits below; compact evidence is list-only. + const graphEvidence = Array.isArray(current.steps) ? current.graph_evidence : mergeGraphEvidence(current.graph_evidence, frame); const changed = + graphEvidence !== current.graph_evidence || merged.notify_mode !== before.notify_mode || !sameResourceWait(merged.resource_wait, before.resource_wait) || merged.status !== before.status || @@ -227,7 +230,33 @@ function applyRunStateFields(current, frame) { merged.executing !== before.executing || merged.cancel_requested !== before.cancel_requested || merged.cleanup_unconfirmed !== before.cleanup_unconfirmed; - return changed ? { ...current, ...merged } : current; + return changed ? { ...current, ...merged, ...(graphEvidence ? { graph_evidence: graphEvidence } : {}) } : current; +} + +// Reuse the detail's monotonic visit merge, then compact by last stage visit and +// distinct route. Keep completeness separate: a delta from an older server or +// a mid-run first frame cannot prove that earlier stages were never visited. +function mergeGraphEvidence(current, frame) { + if (!frame.graph_evidence && !frame.graph_visits?.length && !frame.step) return current; + let visits = current?.visits ?? []; + const incoming = [...(frame.graph_evidence?.visits ?? []), ...(frame.graph_visits ?? []), + ...(frame.step ? [frame.step] : [])]; + for (const step of incoming) { + const { sequence, stage, status, outcome, target } = step; + visits = upsertStep(visits, { sequence, stage, status, outcome, target }); + } + const latest = new Map(); + const routes = new Map(); + for (const visit of visits) { + latest.set(visit.stage, visit.sequence); + if (visit.outcome && visit.target) routes.set(JSON.stringify([visit.stage, visit.outcome, visit.target]), visit.sequence); + } + visits = visits.filter((visit) => latest.get(visit.stage) === visit.sequence || + (visit.outcome && visit.target && routes.get(JSON.stringify([visit.stage, visit.outcome, visit.target])) === visit.sequence)); + // Explicit allowlist: graph evidence never copies diagnostic/private fields. + visits = visits.map(({ sequence, stage, status, outcome, target }) => ({ sequence, stage, status, outcome, target })); + const result = { complete: Boolean(current?.complete || frame.graph_evidence?.complete), visits }; + return JSON.stringify(result) === JSON.stringify(current) ? current : result; } /** @@ -240,7 +269,9 @@ export function newRunSummaryFromFrame(frame) { const pipelineId = Number(frame?.pipeline_id); const name = String(frame?.name ?? ""); if (!(pipelineId > 0) || blank(name)) return null; + const graphEvidence = mergeGraphEvidence(null, frame); return { + ...(graphEvidence ? { graph_evidence: graphEvidence } : {}), resource_wait: frame.resource_wait ?? null, id: Number(frame.run_id), pipeline_id: pipelineId, diff --git a/web/test/miniGraph-events.test.mjs b/web/test/miniGraph-events.test.mjs new file mode 100644 index 00000000..5aeb679d --- /dev/null +++ b/web/test/miniGraph-events.test.mjs @@ -0,0 +1,35 @@ +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { foldRunEvent } from "../src/runEvents.js"; +import { miniatureModel } from "../src/miniGraph.js"; + +test("coalesced live visits update list nodes and routes without a detail fetch", () => { + const identity = { run_id: 1, pipeline_id: 7, name: "Run", version: 2 }; + let runs = foldRunEvent([], { ...identity, status: "running", graph_evidence: { complete: true, visits: [] } }).runs; + const visits = [ + { sequence: 1, stage: "a", status: "completed", outcome: "success", target: "b" }, + { sequence: 2, stage: "b", status: "completed", outcome: "success", target: "c" }, + { sequence: 3, stage: "c", status: "running", diagnostic: "PRIVATE" }, + ]; + runs = foldRunEvent(runs, { ...identity, status: "running", current_stage: "c", graph_visits: visits, step: visits[2] }).runs; + runs = foldRunEvent(runs, { ...identity, status: "failed", step: { sequence: 3, stage: "c", status: "failed" } }).runs; + const model = miniatureModel({ stages: [ + { key: "a", edges: { success: "b", error: "never" } }, + { key: "b", edges: { success: "c" } }, { key: "c", edges: {} }, { key: "never", edges: {} }, + ] }, runs[0]); + assert.deepEqual(model.nodes.map((n) => n.color), ["var(--ok)", "var(--ok)", "var(--status-failed)", null]); + assert.equal(model.edges.filter((e) => !e.untaken).length, 2); + assert.equal(JSON.stringify(runs[0].graph_evidence).includes("PRIVATE"), false); + const same = foldRunEvent(runs, { ...identity, status: "running", graph_visits: visits }).runs; + assert.equal(same, runs); +}); + +test("partial legacy deltas do not manufacture complete history; loops compact", () => { + let runs = [{ id: 1, status: "running" }]; + for (let sequence = 1; sequence <= 100; sequence++) { + runs = foldRunEvent(runs, { run_id: 1, step: { sequence, stage: "a", status: "completed", outcome: "success", target: "a" } }).runs; + } + assert.equal(runs[0].graph_evidence.complete, false); + assert.equal(runs[0].graph_evidence.visits.length, 1); + assert.equal(runs[0].graph_evidence.visits[0].sequence, 100); +}); diff --git a/web/test/miniGraph.test.mjs b/web/test/miniGraph.test.mjs index 8524fab9..1317e8bb 100644 --- a/web/test/miniGraph.test.mjs +++ b/web/test/miniGraph.test.mjs @@ -12,18 +12,44 @@ test("miniatures retain real stage routes, without terminals or fabricated visit assert.deepEqual(model.nodes.map((n) => n.key).sort(), ["a", "b", "c"]); assert.equal(model.edges.length, 2); assert.equal(model.evidence, false); - assert.ok(model.nodes.every((n) => n.color === null && !n.untaken)); + assert.ok(model.nodes.every((n) => n.color === null && n.untaken)); +}); +test("compact list evidence preserves successes before failure and last loop status", () => { + const loopGraph = { stages: [ + { key: "a", edges: { success: "b", error: "never" } }, + { key: "b", edges: { success: "c" } }, + { key: "c", edges: { retry: "a", error: "never" } }, + { key: "never", edges: {} }, + ] }; + const visits = [ + { sequence: 1, stage: "a", status: "completed", outcome: "success", target: "b" }, + { sequence: 2, stage: "b", status: "completed", outcome: "success", target: "c" }, + { sequence: 3, stage: "c", status: "completed", outcome: "retry", target: "a" }, + { sequence: 4, stage: "a", status: "failed", outcome: "", target: "" }, + ]; + const model = miniatureModel(loopGraph, { status: "failed", graph_evidence: { complete: true, visits } }); + assert.equal(model.nodes.find((n) => n.key === "a").color, "var(--status-failed)"); + assert.equal(model.nodes.find((n) => n.key === "b").color, "var(--ok)"); + assert.equal(model.nodes.find((n) => n.key === "never").color, null); + assert.equal(model.nodes.find((n) => n.key === "never").untaken, true); + assert.equal(model.edges.filter((e) => !e.untaken).length, 3); + assert.ok(model.edges.filter((e) => e.outcome === "error").every((e) => e.untaken)); + for (const status of ["waiting", "running", "queued"]) { + const next = miniatureModel(loopGraph, { status, current_stage: "a", executing: status !== "waiting", + graph_evidence: { complete: true, visits: [...visits.slice(0, 3), { sequence: 4, stage: "a", status }] } }); + assert.equal(next.nodes.find((n) => n.key === "a").color, miniatureColor(status)); + } }); test("visited stages/routes use evidence; unvisited branches remain hollow", () => { const model = miniatureModel(graph, { status: "waiting", executing: true, current_stage: "b", steps: [{ stage: "a", status: "completed", outcome: "success", target: "b" }] }); assert.equal(model.nodes.find((n) => n.key === "a").color, "var(--ok)"); - assert.equal(model.nodes.find((n) => n.key === "b").color, "var(--status-waiting)"); + assert.equal(model.nodes.find((n) => n.key === "b").color, "var(--warn)"); assert.equal(model.nodes.find((n) => n.key === "c").untaken, true); assert.equal(model.edges.find((e) => e.outcome === "success").color, "var(--ok)"); assert.equal(model.edges.find((e) => e.outcome === "error").untaken, true); for (const status of ["succeeded", "failed", "running", "waiting", "interrupted", "queued", "canceled"]) { - assert.equal(miniatureColor(status), `var(--status-${status})`); + assert.equal(miniatureColor(status), status === "waiting" ? "var(--warn)" : status === "running" ? "var(--accent)" : `var(--status-${status})`); } }); test("cache deduplicates pinned reads, rejects latest mismatches and scopes by endpoint", async () => { diff --git a/web/test/miniatures-browser.mjs b/web/test/miniatures-browser.mjs index cd70d269..620dc566 100644 --- a/web/test/miniatures-browser.mjs +++ b/web/test/miniatures-browser.mjs @@ -62,17 +62,22 @@ try { const graph = { stages: [{ key:'plan', edges:{success:'build',error:'reject'} }, {key:'build',edges:{success:'finish'}},{key:'reject',edges:{error:'#failure'}}, {key:'finish',edges:{success:'#success'}}] }; - const statuses = ['succeeded','failed','running','interrupted','waiting','queued']; + const statuses = ['succeeded','failed','running','interrupted','waiting','queued','failed']; + const visits = (status) => status === 'queued' ? [] : [ + {sequence:1,stage:'plan',status:'completed',outcome:'success',target:'build'}, + {sequence:2,stage:'build',status:'completed',outcome:'success',target:'finish'}, + {sequence:3,stage:'finish',status:status==='succeeded'?'completed':status, + outcome:status==='succeeded'?'success':'',target:status==='succeeded'?'#success':''}]; const state = { view:'runs', url:'scratch', loading:false, selectedRunId:1, openMenu:null, runFilters:{...defaultRunFilters(),pipelineId:7}, runSort:'server_order', pipelineFilters:{...EMPTY_PIPELINE_FILTERS},pipelineSort:'server_order', pipelinesLoaded:true, runsLoaded:true, pipelines:[{id:7,name:'Pinned workflow',version:3,stages:4,shape:graph}], runs:statuses.map((status,i)=>({id:i+1,pipeline_id:7,version:2,name:'Pinned workflow', title:'A wrapped run title that preserves the complete task context across narrow screens '+status, - status,executing:['running','waiting'].includes(status),current_stage:'build', - created_at:new Date().toISOString(),steps:i===0?[ - {stage:'plan',status:'completed',outcome:'success',target:'build'}, - {stage:'build',status:'completed',outcome:'success',target:'finish'}]:undefined})) }; + status,executing:['running','queued'].includes(status),current_stage:status==='queued'?'plan':'finish', + completed_steps:status==='queued'||i===6?0:status==='succeeded'?3:2, + created_at:new Date().toISOString(), + ...(i===6?{current_stage:'',executing:false}:{graph_evidence:{complete:true,visits:visits(status)}})})) }; let runs, pipelines; const renderContent=()=>document.querySelector('#content').replaceChildren( state.view==='runs'?runs.renderRunList():pipelines.renderPipelineList()); @@ -93,9 +98,13 @@ try { rows:rows.map(row=>{const mini=row.querySelector('.pipeline-mini');const r=row.getBoundingClientRect(); const m=mini.getBoundingClientRect();const svg=mini.querySelector('svg');const node=svg.querySelector('rect'); const status=row.querySelector('.status-icon')?.dataset.status; - const swatch=document.createElement('span');swatch.style.color='var(--status-'+status+')';mini.append(swatch); + const swatch=document.createElement('span');swatch.style.color=status==='waiting'?'var(--warn)':status==='running'?'var(--accent)':'var(--status-'+status+')';mini.append(swatch); const expectedColor=getComputedStyle(swatch).color;swatch.remove(); - return {inset:r.right-m.right,align:svg.getAttribute('preserveAspectRatio'),status,expectedColor, + const nodes=[...svg.querySelectorAll('rect')].map(n=>({stage:n.dataset.stage, + color:getComputedStyle(n).color,fill:getComputedStyle(n).fill,untaken:n.classList.contains('mini-untaken')})); + const edges=[...svg.querySelectorAll('polyline')].map(n=>({route:n.dataset.route, + color:getComputedStyle(n).color,untaken:n.classList.contains('mini-untaken')})); + return {id:Number(row.dataset.runId),nodes,edges,evidence:mini.dataset.evidence,inset:r.right-m.right,align:svg.getAttribute('preserveAspectRatio'),status,expectedColor, color:getComputedStyle(mini).color,nodeColor:getComputedStyle(node).color, right:m.right,rowRight:r.right, rowWidth:r.width,parentWidth:row.parentElement.clientWidth, selected:row.classList.contains('selected')};}), @@ -109,19 +118,60 @@ try { if (view === 'runs') { assert.equal(geometry.titleWrap, true); assert.equal(geometry.filterSeparate, true); - assert.notEqual(geometry.rows[0].color, geometry.rows[1].color); - assert.notEqual(geometry.rows[2].color, geometry.rows[4].color); - assert.ok(geometry.rows.every((row)=>row.color===row.expectedColor)); + const node=(row,stage)=>row.nodes.find(n=>n.stage===stage); + const byId=(id)=>geometry.rows.find(row=>row.id===id); + const failed=byId(2); + assert.equal(node(failed,'plan').color,node(failed,'build').color); + assert.notEqual(node(failed,'build').color,node(failed,'finish').color); + assert.equal(node(failed,'finish').color,failed.expectedColor); + assert.equal(node(failed,'reject').fill,'none'); + assert.equal(node(failed,'reject').untaken,true); + assert.equal(failed.edges.filter(e=>!e.untaken).length,2); + assert.ok(failed.edges.filter(e=>e.route.includes(':error:')).every(e=>e.untaken)); + assert.equal(byId(7).evidence,'unknown'); + assert.ok(byId(7).nodes.every(n=>n.untaken && n.fill==='none')); + for (const row of geometry.rows.filter(row=>row.id!==7)) { + assert.equal(row.evidence,'visits'); + if (['running','waiting','queued'].includes(row.status)) { + assert.equal(node(row,row.status==='queued'?'plan':'finish').color,row.expectedColor); + } + } + assert.notEqual(node(byId(3),'finish').color,node(byId(5),'finish').color); const selected=geometry.rows.find(row=>row.selected); assert.equal(selected.rowWidth,selected.parentWidth); } results.push({view,...geometry}); await page.screenshot(resolve(out, `${view}-${width}.png`)); if (view === 'runs') { - await page.evaluate(`document.querySelector('.run-row[data-run-id="1"]').scrollIntoView({block:'end'})`); + await page.evaluate(`document.querySelector('.run-row[data-run-id="2"]').scrollIntoView({block:'center'})`); await page.screenshot(resolve(out, `runs-evidence-${width}.png`)); } } + for (const status of ['waiting','failed']) { + await page.evaluate(`(async () => { + const {foldRunEvent}=await import('/src/runEvents.js'); + window.beforeLiveRuns??=fixtureState.runs; + fixtureState.view='runs'; + fixtureState.runs=foldRunEvent(fixtureState.runs,{run_id:3,status:${JSON.stringify(status)}, + current_stage:'finish',step:{sequence:3,stage:'finish',status:${JSON.stringify(status)}}}).runs; + paintFixture(); + document.querySelector('.run-row[data-run-id="3"]').scrollIntoView({block:'center'}); + })()`); + const live = await page.evaluate(`(() => { + const mini=document.querySelector('.run-row[data-run-id="3"] .run-mini'); + const nodes=[...mini.querySelectorAll('rect')]; + return {colors:nodes.map(n=>getComputedStyle(n).color), + taken:mini.querySelectorAll('polyline:not(.mini-untaken)').length, + unknown:mini.querySelectorAll('rect.mini-untaken').length}; + })()`); + assert.equal(live.colors[0],live.colors[1]); + assert.equal(live.taken,2); + assert.equal(live.unknown,1); + assert.notEqual(live.colors[0],live.colors[3]); + await page.screenshot(resolve(out, `runs-live-${status}-${width}.png`)); + results.push({view:'live-'+status,width,...live}); + } + await page.evaluate(`fixtureState.runs=beforeLiveRuns;beforeLiveRuns=null;paintFixture()`); } await writeFile(resolve(out, 'geometry.json'), JSON.stringify(results,null,2)); await page.close();