From 94d4ff02d334cae726a9490a59261d9d28d388be Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Mon, 19 Oct 2026 04:05:37 +0100 Subject: [PATCH] web: run detail Graph tab with executed styling and stage panes (R5) Add the run detail's Graph tab (between Summary and Input), reusing the shared src/graph.js renderer (P6) rather than a second renderer. In run mode a visited stage is executed (solid fill + border), an unvisited one hollow with a dashed muted border; a terminal is executed only when a visit resolved to it; a route is executed only when a recorded visit produced that outcome (solid with an arrowhead, success first, error last, others alphabetical, `error*` for the fallback). The Executed / Not executed legend shows only for a run. While the run executes the current stage carries a pulsing halo (static under prefers-reduced-motion) and a ticking elapsed badge; a finished run shows neither. Clicking a stage opens the existing visit pane at that stage's latest visit, and Back/Escape return focus. The empty state is the exact "This server did not include the run graph." extend src/graph.js with the run-mode inputs (runState-driven executed styling, legend, active halo/elapsed badge); keep app.js to wiring. Extend graph.test.mjs with focused run-mode unit tests and ui-smoke.mjs with the run 438 / run 440 / live-run captures. Mark R5 done in web/PARITY.md. Checks: node --check on every touched file; cd web && node --test test/ (178 pass, 0 fail); cd web && node test/ui-smoke.mjs --out captures (UI SMOKE PASS, captures 28-31). --- web/PARITY.md | 9 +-- web/src/app.js | 79 ++++++++++++++++++--- web/src/graph.js | 121 ++++++++++++++++++++++++++++--- web/src/runDetail.js | 70 ++++++++++++++++-- web/styles.css | 68 ++++++++++++++++++ web/test/graph.test.mjs | 112 +++++++++++++++++++++++++++++ web/test/runDetail.test.mjs | 4 +- web/test/ui-smoke.mjs | 138 +++++++++++++++++++++++++++++++++++- 8 files changed, 569 insertions(+), 32 deletions(-) diff --git a/web/PARITY.md b/web/PARITY.md index a2d8ab9d..ec8e8403 100644 --- a/web/PARITY.md +++ b/web/PARITY.md @@ -26,16 +26,16 @@ Status legend: `todo` · `partial` (some of it works) · `done` (working + captu | P3 | Pipeline detail: stages, graph, versions, last run, content hash | `get_pipeline` | done — Summary/Graph/Source tabs; Summary shows content hash (monospace), latest version (`v{n}` or blank), created/updated, and a collapsed-by-default Versions section. Graph tab shows the browser guidance note plus the rendered workflow graph (P6) | | P4 | Templates gallery + template detail | `list_templates`, `validate` | done | | P5 | Create pipeline from a template (validate then submit) | `validate`, `submit` | todo | -| P6 | Workflow graph rendering (nodes, edges, stage panes) | `get_pipeline` | done (captured 2026-10-19: nodes + labelled outcome edges + success/failure terminals, an opened stage definition pane and the expanded view — `captures/08-pipeline-graph.png`, `captures/08a-pipeline-graph-stage-pane.png`, `captures/08b-pipeline-graph-expanded.png`). Reusable `src/graph.js` (`mount` + pure helpers: layout, edges, `error*`, lanes, fit/clamp/zoom, hit-test, stage-definition fields); definition view only, so R5's run-detail Graph tab stays todo. Pane labels match the app's own vocabulary (`Outcomes`, `Tools`) rather than the checklist's category words | +| P6 | Workflow graph rendering (nodes, edges, stage panes) | `get_pipeline` | done (captured 2026-10-19: nodes + labelled outcome edges + success/failure terminals, an opened stage definition pane and the expanded view — `captures/08-pipeline-graph.png`, `captures/08a-pipeline-graph-stage-pane.png`, `captures/08b-pipeline-graph-expanded.png`). Reusable `src/graph.js` (`mount` + pure helpers: layout, edges, `error*`, lanes, fit/clamp/zoom, hit-test, stage-definition fields); the definition view (every route executed, no legend) plus, since R5, a run-mode view driven by `runState` (executed/not-executed stages and routes, the Executed / Not executed legend, the live halo/elapsed badge). Pane labels match the app's own vocabulary (`Outcomes`, `Tools`) rather than the checklist's category words | ## Runs | # | Feature | Protocol | Status | | --- | --- | --- | --- | | R1 | Run history list with status roll-up | `list_runs` | done | | R2 | Filter by status, sort, "needs you" markers | client-side | partial (status/pipeline/time filter + sort implemented and captured; the per-row "needs you" mark has no Android counterpart and its wording is deferred to R15, still todo) | -| R3 | Run detail: run fields, steps/visits, targets, sessions | `get_run` | done — tabbed Summary / Input / Output / Timeline; the Timeline opens a per-visit stage pane with the headline rows (Status, Outcome, Duration, Visit `{v} / {max}`, Model target, Target, Session), the Verdict block (option chip + reason with inline artifact links) and the visit sections Artifacts / Session / Output / Input / This run / Stage definition. Captured 2026-10-19: `captures/20-run-430-summary.png`, `captures/23-run-430-timeline.png`, `captures/24-run-430-stage-artifacts.png`, `captures/25-run-440-verdict.png` | +| R3 | Run detail: run fields, steps/visits, targets, sessions | `get_run` | done — tabbed Summary / Graph / Input / Output / Timeline; the Timeline opens a per-visit stage pane with the headline rows (Status, Outcome, Duration, Visit `{v} / {max}`, Model target, Target, Session), the Verdict block (option chip + reason with inline artifact links) and the visit sections Artifacts / Session / Output / Input / This run / Stage definition. Captured 2026-10-19: `captures/20-run-430-summary.png`, `captures/23-run-430-timeline.png`, `captures/24-run-430-stage-artifacts.png`, `captures/25-run-440-verdict.png` | | R4 | Summary tab incl. collapsible **Changes** viewer (raw + rendered diff) | `get_run` file changes | todo | -| R5 | Graph tab (per-stage panes, verdicts) | `get_run` | todo | +| R5 | Graph tab (per-stage panes, verdicts) | `get_run` | done — the run detail's Graph tab (between Summary and Input) mounts the shared `src/graph.js` renderer in run mode with the app's run note: a visited stage is executed (solid fill + border), an unvisited one hollow with a dashed muted border, a terminal executed only when a visit resolved to it, a route executed only when a visit produced that outcome (solid with an arrowhead; success first, error last, others alphabetical, `error*` for a fallback error route), the Executed / Not executed legend (runs only, never the definition view), and — while executing — the current stage's pulsing halo + elapsed badge (a static ring under `prefers-reduced-motion`; nothing for a finished run). Clicking a stage opens the existing visit pane at that stage's latest visit with its Verdict; Back/Escape close it and restore focus. The empty state is the exact `This server did not include the run graph.` (unit-tested; no live run currently carries a graph-less payload). Captured 2026-10-19: `captures/28-run-438-graph.png` (finished run 438: legend + executed styling + dashed untaken routes), `captures/29-run-438-graph-pane.png` (a graph-opened stage pane showing a Verdict), `captures/30-run-440-graph.png` (failed run 440: hollow/dashed not-executed stages) | | R6 | Input / Output field sections per stage | `get_run` | done — one collapsed section per recorded entry, expanded as a monospace block (primitives verbatim, arrays `, `-joined, objects `k=v` `, `-joined), empty states "No input recorded." / "No output recorded.". Captured 2026-10-19: `captures/21-run-430-input.png`, `captures/22-run-430-output.png`, `captures/27-run-output-empty.png` | | R7 | Timeline | `get_run` | done — one compact row per visit (`{stage} · visit {n}`, stage-outcome chip, paperclip when artifacts recorded, duration, description = first non-blank diagnostic line else `→ {target}`); empty state "No visits recorded.". Captured 2026-10-19: `captures/23-run-430-timeline.png`, `captures/26-run-428-timeline-empty.png` | | R8 | Artifacts gallery + full-screen viewer (images inline, others download/open) | `GET /artifacts/…` | done (captured 2026-10-19: `captures/04-run-430-artifacts.png`, `captures/05-artifact-viewer.png`) | @@ -52,7 +52,8 @@ choice: the visit's exported session is titled **Session** (the item text said "Session export"; Android's `STAGE_SESSION_TITLE` is `Session`), and the step's `session_id` renders as a **headline** row (Status, Outcome, Duration, Visit, Model target, Target, Session), so it is not repeated in the "This run" evidence -section. R5 (Graph tab) deliberately leaves the tab's body unimplemented. +section. R5's Graph tab now renders that same shared graph in run mode (see the +row above), reusing the visit pane this section describes. ## Search | # | Feature | Protocol | Status | diff --git a/web/src/app.js b/web/src/app.js index 7629227c..3c2010f2 100644 --- a/web/src/app.js +++ b/web/src/app.js @@ -24,6 +24,8 @@ import { } from "./artifacts.js"; import { PIPELINE_GRAPH_EMPTY, + RUN_GRAPH_MISSING, + RUN_GRAPH_NOTE, mount as mountGraph, } from "./graph.js"; import { @@ -87,6 +89,7 @@ import { runLabelFor, runDurationText, runTimeline, + runGraphState, nodeLabel, headlineFields, runStepFields, @@ -142,6 +145,10 @@ const state = { // handle is dropped on every re-render so its listeners can never leak. pipelineGraph: null, pipelineGraphExpanded: false, + // The mounted run-mode graph (R5) on the run detail's Graph tab. Dropped on + // every re-render and on a run change, so its wheel/pointer/resize listeners + // and its elapsed timer can never leak. + runGraph: null, versionsExpanded: false, pipelinesLoaded: false, runsLoaded: false, @@ -268,6 +275,10 @@ function renderContent() { state.pipelineGraph.unmount(); state.pipelineGraph = null; } + if (state.runGraph) { + state.runGraph.unmount(); + state.runGraph = null; + } const nodes = []; if (state.error) { nodes.push(h("div", { class: "banner error" }, h("strong", { text: "Error: " }), state.error)); @@ -1081,12 +1092,13 @@ function closeMenu() { } /** - * The run detail: a tab strip (Summary / Input / Output / Timeline) over the - * selected tab's body, wired from the pure helpers in runDetail.js. Summary is - * the default and carries the run's identity, key/value rows and diagnostic; - * Input/Output are one collapsed section per recorded field; the Timeline is one - * compact row per visit that opens the stage pane. Every server string is set - * with textContent, never innerHTML. + * The run detail: a tab strip (Summary / Graph / Input / Output / Timeline) over + * the selected tab's body, wired from the pure helpers in runDetail.js. Summary + * is the default and carries the run's identity, key/value rows and diagnostic; + * the Graph tab mounts the shared workflow graph in run mode; Input/Output are + * one collapsed section per recorded field; the Timeline is one compact row per + * visit that opens the stage pane. Every server string is set with textContent, + * never innerHTML. */ function renderRunDetail() { const d = state.runDetail; @@ -1111,7 +1123,9 @@ function renderRunDetail() { ), ), ); - if (state.runTab === "input") { + if (state.runTab === "graph") { + pane.append(renderRunGraphTab(d)); + } else if (state.runTab === "input") { pane.append(renderRunFieldTab(d.input, "input", EMPTY_INPUT_MESSAGE)); } else if (state.runTab === "output") { pane.append(renderRunFieldTab(d.output, "output", EMPTY_OUTPUT_MESSAGE)); @@ -1124,6 +1138,41 @@ function renderRunDetail() { return pane; } +/** + * The Graph tab (R5): the run's own guidance note plus the shared workflow graph + * mounted in run mode, or the app's exact missing-graph sentence when the server + * sent no stages. The active stage pulses with its elapsed time while the run + * executes; clicking a stage opens the existing visit pane at that stage's most + * recent visit. The mount handle is tracked in `state.runGraph` so a re-render + * (or a tab/run change) always unmounts the previous wheel/pointer/resize + * listeners and the elapsed timer. + */ +function renderRunGraphTab(d) { + const wrap = h("div", { class: "run-tab-body" }); + const stages = d.graph?.stages ?? []; + if (!stages.length) { + wrap.append(h("div", { class: "run-empty muted", text: RUN_GRAPH_MISSING })); + return wrap; + } + wrap.append(h("p", { class: "graph-note muted", text: RUN_GRAPH_NOTE })); + const host = h("div", { class: "graph-host" }); + wrap.append(host); + state.runGraph = mountGraph(host, d.graph, { + runState: runGraphState(d), + onStageTap: (key) => openStagePane(key, latestVisitIndex(d, key)), + }); + return wrap; +} + +/** + * The visit index the graph opens for a stage: its most recent recorded visit + * (`visits.size - 1`, never negative), exactly as RunGraphTab computes it. + */ +function latestVisitIndex(d, key) { + const visits = runTimeline(d.steps ?? []).visitsByStage.get(key) ?? []; + return Math.max(0, visits.length - 1); +} + /** The Summary tab: identity, chip row, key/value rows, diagnostic and gallery. */ function renderRunSummaryTab(d) { const wrap = h("div", { class: "run-tab-body" }); @@ -1488,7 +1537,14 @@ function closeStagePane() { const row = [...document.querySelectorAll(".timeline-row")].find( (node) => node.dataset.stageKey === closing.stageKey && node.dataset.visitIndex === String(closing.visitIndex), ); - row?.focus(); + // A pane opened from the Timeline returns to its row; one opened from the Graph + // returns to the stage node that opened it (there is no timeline row then). + const focusTarget = + row ?? + [...document.querySelectorAll(".graph-node")].find( + (candidate) => candidate.dataset.key === closing.stageKey, + ); + focusTarget?.focus(); } /** Whether the configured server URL can resolve a server-relative artifact. */ @@ -1963,9 +2019,12 @@ async function selectPipeline(summary) { async function selectRun(id, { silent = false } = {}) { state.selectedRunId = id; if (!silent) { - state.runDetail = null; // A different run reseeds the detail: Summary tab, every section closed and - // no stage pane left over from the run the operator navigated away from. + // no stage pane left over from the run the operator navigated away from. Drop + // the mounted run graph first so a live run's timer can never outlive it. + state.runGraph?.unmount(); + state.runGraph = null; + state.runDetail = null; state.runTab = "summary"; state.runSections = new Set(); state.runStagePane = null; diff --git a/web/src/graph.js b/web/src/graph.js index 1816ba43..c93f8fb3 100644 --- a/web/src/graph.js +++ b/web/src/graph.js @@ -26,6 +26,7 @@ import { Protocol, isTerminal, resolveTarget } from "./protocol.js"; import { effectiveStageType } from "./templates.js"; +import { formatDuration, secondsSince } from "./runs.js"; // Re-exported so a caller (and the unit tests) can reach the shared "blank is // the model stage" rule from the graph module it belongs to without a second @@ -61,6 +62,19 @@ const DRAG_THRESHOLD = 4; /** The run tab's empty state when the server omitted the run graph (R5). */ export const RUN_GRAPH_MISSING = "This server did not include the run graph."; +/** + * The run tab's guidance note: the browser adaptation of RunGraphTab's own + * sentence, so the app's pinch/tap become mouse wheel/click while everything + * else (the live pulse, the settled finish, the executed/not-executed shapes) + * stays verbatim. + */ +export const RUN_GRAPH_NOTE = + "The running stage pulses with its elapsed time and executed routes flow; " + + "a finished run settles, and with animations off the running stage stays marked. " + + "Solid means executed, dashed and outlined not executed; executed success and " + + "failure routes are drawn thickest. Mouse wheel to zoom, drag to pan, " + + "click a stage for details."; + /** * The pipeline detail's empty state when the parsed definition declares no * stages. The template gallery has its own Android-authored analogue @@ -203,6 +217,18 @@ export function edgeIsExecuted(edge, runState) { return inSet(runState.takenRoutes, edge) || inSet(runState.takenRoutes, edge.id); } +/** + * The key of the stage a run is executing right now, else null. Only a live run + * (still `executing`) has an active stage, so a finished run never carries a + * halo or an elapsed badge. Pure: drawing, the elapsed badge and the tests share + * one definition of "active". + */ +export function activeStage(runState) { + if (runState == null || !runState.executing) return null; + const key = runState.currentStage; + return key == null || key === "" ? null : key; +} + // --------------------------------------------------------------------------- // Pure viewport maths (WorkflowGraph.kt) // --------------------------------------------------------------------------- @@ -895,19 +921,38 @@ function pathFromPoints(points) { * space does nothing. * * Options: - * runState — omitted for the definition view (every route executed); - * R5 passes `{ visitedStages, takenRoutes }` to dash the - * routes a run did not take. + * runState — omitted for the definition view (every route executed and + * no legend); R5 passes the `runGraphState(run)` shape + * ({ visitedStages, takenRoutes, currentStage, executing, + * currentStageStartedAt }) to render the run: executed nodes + * solid, unvisited ones hollow/dashed, executed routes + * arrowed, the live stage's halo + elapsed badge and the + * Executed / Not executed legend. + * animationsEnabled — honour the caller's animation gate. Defaults to the + * page's `prefers-reduced-motion` setting; when false the + * active stage keeps a static ring instead of pulsing. * expanded — start with the taller panel. - * onStageTap — called with the node key on a node click. + * onStageTap — called with the node key on a node click. When supplied + * (the run tab), the click opens the caller's own stage + * pane and no definition pane is drawn. * onExpandedChange — called with the new expanded flag on toggle. * metrics — layout metrics override (tests). * * Returns `{ unmount }`; call it before discarding the container so the wheel, - * pointer and resize listeners never leak. + * pointer, resize and elapsed-timer handles never leak. */ export function mount(container, graph, options = {}) { const runState = options.runState ?? null; + const activeKey = activeStage(runState); + const reducedMotion = + typeof window !== "undefined" && + typeof window.matchMedia === "function" && + window.matchMedia("(prefers-reduced-motion: reduce)").matches; + // The caller may force animations off; otherwise the page's motion preference + // decides. A finished run never animates regardless (activeKey is null then). + const animationsEnabled = + options.animationsEnabled === undefined ? !reducedMotion : Boolean(options.animationsEnabled); + const pulse = activeKey != null && animationsEnabled; const layout = layoutGraph(graph, options.metrics); const stagesByKey = new Map((graph?.stages ?? []).map((stage) => [stage.key, stage])); @@ -983,6 +1028,7 @@ export function mount(container, graph, options = {}) { // Node layer: real buttons, positioned in graph space. const nodeLayer = el("div", "graph-node-layer"); + let elapsedBadge = null; for (const node of layout.nodes) { const kind = graphNodeKind(node.terminal, node.key, stagesByKey.get(node.key)?.type); const button = el("button", `graph-node ${nodeKindClass(kind)}`, node.label); @@ -998,13 +1044,25 @@ export function mount(container, graph, options = {}) { ? `${node.label}, open details` : `Stage ${node.key}, ${node.type}, open details`, ); - if (!stageIsExecuted(node.key, runState)) button.classList.add("not-executed"); + const executed = stageIsExecuted(node.key, runState); + if (runState != null) button.classList.add(executed ? "executed" : "not-executed"); + if (node.key === activeKey) { + button.classList.add("active"); + if (pulse) button.classList.add("pulsing"); + const badge = el("span", "graph-elapsed"); + badge.setAttribute("aria-hidden", "true"); + button.append(badge); + elapsedBadge = badge; + } button.addEventListener("click", (event) => { if (dragged) { event.preventDefault(); return; } - selectNode(node.key); + // The run tab owns its own stage pane (the shared timeline visit pane), so + // a supplied handler replaces the definition pane rather than stacking on it. + if (typeof options.onStageTap === "function") options.onStageTap(node.key); + else selectNode(node.key); }); nodeLayer.append(button); } @@ -1026,7 +1084,27 @@ export function mount(container, graph, options = {}) { controls.append(fitButton, expandButton); viewport.append(controls); - // The definition pane, hidden until a node is clicked. + // The legend, only under a run (never the definition-only view): a solid, + // arrowed swatch means "executed", a dashed, arrowless one "not executed", + // matching what the graph draws. + if (runState != null) { + const legend = el("div", "graph-legend"); + legend.setAttribute("role", "note"); + legend.setAttribute("aria-label", "Executed and not executed routes"); + for (const entry of [ + { label: "Executed", executed: true }, + { label: "Not executed", executed: false }, + ]) { + const item = el("span", "graph-legend-entry"); + item.append(el("span", `graph-legend-swatch ${entry.executed ? "executed" : "not-executed"}`)); + item.append(el("span", "graph-legend-label", entry.label)); + legend.append(item); + } + viewport.append(legend); + } + + // The definition pane, hidden until a node is clicked (definition view only; + // the run tab opens its own pane through onStageTap instead). const pane = el("div", "graph-pane"); pane.hidden = true; root.append(viewport, pane); @@ -1122,7 +1200,28 @@ export function mount(container, graph, options = {}) { pane.replaceChildren(...children); pane.hidden = false; - if (typeof options.onStageTap === "function") options.onStageTap(key); + } + + // --- Elapsed badge (live run only) --------------------------------------- + + function updateElapsed() { + if (!elapsedBadge) return; + const seconds = secondsSince(runState?.currentStageStartedAt, Date.now()); + elapsedBadge.textContent = seconds == null ? "" : formatDuration(seconds); + } + + let elapsedTimer = null; + if (elapsedBadge != null) { + updateElapsed(); + // Tick only while the graph has a live stage with a known start; a still + // ring (reduced motion) and a finished run never wake up once a second. + if ( + pulse && + typeof setInterval === "function" && + String(runState?.currentStageStartedAt ?? "").trim() !== "" + ) { + elapsedTimer = setInterval(updateElapsed, 1000); + } } // --- Interactions -------------------------------------------------------- @@ -1230,6 +1329,10 @@ export function mount(container, graph, options = {}) { return { unmount() { + if (elapsedTimer != null) { + clearInterval(elapsedTimer); + elapsedTimer = null; + } resizeObserver?.disconnect(); viewport.removeEventListener("pointerdown", onPointerDown); viewport.removeEventListener("pointermove", onPointerMove); diff --git a/web/src/runDetail.js b/web/src/runDetail.js index 6e634666..e22c4384 100644 --- a/web/src/runDetail.js +++ b/web/src/runDetail.js @@ -36,9 +36,9 @@ import { effectiveStageType } from "./templates.js"; /** * The run-detail tabs, Summary first so it is the default selection. The Graph - * tab is present (Android `runDetailTabs`) but has no rendered body yet — it is - * the R5 item — so the renderer filters it out until then. The timeline keeps - * Android's stable key `steps` with the visible title `Timeline`. + * tab sits between Summary and Input (R5) and mounts the shared workflow graph + * in run mode. The timeline keeps Android's stable key `steps` with the visible + * title `Timeline`. */ export const RUN_DETAIL_TABS = [ { key: "summary", label: "Summary" }, @@ -48,8 +48,8 @@ export const RUN_DETAIL_TABS = [ { key: "steps", label: "Timeline" }, ]; -/** The tabs the browser currently renders (the Graph body is the R5 item). */ -export const RENDERED_RUN_TABS = RUN_DETAIL_TABS.filter((tab) => tab.key !== "graph"); +/** The tabs the browser renders: all of them, including the Graph body (R5). */ +export const RENDERED_RUN_TABS = RUN_DETAIL_TABS; // The empty-state sentences, exactly as the app spells them. export const EMPTY_INPUT_MESSAGE = "No input recorded."; @@ -330,6 +330,66 @@ export function graphEdges(graph) { return result; } +/** + * Which stages and routes a run actually recorded, for the graph's execution + * highlighting. Mirrors Android `RunGraphState.from` (GraphSemantics.kt:91-116): + * every step's stage key is a visited stage (insertion order), a step with a + * non-blank outcome and target contributes a taken route + * `{source, outcome, resolvedTarget}` (recorded as a `source\0outcome\0target` + * key the graph matches) and, when that resolved target is a terminal, marks the + * terminal visited too. `currentStage` is the run's own stage, else the last + * visit's stage, else null; `executing` mirrors the run; `currentStageStartedAt` + * is the running visit's start for the active stage, only while executing. Pure + * and DOM-free so the renderer and the tests share one definition. + */ +export function runGraphState(run) { + const visitedStages = []; + const seenStages = new Set(); + const takenRoutes = []; + const seenRoutes = new Set(); + const steps = run?.steps ?? []; + + const visit = (key) => { + if (key == null || seenStages.has(key)) return; + seenStages.add(key); + visitedStages.push(key); + }; + + for (const step of steps) { + visit(step?.stage); + const outcome = String(step?.outcome ?? ""); + const target = String(step?.target ?? ""); + if (target.trim() !== "" && outcome.trim() !== "") { + const resolved = resolveTarget(outcome, target); + const route = `${step?.stage}\u0000${outcome}\u0000${resolved}`; + if (!seenRoutes.has(route)) { + seenRoutes.add(route); + takenRoutes.push(route); + } + if (isTerminal(resolved)) visit(resolved); + } + } + + const lastStage = steps.length > 0 ? steps[steps.length - 1]?.stage : ""; + const rawCurrent = String(run?.current_stage ?? "").trim() !== "" ? run.current_stage : lastStage; + const currentStage = String(rawCurrent ?? "").trim() !== "" ? String(rawCurrent) : null; + + const executing = Boolean(run?.executing); + let currentStageStartedAt = null; + if (executing && currentStage != null) { + for (let index = steps.length - 1; index >= 0; index -= 1) { + const step = steps[index]; + if (step?.stage === currentStage && step?.status === "running") { + const started = String(step?.started_at ?? ""); + if (started.trim() !== "") currentStageStartedAt = started; + break; + } + } + } + + return { visitedStages, takenRoutes, currentStage, executing, currentStageStartedAt }; +} + // --------------------------------------------------------------------------- // Stage pane (ui/graph/StageDetailPane.kt) // --------------------------------------------------------------------------- diff --git a/web/styles.css b/web/styles.css index 1c508c9b..fe429613 100644 --- a/web/styles.css +++ b/web/styles.css @@ -610,6 +610,74 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font- } .graph-control:hover { border-color: var(--accent); color: var(--accent); } +/* The run-mode legend (R5), pinned top-start opposite the Fit/expand controls. + A solid, arrowed swatch means "executed"; a dashed, arrowless one "not + executed". Never shown for the definition-only view. */ +.graph-legend { + position: absolute; + top: 8px; + left: 8px; + z-index: 2; + display: flex; + gap: 12px; + align-items: center; + padding: 4px 8px; + border: 1px solid var(--border); + border-radius: 8px; + background: color-mix(in srgb, var(--surface) 85%, transparent); + font-size: 12px; + color: var(--muted); +} +.graph-legend-entry { display: inline-flex; gap: 6px; align-items: center; } +.graph-legend-swatch { + position: relative; + width: 26px; + border-top: 3px solid var(--muted); +} +.graph-legend-swatch.executed { border-top-color: var(--text); } +/* A small filled arrowhead on the executed swatch, matching the drawn head. */ +.graph-legend-swatch.executed::after { + content: ""; + position: absolute; + top: -6px; + right: -1px; + border-left: 7px solid var(--text); + border-top: 4px solid transparent; + border-bottom: 4px solid transparent; +} +.graph-legend-swatch.not-executed { border-top-style: dashed; } + +/* The live active stage (R5): a ring around the node plus a soft glow, pulsing + while the run executes and static when the user prefers reduced motion. */ +.graph-node.active { + border-color: var(--accent); + box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 40%, transparent); +} +.graph-node.active.pulsing { animation: graph-halo-pulse 1.6s ease-in-out infinite; } +@keyframes graph-halo-pulse { + 0%, + 100% { box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 55%, transparent); } + 50% { box-shadow: 0 0 0 7px color-mix(in srgb, var(--accent) 20%, transparent); } +} +@media (prefers-reduced-motion: reduce) { + .graph-node.active.pulsing { animation: none; } +} + +/* The live elapsed-time badge on the active node. */ +.graph-elapsed { + position: absolute; + bottom: -9px; + right: 6px; + padding: 0 5px; + border: 1px solid color-mix(in srgb, var(--accent) 45%, var(--border)); + border-radius: 999px; + background: var(--surface); + color: var(--accent); + font-size: 10px; + font-weight: 600; + line-height: 16px; +} + /* The definition pane opened from a node click. */ .graph-pane { display: grid; diff --git a/web/test/graph.test.mjs b/web/test/graph.test.mjs index 9e62f673..8b957ec2 100644 --- a/web/test/graph.test.mjs +++ b/web/test/graph.test.mjs @@ -14,6 +14,7 @@ import { MAX_SCALE, PIPELINE_GRAPH_EMPTY, RUN_GRAPH_MISSING, + RUN_GRAPH_NOTE, NO_NODE_DETAILS, STAGE_DEFINITION_TITLE, configLabel, @@ -33,7 +34,11 @@ import { clampOffset, fitScale, zoomAbout, + stageIsExecuted, + edgeIsExecuted, + activeStage, } from "../src/graph.js"; +import { runGraphState } from "../src/runDetail.js"; // --------------------------------------------------------------------------- // Fixtures @@ -369,12 +374,119 @@ test("terminalFields lists the incoming routes into a terminal", () => { assert.deepEqual(terminalFields(twoStageGraph(), "#nope"), []); }); +// --------------------------------------------------------------------------- +// Run-mode execution state (R5: GraphSemantics RunGraphState.from) +// --------------------------------------------------------------------------- + +test("runGraphState resolves visited stages, taken routes and reached terminals", () => { + const run = { + executing: false, + current_stage: "committer", + steps: [ + { stage: "implementer", sequence: 1, status: "completed", outcome: "success", target: "reviewer" }, + { stage: "reviewer", sequence: 2, status: "completed", outcome: "rejected", target: "implementer" }, + { stage: "implementer", sequence: 3, status: "completed", outcome: "success", target: "reviewer" }, + { stage: "committer", sequence: 4, status: "completed", outcome: "success", target: "#success" }, + ], + }; + const state = runGraphState(run); + assert.deepEqual(state.visitedStages, ["implementer", "reviewer", "committer", "#success"]); + assert.equal(state.currentStage, "committer"); + assert.equal(state.executing, false); + assert.equal(state.currentStageStartedAt, null); + assert.deepEqual(state.takenRoutes, [ + "implementer\u0000success\u0000reviewer", + "reviewer\u0000rejected\u0000implementer", + "committer\u0000success\u0000#success", + ]); +}); + +test("runGraphState marks a terminal only when a visit resolved to it", () => { + // A `#` target resolves by outcome: error -> #failure, everything else -> #success. + const failed = runGraphState({ + executing: false, + steps: [{ stage: "impl", outcome: "error", target: "#" }], + }); + assert.deepEqual(failed.visitedStages, ["impl", "#failure"]); + assert.equal(stageIsExecuted("#failure", failed), true); + assert.equal(stageIsExecuted("#success", failed), false); + + const midRun = runGraphState({ + executing: false, + steps: [{ stage: "impl", outcome: "success", target: "review" }], + }); + assert.equal(stageIsExecuted("#success", midRun), false); + assert.equal(stageIsExecuted("#failure", midRun), false); + assert.equal(stageIsExecuted("review", midRun), false, "a target is not visited until a step lands on it"); +}); + +test("stageIsExecuted is true for a visited stage and for the definition view", () => { + const state = runGraphState({ + executing: false, + steps: [{ stage: "impl", outcome: "success", target: "review" }], + }); + assert.equal(stageIsExecuted("impl", state), true); + assert.equal(stageIsExecuted("review", state), false); + // The definition view passes no runState, so every stage is executed. + assert.equal(stageIsExecuted("review", null), true); +}); + +test("edgeIsExecuted is true only for a route a recorded visit produced", () => { + const state = runGraphState({ + executing: false, + steps: [ + { stage: "impl", outcome: "success", target: "review" }, + { stage: "review", outcome: "error", target: "#" }, + ], + }); + const taken = { source: "impl", outcome: "success", target: "review" }; + const byFallback = { source: "review", outcome: "error", target: "#failure" }; + const untaken = { source: "impl", outcome: "blocked", target: "#failure" }; + assert.equal(edgeIsExecuted(taken, state), true); + assert.equal(edgeIsExecuted(byFallback, state), true, "a resolved fallback route counts"); + assert.equal(edgeIsExecuted(untaken, state), false); + // The definition view draws every route executed. + assert.equal(edgeIsExecuted(untaken, null), true); +}); + +test("activeStage resolves only while the run is executing", () => { + const live = runGraphState({ + executing: true, + current_stage: "review", + steps: [ + { stage: "review", status: "running", started_at: "2026-01-01T00:00:00Z" }, + ], + }); + assert.equal(activeStage(live), "review"); + assert.equal(live.currentStageStartedAt, "2026-01-01T00:00:00Z"); + + const settled = runGraphState({ + executing: false, + current_stage: "review", + steps: [ + { stage: "review", status: "running", started_at: "2026-01-01T00:00:00Z" }, + ], + }); + assert.equal(activeStage(settled), null, "a finished run has no active stage"); + assert.equal(settled.currentStageStartedAt, null); + assert.equal(activeStage(null), null, "the definition view has no active stage"); +}); + +test("runGraphState falls back to the last visit's stage, else null", () => { + const state = runGraphState({ executing: false, steps: [{ stage: "a" }, { stage: "b" }] }); + assert.equal(state.currentStage, "b"); + assert.equal(runGraphState({ executing: false, steps: [] }).currentStage, null); + assert.equal(runGraphState({}).currentStage, null); +}); + // --------------------------------------------------------------------------- // Wording, exports and the no-innerHTML contract // --------------------------------------------------------------------------- test("the empty-state and pane wording matches the app's sentences", () => { assert.equal(RUN_GRAPH_MISSING, "This server did not include the run graph."); + assert.ok(RUN_GRAPH_NOTE.includes("pulses")); + assert.ok(RUN_GRAPH_NOTE.includes("Mouse wheel to zoom")); assert.equal(PIPELINE_GRAPH_EMPTY, "This pipeline has no stages."); assert.equal(NO_NODE_DETAILS, "No details recorded for this node."); assert.equal(STAGE_DEFINITION_TITLE, "Stage definition"); diff --git a/web/test/runDetail.test.mjs b/web/test/runDetail.test.mjs index b76a4af8..76f40c7a 100644 --- a/web/test/runDetail.test.mjs +++ b/web/test/runDetail.test.mjs @@ -79,10 +79,10 @@ test("RUN_DETAIL_TABS is the Android order, Summary first, Timeline keyed 'steps RUN_DETAIL_TABS.map((tab) => tab.label), ["Summary", "Graph", "Input", "Output", "Timeline"], ); - // The Graph body is the R5 item; only the other four render today. + // The Graph body (R5) now renders too, so every tab is present. assert.deepEqual( RENDERED_RUN_TABS.map((tab) => tab.label), - ["Summary", "Input", "Output", "Timeline"], + ["Summary", "Graph", "Input", "Output", "Timeline"], ); }); diff --git a/web/test/ui-smoke.mjs b/web/test/ui-smoke.mjs index d4451115..7d1d1b29 100644 --- a/web/test/ui-smoke.mjs +++ b/web/test/ui-smoke.mjs @@ -590,11 +590,14 @@ try { await page.click('.list.runs .run-row-meta[data-run-id="430"]'); await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); - // The run-detail tabs, in the app's order (the Graph body is the R5 item). + // The run-detail tabs, in the app's order (Summary / Graph / Input / Output / + // Timeline; the Graph body is R5 and now rendered). const runTabs = await page.evaluate( `[...document.querySelectorAll(".detail .detail-tabs .detail-tab")].map((n) => n.textContent)`, ); - if (JSON.stringify(runTabs) !== JSON.stringify(["Summary", "Input", "Output", "Timeline"])) { + if ( + JSON.stringify(runTabs) !== JSON.stringify(["Summary", "Graph", "Input", "Output", "Timeline"]) + ) { throw new Error(`run tabs are wrong: ${runTabs.join(",")}`); } console.log(` run tabs: ${runTabs.join(" / ")}`); @@ -784,6 +787,137 @@ try { console.log(` timeline empty state: ${emptyTimeline}`); shots.push(await page.screenshot(`${out}/26-run-428-timeline-empty.png`)); + // R5: the run-detail Graph tab — the shared workflow graph in run mode. Run 438 + // is a finished run with several visits and the full outcome set: its graph + // shows the Executed / Not executed legend, solid executed nodes and arrowed + // executed routes, and dashed untaken routes. Clicking a stage opens the + // existing visit pane (with its Verdict) at that stage's latest visit. Run 440 + // shows the hollow, dashed nodes for the stages the failed run never reached. + step("opening run 438 and capturing its Graph tab (R5)"); + await page.click('.list.runs .run-row-meta[data-run-id="438"]'); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await page.clickText(".detail .detail-tabs .detail-tab", "Graph"); + await page.waitForSelector(".run-detail .graph-note", { timeout: 15000 }); + const runGraphNote = await text(".run-detail .graph-note"); + if (!runGraphNote.includes("pulses with its elapsed time")) { + throw new Error(`unexpected run graph note: ${runGraphNote}`); + } + await page.waitForSelector(".run-detail .graph-node", { timeout: 15000 }); + await eventually(async () => { + const current = await graphState(); + return current != null && current.scale > 0; + }, { what: "the run graph to lay out" }); + + const legend = await page.evaluate( + `[...document.querySelectorAll(".run-detail .graph-legend .graph-legend-label")].map((n) => n.textContent)`, + ); + if (JSON.stringify(legend) !== JSON.stringify(["Executed", "Not executed"])) { + throw new Error(`the run graph legend is wrong: ${JSON.stringify(legend)}`); + } + const graph438 = await page.evaluate(`(() => ({ + executedNodes: document.querySelectorAll(".run-detail .graph-node.executed").length, + notExecutedNodes: document.querySelectorAll(".run-detail .graph-node.not-executed").length, + executedEdges: document.querySelectorAll(".run-detail .graph-edge-path.executed").length, + notExecutedEdges: document.querySelectorAll(".run-detail .graph-edge-path.not-executed").length, + arrowedEdges: document.querySelectorAll('.run-detail .graph-edge-path[marker-end]').length, + active: document.querySelectorAll(".run-detail .graph-node.active").length, + }))()`); + if (!graph438.executedNodes || !graph438.executedEdges || !graph438.notExecutedEdges) { + throw new Error(`run 438 should show executed stages and both executed/untaken routes: ${JSON.stringify(graph438)}`); + } + if (graph438.arrowedEdges !== graph438.executedEdges) { + throw new Error(`only executed routes carry an arrowhead: ${JSON.stringify(graph438)}`); + } + if (graph438.active !== 0) { + throw new Error(`a finished run must have no active halo: ${JSON.stringify(graph438)}`); + } + console.log( + ` run 438 graph: ${graph438.executedNodes} executed / ${graph438.notExecutedNodes} not-executed nodes, ` + + `${graph438.executedEdges} arrowed / ${graph438.notExecutedEdges} dashed routes, legend ${legend.join("/")}`, + ); + await page.rect(".run-detail .graph-viewport"); + shots.push(await page.screenshot(`${out}/28-run-438-graph.png`)); + + step("opening a stage's visit pane from the run 438 graph"); + await page.evaluate( + `document.querySelector('.run-detail .graph-node[data-key="ui_reviewer"]').click()`, + ); + await page.waitForSelector(".stage-pane", { timeout: 15000 }); + await page.waitForText("Verdict", { timeout: 15000 }); + const graphPane = await page.evaluate(`(() => ({ + title: document.querySelector(".stage-pane-title")?.textContent ?? "", + verdict: document.querySelector(".stage-pane .verdict .outcome-chip")?.textContent ?? "", + }))()`); + if (graphPane.title !== "ui_reviewer") { + throw new Error(`the graph-opened pane named the wrong stage: ${graphPane.title}`); + } + if (!graphPane.verdict) throw new Error("the graph-opened pane did not show a verdict"); + console.log(` graph-opened pane: ${graphPane.title} — verdict ${graphPane.verdict}`); + await page.rect(".stage-pane-sheet"); + shots.push(await page.screenshot(`${out}/29-run-438-graph-pane.png`)); + await page.click(".stage-pane-back"); + await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), { + timeout: 5000, + what: "the graph stage pane to close", + }); + + step("opening run 440 to capture the hollow, not-executed stages (R5)"); + await page.click('.list.runs .run-row-meta[data-run-id="440"]'); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await page.clickText(".detail .detail-tabs .detail-tab", "Graph"); + await page.waitForSelector(".run-detail .graph-node", { timeout: 15000 }); + const graph440 = await page.evaluate(`(() => ({ + executedNodes: document.querySelectorAll(".run-detail .graph-node.executed").length, + notExecutedNodes: document.querySelectorAll(".run-detail .graph-node.not-executed").length, + hollow: [...document.querySelectorAll(".run-detail .graph-node.not-executed")].every( + (n) => getComputedStyle(n).borderStyle === "dashed", + ), + }))()`); + if (!graph440.executedNodes || !graph440.notExecutedNodes) { + throw new Error(`run 440 should show visited and unvisited stages: ${JSON.stringify(graph440)}`); + } + if (!graph440.hollow) { + throw new Error(`an unvisited node is not hollow/dashed: ${JSON.stringify(graph440)}`); + } + console.log(` run 440 graph: ${graph440.executedNodes} executed / ${graph440.notExecutedNodes} not-executed (dashed) nodes`); + await page.rect(".run-detail .graph-viewport"); + shots.push(await page.screenshot(`${out}/30-run-440-graph.png`)); + + // R5: a live run's Graph tab — the current stage carries the pulsing halo and + // a ticking elapsed badge; a finished run (above) carries neither. Best effort: + // the run may stop before we look, so skip rather than fail if none is running. + step("opening a live run's Graph tab (R5: halo + elapsed badge)"); + const liveRunId = await page.evaluate(`(() => { + const row = [...document.querySelectorAll(".list.runs .run-row")].find((n) => n.querySelector(".chip-running")); + const meta = row?.querySelector(".run-row-meta[data-run-id]"); + return meta ? Number(meta.getAttribute("data-run-id")) : null; + })()`); + if (liveRunId == null) { + console.log(" -- no running run available; skipped the live graph halo capture"); + } else { + await page.click(`.list.runs .run-row-meta[data-run-id="${liveRunId}"]`); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await page.clickText(".detail .detail-tabs .detail-tab", "Graph"); + await page.waitForSelector(".run-detail .graph-node", { timeout: 15000 }); + const live = await eventually( + async () => + page.evaluate(`(() => { + const active = document.querySelector(".run-detail .graph-node.active"); + if (!active) return null; + return { + activeKey: active.dataset.key ?? "", + pulsing: active.classList.contains("pulsing"), + badge: active.querySelector(".graph-elapsed")?.textContent ?? "", + }; + })()`), + { timeout: 15000, what: "the live run's active stage" }, + ); + if (!live.badge) throw new Error(`the active stage showed no elapsed badge: ${JSON.stringify(live)}`); + console.log(` live run ${liveRunId}: active stage ${live.activeKey} (pulsing=${live.pulsing}), badge ${live.badge}`); + await page.rect(".run-detail .graph-viewport"); + shots.push(await page.screenshot(`${out}/31-run-live-graph.png`)); + } + // The Output empty state, on the running run that has not produced output yet. step("opening the Output tab on a run with no output recorded"); const runningId = await page.evaluate(`(() => {