@crvouga/atlas 1.16.0 → 1.17.0

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

@@ -3,7 +3,9 @@ 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 { assessBehavior, assessResult, hasRelease, needsAttention } from './applicability';
+import type { TestResultEntry, TestSummary } from '@crvouga/atlas/reports/test-catalog';
+
+import { assessBehavior, assessResult, assessTest, attentionRank, hasRelease, needsAttention } from './applicability';
 import { behaviorOf, type RevisionSource } from './behavior';
 import { featureModel } from './gherkin';
 
@@ -129,3 +131,68 @@ test('a behavior is read by its best completed result and its status is untouche
   const running = assessBehavior(behaviorOf(ADD, slot([result('l1', {}, 'running')]), null, same, 'k'), same, {});
   expect(running.verdict).toBe('none');
 });
+
+type Outcome = Partial<TestResultEntry>;
+function testOf(outcomes: Outcome[], fingerprint: string | null = 'f1'): TestSummary {
+  return {
+    key: 'k', id: 'k', title: 'Lists: Add', specPath: 'specs/a.feature',
+    spec: { path: 'specs/a.feature', title: 'Lists', domain: 'lists', kind: 'gherkin', ...(fingerprint ? { fingerprint } : {}) },
+    outcomes: outcomes.map((outcome, index) => ({
+      at: 1_000, status: 'passed', durationMs: null, environment: 'desktop-web', producer: 'p', kind: 'behavior', parameters: {}, branch: 'main', sha: null, runUrl: null,
+      run: 'r', layer: `l${index + 1}`, backend: 'b', detail: '', specRevision: 'f1', ...outcome
+    }))
+  } as unknown as TestSummary;
+}
+
+test('a test whose promise changed after its only result is stale, and the same test read from the catalog agrees with the page', () => {
+  const stale = assessTest(testOf([{ specRevision: 'f0' }]), {});
+  expect(stale.verdict).toBe('stale');
+  expect(stale.reasons[0]).toContain('not proof of the current promise');
+  expect(assessTest(testOf([{ specRevision: 'f1' }]), {}).verdict).toBe('applies');
+  // The same facts, read from the report, give the same verdict.
+  expect(assessResult(result('l1'), revisions('f1', { l1: 'f0' }), {}).verdict).toBe(stale.verdict);
+});
+
+test('a test with no recorded revision or no promise fingerprint is unknown, never applying', () => {
+  expect(assessTest(testOf([{ specRevision: undefined }]), {}).verdict).toBe('unknown');
+  expect(assessTest(testOf([{ specRevision: 'f1' }], null), {}).verdict).toBe('unknown');
+});
+
+test('a test with no completed result has none, and its failure is not read at all as stale', () => {
+  expect(assessTest(testOf([{ status: 'running' }, { status: 'not-run' }]), {}).verdict).toBe('none');
+  expect(assessTest(testOf([]), { build: '9' }).release).toBe('unknown');
+  expect(assessTest(testOf([{ status: 'failed' }]), {}).verdict).toBe('applies');
+});
+
+test('a test is read against the release from its provenance: build, platform, modified checkout and asserted compatibility', () => {
+  const release = { build: '91' };
+  expect(assessTest(testOf([{ provenance: { build: '90' } }]), release).release).toBe('other');
+  expect(assessTest(testOf([{ provenance: { build: '91' } }]), release).release).toBe('exact');
+  expect(assessTest(testOf([{ provenance: { build: '91' } }]), { ...release, platform: 'ios' }).release).toBe('unknown');
+  expect(assessTest(testOf([{ provenance: { build: '91' }, freshness: 'modified' }]), release).release).toBe('unknown');
+  const asserted = (by: Record<string, string>) => assessTest(testOf([{ provenance: { build: '90', 'applies-to': '91', ...by } }]), release);
+  expect(asserted({ 'applies-to-by': 'policy-7' }).release).toBe('asserted');
+  expect(asserted({}).release).toBe('unknown');
+  // A branch never supplies deployment state.
+  expect(assessTest(testOf([{ branch: 'release/91' }]), release).release).toBe('unknown');
+});
+
+test('the best of a test\'s current results is kept, and stale evidence sorts before evidence that applies', () => {
+  const both = assessTest(testOf([{ specRevision: 'f0', at: 5_000 }, { specRevision: 'f1', at: 1_000 }]), {});
+  expect(both.verdict).toBe('applies');
+  expect(both.layer).toBe('l2');
+  expect(both.others).toBe(1);
+  const ranks = [assessTest(testOf([{}]), {}), assessTest(testOf([{ specRevision: 'f0' }]), {}), assessTest(testOf([{ specRevision: undefined }]), {}), assessTest(testOf([]), {})].map(attentionRank);
+  expect(ranks).toEqual([3, 0, 1, 2]);
+});
+
+test('when evidence was published or enriched is carried apart from when the checks ran, and a time that cannot be read is no time', () => {
+  const facts = assessTest(testOf([{ at: 1_000, provenance: { 'published-at': '1700000000000', 'enriched-at': '2026-10-01T00:00:00Z' } }]), {}).facts!;
+  expect(facts.executedAtMs).toBe(1_000);
+  expect(facts.publishedAtMs).toBe(1_700_000_000_000);
+  expect(facts.enrichedAtMs).toBe(Date.parse('2026-10-01T00:00:00Z'));
+  const unreadable = assessTest(testOf([{ provenance: { 'published-at': 'yesterday-ish', 'enriched-at': '0' } }]), {}).facts!;
+  expect([unreadable.publishedAtMs, unreadable.enrichedAtMs]).toEqual([null, null]);
+  // Read from the report, labels at the layer or the check say the same.
+  expect(assessResult(result('l1', { layerLabels: { 'published-at': '1700000000000' } }), same, {}).facts!.publishedAtMs).toBe(1_700_000_000_000);
+});

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

