@crvouga/atlas 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog: @crvouga/atlas
 
-## 1.6.0 (2026-10-29)
+## 1.7.0 (2026-10-29)
+
+### Features
+
+- explain selected, aggregate and historical outcomes without contradictory summaries ([018d2fe](https://github.com/crvouga/atlas/commit/018d2fe91a9c17cbefa8f9d24ad6f3d70550c5d1))
+
+## 1.6.0 (2026-10-28)
 
 ### Features
 

package/docs/extending.md

@@ -104,6 +104,23 @@ every kind of evidence and values from the future) and `layer-extensibility.test
 fields survive at every level, malformed evidence is dropped without losing the result, and a reader of the
 first version of the format still reads it all.
 
+### Saying what failed
+
+A failed check or step may declare the expectation it broke under the `atlas.failure` extension, so a reviewer sees
+it before the raw log. Every field is optional, and the declaration never changes the result.
+
+```json
+{
+  "name": "The list includes tea", "kind": "then", "status": "failed",
+  "extensions": { "atlas.failure": { "expected": "tea in the list", "actual": "the list is empty", "attribution": "product" } }
+}
+```
+
+`expected` and `actual` are shown as written. `attribution` is `product`, `test-harness` or `environment`; leave it out
+when you do not know, and the viewer says the cause is unknown. It is never inferred from the message. Whether setup
+failed before the behavior started comes from the failed step's `kind`: `hook`, `setup`, `fixture`, `before`,
+`beforeAll`, `beforeEach` or `given` mean preparation; `when`, `then`, `assertion` or `expect` mean the behavior.
+
 ## Attach evidence
 
 ### From the command line

package/docs/ui.md

@@ -87,6 +87,20 @@ when Watch is on screen.
 - The spec index searches titles, paths and declared domains, and can group by the domain from spec metadata (specs with
   none are listed under "No domain declared"; the Tests view reports domain problems).
 
+## Outcome summary
+
+A test or behavior detail states what the **selected** result says apart from what the other current sources say
+(`evidence/outcome.ts`, `outcome-summary.tsx`). The heading is the selected source's outcome first ("Selected result
+passed; another scoped source failed"), never the combined status; the combined status is labelled as the worst current
+result. Each other current source is one click away, and sources that share an environment are told apart by status,
+time, revision and their place among them. A failure leads with whether the behavior was reached (decided only by the
+recorded step `kind`: a `hook`, `setup`, `fixture`, `before*` or `given` step failing is "Behavior not verified: setup
+failed", `when`, `then`, `assertion` or `expect` is "Expectation not met", anything else is unknown), then the expected
+and observed values and the closest step and video, then the original output. The cause (product, test harness,
+environment) is unknown unless the producer declared it under the `atlas.failure` extension; it is never read from error
+wording. Records of one source whose outcome changed are listed oldest first, and a later pass is never called a fix.
+In the explorer the chosen source is the `source` search parameter (a layer id; unlike `layer` it does not pin a run).
+
 ## Icons and notation marks
 
 Use named imports from `@tabler/icons-react` for all UI glyphs. The icon package supplies SVG paths;

package/llms-full.txt

@@ -2900,6 +2900,23 @@ every kind of evidence and values from the future) and `layer-extensibility.test
 fields survive at every level, malformed evidence is dropped without losing the result, and a reader of the
 first version of the format still reads it all.
 
+### Saying what failed
+
+A failed check or step may declare the expectation it broke under the `atlas.failure` extension, so a reviewer sees
+it before the raw log. Every field is optional, and the declaration never changes the result.
+
+```json
+{
+  "name": "The list includes tea", "kind": "then", "status": "failed",
+  "extensions": { "atlas.failure": { "expected": "tea in the list", "actual": "the list is empty", "attribution": "product" } }
+}
+```
+
+`expected` and `actual` are shown as written. `attribution` is `product`, `test-harness` or `environment`; leave it out
+when you do not know, and the viewer says the cause is unknown. It is never inferred from the message. Whether setup
+failed before the behavior started comes from the failed step's `kind`: `hook`, `setup`, `fixture`, `before`,
+`beforeAll`, `beforeEach` or `given` mean preparation; `when`, `then`, `assertion` or `expect` mean the behavior.
+
 ## Attach evidence
 
 ### From the command line
@@ -3919,6 +3936,20 @@ when Watch is on screen.
 - The spec index searches titles, paths and declared domains, and can group by the domain from spec metadata (specs with
   none are listed under "No domain declared"; the Tests view reports domain problems).
 
+## Outcome summary
+
+A test or behavior detail states what the **selected** result says apart from what the other current sources say
+(`evidence/outcome.ts`, `outcome-summary.tsx`). The heading is the selected source's outcome first ("Selected result
+passed; another scoped source failed"), never the combined status; the combined status is labelled as the worst current
+result. Each other current source is one click away, and sources that share an environment are told apart by status,
+time, revision and their place among them. A failure leads with whether the behavior was reached (decided only by the
+recorded step `kind`: a `hook`, `setup`, `fixture`, `before*` or `given` step failing is "Behavior not verified: setup
+failed", `when`, `then`, `assertion` or `expect` is "Expectation not met", anything else is unknown), then the expected
+and observed values and the closest step and video, then the original output. The cause (product, test harness,
+environment) is unknown unless the producer declared it under the `atlas.failure` extension; it is never read from error
+wording. Records of one source whose outcome changed are listed oldest first, and a later pass is never called a fix.
+In the explorer the chosen source is the `source` search parameter (a layer id; unlike `layer` it does not pin a run).
+
 ## Icons and notation marks
 
 Use named imports from `@tabler/icons-react` for all UI glyphs. The icon package supplies SVG paths;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crvouga/atlas",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Atlas: specs of any kind, reported as layered evidence. Publish checks from any runner (JUnit, CTRF, a script), combine them across nodes, branches, environments and backends, gate CI on the result, and run statecharts against the real app.",
   "license": "MIT",
   "type": "module",

package/packages/visualizer/src/evidence/behavior-panel.tsx

@@ -6,12 +6,9 @@
  * record: run, environment, source, attempts). Also the coverage summary of the whole feature. A recording is always
  * labelled as illustrative evidence with its own status, provenance and revision; it never stands for approval.
  */
-import type { EvidenceHolder } from '@crvouga/atlas/reports/evidence-detail';
-import { isVideoAttachment } from '@crvouga/atlas/reports/evidence-detail';
 import { effectiveScope } from '@crvouga/atlas/reports/evidence-scope';
 import type { EvidenceResult } from '@crvouga/atlas/reports/layer-merge';
 import { environmentLabel } from '@crvouga/atlas/reports/layer-axes';
-import type { Attachment } from '@crvouga/atlas/schema';
 import { Alert, Badge, Box, Group, List, Paper, Stack, Tabs, Text, Title } from '@mantine/core';
 import { useMemo, type ReactNode } from 'react';
 
@@ -23,6 +20,7 @@ import { ScopeNotice } from './evidence-scope';
 import { plural, statusWord, useNow } from './format';
 import { exampleIndexFor, exampleRows, fillExample, type FeatureStep } from './gherkin';
 import { Origin, StatusMark } from './marks';
+import { outcomeHeadline, videosIn } from './outcome';
 
 /** The short, readable form of a spec fingerprint (`<length>:<hash>:<hash>`): its length and the start of its hash. */
 export function shortRevision(fingerprint: string): string {
@@ -80,19 +78,6 @@ function expectedSteps(steps: readonly FeatureStep[]): FeatureStep[] {
   return at < 0 ? [] : steps.slice(at);
 }
 
-function videosIn(holder: EvidenceHolder | undefined): Attachment[] {
-  if (!holder) return [];
-  const own = (holder.attachments ?? []).filter(isVideoAttachment);
-  return [
-    ...own,
-    ...(holder.steps ?? []).flatMap((step) => (step.attachments ?? []).filter(isVideoAttachment)),
-    ...(holder.attempts ?? []).flatMap((attempt) => [
-      ...(attempt.attachments ?? []).filter(isVideoAttachment),
-      ...(attempt.steps ?? []).flatMap((step) => (step.attachments ?? []).filter(isVideoAttachment))
-    ])
-  ];
-}
-
 /** The recording of one result, read only when this is on screen. */
 function Player({ result }: { result: EvidenceResult }) {
   const detail = useCheckDetail(result.layer, result.row);
@@ -171,6 +156,13 @@ export function BehaviorPanel({
   const steps = useMemo(() => (entry ? fillExample(scenario.steps, entry) : scenario.steps), [scenario, entry]);
   const expected = expectedSteps(steps);
   const named = example !== null && entry === null;
+  // The coverage state is the check's combined status; this says what the recording or result shown here recorded, apart from it.
+  const outcome =
+    subject && behavior.slot ? (
+      <Text component="div" fw={600} data-outcome-headline>
+        {outcomeHeadline({ layer: subject.layer, row: subject.row }, behavior.slot).text}
+      </Text>
+    ) : null;
   return (
     <Tabs
       defaultValue={start ?? (demo ? 'watch' : state === 'running' || behavior.slot?.live ? 'inspect' : 'read')}
@@ -190,6 +182,7 @@ export function BehaviorPanel({
               {COVERAGE[state].meaning}
             </Text>
           </Group>
+          {outcome}
           {example !== null && (
             <Text component="div" c="dimmed">
               Example: {example}
@@ -209,6 +202,7 @@ export function BehaviorPanel({
             <CoverageBadge state={state} />
             {behavior.representative && <Badge variant="outline">Representative demo</Badge>}
           </Group>
+          {outcome}
           {expected.length > 0 && (
             <Box component="section" aria-label="Expected outcome">
               <Title order={4} mb="xs">

package/packages/visualizer/src/evidence/check-detail.tsx

@@ -9,12 +9,14 @@ import { useQuery } from '@tanstack/react-query';
 import { useMemo, useState, type ReactNode } from 'react';
 import { TestProgress, useTestProgress } from '../live/test-progress';
 import { reportJson } from './api';
-import { ResultEvidence } from './artifacts';
+import { ResultEvidence, useCheckDetail } from './artifacts';
 import { useEvidence } from './evidence-context';
 import { ago, duration, plural, statusWord, useNow } from './format';
 import type { FeatureExamples, FeatureStep } from './gherkin';
 import { Bounded, Origin, StatusMark } from './marks';
 import { ModelTrace } from './model-trace';
+import { OutcomeSummary } from './outcome-summary';
+import { failedReportStep, failedStep, recordOf, sourceLabels, type ResultRecord } from './outcome';
 import { recordedModelStates } from './quint';
 /** What the address says is open: a check, and optionally one particular layer's record of it. */
 export type CheckSelection = {
@@ -49,13 +51,6 @@ function environmentMarks(slot: CheckSlot) {
   if (seen.size < 2) return [];
   return [...seen].map(([id, status]) => ({ id, status }));
 }
-function outcomeName(outcome: EvidenceResult) {
-  const environment = outcome.layer.environment ? environmentLabel(outcome.layer.environment) : '';
-  const parameters = Object.entries(outcome.parameters)
-    .map(([name, value]) => `${name}: ${value}`)
-    .join(', ');
-  return [environment, parameters].filter(Boolean).join(' · ') || outcome.layer.producer;
-}
 export function ResultRow({
   label,
   slot,
@@ -93,7 +88,7 @@ export function ResultRow({
                   <Flex component="span" display="inline-flex" gap="xs" align="center" wrap="wrap">
                     {marks.map((mark) => (
                       <Text key={mark.id || 'unspecified'} data-status={mark.status} span inherit>
-                        {environmentLabel(mark.id || null)}
+                        {environmentLabel(mark.id || null)} {statusWord(mark.status).toLowerCase()}
                       </Text>
                     ))}
                   </Flex>
@@ -276,6 +271,14 @@ type Props = {
   pinned?: HistoryEntry;
   /** Choosing a run in the history always names its layer, even when that result is a current one, so the choice stays pinned. */
   pin?: boolean;
+  /** The layer id of the current source the address selected (without pinning a run). Used with `onSource`; otherwise the choice is local. */
+  source?: string;
+  /** Called with the layer id when a source is chosen (null for the newest), so the page can keep the choice in its address. */
+  onSource?: (layerId: string | null) => void;
+  /** Whether the outcome summary states its own heading. False when the page already shows it. */
+  headline?: boolean;
+  /** Every record of this check the page knows (a node's history of it), when the layers held here are only the winners. */
+  records?: readonly ResultRecord[];
 };
 /** Everything recorded for one check: the chosen result, how it went, and every other run of it. */
 export function CheckDetail(props: Props) {
@@ -306,16 +309,28 @@ export function CheckDetail(props: Props) {
     </>
   );
 }
-function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pin }: Props) {
+function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pin, source, onSource, headline = true, records }: Props) {
   const { evidence, backends, ready, pending } = useEvidence();
   const now = useNow();
   const [variant, setVariant] = useState(0);
   const history = useMemo(() => checkHistory(evidence, slot.specPath, slot.id), [evidence, slot.specPath, slot.id]);
-  const winner = slot.outcomes[Math.min(variant, slot.outcomes.length - 1)]!;
+  const sourceAt = onSource && source ? slot.outcomes.findIndex((outcome) => outcome.layer.id === source) : -1;
+  const index = Math.min(onSource ? Math.max(sourceAt, 0) : variant, slot.outcomes.length - 1);
+  const winner = slot.outcomes[index]!;
   const earlier = pinned ?? (layerId ? history.find((entry) => entry.layer.id === layerId) : undefined);
   const chosen: HistoryEntry = earlier ?? { layer: winner.layer, row: winner.row };
   const superseded = !slot.outcomes.some((outcome) => outcome.layer.id === chosen.layer.id);
   const { paths, report } = useRecordedReport(chosen);
+  const recorded = useCheckDetail(chosen.layer, chosen.row);
+  const point = useMemo(
+    () => (chosen.row.status === 'failed' ? (failedStep(recorded.data?.check.steps) ?? failedReportStep(report.data)) : undefined),
+    [chosen.row.status, recorded.data, report.data]
+  );
+  const labels = sourceLabels(slot.outcomes, now);
+  const choose = (at: number) => {
+    setVariant(at);
+    onSource?.(at === 0 ? null : slot.outcomes[at]!.layer.id);
+  };
   const moments = report.data ? flattenFrames(report.data.steps).length : 0;
   const timings = superseded ? [] : slot.diagnostics.filter((entry) => entry.layer.id === chosen.layer.id || slot.diagnostics.length === 1);
   const note = superseded ? 'An earlier result. A newer run replaced it in the combined report.' : qualification(winner.warning);
@@ -328,12 +343,32 @@ function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pi
       : '';
   return (
     <Stack gap="sm" miw={0}>
+      <OutcomeSummary
+        slot={slot}
+        selected={chosen}
+        history={records && records.length > history.length ? records : history.map(recordOf)}
+        point={point}
+        detail={recorded.data}
+        now={now}
+        showHeadline={headline}
+        choose={(layer) => {
+          const at = slot.outcomes.findIndex((outcome) => outcome.layer.id === layer);
+          if (at >= 0) choose(at);
+          else select({ layer });
+        }}
+      />
       {slot.outcomes.length > 1 && !earlier && (
         <Flex role="group" aria-label="Environments" gap="xs" align="center" wrap="wrap">
-          {slot.outcomes.map((outcome, index) => (
-            <Button key={outcome.key} type="button" aria-pressed={index === variant} onClick={() => setVariant(index)} variant="light">
+          {slot.outcomes.map((outcome, at) => (
+            <Button
+              key={outcome.key}
+              type="button"
+              aria-pressed={at === index}
+              onClick={() => choose(at)}
+              variant="light"
+            >
               <StatusMark status={outcome.row.status} size={12} />
-              {outcomeName(outcome)}
+              {labels[at]!.text}
             </Button>
           ))}
         </Flex>
@@ -410,7 +445,7 @@ function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pi
           {moments > 0 && (
             <Button
               type="button"
-              onClick={() => select({ view: 'recording', check: slot.id, layer: earlier || variant > 0 ? chosen.layer.id : null })}
+              onClick={() => select({ view: 'recording', check: slot.id, layer: earlier || index > 0 ? chosen.layer.id : null })}
               variant="filled"
             >
               Open recording{' '}

package/packages/visualizer/src/evidence/outcome-summary.tsx

@@ -0,0 +1,208 @@
+/**
+ * @module Outcome summary
+ *
+ * What the selected result says, stated apart from the other current sources, and the failure explained before its
+ * raw output: the heading names the selected source's outcome and what the other scoped sources recorded (each one
+ * click away), whether the behavior was reached, the recorded expected and observed values, the closest video and
+ * step, the chronology of the source, and who is to blame, which stays unknown unless the producer declared it. The
+ * original diagnostics remain below, untouched.
+ */
+import type { CheckSlot, HistoryEntry } from '@crvouga/atlas/reports/evidence-view';
+import type { CheckDetail } from '@crvouga/atlas/reports/evidence-detail';
+import { effectiveScope, scopeBadges } from '@crvouga/atlas/reports/evidence-scope';
+import { Badge, Box, Button, Flex, List, Paper, Stack, Text, Title } from '@mantine/core';
+
+import { ago, duration, shortSha, statusWord } from './format';
+import { StatusMark } from './marks';
+import {
+  chronology,
+  failureNote,
+  outcomeHeadline,
+  passedAfterFailure,
+  recordOf,
+  type ResultRecord,
+  reachOf,
+  sourceLabels,
+  videosIn,
+  type FailurePoint
+} from './outcome';
+
+const BLAME: Record<string, string> = {
+  product: 'the product',
+  'test-harness': 'the test harness',
+  environment: 'the environment'
+};
+
+/**
+ * The outcome of the selected result in words, the other current sources beside it, and, for a failure, where and
+ * how it failed. `point` is the failed step found in the recording (undefined when none was recorded); `detail` is the
+ * check's full record, for its videos and scope. `choose` selects one of the other current sources; `showHeadline`
+ * is false when the page already shows the heading.
+ */
+export function OutcomeSummary({
+  slot,
+  selected,
+  history,
+  point,
+  detail,
+  now,
+  choose,
+  showHeadline = true
+}: {
+  slot: CheckSlot;
+  selected: HistoryEntry;
+  history: readonly ResultRecord[];
+  point: FailurePoint | undefined;
+  detail: CheckDetail | undefined;
+  now: number;
+  choose: (layerId: string) => void;
+  showHeadline?: boolean;
+}) {
+  const headline = outcomeHeadline(selected, slot);
+  const failed = selected.row.status === 'failed';
+  const reach = failed ? reachOf(point) : undefined;
+  const note = point?.note ?? failureNote(detail?.check.extensions);
+  const every = sourceLabels(slot.outcomes, now);
+  const labels = headline.others.map((outcome) => every[slot.outcomes.indexOf(outcome)]!);
+  const video = point?.videos[0] ?? videosIn(detail?.check)[0];
+  const scope = video ? effectiveScope(video.scope, detail?.check.scope, detail?.inheritedScope) : undefined;
+  const timeline = chronology(recordOf(selected), history);
+  return (
+    <Paper component="section" aria-label="Outcome summary" data-outcome={selected.row.status} withBorder p="md">
+      <Stack gap="sm" miw={0}>
+        {showHeadline && (
+          <Title order={3} data-outcome-headline>
+            {headline.text}
+          </Title>
+        )}
+        {headline.others.length > 0 && (
+          <Stack gap="xs" component="section" aria-label="Other current sources">
+            <Text component="div" c="dimmed">
+              Other current sources of this check
+            </Text>
+            <List listStyleType="none" spacing="xs">
+              {headline.others.map((outcome, index) => (
+                <List.Item key={outcome.key}>
+                  <Button type="button" variant="light" onClick={() => choose(outcome.layer.id)} aria-label={`Open ${labels[index]!.text}`}>
+                    <StatusMark status={outcome.row.status} size={12} />
+                    <Text span inherit>
+                      {labels[index]!.text}
+                    </Text>
+                  </Button>
+                </List.Item>
+              ))}
+            </List>
+          </Stack>
+        )}
+        {reach && (
+          <Flex gap="xs" align="center" wrap="wrap" data-reach={reach.state}>
+            <Badge variant={reach.state === 'setup-failed' ? 'filled' : 'light'} color={reach.state === 'unknown' ? 'gray' : 'red'}>
+              {reach.state === 'setup-failed'
+                ? 'Behavior not verified'
+                : reach.state === 'expectation-failed'
+                  ? 'Expectation not met'
+                  : 'Failure point unknown'}
+            </Badge>
+            <Text span inherit>
+              {reach.text}
+            </Text>
+          </Flex>
+        )}
+        {failed && (note?.expected !== undefined || note?.actual !== undefined) && (
+          <Box component="dl" aria-label="Expected and observed" m={0}>
+            {note?.expected !== undefined && (
+              <>
+                <Text component="dt" fw={600}>
+                  Expected
+                </Text>
+                <Text component="dd" m={0}>
+                  {note.expected}
+                </Text>
+              </>
+            )}
+            {note?.actual !== undefined && (
+              <>
+                <Text component="dt" fw={600}>
+                  Observed
+                </Text>
+                <Text component="dd" m={0}>
+                  {note.actual}
+                </Text>
+              </>
+            )}
+          </Box>
+        )}
+        {failed && (point || video) && (
+          <Stack gap="xs" component="section" aria-label="Closest evidence">
+            {point && (
+              <Text component="div">
+                Closest step:{' '}
+                <Text span inherit fw={600}>
+                  {point.name}
+                </Text>
+                {point.offsetMs !== undefined && (
+                  <Text span inherit c="dimmed">
+                    {' '}
+                    at {duration(point.offsetMs) || '0 ms'} into the check
+                  </Text>
+                )}
+              </Text>
+            )}
+            {video && (
+              <Text component="div">
+                Closest video:{' '}
+                <Text span inherit fw={600}>
+                  {video.description ?? video.name}
+                </Text>
+                <Text span inherit c="dimmed">
+                  {' '}
+                  {point?.videos.length ? 'attached to that step' : 'recorded for the whole check'}
+                  {' · '}
+                  {scopeBadges(scope)
+                    .map((badge) => badge.text)
+                    .join(', ')}
+                </Text>
+              </Text>
+            )}
+          </Stack>
+        )}
+        {failed && (
+          <Text component="div" c="dimmed" data-attribution={note?.attribution ?? 'unknown'}>
+            Cause:{' '}
+            {note?.attribution
+              ? `${BLAME[note.attribution]}, as declared by the producer`
+              : 'unknown. Nothing recorded says whether the product, the test harness or the environment is at fault.'}
+          </Text>
+        )}
+        {timeline.length > 0 && (
+          <Stack gap="xs" component="section" aria-label="Chronology of this source">
+            <Text component="div" c="dimmed">
+              Records of this source, oldest first
+            </Text>
+            <List listStyleType="none" spacing="xs" type="ordered">
+              {timeline.map(({ record, selected: current }) => (
+                <List.Item key={`${record.layer}|${record.kind}`} aria-current={current || undefined} data-status={record.status}>
+                  <Flex gap="xs" align="center" wrap="wrap">
+                    <StatusMark status={record.status} size={12} />
+                    <Text span inherit fw={current ? 600 : undefined}>
+                      {statusWord(record.status)}
+                    </Text>
+                    <Text span inherit c="dimmed">
+                      {ago(record.at, now)} · {shortSha(record.sha) ?? 'revision not recorded'}
+                      {current ? ' · selected' : ''}
+                    </Text>
+                  </Flex>
+                </List.Item>
+              ))}
+            </List>
+            {passedAfterFailure(timeline) && (
+              <Text component="div" role="status">
+                The latest run passed after an earlier failure. Nothing recorded shows that the failure was fixed or why it passed.
+              </Text>
+            )}
+          </Stack>
+        )}
+      </Stack>
+    </Paper>
+  );
+}

package/packages/visualizer/src/evidence/outcome.test.ts

@@ -0,0 +1,129 @@
+import type { LayerHeader, LayerRow } from '@crvouga/atlas/reports/evidence-types';
+import type { CheckSlot } from '@crvouga/atlas/reports/evidence-view';
+import type { EvidenceResult } from '@crvouga/atlas/reports/layer-merge';
+import { expect, test } from 'bun:test';
+
+import {
+  chronology,
+  failedStep,
+  failureNote,
+  outcomeHeadline,
+  passedAfterFailure,
+  phaseOf,
+  reachOf,
+  recordOf,
+  selectedResult,
+  sourceLabels,
+  type ResultRecord
+} from './outcome';
+
+const header = (id: string, at: number, extra: Partial<LayerHeader> = {}): LayerHeader => ({
+  id, backend: 'b', producer: 'p', packageDir: null, recordedAtMs: at, sha: null, branch: null, environment: 'desktop-web', runUrl: null,
+  parameters: {}, recording: null, live: false, counts: { passed: 0, failed: 0, running: 0, 'not-run': 0 }, execution: id, ...extra
+});
+const row = (status: LayerRow['status']): LayerRow => ({
+  kind: 'checks', id: 'x', title: 'X', status, specPath: null, detail: '', measurements: [], testId: null, variant: {}, durationMs: null
+});
+const result = (id: string, status: LayerRow['status'], extra: Partial<LayerHeader> = {}): EvidenceResult => ({
+  key: id, slot: 's', layer: header(id, 1, extra), parameters: {}, warning: null, row: row(status)
+});
+const slot = (status: CheckSlot['status'], outcomes: EvidenceResult[]): CheckSlot => ({
+  key: 's', id: 'x', title: 'X', specPath: null, status, outcomes, diagnostics: [], latestAtMs: 1, live: false
+});
+const entry = (r: EvidenceResult) => ({ layer: r.layer, row: r.row });
+
+test('the heading names the selected outcome before the other sources, and never reads it as the combined status', () => {
+  const passed = result('a', 'passed');
+  const failed = result('b', 'failed', { environment: 'api' });
+  const both = slot('failed', [passed, failed]);
+  expect(outcomeHeadline(entry(passed), both).text).toBe('Selected result passed; another scoped source failed');
+  expect(outcomeHeadline(entry(failed), both).text).toBe('Selected result failed; the other scoped source: 1 passed');
+  expect(outcomeHeadline(entry(passed), slot('passed', [passed])).text).toBe('Selected result passed');
+  expect(outcomeHeadline(entry(result('c', 'running')), slot('running', [result('c', 'running')])).text).toBe('Selected result is still running');
+  expect(outcomeHeadline(entry(passed), slot('failed', [passed, failed, result('d', 'failed')])).text).toContain('2 other scoped sources failed');
+});
+
+test('an earlier result says so and names what the combined report now shows', () => {
+  const current = result('new', 'passed');
+  const old = result('old', 'failed');
+  const headline = outcomeHeadline(entry(old), slot('passed', [current]));
+  expect(headline.current).toBe(false);
+  expect(headline.text).toBe('This earlier result failed; the combined report now shows passed across its current source');
+});
+
+test('the selected result is the pinned run, else the named source, else the newest', () => {
+  const a = result('a', 'passed');
+  const b = result('b', 'failed');
+  const both = slot('failed', [a, b]);
+  expect(selectedResult(both)?.layer.id).toBe('a');
+  expect(selectedResult(both, undefined, 'b')?.layer.id).toBe('b');
+  expect(selectedResult(both, undefined, 'unknown')?.layer.id).toBe('a');
+  expect(selectedResult(both, entry(b), 'a')?.layer.id).toBe('b');
+  expect(selectedResult(slot('passed', []))).toBeUndefined();
+});
+
+test('sources that share a name are told apart by status, revision and their place among them', () => {
+  const labels = sourceLabels(
+    [result('a', 'passed', { sha: 'b'.repeat(40), producer: 'one' }), result('b', 'failed', { sha: 'a'.repeat(40), producer: 'two' }), result('c', 'passed', { environment: 'api' })],
+    1_000
+  );
+  expect(labels.map((label) => label.text)).toEqual([
+    'Desktop web · Passed · just now · bbbbbbb · result 1 of 2 from one',
+    'Desktop web · Failed · just now · aaaaaaa · result 2 of 2 from two',
+    'Api · Passed · just now · revision not recorded'
+  ]);
+});
+
+test('the phase comes from the recorded kind, never from the wording', () => {
+  expect(phaseOf('hook')).toBe('setup');
+  expect(phaseOf('Given')).toBe('setup');
+  expect(phaseOf('then')).toBe('behavior');
+  expect(phaseOf('action')).toBe('unspecified');
+  expect(phaseOf(undefined)).toBe('unspecified');
+  const point = failedStep([{ name: 'setup failed to connect', status: 'failed', offsetMs: 0 }]);
+  expect(point?.phase).toBe('unspecified');
+  expect(reachOf(point).state).toBe('unknown');
+  expect(reachOf(undefined).state).toBe('unknown');
+  expect(reachOf(failedStep([{ name: 'Seed', kind: 'hook', status: 'failed' }])).state).toBe('setup-failed');
+  expect(reachOf(failedStep([{ name: 'Check', kind: 'assertion', status: 'failed' }])).state).toBe('expectation-failed');
+});
+
+test('the failed step is the first innermost one in time order', () => {
+  const point = failedStep([
+    { id: 'late', name: 'Late', status: 'failed', offsetMs: 900 },
+    { id: 'group', name: 'Group', status: 'failed', offsetMs: 100 },
+    { id: 'leaf', parentId: 'group', name: 'Leaf', status: 'failed', offsetMs: 150, detail: 'nope' },
+    { name: 'Fine', status: 'passed', offsetMs: 0 }
+  ]);
+  expect(point?.name).toBe('Leaf');
+  expect(point?.detail).toBe('nope');
+  expect(failedStep([{ name: 'ok', status: 'passed' }])).toBeUndefined();
+  expect(failedStep(undefined)).toBeUndefined();
+});
+
+test('only a producer-declared failure is read, and only a known attribution counts', () => {
+  expect(failureNote({ 'atlas.failure': { expected: 200, actual: { status: 500 }, attribution: 'environment' } })).toEqual({
+    expected: '200',
+    actual: '{"status":500}',
+    attribution: 'environment'
+  });
+  expect(failureNote({ 'atlas.failure': { attribution: 'the intern' } })).toBeUndefined();
+  expect(failureNote({ other: {} })).toBeUndefined();
+  expect(failureNote(undefined)).toBeUndefined();
+});
+
+test('a chronology is only told for one source whose outcome changed, oldest first, without declaring a cause', () => {
+  const record = (layer: string, status: ResultRecord['status'], at: number, env: string | null = 'desktop-web'): ResultRecord => ({
+    ...recordOf(entry(result(layer, status, { environment: env, recordedAtMs: at }))),
+    at
+  });
+  const early = record('1', 'failed', 100);
+  const late = record('2', 'passed', 200);
+  const timeline = chronology(late, [late, early, record('3', 'passed', 150, 'api')]);
+  expect(timeline.map((each) => each.record.layer)).toEqual(['1', '2']);
+  expect(timeline[1]!.selected).toBe(true);
+  expect(passedAfterFailure(timeline)).toBe(true);
+  expect(passedAfterFailure(chronology(early, [early, late]).slice().reverse())).toBe(false);
+  expect(chronology(late, [late])).toEqual([]);
+  expect(chronology(late, [late, record('4', 'passed', 50)])).toEqual([]);
+});

package/packages/visualizer/src/evidence/outcome.ts

@@ -0,0 +1,309 @@
+/**
+ * @module Outcome explanation
+ *
+ * Pure reading of what one selected result says, set beside everything else recorded for the same check, so a
+ * detail never leads with a summary that contradicts its evidence. The selected source's outcome, the other current
+ * sources, where a failure happened, whether the behavior was reached, and the chronology of one source are all
+ * stated separately. Nothing here changes a status or a winner: it only words what was recorded, and anything that
+ * was not recorded stays unknown. In particular a failure is never attributed to the product, the test harness or
+ * the environment from the wording of its message; only a producer's own `atlas.failure` declaration is shown.
+ */
+import type { HistoryEntry, CheckSlot } from '@crvouga/atlas/reports/evidence-view';
+import { isVideoAttachment, type EvidenceHolder } from '@crvouga/atlas/reports/evidence-detail';
+import { environmentLabel } from '@crvouga/atlas/reports/layer-axes';
+import type { EvidenceResult } from '@crvouga/atlas/reports/layer-merge';
+import type { ReportStep, RunReport } from '@crvouga/atlas/reports/report-types';
+import type { Attachment, Step } from '@crvouga/atlas/schema';
+import { ago, shortSha, statusWord } from './format';
+
+/** The extension key under which a producer may declare why and where a check failed. */
+export const FAILURE_EXTENSION = 'atlas.failure';
+
+/** Who a producer declared a failure to be the fault of. Absent is unknown, never inferred. */
+export type Attribution = 'product' | 'test-harness' | 'environment';
+
+const ATTRIBUTIONS: readonly string[] = ['product', 'test-harness', 'environment'];
+
+/** What a producer declared about a failure: the expectation, what was observed, and optionally whose fault it was. */
+export type FailureNote = {
+  readonly expected?: string;
+  readonly actual?: string;
+  readonly attribution?: Attribution;
+};
+
+/** Whether the failed step belongs to getting ready for the behavior, to the behavior itself, or is not known to be either. */
+export type Phase = 'setup' | 'behavior' | 'unspecified';
+
+/** Step kinds (an open vocabulary) that are preparation, not the behavior under test. */
+const SETUP_KINDS = new Set(['hook', 'setup', 'fixture', 'before', 'beforeall', 'beforeeach', 'given']);
+/** Step kinds that are the behavior being exercised or an expectation about it. */
+const BEHAVIOR_KINDS = new Set(['when', 'then', 'assertion', 'expect']);
+
+/**
+ * Which phase a step of this `kind` belongs to. Decided by the recorded kind only, never by a step's name or message;
+ * a kind that is not recognized, or none, is `unspecified`.
+ */
+export function phaseOf(kind: string | undefined): Phase {
+  const key = kind?.toLowerCase();
+  if (!key) return 'unspecified';
+  return SETUP_KINDS.has(key) ? 'setup' : BEHAVIOR_KINDS.has(key) ? 'behavior' : 'unspecified';
+}
+
+/** The step at which a result failed, as far as the recording says. */
+export type FailurePoint = {
+  readonly name: string;
+  readonly kind: string | undefined;
+  readonly phase: Phase;
+  /** The step's own message, as recorded. */
+  readonly detail: string | undefined;
+  /** How long after the check started it began, when recorded. */
+  readonly offsetMs: number | undefined;
+  readonly note: FailureNote | undefined;
+  /** The videos on the step itself, if it has any. */
+  readonly videos: readonly Attachment[];
+};
+
+function text(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  return JSON.stringify(value);
+}
+
+/**
+ * The failure a producer declared under {@link FAILURE_EXTENSION} in `extensions`: `expected`, `actual` and an
+ * `attribution` of `product`, `test-harness` or `environment`. Anything else is ignored; undefined when nothing usable is there.
+ */
+export function failureNote(extensions: Readonly<Record<string, unknown>> | undefined): FailureNote | undefined {
+  const raw = extensions?.[FAILURE_EXTENSION];
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const { expected, actual, attribution } = raw as Record<string, unknown>;
+  const note: { expected?: string; actual?: string; attribution?: Attribution } = {};
+  const e = text(expected);
+  const a = text(actual);
+  if (e !== undefined) note.expected = e;
+  if (a !== undefined) note.actual = a;
+  if (typeof attribution === 'string' && ATTRIBUTIONS.includes(attribution)) note.attribution = attribution as Attribution;
+  return Object.keys(note).length ? note : undefined;
+}
+
+/**
+ * The first failed step of a recorded check, preferring the innermost one (a failed action inside a failed group is
+ * the action). Steps are ordered by their start offset, else by their position. Undefined when no step failed or none
+ * was recorded.
+ */
+export function failedStep(steps: readonly Step[] | undefined): FailurePoint | undefined {
+  if (!steps?.length) return undefined;
+  const failedParents = new Set(steps.filter((step) => step.status === 'failed' && step.parentId).map((step) => step.parentId));
+  const order = steps.map((step, index) => ({ step, index }));
+  order.sort((a, b) => (a.step.offsetMs ?? 0) - (b.step.offsetMs ?? 0) || a.index - b.index);
+  const found = order.find(({ step }) => step.status === 'failed' && !(step.id !== undefined && failedParents.has(step.id)))?.step;
+  if (!found) return undefined;
+  return {
+    name: found.name,
+    kind: found.kind,
+    phase: phaseOf(found.kind),
+    detail: found.detail,
+    offsetMs: found.offsetMs,
+    note: failureNote(found.extensions),
+    videos: (found.attachments ?? []).filter(isVideoAttachment)
+  };
+}
+
+/** The first innermost failed step of an Atlas run's own timeline (see {@link failedStep}). */
+export function failedReportStep(report: RunReport | undefined): FailurePoint | undefined {
+  if (!report) return undefined;
+  const walk = (steps: readonly ReportStep[]): ReportStep | undefined => {
+    for (const step of steps) {
+      if (step.status !== 'failed') continue;
+      return walk(step.steps) ?? step;
+    }
+    return undefined;
+  };
+  const found = walk(report.steps);
+  if (!found) return undefined;
+  return {
+    name: found.title,
+    kind: found.kind,
+    phase: phaseOf(found.kind),
+    detail: found.error,
+    offsetMs: Math.max(0, found.startedAtMs - report.meta.startedAtMs),
+    note: undefined,
+    videos: []
+  };
+}
+
+/** The recorded videos a holder carries on itself, its steps and its attempts. */
+export function videosIn(holder: EvidenceHolder | undefined): Attachment[] {
+  if (!holder) return [];
+  return [
+    ...(holder.attachments ?? []).filter(isVideoAttachment),
+    ...(holder.steps ?? []).flatMap((step) => (step.attachments ?? []).filter(isVideoAttachment)),
+    ...(holder.attempts ?? []).flatMap((attempt) => [
+      ...(attempt.attachments ?? []).filter(isVideoAttachment),
+      ...(attempt.steps ?? []).flatMap((step) => (step.attachments ?? []).filter(isVideoAttachment))
+    ])
+  ];
+}
+
+/** The one-line statement of what the failure point says about the behavior. */
+export function reachOf(point: FailurePoint | undefined): { readonly state: 'setup-failed' | 'expectation-failed' | 'unknown'; readonly text: string } {
+  if (!point) return { state: 'unknown', text: 'Where it failed was not recorded, so whether the behavior was reached is unknown.' };
+  if (point.phase === 'setup')
+    return { state: 'setup-failed', text: `Behavior not verified: setup failed at “${point.name}”. The execution is still recorded as failed.` };
+  if (point.phase === 'behavior')
+    return { state: 'expectation-failed', text: `The behavior was reached and an expectation was not met at “${point.name}”.` };
+  return { state: 'unknown', text: `Failed at “${point.name}”. Whether the behavior was reached is not recorded.` };
+}
+
+const WORD = { passed: 'passed', failed: 'failed', running: 'is still running', 'not-run': 'was not run' } as const;
+
+/** Counts of results by status, in words: `1 passed, 2 failed`. */
+function tally(results: readonly EvidenceResult[]): string {
+  const counts = new Map<string, number>();
+  for (const { row } of results) counts.set(row.status, (counts.get(row.status) ?? 0) + 1);
+  return (['passed', 'failed', 'running', 'not-run'] as const)
+    .filter((status) => counts.has(status))
+    .map((status) => `${counts.get(status)} ${status === 'not-run' ? 'not run' : status}`)
+    .join(', ');
+}
+
+/** What the selected result says, and the current results of the other sources it must be read beside. */
+export type Headline = {
+  readonly text: string;
+  /** The current results from other sources than the selected one, newest first. */
+  readonly others: readonly EvidenceResult[];
+  /** False when the selected result is an earlier one that a newer run has replaced in the combined report. */
+  readonly current: boolean;
+};
+
+/**
+ * The heading for a selected result: its own outcome first, then what the other current sources recorded. A passing
+ * selection beside a failing source says both; an earlier result says it is earlier and names the combined status.
+ * Never reads the selected outcome as the check's status.
+ */
+export function outcomeHeadline(selected: HistoryEntry, slot: CheckSlot): Headline {
+  const current = slot.outcomes.some((outcome) => outcome.layer.id === selected.layer.id);
+  const others = slot.outcomes.filter((outcome) => outcome.layer.id !== selected.layer.id);
+  const own = WORD[selected.row.status];
+  if (!current) {
+    return {
+      current,
+      others,
+      text: `This earlier result ${own}; the combined report now shows ${statusWord(slot.status).toLowerCase()} across ${others.length === 1 ? 'its current source' : `its ${others.length} current sources`}`
+    };
+  }
+  const failed = others.filter((outcome) => outcome.row.status === 'failed').length;
+  let text = `Selected result ${own}`;
+  if (selected.row.status === 'passed' && failed > 0) text += `; ${failed === 1 ? 'another scoped source' : `${failed} other scoped sources`} failed`;
+  else if (others.length > 0) text += `; ${others.length === 1 ? 'the other scoped source' : 'other scoped sources'}: ${tally(others)}`;
+  return { current, others, text };
+}
+
+/**
+ * The result a detail shows: the run the address pins, else the current result of the source it names, else the newest.
+ * Undefined only for a check with no result.
+ */
+export function selectedResult(slot: CheckSlot, pinned?: HistoryEntry, source?: string): HistoryEntry | undefined {
+  if (pinned) return pinned;
+  const found = (source ? slot.outcomes.find((outcome) => outcome.layer.id === source) : undefined) ?? slot.outcomes[0];
+  return found ? { layer: found.layer, row: found.row } : undefined;
+}
+
+/** How a choosable source is told apart from its siblings without reading opaque producer ids. */
+export type SourceLabel = {
+  /** The environment and parameters, or the producer when neither is named. */
+  readonly name: string;
+  /** Status in words. */
+  readonly status: string;
+  /** When it was recorded, relative. */
+  readonly when: string;
+  /** The commit, or the branch, or `revision not recorded`. */
+  readonly revision: string;
+  /** Present when other sources share the same name: its place among them, newest first, and its producer. */
+  readonly attempt: string | undefined;
+  /** All of the above in one line. */
+  readonly text: string;
+};
+
+/**
+ * Labels for the current results of a check so each can be told from the others by status, time, revision and,
+ * when several share a name, its place among them. `now` is epoch milliseconds.
+ */
+export function sourceLabels(outcomes: readonly EvidenceResult[], now: number): SourceLabel[] {
+  const names = outcomes.map((outcome) => {
+    const environment = outcome.layer.environment ? environmentLabel(outcome.layer.environment) : '';
+    const parameters = Object.entries(outcome.parameters)
+      .map(([name, value]) => `${name}: ${value}`)
+      .join(', ');
+    return [environment, parameters].filter(Boolean).join(' · ') || outcome.layer.producer;
+  });
+  return outcomes.map((outcome, index) => {
+    const name = names[index]!;
+    const siblings = names.flatMap((each, at) => (each === name ? [at] : []));
+    const attempt =
+      siblings.length > 1 ? `result ${siblings.indexOf(index) + 1} of ${siblings.length} from ${outcome.layer.producer}` : undefined;
+    const revision = shortSha(outcome.layer.sha) ?? outcome.layer.branch ?? 'revision not recorded';
+    const status = statusWord(outcome.row.status);
+    const when = ago(outcome.layer.recordedAtMs, now);
+    return { name, status, when, revision, attempt, text: [name, status, when, revision, attempt].filter(Boolean).join(' · ') };
+  });
+}
+
+/** What the chronology needs to know of one recorded result, whether it came from the held layers or from a test's history. */
+export type ResultRecord = {
+  /** The id of the layer that recorded it. */
+  readonly layer: string;
+  readonly kind: string;
+  readonly status: HistoryEntry['row']['status'];
+  readonly at: number;
+  readonly sha: string | null;
+  readonly producer: string;
+  readonly environment: string | null;
+  readonly parameters: Readonly<Record<string, string>>;
+};
+
+/** The record of a layer's result. */
+export function recordOf(entry: HistoryEntry): ResultRecord {
+  const { layer, row } = entry;
+  return {
+    layer: layer.id,
+    kind: row.kind,
+    status: row.status,
+    at: layer.recordedAtMs,
+    sha: layer.sha,
+    producer: layer.producer,
+    environment: layer.environment,
+    parameters: layer.parameters
+  };
+}
+
+/** One record of the selected result's own source, for the chronology. */
+export type ChronologyEntry = { readonly record: ResultRecord; readonly selected: boolean };
+
+function samePlace(a: ResultRecord, b: ResultRecord): boolean {
+  return (
+    a.producer === b.producer &&
+    a.environment === b.environment &&
+    JSON.stringify(Object.entries(a.parameters).sort()) === JSON.stringify(Object.entries(b.parameters).sort())
+  );
+}
+
+/**
+ * The records of the selected result's own source (same producer, environment and parameters), oldest first, one per
+ * layer. Empty when there is only one, or when they all have the same outcome, so there is no chronology to tell.
+ */
+export function chronology(selected: ResultRecord, history: readonly ResultRecord[]): ChronologyEntry[] {
+  const seen = new Set<string>();
+  const own = history
+    .filter((record) => samePlace(record, selected) && !seen.has(`${record.layer}|${record.kind}`) && seen.add(`${record.layer}|${record.kind}`))
+    .sort((a, b) => a.at - b.at);
+  if (own.length < 2 || new Set(own.map((record) => record.status)).size < 2) return [];
+  return own.map((record) => ({ record, selected: record.layer === selected.layer && record.kind === selected.kind }));
+}
+
+/** Whether the newest record of a chronology passed after an earlier one failed. */
+export function passedAfterFailure(entries: readonly ChronologyEntry[]): boolean {
+  const last = entries.at(-1);
+  return last !== undefined && last.record.status === 'passed' && entries.slice(0, -1).some((each) => each.record.status === 'failed');
+}

package/packages/visualizer/src/explorer/TestDetail.tsx

@@ -17,6 +17,7 @@ import { CheckDetail } from '../evidence/check-detail';
 import { ago, exactTime, plural, shortSha, statusWord, useNow } from '../evidence/format';
 import { useEvidence } from '../evidence/evidence-context';
 import { Origin, StatusMark } from '../evidence/marks';
+import { outcomeHeadline, selectedResult } from '../evidence/outcome';
 import { useTestHistory } from './catalog';
 import { patched, useExplorerNavigate, useExplorerSearch } from './navigate';
 import { Badges, runName } from './parts';
@@ -126,7 +127,7 @@ function Scope({ pinned, slot }: { pinned: PinnedResult; slot: CheckSlot | undef
 export function TestDetail({ test, slot }: { test: TestSummary; slot: CheckSlot | undefined }) {
   const now = useNow();
   const history = useTestHistory(test.key);
-  const { layer } = useExplorerSearch();
+  const { layer, source } = useExplorerSearch();
   const go = useExplorerNavigate();
   const pinned = usePinnedResult(layer, test.key);
   const [recording, setRecording] = useState(false);
@@ -134,6 +135,7 @@ export function TestDetail({ test, slot }: { test: TestSummary; slot: CheckSlot
   const [moment, setMoment] = useState<number | null>(null);
   const [rows, setRows] = useState(HISTORY_ROWS);
   const entries = history.data?.history ?? [];
+  const selected = slot && (!layer || pinned.state === 'ready') ? selectedResult(slot, pinned.state === 'ready' ? pinned.entry : undefined, source) : undefined;
   const stats = test.stats;
   const d = stats.durations;
   if (recording && slot) {
@@ -211,6 +213,9 @@ export function TestDetail({ test, slot }: { test: TestSummary; slot: CheckSlot
           <Text data-status={test.status} span inherit fw={600}>
             {statusWord(test.status)}
           </Text>
+          <Text span inherit c="dimmed">
+            worst current result of {plural(test.outcomes.length, 'source', 'sources')}
+          </Text>
           {stats.flaky && (
             <Text title={stats.flakyReason} span inherit>
               Flaky: {stats.flakyReason}
@@ -218,6 +223,11 @@ export function TestDetail({ test, slot }: { test: TestSummary; slot: CheckSlot
           )}
           <Badges test={test} />
         </Flex>
+        {selected && slot && (
+          <Text component="p" role="status" fw={600} data-outcome-headline>
+            {outcomeHeadline(selected, slot).text}
+          </Text>
+        )}
         {test.spec && <Code c="dimmed">{test.spec!.path}</Code>}
         <Code title="Check id" c="dimmed">
           {test.id}
@@ -425,6 +435,18 @@ export function TestDetail({ test, slot }: { test: TestSummary; slot: CheckSlot
             layerId={layer}
             {...(pinned.state === 'ready' ? { pinned: pinned.entry, pin: true } : {})}
             reads="steps"
+            headline={false}
+            records={entries.map((entry) => ({
+              layer: entry.layer,
+              kind: entry.kind,
+              status: entry.status,
+              at: entry.at,
+              sha: entry.sha,
+              producer: entry.producer,
+              environment: entry.environment,
+              parameters: entry.parameters
+            }))}
+            {...(layer ? {} : { source, onSource: (next: string | null) => go({ source: next ?? undefined }) })}
             select={(patch) => {
               if (patch.view === 'recording') {
                 setRecordingLayer(patch.layer ?? undefined);

package/packages/visualizer/src/explorer/search.ts

@@ -67,6 +67,8 @@ export const ExplorerSearchFields = {
   openRun: text,
   /** Pins the open test's detail to one exact layer (a run's record of it), instead of the latest combined evidence. With `openRun` and `artifact` it names the layer the file is in. */
   layer: text,
+  /** Which current source (a layer id) of the open test the detail's outcome summary, media and failure describe, without pinning a run. Unknown or absent: the newest. */
+  source: text,
   /** With `openRun` and `layer`: the one file of that layer (an `artifactRef`: `id:…`, `key:…` or `name:…`) the run's Artifacts select. */
   artifact: text,
   /** Only the runs, and the results of an opened run, that have a playable video recording. */
@@ -98,6 +100,7 @@ export type ExplorerSearch = {
   readonly tab?: 'runs' | 'artifacts';
   readonly openRun?: string;
   readonly layer?: string;
+  readonly source?: string;
   readonly artifact?: string;
   readonly video?: true;
 };