@@ -13,9 +13,16 @@
  * the app under test was), `platform` (the client family; the environment when absent), `applies-to` (a comma
  * separated list of builds or commits the producer asserts the evidence is still good for) and `applies-to-by`
  * (the policy, person or tool that makes the assertion). An assertion without `applies-to-by` is not accepted.
+ * `published-at` and `enriched-at` say when the evidence was published or enriched (epoch milliseconds or an ISO date).
+ * Layers carry no publication time of their own, because a layer's id is the digest of its content and a time of
+ * upload in it would make a retried publish a different layer; a producer that knows states it as a label. It is shown
+ * apart from when the checks ran and is never the age of the evidence.
+ *
+ * The same reading serves a feature page (from the report's results, {@link assessBehavior}) and the test explorer (from
+ * the catalog's current results, {@link assessTest}).
  */
-import type { LayerHeader } from '@crvouga/atlas/reports/evidence-types';
 import type { EvidenceResult } from '@crvouga/atlas/reports/layer-merge';
+import type { TestResultEntry, TestSummary } from '@crvouga/atlas/reports/test-catalog';
 
 import { compareRevisions, type Behavior, type Revision, type RevisionSource } from './behavior';
 
@@ -58,6 +65,10 @@ export const VERDICTS: Readonly<Record<Verdict, { readonly label: string; readon
 export type EvidenceFacts = {
   /** When the checks ran, epoch milliseconds. The age of evidence counts from here, not from publication or enrichment. */
   readonly executedAtMs: number;
+  /** When the evidence was published, from the `published-at` label, or null when the producer did not say. Never the age of the evidence. */
+  readonly publishedAtMs: number | null;
+  /** When the evidence was enriched (annotated, captioned, re-indexed), from the `enriched-at` label, or null. Never the age of the evidence. */
+  readonly enrichedAtMs: number | null;
   readonly build: string | null;
   readonly sha: string | null;
   /** The `platform` label, else the layer's environment. */
@@ -83,8 +94,10 @@ export type Assessment = {
   readonly assertion: Assertion | null;
   /** Sentences saying why, in the order a reader needs them. Empty when there is nothing to add. */
   readonly reasons: readonly string[];
-  /** The result this reading is of, or null when there is none. */
+  /** The result this reading is of, or null when there is none (or it was read from a test catalog, which holds its layer id instead). */
   readonly result: EvidenceResult | null;
+  /** The id of the layer that recorded the result this reading is of, or null when there is none. */
+  readonly layer: string | null;
   /** How many other completed results were read and set aside for this one. */
   readonly others: number;
 };
@@ -107,23 +120,38 @@ function labelsOf(result: EvidenceResult): Readonly<Record<string, string>> {
   return { ...(result.layer.evidence?.labels ?? {}), ...(result.row.evidence?.labels ?? {}) };
 }
 
-/** What a result's layer and labels say it ran against. */
-export function evidenceFacts(result: EvidenceResult): EvidenceFacts {
-  const labels = labelsOf(result);
-  const layer: LayerHeader = result.layer;
+/** A time a label states: epoch milliseconds or an ISO date. Anything else is no time. */
+function labelTime(value: string | undefined): number | null {
+  const text = value?.trim();
+  if (!text) return null;
+  const at = /^\d{9,}$/.test(text) ? Number(text) : /^\d{4}-\d{2}-\d{2}/.test(text) ? Date.parse(text) : Number.NaN;
+  return Number.isFinite(at) && at > 0 ? at : null;
+}
+
+/** What one result recorded about itself, whether read from the report or from the test catalog. */
+type Recorded = {
+  readonly labels: Readonly<Record<string, string>>;
+  readonly executedAtMs: number;
+  readonly sha: string | null;
+  readonly environment: string | null;
+  readonly freshness: 'modified' | 'unknown' | null;
+};
+
+function factsFrom(recorded: Recorded): EvidenceFacts {
+  const { labels } = recorded;
   return {
-    executedAtMs: layer.recordedAtMs,
+    executedAtMs: recorded.executedAtMs,
+    publishedAtMs: labelTime(labels['published-at']),
+    enrichedAtMs: labelTime(labels['enriched-at']),
     build: labels.build?.trim() || null,
-    sha: layer.sha,
-    platform: labels.platform?.trim() || layer.environment,
-    environment: layer.environment,
-    provenance: layer.freshness ?? null
+    sha: recorded.sha,
+    platform: labels.platform?.trim() || recorded.environment,
+    environment: recorded.environment,
+    provenance: recorded.freshness
   };
 }
 
-/** The assertion a result's labels make, or null when it makes none. */
-export function assertionOf(result: EvidenceResult): Assertion | null {
-  const labels = labelsOf(result);
+function assertionFrom(labels: Readonly<Record<string, string>>): Assertion | null {
   const builds = (labels['applies-to'] ?? '')
     .split(',')
     .map((each) => each.trim())
@@ -131,6 +159,32 @@ export function assertionOf(result: EvidenceResult): Assertion | null {
   return builds.length ? { builds, by: labels['applies-to-by']?.trim() || null } : null;
 }
 
+const ofResult = (result: EvidenceResult): Recorded => ({
+  labels: labelsOf(result),
+  executedAtMs: result.layer.recordedAtMs,
+  sha: result.layer.sha,
+  environment: result.layer.environment,
+  freshness: result.layer.freshness ?? null
+});
+
+const ofOutcome = (outcome: TestResultEntry): Recorded => ({
+  labels: outcome.provenance ?? {},
+  executedAtMs: outcome.at,
+  sha: outcome.sha,
+  environment: outcome.environment,
+  freshness: outcome.freshness ?? null
+});
+
+/** What a result's layer and labels say it ran against. */
+export function evidenceFacts(result: EvidenceResult): EvidenceFacts {
+  return factsFrom(ofResult(result));
+}
+
+/** The assertion a result's labels make, or null when it makes none. */
+export function assertionOf(result: EvidenceResult): Assertion | null {
+  return assertionFrom(labelsOf(result));
+}
+
 const RANK: Readonly<Record<Verdict, number>> = { applies: 0, unknown: 1, stale: 2, none: 3 };
 
 /** How one result's evidence stands against the release. Never reads a branch or a status. */
@@ -193,11 +247,10 @@ function matchRelease(facts: EvidenceFacts, release: ReleaseIdentity, promise: R
   return { match: 'exact', reasons };
 }
 
-/** One result against the promise and the release. */
-export function assessResult(result: EvidenceResult, revisions: RevisionSource, release: ReleaseIdentity): Assessment {
-  const facts = evidenceFacts(result);
-  const revision = compareRevisions(revisions.current, revisions.recorded(result.layer.id));
-  const assertion = assertionOf(result);
+/** One recorded result against the promise (current and recorded fingerprints) and the release. */
+function read(recorded: Recorded, revision: Revision, release: ReleaseIdentity, source: { result: EvidenceResult | null; layer: string }): Assessment {
+  const facts = factsFrom(recorded);
+  const assertion = assertionFrom(recorded.labels);
   const { match, reasons } = matchRelease(facts, release, revision.match, assertion);
   const promiseReason =
     revision.match === 'different'
@@ -214,11 +267,36 @@ export function assessResult(result: EvidenceResult, revisions: RevisionSource,
     facts,
     assertion,
     reasons: [...(promiseReason ? [promiseReason] : []), ...reasons],
-    result,
+    result: source.result,
+    layer: source.layer,
     others: 0
   };
 }
 
+/** One result against the promise and the release. */
+export function assessResult(result: EvidenceResult, revisions: RevisionSource, release: ReleaseIdentity): Assessment {
+  const revision = compareRevisions(revisions.current, revisions.recorded(result.layer.id));
+  return read(ofResult(result), revision, release, { result, layer: result.layer.id });
+}
+
+const NOTHING = (release: ReleaseIdentity): Assessment => ({
+  verdict: 'none',
+  promise: 'unknown',
+  release: hasRelease(release) ? 'unknown' : 'not-selected',
+  facts: null,
+  assertion: null,
+  reasons: [],
+  result: null,
+  layer: null,
+  others: 0
+});
+
+/** The reading that best applies (applies, then unknown, then stale; the newest execution among equals), with how many were set aside. */
+function best(readings: Assessment[]): Assessment {
+  readings.sort((a, b) => RANK[a.verdict] - RANK[b.verdict] || b.facts!.executedAtMs - a.facts!.executedAtMs);
+  return { ...readings[0]!, others: readings.length - 1 };
+}
+
 /**
  * The reading of a behavior's evidence: every completed result is read and the one that best applies is kept
  * (applies, then unknown, then stale; the newest execution among equals), so a recording on the release's platform is
@@ -227,12 +305,29 @@ export function assessResult(result: EvidenceResult, revisions: RevisionSource,
  */
 export function assessBehavior(behavior: Behavior, revisions: RevisionSource, release: ReleaseIdentity): Assessment {
   const completed = (behavior.slot?.outcomes ?? []).filter((result) => result.row.status === 'passed' || result.row.status === 'failed');
-  if (completed.length === 0) {
-    return { verdict: 'none', promise: 'unknown', release: hasRelease(release) ? 'unknown' : 'not-selected', facts: null, assertion: null, reasons: [], result: null, others: 0 };
-  }
-  const readings = completed.map((result) => assessResult(result, revisions, release));
-  readings.sort((a, b) => RANK[a.verdict] - RANK[b.verdict] || b.facts!.executedAtMs - a.facts!.executedAtMs);
-  return { ...readings[0]!, others: readings.length - 1 };
+  if (completed.length === 0) return NOTHING(release);
+  return best(completed.map((result) => assessResult(result, revisions, release)));
+}
+
+/**
+ * The reading of a test of the catalog from its current results: the spec's fingerprint now (`test.spec.fingerprint`) against
+ * the one each result recorded (`specRevision`), and the build, commit, platform and provenance each states. The same
+ * rules as {@link assessBehavior}; a result without a recorded revision, or a test whose spec has no fingerprint, is unknown.
+ * Only completed results (passed or failed) are read; a test with none has `none`. Statuses are unchanged by this.
+ */
+export function assessTest(test: TestSummary, release: ReleaseIdentity): Assessment {
+  const completed = test.outcomes.filter((outcome) => outcome.status === 'passed' || outcome.status === 'failed');
+  if (completed.length === 0) return NOTHING(release);
+  const current = test.spec?.fingerprint ?? null;
+  return best(completed.map((outcome) => read(ofOutcome(outcome), compareRevisions(current, outcome.specRevision), release, { result: null, layer: outcome.layer })));
+}
+
+/**
+ * The order the explorer lists tests in when sorted by evidence: what needs a look first (stale, then unknown, then
+ * without evidence), evidence that applies last. A rank for sorting only; it is never shown as a status.
+ */
+export function attentionRank(assessment: Assessment): number {
+  return { stale: 0, unknown: 1, none: 2, applies: 3 }[assessment.verdict];
 }
 
 /** Whether a behavior belongs under "stale or unverified": anything but evidence that applies. */

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

@@ -1,5 +1,5 @@
 import { SpecLogo } from '../components/SpecLogo';
-import { IconVideo, IconX } from '@tabler/icons-react';
+import { IconAlertTriangle, IconVideo, IconX } from '@tabler/icons-react';
 import {
   Accordion,
   Alert,
@@ -44,6 +44,8 @@ import {
 } from '@crvouga/atlas/reports/test-catalog';
 import { Link } from '@tanstack/react-router';
 import { useDeferredValue, useEffect, useMemo, useState } from 'react';
+import { attentionRank, hasRelease, needsAttention, type Assessment, type ReleaseIdentity } from '../evidence/applicability';
+import { ApplicabilityControls, VerdictBadge } from '../evidence/applicability-view';
 import { staticEvidence } from '../evidence/api';
 import { useEvidence } from '../evidence/evidence-context';
 import { ago, plural, useNow } from '../evidence/format';
@@ -53,6 +55,7 @@ import { behaviorDocs, behaviorId, describeHit, testHasVideo } from '../find/beh
 import { useDocSearch } from '../find/doc-search';
 import { hasFilters, passesFilters, withoutToken, type FilterKey, type ParsedSearch } from '../find/query';
 import type { FindDoc, Ranked } from '../find/rank';
+import { assessTests, releaseOf, useExplorerApplicability } from './applicability';
 import { useRunDetail, useTestCatalog } from './catalog';
 import { groupTests, tally, type TestGroupView } from './groups';
 import { patched, useExplorerNavigate, useExplorerSearch } from './navigate';
@@ -80,6 +83,7 @@ const GROUP_LABEL: Record<TestGroup, string> = {
 };
 const SORT_LABEL: Record<ExplorerSort, string> = {
   relevance: 'Best match',
+  evidence: 'Stale evidence first',
   spec: 'Spec',
   title: 'Title',
   recent: 'Most recent',
@@ -119,8 +123,12 @@ function useListing(model: CatalogModel | null, search: ExplorerSearch, q: strin
   const list = useMemo(() => [...docs.values()], [docs]);
   const found = useDocSearch(list, q);
   const sort = sortOf(search);
+  const { release: releaseBuild, releaseSha, releasePlatform } = search;
+  const release = useMemo(() => releaseOf({ release: releaseBuild, releaseSha, releasePlatform }), [releaseBuild, releaseSha, releasePlatform]);
+  // Every test's evidence read against its promise and the named release: a reading, never a status.
+  const assessments = useMemo(() => (model ? assessTests(model.tests, release) : null), [model?.tests, release]);
   const listing = useMemo(() => {
-    if (!model) return null;
+    if (!model || !assessments) return null;
     const query: TestQuery = { ...queryOf(search), q: undefined };
     // `has:video` typed in the box and the Has video button are the same filter.
     const operator = { ...found.parsed.filters, video: found.parsed.filters.video || search.video === true };
@@ -129,17 +137,25 @@ function useListing(model: CatalogModel | null, search: ExplorerSearch, q: strin
     const passes = (test: TestSummary, omit: ReadonlySet<FilterKey>) =>
       (!hits || hits.has(behaviorId(test.key))) && (!structured || passesFilters(docs.get(test.key)?.facets, operator, omit));
     let shown = testCatalog(model, { ...query, limit: 20000 }).tests.filter((test) => (!inRun || inRun.has(test.key)) && passes(test, NO_STRUCTURE));
+    const attention = (test: TestSummary) => needsAttention(assessments.get(test.key)!);
+    if (search.evidence === 'stale') shown = shown.filter(attention);
     if (sort === 'relevance' && hits) {
       const order = new Map([...hits.keys()].map((id, at) => [id, at] as const));
       shown = [...shown].sort((a, b) => (order.get(behaviorId(a.key)) ?? 0) - (order.get(behaviorId(b.key)) ?? 0));
     }
+    // Stale evidence first; the order of the spec list is kept among equals.
+    if (sort === 'evidence') shown = [...shown].sort((a, b) => attentionRank(assessments.get(a.key)!) - attentionRank(assessments.get(b.key)!));
     // The strip and the status and environment counts describe what the other filters leave.
     const scope = model.tests.filter((test) => matchesQuery(model, test, { ...query, status: [], environment: [] }, inRun) && passes(test, WITHOUT_STATUS_AND_ENVIRONMENT));
     const byEnvironment = scope.filter((test) => matchesQuery(model, test, { environment: query.environment }) && passes(test, WITHOUT_STATUS));
     const byStatus = scope.filter((test) => matchesQuery(model, test, { status: query.status }) && passes(test, WITHOUT_ENVIRONMENT));
     const videoScope = model.tests.filter((test) => matchesQuery(model, test, query, inRun) && passes(test, WITHOUT_VIDEO));
+    const evidenceScope = model.tests.filter((test) => matchesQuery(model, test, query, inRun) && passes(test, NO_STRUCTURE));
     return {
       shown,
+      assessments,
+      release,
+      stale: evidenceScope.filter(attention).length,
       withVideo: videoScope.filter((test) => docs.get(test.key)?.facets?.video ?? testHasVideo(test)).length,
       scope,
       byEnvironment,
@@ -150,7 +166,7 @@ function useListing(model: CatalogModel | null, search: ExplorerSearch, q: strin
       runPending: !!search.inRun && run.isPending,
       runMissing: !!search.inRun && run.isSuccess && run.data === null
     };
-  }, [model, search, found, docs, sort, inRun, run.isPending, run.isSuccess, run.data]);
+  }, [model, search, found, docs, sort, inRun, assessments, release, run.isPending, run.isSuccess, run.data]);
   return listing;
 }
 /** The project home: the published spec kinds, the insight strip, the toolbar, the grouped list and the open test. */
@@ -301,7 +317,7 @@ export function Explorer() {
                   That run is not in the report any more.
                 </Alert>
               )}
-              <TestList tests={listing.shown} search={search} total={model.tests.length} hits={listing.hits} sort={search.sort ?? (listing.hits ? 'relevance' : 'spec')} />
+              <TestList tests={listing.shown} search={search} total={model.tests.length} hits={listing.hits} sort={search.sort ?? (listing.hits ? 'relevance' : 'spec')} assessments={listing.assessments} release={listing.release} />
             </>
           ))}
       </Box>
@@ -680,6 +696,19 @@ function Toolbar({
             {listing.withVideo.toLocaleString()}
           </Text>
         </Button>
+        <Button
+          type="button"
+          aria-pressed={search.evidence === 'stale'}
+          aria-label={`Stale or unverified evidence: ${plural(listing.stale, 'test', 'tests')}`}
+          onClick={() => go({ evidence: search.evidence ? undefined : 'stale' })}
+          variant={search.evidence === 'stale' ? 'light' : 'subtle'}
+          leftSection={<IconAlertTriangle size={16} aria-hidden="true" />}
+        >
+          Stale or unverified{' '}
+          <Text span inherit>
+            {listing.stale.toLocaleString()}
+          </Text>
+        </Button>
         {model.facets.producers.length > 1 && (
           <Box component="label">
             <VisuallyHidden>Producer</VisuallyHidden>
@@ -788,7 +817,8 @@ function Toolbar({
                 artifactTag: undefined,
                 inherited: undefined,
                 inRun: undefined,
-                video: undefined
+                video: undefined,
+                evidence: undefined
               });
             }}
             variant="subtle"
@@ -798,10 +828,47 @@ function Toolbar({
         )}
       </Flex>
       <SearchNotes issues={listing.parsed.issues} semantic={listing.semantic} />
+      <ReleaseReading />
     </Box>
   );
 }
-function TestList({ tests, search, total, hits, sort }: { tests: readonly TestSummary[]; search: ExplorerSearch; total: number; hits: ReadonlyMap<string, Ranked> | null; sort: ExplorerSort }) {
+/**
+ * Names the release the evidence of the tests is read against (build, commit and platform). Folded away until a release is
+ * named, because most readers only ask whether evidence is stale.
+ */
+function ReleaseReading() {
+  const applicability = useExplorerApplicability();
+  const named = hasRelease(applicability.release) || !!applicability.release.platform;
+  return (
+    <Accordion variant="separated" defaultValue={named ? 'release' : null} mt="sm">
+      <Accordion.Item value="release">
+        <Accordion.Control>Release the evidence is read against</Accordion.Control>
+        <Accordion.Panel>
+          <ApplicabilityControls state={applicability} filter={false} />
+        </Accordion.Panel>
+      </Accordion.Item>
+    </Accordion>
+  );
+}
+function TestList({
+  tests,
+  search,
+  total,
+  hits,
+  sort,
+  assessments,
+  release
+}: {
+  tests: readonly TestSummary[];
+  search: ExplorerSearch;
+  total: number;
+  hits: ReadonlyMap<string, Ranked> | null;
+  sort: ExplorerSort;
+  assessments: ReadonlyMap<string, Assessment>;
+  release: ReleaseIdentity;
+}) {
+  // A reading is shown on every row only when the reader asked about evidence; otherwise only evidence known to be stale.
+  const asked = search.evidence === 'stale' || sort === 'evidence' || hasRelease(release);
   const by = search.group ?? 'spec';
   const groups = useMemo(() => groupTests(tests, by, sort === 'spec'), [tests, by, sort]);
   const [overrides, setOverrides] = useState<ReadonlyMap<string, boolean>>(new Map());
@@ -864,6 +931,8 @@ function TestList({ tests, search, total, hits, sort }: { tests: readonly TestSu
               open={isOpen(group)}
               selected={search.test}
               hits={hits}
+              assessments={assessments}
+              asked={asked}
               onToggle={() => setOverrides(new Map(overrides).set(`${by}|${group.key}`, !isOpen(group)))}
             />
           </Stack>
@@ -878,6 +947,8 @@ function TestGroupSection({
   open,
   selected,
   hits,
+  assessments,
+  asked,
   onToggle
 }: {
   group: TestGroupView;
@@ -885,6 +956,8 @@ function TestGroupSection({
   open: boolean;
   selected: string | undefined;
   hits: ReadonlyMap<string, Ranked> | null;
+  assessments: ReadonlyMap<string, Assessment>;
+  asked: boolean;
   onToggle: () => void;
 }) {
   const [shown, setShown] = useState(by === 'none' ? 100 : GROUP_ROWS);
@@ -892,7 +965,7 @@ function TestGroupSection({
   const rows = (
     <List spacing="xs" listStyleType="none">
       {group.tests.slice(0, shown).map((test) => (
-        <TestRow key={test.key} test={test} selected={selected === test.key} now={now} hit={hits?.get(behaviorId(test.key))} />
+        <TestRow key={test.key} test={test} selected={selected === test.key} now={now} hit={hits?.get(behaviorId(test.key))} assessment={assessments.get(test.key)} asked={asked} />
       ))}
       {group.tests.length > shown && (
         <List.Item>
@@ -937,7 +1010,21 @@ function TestGroupSection({
     </Box>
   );
 }
-function TestRow({ test, selected, now, hit }: { test: TestSummary; selected: boolean; now: number; hit: Ranked | undefined }) {
+function TestRow({
+  test,
+  selected,
+  now,
+  hit,
+  assessment,
+  asked
+}: {
+  test: TestSummary;
+  selected: boolean;
+  now: number;
+  hit: Ranked | undefined;
+  assessment: Assessment | undefined;
+  asked: boolean;
+}) {
   const why = hit ? describeHit(hit) : '';
   const failure = test.status === 'failed' ? test.outcomes.find((outcome) => outcome.status === 'failed')?.detail.split('\n')[0] : '';
   return (
@@ -966,6 +1053,7 @@ function TestRow({ test, selected, now, hit }: { test: TestSummary; selected: bo
             <Group gap="xs">
               <EnvironmentChips test={test} />
               <Badges test={test} />
+              {assessment && (assessment.verdict === 'stale' || (asked && assessment.verdict !== 'applies')) && <VerdictBadge verdict={assessment.verdict} />}
             </Group>
             {failure && (
               <Text size="xs" c="red.7" lineClamp={2}>

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

@@ -13,12 +13,15 @@ import { environmentLabel } from '@crvouga/atlas/reports/layer-axes';
 import { formatMs, runKey, type TestResultEntry, type TestSummary } from '@crvouga/atlas/reports/test-catalog';
 import { Link } from '@tanstack/react-router';
 import { lazy, Suspense, useState } from 'react';
+import { assessTest } from '../evidence/applicability';
+import { ApplicabilitySummary } from '../evidence/applicability-view';
 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 { releaseOf } from './applicability';
 import { patched, useExplorerNavigate, useExplorerSearch } from './navigate';
 import { Badges, runName } from './parts';
 import { Reliability } from './Reliability';
@@ -129,7 +132,10 @@ 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, source } = useExplorerSearch();
+  const search = useExplorerSearch();
+  const { layer, source } = search;
+  const release = releaseOf(search);
+  const applicability = assessTest(test, release);
   const go = useExplorerNavigate();
   const pinned = usePinnedResult(layer, test.key);
   const [recording, setRecording] = useState(false);
@@ -238,6 +244,13 @@ export function TestDetail({ test, slot }: { test: TestSummary; slot: CheckSlot
 
       <Scope pinned={pinned} slot={slot} />
 
+      <Box aria-label="Evidence applicability" component="section" mb="lg">
+        <Title order={3} mb="sm" c="dimmed">
+          Does this evidence apply?
+        </Title>
+        <ApplicabilitySummary assessment={applicability} release={release} />
+      </Box>
+
       <Box aria-label="Current results" component="section" mb="lg">
         <Title order={3} mb="sm" c="dimmed">
           Current result per environment

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

@@ -0,0 +1,43 @@
+/**
+ * @module Explorer evidence applicability
+ *
+ * The explorer's part of evidence applicability: the release a reader names and the stale-or-unverified filter, held in
+ * the explorer's address (`release`, `releaseSha`, `releasePlatform`, `evidence=stale`, the same names a spec page uses),
+ * and the reading of every test of the catalog against them. The reading is the one a feature page makes
+ * (`evidence/applicability.ts`); it never changes a test's status.
+ */
+import { useMemo } from 'react';
+import type { TestSummary } from '@crvouga/atlas/reports/test-catalog';
+
+import { assessTest, type Assessment, type ReleaseIdentity } from '../evidence/applicability';
+import type { ApplicabilityState } from '../evidence/applicability-view';
+import { useExplorerNavigate, useExplorerSearch } from './navigate';
+import type { ExplorerSearch } from './search';
+
+/** The release an explorer address names; every part is optional. */
+export function releaseOf(search: ExplorerSearch): ReleaseIdentity {
+  return {
+    ...(search.release ? { build: search.release } : {}),
+    ...(search.releaseSha ? { sha: search.releaseSha } : {}),
+    ...(search.releasePlatform ? { platform: search.releasePlatform } : {})
+  };
+}
+
+/** Each test's evidence read against the promise and the release, by test key. */
+export function assessTests(tests: readonly TestSummary[], release: ReleaseIdentity): ReadonlyMap<string, Assessment> {
+  return new Map(tests.map((test) => [test.key, assessTest(test, release)] as const));
+}
+
+/** The release and the evidence filter of the explorer's address, with the ways to change them. */
+export function useExplorerApplicability(): ApplicabilityState {
+  const search = useExplorerSearch();
+  const go = useExplorerNavigate();
+  const { release: build, releaseSha: sha, releasePlatform: platform } = search;
+  const release = useMemo(() => releaseOf({ release: build, releaseSha: sha, releasePlatform: platform }), [build, sha, platform]);
+  return {
+    release,
+    onlyStale: search.evidence === 'stale',
+    setRelease: (next) => go({ release: next.build || undefined, releaseSha: next.sha || undefined, releasePlatform: next.platform || undefined }, { replace: true }),
+    setOnlyStale: (on) => go({ evidence: on ? 'stale' : undefined }, { replace: true })
+  };
+}