@shipfox/client-workflows 14.0.1 → 16.0.0

package/src/components/workflow-run-view/workflow-run-view.test.tsx

@@ -1,17 +1,12 @@
+import type {AnnotationDto} from '@shipfox/annotations-dto';
 import type {WorkflowRunDetailResponseDto} from '@shipfox/api-workflows-dto';
 import {configureApiClient} from '@shipfox/client-api';
-import {toast} from '@shipfox/react-ui/toast';
 import {screen, waitFor, within} from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import {workflowRunsQueryKeys} from '#hooks/api/workflow-runs.js';
-import {inlineLogBody, outputLine} from '#test/fixtures/logs.js';
 import {
-  runAttemptsResponseDto,
   workflowJobDto,
   workflowJobExecutionDto,
-  workflowRunAttemptDto,
   workflowRunDetailDto,
-  workflowRunDto,
   workflowStepAttemptDto,
   workflowStepDto,
 } from '#test/fixtures/workflow-run.js';
@@ -20,700 +15,275 @@ import {WorkflowRunView} from './workflow-run-view.js';
 
 const RUN_ID = '66666666-6666-4666-8666-666666666666';
 const PROJECT_ID = '44444444-4444-4444-8444-444444444444';
-const DEFINITION_ID = '55555555-5555-4555-8555-555555555555';
 const BUILD_JOB_ID = '77777777-7777-4777-8777-777777777777';
 const DEPLOY_JOB_ID = '88888888-8888-4888-8888-888888888888';
-const CHECKOUT_STEP_ID = '99999999-9999-4999-8999-999999999999';
-const CHECKOUT_ATTEMPT_ID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
-const RERUN_BUTTON_NAME = /^Re-run/;
-const BUILD_JOB_BUTTON_NAME = 'build, Succeeded';
-const DEPLOY_JOB_BUTTON_NAME = 'deploy, Running';
-const ATTEMPT_2_PATTERN = /Attempt 2/;
-const COPY_RUN_BUTTON_NAME = /Copy run/;
-const EXECUTION_ONE_MENU_ITEM_PATTERN = /#1/;
-const LISTENING_EXECUTION_SWITCHER_NAME =
-  'Switch job execution, currently execution 2: Deployment status event';
-const JOB_TEMPLATE_NAME = ['Implement $', '{{ event.issue.identifier }}'].join('');
+const BUILD_EXECUTION_ID = '99999999-9999-4999-8999-000000000001';
+const BUILD_STEP_ID = '55555555-5555-4555-8555-000000000001';
+const BUILD_ATTEMPT_ID = '66666666-6666-4666-8666-000000000001';
+const ANNOTATION_ID_ONE = 'aaaaaaaa-aaaa-4aaa-8aaa-000000000001';
+const ANNOTATION_ID_TWO = 'aaaaaaaa-aaaa-4aaa-8aaa-000000000002';
+const TASK_NINE_PATTERN = /Task nine/;
+const SHOW_MORE_PATTERN = /Show \d+ more/;
 
 describe('WorkflowRunView', () => {
-  test('keeps the real tab strip visible while the run is loading', async () => {
+  beforeEach(() => {
+    Element.prototype.scrollIntoView = vi.fn();
+  });
+
+  test('reserves the shared run workspace while the run is loading', async () => {
     configureApiClient({fetchImpl: vi.fn(() => new Promise<Response>(() => undefined))});
 
-    renderView({tab: 'summary'});
+    renderView();
 
-    expect(await screen.findByRole('tab', {name: 'Summary'})).toBeInTheDocument();
-    expect(screen.getByRole('tab', {name: 'Jobs'})).toBeInTheDocument();
-    expect(screen.getByRole('tab', {name: 'Annotations'})).toBeInTheDocument();
-    expect(screen.getByRole('tab', {name: 'Source'})).toBeInTheDocument();
+    expect(await screen.findByRole('region', {name: 'Loading workflow run'})).toBeInTheDocument();
+    expect(screen.getByLabelText('Loading run navigation')).toBeInTheDocument();
     expect(screen.getByRole('region', {name: 'Loading workflow run content'})).toBeInTheDocument();
+    expect(screen.queryByRole('tab', {name: 'Jobs'})).not.toBeInTheDocument();
   });
 
-  test('renders the run summary, jobs list, and selected job step attempts when a run loads', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() => Promise.resolve(jsonResponse(workflowRunViewDetailDto()))),
-    });
+  test('opens the all-jobs Summary on the dependency graph by default', async () => {
+    configureRunFetch();
 
-    renderView();
+    const {container} = renderView();
 
     const summary = await screen.findByRole('region', {name: 'deploy-web'});
-
     expect(within(summary).getByRole('heading', {name: 'deploy-web'})).toBeInTheDocument();
-    expect(within(summary).getAllByText('Running')).not.toHaveLength(0);
-    expect(within(summary).getByText('fire')).toBeInTheDocument();
+    expect(screen.getByRole('navigation', {name: 'Run workspace'})).toBeInTheDocument();
     expect(
-      within(summary).queryByRole('button', {name: COPY_RUN_BUTTON_NAME}),
-    ).not.toBeInTheDocument();
-    expect(await screen.findByRole('region', {name: 'Workflow jobs'})).toBeInTheDocument();
-    expect(screen.getByRole('button', {name: BUILD_JOB_BUTTON_NAME})).toBeInTheDocument();
-    expect(screen.getByRole('button', {name: DEPLOY_JOB_BUTTON_NAME})).toBeInTheDocument();
-    expect(screen.getByRole('button', {name: BUILD_JOB_BUTTON_NAME})).toHaveClass(
-      'bg-background-components-hover',
-      'hover:bg-background-components-pressed',
+      screen
+        .getByRole('navigation', {name: 'Run workspace'})
+        .closest('[data-run-workspace-layout]'),
+    ).toHaveClass('border-t', 'border-border-neutral-base', 'min-[768px]:flex-row');
+    expect(screen.getByRole('link', {name: 'Summary'})).toHaveAttribute('aria-current', 'page');
+    expect(screen.getByRole('heading', {name: 'Jobs'})).toBeInTheDocument();
+    expect(screen.getByRole('heading', {name: 'Run details'})).toBeInTheDocument();
+    expect(screen.getByRole('region', {name: 'All jobs summary'})).toBeInTheDocument();
+    expect(screen.getByRole('region', {name: 'Workflow jobs'})).toBeInTheDocument();
+    expect(container.querySelector('[data-run-workspace-content]')).toHaveClass(
+      'bg-background-neutral-base',
+      'flex-1',
     );
-    expect(screen.getByRole('tabpanel')).toHaveClass('max-w-[1120px]', 'px-24');
-    expect(screen.getByRole('region', {name: 'build'})).toBeInTheDocument();
-    expect(
-      screen.getByRole('button', {name: 'checkout, Succeeded, attempt 1'}),
-    ).toBeInTheDocument();
+    expect(screen.queryByRole('tab', {name: 'Jobs'})).not.toBeInTheDocument();
   });
 
-  test('uses the selected job execution name as the job card title', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: BUILD_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: JOB_TEMPLATE_NAME,
-                  job_executions: [
-                    workflowJobExecutionDto({
-                      job_id: BUILD_JOB_ID,
-                      name: 'Implement ENG-123',
-                    }),
-                  ],
-                }),
-              ],
-            }),
-          ),
-        ),
-      ),
-    });
+  test('treats the removed Jobs tab URL as the graph Summary', async () => {
+    configureRunFetch();
 
-    renderView();
+    renderView({tab: 'jobs'});
 
-    expect(await screen.findByRole('region', {name: 'Implement ENG-123'})).toBeInTheDocument();
-    expect(screen.queryByRole('region', {name: JOB_TEMPLATE_NAME})).not.toBeInTheDocument();
+    expect(await screen.findByRole('region', {name: 'All jobs summary'})).toBeInTheDocument();
+    expect(screen.getByRole('link', {name: 'Summary'})).toHaveAttribute('aria-current', 'page');
   });
 
-  test('renders active step attempt logs inline when the selected job is running', async () => {
-    const stepId = '99999999-9999-4999-8999-000000000001';
-    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
-      const url = requestUrl(input);
-      if (url.pathname === `/steps/${stepId}/attempts/1/logs`) {
-        return Promise.resolve(jsonResponse(inlineLogBody(outputLine('live output\n'), 1)));
-      }
-      return Promise.resolve(
-        jsonResponse(
-          workflowRunViewDetailDto({
-            jobs: [
-              workflowJobDto({
-                id: BUILD_JOB_ID,
-                run_attempt_id: RUN_ID,
-                name: 'build',
-                status: 'running',
-                steps: [
-                  workflowStepDto({
-                    id: stepId,
-                    key: 'test',
-                    name: 'test',
-                    status: 'running',
-                    attempts: [
-                      workflowStepAttemptDto({
-                        id: 'aaaaaaaa-aaaa-4aaa-8aaa-000000000001',
-                        step_id: stepId,
-                        status: 'running',
-                        exit_code: null,
-                        finished_at: null,
-                      }),
-                    ],
-                  }),
-                ],
-              }),
-            ],
-          }),
-        ),
-      );
-    });
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
+  test('navigates graph and rail jobs to their dedicated job routes', async () => {
+    const user = userEvent.setup();
+    configureRunFetch();
 
-    renderView();
+    const {router} = renderView();
+    await user.click(await screen.findByRole('button', {name: 'deploy, Running'}));
 
-    expect(await screen.findByText('live output')).toBeInTheDocument();
-    const logRequest = fetchImpl.mock.calls
-      .map((call) => new URL((call[0] as Request).url))
-      .find((url) => url.pathname === `/steps/${stepId}/attempts/1/logs`);
-    expect(logRequest?.searchParams.get('cursor')).toBe('0');
+    await waitFor(() =>
+      expect(router.state.location.pathname).toBe(
+        `/w/${PROJECT_TEST_WSLUG}/p/project/runs/${RUN_ID}/jobs/${DEPLOY_JOB_ID}`,
+      ),
+    );
   });
 
-  test('switches executions from the listening job header', async () => {
+  test('keeps run Annotations and Source in the workspace navigation', async () => {
     const user = userEvent.setup();
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: BUILD_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'release-gates',
-                  mode: 'listening',
-                  status: 'running',
-                  listener_status: 'listening',
-                  job_executions: [
-                    workflowJobExecutionDto({
-                      id: '77777777-7777-4777-8777-000000000001',
-                      job_id: BUILD_JOB_ID,
-                      sequence: 1,
-                      name: 'Pull request event',
-                      status: 'succeeded',
-                      trigger_events: [
-                        {
-                          source: 'github',
-                          event: 'pull_request',
-                          delivery_id: 'delivery-1',
-                          received_at: '2026-05-07T01:00:00.000Z',
-                          project: null,
-                          repository: null,
-                          ref: null,
-                          commit: null,
-                          data: {number: 12},
-                        },
-                      ],
-                      started_at: '2026-05-07T01:01:00.000Z',
-                      finished_at: '2026-05-07T01:01:20.000Z',
-                      steps: [
-                        workflowStepDto({
-                          key: 'first-event',
-                          name: 'first-event',
-                          status: 'succeeded',
-                          attempts: [
-                            workflowStepAttemptDto({
-                              status: 'succeeded',
-                              finished_at: '2026-05-07T01:01:20.000Z',
-                            }),
-                          ],
-                        }),
-                      ],
-                    }),
-                    workflowJobExecutionDto({
-                      id: '77777777-7777-4777-8777-000000000002',
-                      job_id: BUILD_JOB_ID,
-                      sequence: 2,
-                      name: 'Deployment status event',
-                      status: 'failed',
-                      status_reason: 'step_failed',
-                      trigger_events: [
-                        {
-                          source: 'github',
-                          event: 'deployment_status',
-                          delivery_id: 'delivery-2',
-                          received_at: '2026-05-07T01:01:00.000Z',
-                          project: null,
-                          repository: null,
-                          ref: null,
-                          commit: null,
-                          data: {state: 'success'},
-                        },
-                        {
-                          source: 'github',
-                          event: 'check_run',
-                          delivery_id: 'delivery-3',
-                          received_at: '2026-05-07T01:01:10.000Z',
-                          project: null,
-                          repository: null,
-                          ref: null,
-                          commit: null,
-                          data: {status: 'completed'},
-                        },
-                      ],
-                      started_at: '2026-05-07T01:02:00.000Z',
-                      finished_at: '2026-05-07T01:02:20.000Z',
-                      steps: [
-                        workflowStepDto({
-                          key: 'second-event',
-                          name: 'second-event',
-                          status: 'failed',
-                          attempts: [
-                            workflowStepAttemptDto({
-                              status: 'failed',
-                              exit_code: 1,
-                              finished_at: '2026-05-07T01:02:20.000Z',
-                            }),
-                          ],
-                        }),
-                      ],
-                    }),
-                  ],
-                }),
-              ],
-            }),
-          ),
-        ),
-      ),
-    });
+    configureRunFetch();
 
-    renderView();
-    expect(
-      await screen.findByRole('region', {name: 'Deployment status event'}),
-    ).toBeInTheDocument();
-    expect(await screen.findByText('second-event')).toBeInTheDocument();
-    expect(
-      await screen.findByRole('button', {name: 'github · deployment_status (2 events)'}),
-    ).toBeInTheDocument();
-    expect(screen.getByText('deployment_status (2)')).toBeInTheDocument();
-
-    await user.click(screen.getByRole('button', {name: LISTENING_EXECUTION_SWITCHER_NAME}));
-    await user.click(screen.getByRole('menuitem', {name: EXECUTION_ONE_MENU_ITEM_PATTERN}));
+    const {router} = renderView();
+    await screen.findByRole('region', {name: 'Workflow jobs'});
+    await user.click(screen.getByRole('link', {name: 'Annotations'}));
 
-    expect(await screen.findByText('first-event')).toBeInTheDocument();
-    expect(screen.getByRole('region', {name: 'Pull request event'})).toBeInTheDocument();
-    expect(screen.queryByText('second-event')).not.toBeInTheDocument();
-    expect(await screen.findByRole('button', {name: 'github · pull_request'})).toBeInTheDocument();
-    expect(screen.getByText('pull_request')).toBeInTheDocument();
-    expect(screen.queryByText('deployment_status (2)')).not.toBeInTheDocument();
+    await waitFor(() => expect(router.state.location.search).toMatchObject({tab: 'annotations'}));
   });
 
-  test('shows generic provider setup guidance for agent config failures', async () => {
-    const user = userEvent.setup();
-    const stepId = '99999999-9999-4999-8999-000000000004';
-    const attemptId = 'aaaaaaaa-aaaa-4aaa-8aaa-000000000004';
-    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
-      const url = requestUrl(input);
-      if (url.pathname === `/steps/${stepId}/attempts/1/logs`) {
-        return Promise.resolve(
-          jsonResponse(inlineLogBody(outputLine('configuration failed\n'), 1)),
-        );
-      }
-      return Promise.resolve(
-        jsonResponse(
-          workflowRunViewDetailDto({
-            jobs: [
-              workflowJobDto({
-                id: BUILD_JOB_ID,
-                run_attempt_id: RUN_ID,
-                name: 'build',
-                status: 'failed',
-                steps: [
-                  workflowStepDto({
-                    id: stepId,
-                    key: 'implement',
-                    name: 'Fix the failing tests.',
-                    type: 'agent',
-                    status: 'failed',
-                    config: {
-                      provider: 'anthropic',
-                      model: 'claude-opus-4-8',
-                      thinking: 'high',
-                      prompt: 'Fix the failing tests.',
-                    },
-                    error: {
-                      message: 'Model provider request failed',
-                      reason: 'agent_invocation_failed',
-                      category: 'user',
-                    },
-                    attempts: [
-                      workflowStepAttemptDto({
-                        id: attemptId,
-                        step_id: stepId,
-                        status: 'failed',
-                        exit_code: 1,
-                        error: {
-                          message: 'Model provider credentials are not configured',
-                          reason: 'agent_config_invalid',
-                          agentConfigIssue: 'provider_not_configured',
-                        },
-                        finished_at: '2026-05-07T01:01:20.000Z',
-                      }),
-                    ],
-                  }),
-                ],
-              }),
-            ],
-          }),
-        ),
-      );
-    });
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
+  test('filters the single run-level Annotations page by job', async () => {
+    configureRunFetch();
 
-    renderView();
-    await user.click(
-      await screen.findByRole('button', {
-        name: 'Fix the failing tests., Failed, attempt 1, User',
-      }),
-    );
+    renderView({tab: 'annotations', selection: {jobId: BUILD_JOB_ID}});
 
     expect(
-      screen.queryByRole('region', {name: 'Resolved agent configuration'}),
-    ).not.toBeInTheDocument();
-    expect(screen.queryByText('anthropic')).not.toBeInTheDocument();
-    expect(screen.queryByText('claude-opus-4-8')).not.toBeInTheDocument();
-    expect(screen.queryByText('high')).not.toBeInTheDocument();
-    expect(screen.getByText('Configure credentials for anthropic')).toBeInTheDocument();
-    expect(
-      screen.getByText(
-        'This step uses anthropic, but no workspace credentials are configured for that model provider. Configure anthropic in Agents, then re-run the workflow.',
-      ),
-    ).toBeInTheDocument();
-    expect(screen.getByRole('link', {name: 'Configure Agents'})).toHaveAttribute(
-      'href',
-      `/w/${PROJECT_TEST_WSLUG}/settings/agents`,
-    );
+      await screen.findByRole('combobox', {name: 'Filter annotations by job'}),
+    ).toHaveTextContent('build');
+    expect(await screen.findByText('This run has no annotations to show.')).toBeInTheDocument();
+    expect(screen.queryByRole('tab', {name: 'Annotations'})).not.toBeInTheDocument();
   });
 
-  test('falls back to the step error when an agent attempt has no typed error', async () => {
-    const user = userEvent.setup();
-    const stepId = '99999999-9999-4999-8999-000000000005';
-    const attemptId = 'aaaaaaaa-aaaa-4aaa-8aaa-000000000005';
-    configureApiClient({
-      fetchImpl: vi.fn((input: RequestInfo | URL) => {
-        const url = requestUrl(input);
-        if (url.pathname === `/steps/${stepId}/attempts/1/logs`) {
-          return Promise.resolve(
-            jsonResponse(inlineLogBody(outputLine('configuration failed\n'), 1)),
-          );
-        }
-        return Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: BUILD_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'build',
-                  status: 'failed',
-                  steps: [
-                    workflowStepDto({
-                      id: stepId,
-                      key: 'implement',
-                      name: 'Fix the failing tests.',
-                      type: 'agent',
-                      status: 'failed',
-                      config: {
-                        provider: 'anthropic',
-                        model: 'claude-opus-4-8',
-                        thinking: 'high',
-                        prompt: 'Fix the failing tests.',
-                      },
-                      error: {
-                        message: 'Model provider credentials are not configured',
-                        reason: 'agent_config_invalid',
-                        agent_config_issue: 'provider_not_configured',
-                        category: 'user',
-                      },
-                      attempts: [
-                        workflowStepAttemptDto({
-                          id: attemptId,
-                          step_id: stepId,
-                          status: 'failed',
-                          exit_code: 1,
-                          error: null,
-                          finished_at: '2026-05-07T01:01:20.000Z',
-                        }),
-                      ],
-                    }),
-                  ],
-                }),
-              ],
-            }),
-          ),
-        );
+  test('renders annotation bodies once, severity first, with provenance', async () => {
+    configureRunFetch([
+      annotationDto({id: ANNOTATION_ID_ONE, context: 'coverage', style: 'info', sequence: 1}),
+      annotationDto({
+        id: ANNOTATION_ID_TWO,
+        context: 'smoke check',
+        style: 'error',
+        sequence: 2,
+        body: 'Task nine **failed**.',
       }),
-    });
+    ]);
 
-    renderView();
-    await user.click(
-      await screen.findByRole('button', {
-        name: 'Fix the failing tests., Failed, attempt 1, User',
-      }),
-    );
+    renderView({tab: 'annotations'});
 
-    expect(screen.queryByText('anthropic')).not.toBeInTheDocument();
-    expect(screen.queryByText('claude-opus-4-8')).not.toBeInTheDocument();
-    expect(screen.queryByText('high')).not.toBeInTheDocument();
-    expect(screen.getByText('Configure credentials for anthropic')).toBeInTheDocument();
-    expect(screen.getByRole('link', {name: 'Configure Agents'})).toHaveAttribute(
-      'href',
-      `/w/${PROJECT_TEST_WSLUG}/settings/agents`,
-    );
+    const headings = await screen.findAllByRole('heading', {level: 3});
+    expect(headings.map((heading) => heading.textContent)).toEqual(['smoke check', 'coverage']);
+    expect(screen.getByText(TASK_NINE_PATTERN)).toBeInTheDocument();
+    expect(screen.getAllByText('build · checkout · attempt 1')).toHaveLength(2);
+    expect(screen.getByText('2 annotations')).toBeInTheDocument();
   });
 
-  test('renders skipped zero-attempt jobs as skipped instead of missing attempts', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'deploy',
-                  status: 'skipped',
-                  status_reason: 'dependency_not_completed',
-                  job_executions: [],
-                }),
-              ],
-            }),
-          ),
-        ),
-      ),
-    });
+  test('links an annotation back to the step that emitted it', async () => {
+    configureRunFetch([annotationDto({id: ANNOTATION_ID_ONE, context: 'coverage'})]);
 
-    renderView();
+    renderView({tab: 'annotations'});
 
-    expect(await screen.findByText('This job was skipped')).toBeInTheDocument();
-    expect(
-      screen.getByText('A required job did not complete, so this job was skipped.'),
-    ).toBeInTheDocument();
-    expect(screen.queryByText('No steps recorded')).not.toBeInTheDocument();
-  });
+    const href = (await screen.findByRole('link', {name: 'Open step'})).getAttribute('href') ?? '';
+    const [pathname, query = ''] = href.split('?');
 
-  test('keeps a terminal job status over inconsistent zero-step execution activity', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'deploy',
-                  status: 'succeeded',
-                  job_executions: [
-                    workflowJobExecutionDto({
-                      id: '77777777-7777-4777-8777-000000000003',
-                      job_id: DEPLOY_JOB_ID,
-                      sequence: 2,
-                      name: 'retry',
-                      status: 'running',
-                      steps: [],
-                    }),
-                  ],
-                }),
-              ],
-            }),
-          ),
-        ),
-      ),
+    expect(pathname).toBe(`/w/${PROJECT_TEST_WSLUG}/p/project/runs/${RUN_ID}/jobs/${BUILD_JOB_ID}`);
+    expect(Object.fromEntries(new URLSearchParams(query))).toEqual({
+      jobExecution: BUILD_EXECUTION_ID,
+      step: BUILD_STEP_ID,
+      stepAttempt: BUILD_ATTEMPT_ID,
+      runAttempt: '"1"',
     });
-
-    renderView();
-
-    expect(await screen.findByText('No steps recorded')).toBeInTheDocument();
-    expect(screen.getByText('Execution #2 finished without recorded steps.')).toBeInTheDocument();
-    expect(screen.queryByText('Waiting for the first step')).not.toBeInTheDocument();
   });
 
-  test('renders pending zero-step jobs as waiting to start', async () => {
+  test('shows a failed annotations read as an error, never as an empty run', async () => {
     configureApiClient({
-      fetchImpl: vi.fn(() =>
+      fetchImpl: vi.fn((input: RequestInfo | URL) =>
         Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'deploy',
-                  status: 'pending',
-                  steps: [],
-                }),
-              ],
-            }),
-          ),
+          requestUrl(input).includes('/annotations')
+            ? jsonResponse({code: 'internal'}, {status: 500})
+            : jsonResponse(workflowRunViewDetailDto()),
         ),
       ),
     });
 
-    renderView();
+    renderView({tab: 'annotations'});
 
-    expect(await screen.findByText('Waiting for this job to start')).toBeInTheDocument();
-    expect(screen.getByText('Steps will appear here once the job starts.')).toBeInTheDocument();
-    expect(screen.queryByText('No steps recorded')).not.toBeInTheDocument();
+    expect(await screen.findByRole('button', {name: 'Retry loading annotations'})).toBeVisible();
+    expect(screen.queryByText('This run has no annotations to show.')).not.toBeInTheDocument();
   });
 
-  test('renders claimed idle jobs as runner preparation', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'deploy',
-                  status: 'running',
-                  job_executions: [
-                    workflowJobExecutionDto({
-                      job_id: DEPLOY_JOB_ID,
-                      status: 'running',
-                      steps: [],
-                    }),
-                  ],
-                }),
-              ],
-            }),
-          ),
-        ),
+  test('bounds how many annotation bodies render at once', async () => {
+    configureRunFetch(
+      Array.from({length: 30}, (_unused, index) =>
+        annotationDto({
+          id: `aaaaaaaa-aaaa-4aaa-8aaa-${String(index).padStart(12, '0')}`,
+          context: `context-${index}`,
+          sequence: index + 1,
+        }),
       ),
-    });
+    );
 
-    renderView();
+    renderView({tab: 'annotations'});
 
-    expect(await screen.findByText('Runner preparing job')).toBeInTheDocument();
-    expect(
-      screen.getByText('A runner is assigned. Steps will appear here when work begins.'),
-    ).toBeInTheDocument();
-    expect(
-      screen.queryByText('This job is running, but no steps have started yet.'),
-    ).not.toBeInTheDocument();
-    expect(screen.queryByText('No steps recorded')).not.toBeInTheDocument();
+    expect(await screen.findAllByRole('heading', {level: 3})).toHaveLength(25);
+    const showMore = screen.getByRole('button', {name: 'Show 5 more of 30'});
+
+    await userEvent.click(showMore);
+
+    expect(screen.getAllByRole('heading', {level: 3})).toHaveLength(30);
+    expect(screen.queryByRole('button', {name: SHOW_MORE_PATTERN})).not.toBeInTheDocument();
   });
 
-  test('renders active listening jobs with no executions as waiting for trigger events', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'release-gates',
-                  mode: 'listening',
-                  status: 'running',
-                  listener_status: 'listening',
-                  job_executions: [],
-                }),
-              ],
-            }),
-          ),
-        ),
+  test('focuses a deep-linked annotation beyond the render window', async () => {
+    const deepLinkedId = 'aaaaaaaa-aaaa-4aaa-8aaa-000000000029';
+    configureRunFetch(
+      Array.from({length: 30}, (_unused, index) =>
+        annotationDto({
+          id:
+            index === 29
+              ? deepLinkedId
+              : `aaaaaaaa-aaaa-4aaa-8aaa-${String(index).padStart(12, '0')}`,
+          context: `context-${index}`,
+          sequence: index + 1,
+        }),
       ),
-    });
+    );
 
-    renderView();
+    renderView({tab: 'annotations', selection: {annotation: deepLinkedId}});
 
-    expect(await screen.findByText('Waiting for trigger events')).toBeInTheDocument();
-    expect(
-      screen.getByText('Matching trigger events will create job executions here.'),
-    ).toBeInTheDocument();
-    expect(screen.queryByText('Execution details unavailable')).not.toBeInTheDocument();
+    const target = await screen.findByRole('heading', {level: 3, name: 'context-29'});
+    const selected = target.closest('li');
+    await waitFor(() => expect(selected).toHaveFocus());
+    expect(selected).toHaveAttribute('aria-current', 'true');
+    expect(selected).toHaveClass('shadow-border-interactive-with-active');
   });
 
-  test('renders finished one-shot jobs with no execution as unavailable execution details', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'deploy',
-                  status: 'succeeded',
-                  job_executions: [],
-                }),
-              ],
-            }),
-          ),
-        ),
-      ),
-    });
+  test('separates a filtered miss from a run with no annotations', async () => {
+    configureRunFetch([annotationDto({id: ANNOTATION_ID_ONE, context: 'coverage', style: 'info'})]);
 
-    renderView();
+    renderView({tab: 'annotations', selection: {severity: 'error'}});
 
-    expect(await screen.findByText('Execution details unavailable')).toBeInTheDocument();
+    expect(await screen.findByText('No matching annotations')).toBeInTheDocument();
     expect(
-      screen.getByText('This job finished, but no job execution record is available.'),
+      screen.getByText('This run has annotations, but none at error severity.'),
     ).toBeInTheDocument();
-    expect(screen.queryByText('Waiting for trigger events')).not.toBeInTheDocument();
+    expect(screen.getByRole('button', {name: 'Clear filters'})).toBeInTheDocument();
   });
 
-  test('renders cancelled zero-attempt jobs separately from skipped jobs', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'deploy',
-                  status: 'cancelled',
-                  job_executions: [
-                    workflowJobExecutionDto({
-                      job_id: DEPLOY_JOB_ID,
-                      status: 'cancelled',
-                      steps: [],
-                    }),
-                  ],
-                }),
-              ],
-            }),
-          ),
-        ),
-      ),
-    });
+  test('does not claim a filtered miss beyond the loaded annotation budget', async () => {
+    configureRunFetch(
+      [annotationDto({id: ANNOTATION_ID_ONE, context: 'coverage', style: 'info'})],
+      {},
+      {has_more: true, next_cursor: 'next-page'},
+    );
 
-    renderView();
+    renderView({tab: 'annotations', selection: {severity: 'error'}});
 
-    expect(await screen.findByText('Cancelled before start')).toBeInTheDocument();
-    expect(screen.getByText('This job was cancelled before any step started.')).toBeInTheDocument();
-    expect(screen.queryByText('This job was skipped')).not.toBeInTheDocument();
+    expect(await screen.findByText('No matches in loaded annotations')).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'None of the loaded annotations are at error severity. Load more annotations to continue searching.',
+      ),
+    ).toBeInTheDocument();
+    expect(screen.getByRole('button', {name: 'Load more annotations'})).toBeInTheDocument();
+    expect(screen.queryByText('No matching annotations')).not.toBeInTheDocument();
   });
 
-  test('shows the not-found surface when the run 404s', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() => Promise.resolve(jsonResponse({code: 'not-found'}, {status: 404}))),
+  test('clears annotation filters and legacy step selection together', async () => {
+    const user = userEvent.setup();
+    configureRunFetch([annotationDto({id: ANNOTATION_ID_ONE, context: 'coverage', style: 'info'})]);
+
+    const {router} = renderView({
+      tab: 'annotations',
+      selection: {
+        jobId: DEPLOY_JOB_ID,
+        jobExecutionId: BUILD_EXECUTION_ID,
+        stepId: BUILD_STEP_ID,
+        stepAttemptId: BUILD_ATTEMPT_ID,
+        severity: 'error',
+        annotation: ANNOTATION_ID_ONE,
+      },
     });
 
-    renderView();
+    await user.click(await screen.findByRole('button', {name: 'Clear filters'}));
 
-    expect(await screen.findByText('Run not found')).toBeInTheDocument();
+    await waitFor(() => expect(router.state.location.search).toEqual({tab: 'annotations'}));
   });
 
-  test('shows the load-error placeholder when the run fails to load', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() => Promise.resolve(jsonResponse({code: 'server-error'}, {status: 500}))),
-    });
+  test('blames only the filters that are actually active', async () => {
+    // The annotation belongs to build, so filtering to deploy is a job-only miss. Naming
+    // severity here would send the reader to change a control they never touched.
+    configureRunFetch([annotationDto({id: ANNOTATION_ID_ONE, context: 'coverage', style: 'info'})]);
 
-    renderView();
+    renderView({tab: 'annotations', selection: {jobId: DEPLOY_JOB_ID}});
 
     expect(
-      await screen.findByRole('button', {name: 'Retry loading workflow run'}),
+      await screen.findByText('This run has annotations, but none from deploy.'),
     ).toBeInTheDocument();
   });
 
-  test('renders the full workflow source in the Source tab', async () => {
+  test('renders the captured workflow source in the Source section', async () => {
     configureApiClient({
       fetchImpl: vi.fn(() =>
         Promise.resolve(
           jsonResponse(
             workflowRunViewDetailDto({
-              source_snapshot: {
-                format: 'yaml',
-                content: 'jobs:\n  build:\n    steps:\n      - run: pnpm test',
-              },
+              source_snapshot: {format: 'yaml', content: 'jobs:\n  build:\n    steps: []'},
             }),
           ),
         ),
@@ -722,496 +292,81 @@ describe('WorkflowRunView', () => {
 
     renderView({tab: 'source'});
 
-    expect(await screen.findByRole('tab', {name: 'Source'})).toHaveAttribute(
-      'aria-selected',
-      'true',
-    );
-    expect(await screen.findByText('pnpm test')).toBeInTheDocument();
-    expect(screen.queryByRole('dialog', {name: 'Workflow source'})).not.toBeInTheDocument();
-  });
-
-  test('highlights selected step source lines when the source panel opens', async () => {
-    const user = userEvent.setup();
-    const stepId = '99999999-9999-4999-8999-000000000003';
-    const stepAttemptId = 'aaaaaaaa-aaaa-4aaa-8aaa-000000000003';
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(
-          jsonResponse(
-            workflowRunViewDetailDto({
-              source_snapshot: {
-                format: 'yaml',
-                content: 'jobs:\n  deploy:\n    steps:\n      - run: ship',
-              },
-              jobs: [
-                workflowJobDto({
-                  id: DEPLOY_JOB_ID,
-                  run_attempt_id: RUN_ID,
-                  name: 'deploy',
-                  status: 'running',
-                  job_executions: [
-                    workflowJobExecutionDto({
-                      job_id: DEPLOY_JOB_ID,
-                      name: 'deploy',
-                      status: 'running',
-                      steps: [
-                        workflowStepDto({
-                          id: stepId,
-                          key: 'deploy',
-                          name: 'deploy',
-                          source_location: {start_line: 2, end_line: 3},
-                          status: 'running',
-                          attempts: [
-                            workflowStepAttemptDto({
-                              id: stepAttemptId,
-                              step_id: stepId,
-                              status: 'running',
-                            }),
-                          ],
-                        }),
-                      ],
-                    }),
-                  ],
-                }),
-              ],
-            }),
-          ),
-        ),
-      ),
-    });
-
-    renderView({tab: 'jobs', selection: {stepId, stepAttemptId}});
-    const jobRegion = await screen.findByRole('region', {name: 'deploy'});
-    await user.click(within(jobRegion).getByRole('button', {name: 'View source'}));
-
-    const sourceDialog = await screen.findByRole('dialog', {name: 'Workflow source'});
-    const highlightedLines = sourceDialog.querySelectorAll('.line.highlighted-line');
-    expect(highlightedLines).toHaveLength(2);
-    expect(highlightedLines[0]).toHaveTextContent('deploy:');
-    expect(highlightedLines[1]).toHaveTextContent('steps:');
+    expect(await screen.findByText('build:')).toBeInTheDocument();
+    expect(screen.getByRole('link', {name: 'Source'})).toHaveAttribute('aria-current', 'page');
   });
 
   test('explains when the run has no source snapshot', async () => {
-    configureApiClient({
-      fetchImpl: vi.fn(() =>
-        Promise.resolve(jsonResponse(workflowRunViewDetailDto({source_snapshot: null}))),
-      ),
-    });
+    configureRunFetch();
 
     renderView({tab: 'source'});
 
-    await screen.findByRole('region', {name: 'deploy-web'});
-
     expect(await screen.findByText('Source snapshot unavailable')).toBeInTheDocument();
   });
 
-  test('opens the source panel highlighting a step from the job header Source button', async () => {
-    const user = userEvent.setup();
-    configureApiClient({
-      fetchImpl: vi.fn(() => Promise.resolve(jsonResponse(locatedStepSourceDetail()))),
-    });
-
-    renderView();
-
-    const jobRegion = await screen.findByRole('region', {name: 'build'});
-    await user.click(screen.getByRole('button', {name: 'checkout, Succeeded, attempt 1'}));
-    const jobSourceButton = within(jobRegion).getByRole('button', {name: 'View source'});
-    expect(jobSourceButton).toHaveAttribute('aria-expanded', 'false');
-    expect(jobSourceButton).toHaveAttribute('aria-controls');
-
-    await user.click(jobSourceButton);
-
-    const sourceDialog = await screen.findByRole('dialog', {name: 'Workflow source'});
-    const highlighted = sourceDialog.querySelectorAll('.line.highlighted-line');
-    expect(highlighted).toHaveLength(2);
-    expect(highlighted[0]).toHaveTextContent('build:');
-    expect(highlighted[1]).toHaveTextContent('steps:');
-    expect(jobSourceButton).toHaveAttribute('aria-expanded', 'true');
-  });
-
-  test('returns focus to the job Source button on close and preserves the selected job', async () => {
-    const user = userEvent.setup();
-    configureApiClient({
-      fetchImpl: vi.fn(() => Promise.resolve(jsonResponse(locatedStepSourceDetail()))),
-    });
-
-    renderView();
-
-    const jobRegion = await screen.findByRole('region', {name: 'build'});
-    await user.click(screen.getByRole('button', {name: 'checkout, Succeeded, attempt 1'}));
-    const jobSourceButton = within(jobRegion).getByRole('button', {name: 'View source'});
-
-    await user.click(jobSourceButton);
-    await screen.findByRole('dialog', {name: 'Workflow source'});
-    await user.click(screen.getByRole('button', {name: 'Close source'}));
-
-    await waitFor(() => expect(jobSourceButton).toHaveFocus());
-    expect(jobSourceButton).toHaveAttribute('aria-expanded', 'false');
-    expect(screen.getByRole('region', {name: 'build'})).toBeInTheDocument();
-  });
-
-  test('closes the source panel when refetch removes the focused step source', async () => {
-    const user = userEvent.setup();
-    let detailRequests = 0;
-    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
-      const url = requestUrl(input);
-      if (url.pathname === `/workflows/runs/${RUN_ID}`) {
-        detailRequests += 1;
-        return Promise.resolve(
-          jsonResponse(
-            detailRequests === 1
-              ? locatedStepSourceDetail()
-              : locatedStepSourceDetail({
-                  jobs: [
-                    workflowJobDto({
-                      id: BUILD_JOB_ID,
-                      name: 'build',
-                      status: 'succeeded',
-                      steps: [
-                        workflowStepDto({
-                          id: CHECKOUT_STEP_ID,
-                          name: 'checkout',
-                          status: 'succeeded',
-                          source_location: null,
-                          attempts: [
-                            workflowStepAttemptDto({
-                              id: CHECKOUT_ATTEMPT_ID,
-                              step_id: CHECKOUT_STEP_ID,
-                              status: 'succeeded',
-                              exit_code: 0,
-                              finished_at: '2026-05-07T01:01:20.000Z',
-                            }),
-                          ],
-                        }),
-                      ],
-                    }),
-                  ],
-                }),
-          ),
-        );
-      }
-      return Promise.resolve(jsonResponse(inlineLogBody(outputLine('done\n'), 1)));
-    });
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
-
-    const {queryClient} = renderView();
-
-    const jobRegion = await screen.findByRole('region', {name: 'build'});
-    await user.click(screen.getByRole('button', {name: 'checkout, Succeeded, attempt 1'}));
-    const jobSourceButton = within(jobRegion).getByRole('button', {name: 'View source'});
-    await user.click(jobSourceButton);
-    await screen.findByRole('dialog', {name: 'Workflow source'});
-
-    await queryClient.refetchQueries({queryKey: workflowRunsQueryKeys.detail(RUN_ID)});
-    await waitFor(() =>
-      expect(
-        within(jobRegion).queryByRole('button', {name: 'View source'}),
-      ).not.toBeInTheDocument(),
-    );
-    expect(screen.queryByRole('dialog', {name: 'Workflow source'})).not.toBeInTheDocument();
-  });
-
-  test('re-runs all jobs from a succeeded run and navigates to the new run', async () => {
-    const user = userEvent.setup();
-    const rerunId = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
-    const successSpy = vi.spyOn(toast, 'success').mockImplementation(() => 'toast-id');
-    const postBodies: unknown[] = [];
-    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
-      const request = input as Request;
-      const url = requestUrl(input);
-      if (request.method === 'POST' && url.pathname === `/workflows/runs/${RUN_ID}/rerun`) {
-        postBodies.push(await request.clone().json());
-        return jsonResponse(workflowRunDto({id: rerunId, status: 'pending'}));
-      }
-      return jsonResponse(
-        workflowRunViewDetailDto({
-          status: 'succeeded',
-          jobs: [
-            workflowJobDto({
-              id: BUILD_JOB_ID,
-              run_attempt_id: RUN_ID,
-              name: 'build',
-              status: 'succeeded',
-            }),
-          ],
-        }),
-      );
-    });
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
-
-    const {router} = renderView({}, '?runAttempt=1');
-    await user.click(await screen.findByRole('button', {name: 'Re-run workflow'}));
-
-    const postRequest = await findRequest(fetchImpl, 'POST', `/workflows/runs/${RUN_ID}/rerun`);
-    expect(postRequest).toBeDefined();
-    expect(postBodies).toEqual([{mode: 'all'}]);
-    expect(successSpy).toHaveBeenCalledWith('Re-run started');
-    await waitFor(() =>
-      expect(router.state.location.pathname).toBe(
-        `/w/${PROJECT_TEST_WSLUG}/p/project/runs/${rerunId}`,
-      ),
-    );
-    expect((router.state.location.search as Record<string, unknown>).runAttempt).toBeUndefined();
-  });
-
-  test('re-runs failed jobs from the dropdown', async () => {
-    const user = userEvent.setup();
-    const postBodies: unknown[] = [];
-    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
-      const request = input as Request;
-      const url = requestUrl(input);
-      if (request.method === 'POST' && url.pathname === `/workflows/runs/${RUN_ID}/rerun`) {
-        postBodies.push(await request.clone().json());
-        return jsonResponse(workflowRunDto({id: 'cccccccc-cccc-4ccc-8ccc-cccccccccccc'}));
-      }
-      return jsonResponse(
-        workflowRunViewDetailDto({
-          status: 'failed',
-          jobs: [
-            workflowJobDto({
-              id: BUILD_JOB_ID,
-              run_attempt_id: RUN_ID,
-              name: 'build',
-              status: 'failed',
-            }),
-            workflowJobDto({
-              id: DEPLOY_JOB_ID,
-              run_attempt_id: RUN_ID,
-              name: 'deploy',
-              status: 'cancelled',
-              position: 1,
-            }),
-          ],
-        }),
-      );
-    });
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
-
-    renderView();
-    await user.click(await screen.findByRole('button', {name: 'Re-run jobs'}));
-    await user.click(await screen.findByRole('menuitem', {name: 'Re-run failed jobs'}));
-
-    const postRequest = await findRequest(fetchImpl, 'POST', `/workflows/runs/${RUN_ID}/rerun`);
-    expect(postRequest).toBeDefined();
-    expect(postBodies).toEqual([{mode: 'failed'}]);
-  });
-
-  test('shows an error toast when rerun creation fails', async () => {
-    const user = userEvent.setup();
-    const errorSpy = vi.spyOn(toast, 'error').mockImplementation(() => 'toast-id');
-    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
-      const request = input as Request;
-      const url = requestUrl(input);
-      if (request.method === 'POST' && url.pathname === `/workflows/runs/${RUN_ID}/rerun`) {
-        return Promise.resolve(
-          jsonResponse({code: 'no-failed-jobs', message: 'Run has no failed jobs'}, {status: 409}),
-        );
-      }
-      return Promise.resolve(jsonResponse(workflowRunViewDetailDto({status: 'succeeded'})));
-    });
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
-
-    renderView();
-    await user.click(await screen.findByRole('button', {name: 'Re-run workflow'}));
-
-    await waitFor(() => expect(errorSpy).toHaveBeenCalledWith('Run has no failed jobs'));
-  });
-
-  test('selects another run attempt and clears job selection search', async () => {
-    const user = userEvent.setup();
-    const secondAttemptId = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
-    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
-      const url = requestUrl(input);
-      if (url.pathname === `/workflows/runs/${RUN_ID}/attempts`) {
-        return Promise.resolve(
-          jsonResponse(
-            runAttemptsResponseDto({
-              attempts: [
-                workflowRunAttemptDto({
-                  id: RUN_ID,
-                  attempt: 1,
-                  status: 'succeeded',
-                  created_at: '2026-05-07T01:01:00.000Z',
-                }),
-                workflowRunAttemptDto({
-                  id: secondAttemptId,
-                  attempt: 2,
-                  status: 'running',
-                  created_at: '2026-05-07T01:02:00.000Z',
-                  rerun_mode: 'all',
-                }),
-              ],
-            }),
-          ),
-        );
-      }
-      return Promise.resolve(
-        jsonResponse(
-          workflowRunViewDetailDto({
-            current_attempt: 1,
-            latest_attempt: 2,
-            run_attempt: workflowRunAttemptDto({id: RUN_ID, workflow_run_id: RUN_ID, attempt: 1}),
-          }),
-        ),
-      );
-    });
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
-
-    const {router} = renderProjectPage(
-      `/w/${PROJECT_TEST_WSLUG}/p/project/runs/${RUN_ID}?job=${BUILD_JOB_ID}&step=${CHECKOUT_STEP_ID}&stepAttempt=${CHECKOUT_ATTEMPT_ID}`,
-      () => (
-        <WorkflowRunView
-          projectId={PROJECT_ID}
-          workspaceSlug={PROJECT_TEST_WSLUG}
-          projectSlug="project"
-          workflowRunId={RUN_ID}
-        />
-      ),
-    );
-
-    await user.click(await screen.findByRole('button', {name: 'Switch attempt, currently 1 of 2'}));
-    await user.click(await screen.findByRole('menuitem', {name: ATTEMPT_2_PATTERN}));
-
-    await waitFor(() =>
-      expect(router.state.location.pathname).toBe(
-        `/w/${PROJECT_TEST_WSLUG}/p/project/runs/${RUN_ID}`,
-      ),
-    );
-    expect(router.state.location.search).toEqual({runAttempt: 2});
-  });
-
-  test('does not render rerun controls for non-terminal runs', async () => {
+  test('shows the not-found surface when the run 404s', async () => {
     configureApiClient({
-      fetchImpl: vi.fn(() => Promise.resolve(jsonResponse(workflowRunViewDetailDto()))),
+      fetchImpl: vi.fn(() => Promise.resolve(jsonResponse({code: 'not-found'}, {status: 404}))),
     });
 
     renderView();
 
-    await screen.findByRole('region', {name: 'deploy-web'});
-    expect(screen.queryByRole('button', {name: RERUN_BUTTON_NAME})).not.toBeInTheDocument();
-  });
-
-  test('renders carried-over steps without requesting attempt logs', async () => {
-    const user = userEvent.setup();
-    const fetchImpl = vi.fn(() =>
-      Promise.resolve(
-        jsonResponse(
-          workflowRunViewDetailDto({
-            status: 'succeeded',
-            jobs: [
-              workflowJobDto({
-                id: BUILD_JOB_ID,
-                run_attempt_id: RUN_ID,
-                name: 'build',
-                status: 'succeeded',
-                carried_over: true,
-                steps: [
-                  workflowStepDto({
-                    id: CHECKOUT_STEP_ID,
-                    key: 'checkout',
-                    name: 'checkout',
-                    status: 'succeeded',
-                    attempts: [],
-                  }),
-                ],
-              }),
-            ],
-          }),
-        ),
-      ),
-    );
-    configureApiClient({fetchImpl: fetchImpl as typeof fetch});
-
-    renderView();
-    expect(
-      await screen.findByRole('button', {name: 'build, Succeeded, reused'}),
-    ).toBeInTheDocument();
-    expect(screen.getAllByText('reused')).toHaveLength(1);
-    await user.click(screen.getByRole('button', {name: 'checkout, Succeeded, attempt 1'}));
-
-    expect(await screen.findByText('Not executed in this run.')).toBeInTheDocument();
-    expect(
-      mockRequests(fetchImpl).some((request) => requestUrl(request).pathname.includes('/logs')),
-    ).toBe(false);
+    expect(await screen.findByText('Run not found')).toBeInTheDocument();
   });
 });
 
-function renderView(props: Partial<Parameters<typeof WorkflowRunView>[0]> = {}, search = '') {
-  return renderProjectPage(`/w/${PROJECT_TEST_WSLUG}/p/project/runs/${RUN_ID}${search}`, () => (
+function renderView(props: Partial<Parameters<typeof WorkflowRunView>[0]> = {}) {
+  return renderProjectPage(`/w/${PROJECT_TEST_WSLUG}/p/project/runs/${RUN_ID}`, () => (
     <WorkflowRunView
       projectId={PROJECT_ID}
       workspaceSlug={PROJECT_TEST_WSLUG}
       projectSlug="project"
       workflowRunId={RUN_ID}
-      tab="jobs"
       {...props}
     />
   ));
 }
 
-function requestUrl(input: RequestInfo | URL): URL {
-  if (input instanceof Request) return new URL(input.url);
-  return new URL(String(input));
+/** The API client hands `fetchImpl` a `Request`, whose URL only `.url` exposes. */
+function requestUrl(input: RequestInfo | URL): string {
+  if (typeof input === 'string') return input;
+  return input instanceof URL ? input.href : input.url;
 }
 
-async function findRequest(
-  fetchImpl: ReturnType<typeof vi.fn>,
-  method: string,
-  pathname: string,
-): Promise<Request> {
-  await waitFor(() => {
-    const match = mockRequests(fetchImpl).find(
-      (request) => request.method === method && requestUrl(request).pathname === pathname,
-    );
-    expect(match).toBeDefined();
+/** Routes the run detail and the annotations read, which are two independent fetches. */
+function configureRunFetch(
+  annotations: AnnotationDto[] = [],
+  runOverrides: Partial<WorkflowRunDetailResponseDto> = {},
+  annotationPageOverrides: Partial<{has_more: boolean; next_cursor: string | null}> = {},
+) {
+  configureApiClient({
+    fetchImpl: vi.fn((input: RequestInfo | URL) =>
+      Promise.resolve(
+        requestUrl(input).includes('/annotations')
+          ? jsonResponse({
+              annotations,
+              has_more: false,
+              next_cursor: null,
+              ...annotationPageOverrides,
+            })
+          : jsonResponse(workflowRunViewDetailDto(runOverrides)),
+      ),
+    ),
   });
-  const match = mockRequests(fetchImpl).find(
-    (request) => request.method === method && requestUrl(request).pathname === pathname,
-  );
-  if (!match) throw new Error(`Missing ${method} ${pathname}`);
-  return match;
-}
-
-function mockRequests(fetchImpl: ReturnType<typeof vi.fn>): Request[] {
-  return (fetchImpl.mock.calls as unknown[][])
-    .map((call) => call[0])
-    .filter((input): input is Request => input instanceof Request);
 }
 
-function locatedStepSourceDetail(
-  overrides: Partial<WorkflowRunDetailResponseDto> = {},
-): WorkflowRunDetailResponseDto {
-  return workflowRunViewDetailDto({
-    source_snapshot: {
-      format: 'yaml',
-      content: 'jobs:\n  build:\n    steps:\n      - run: pnpm test',
-    },
-    jobs: [
-      workflowJobDto({
-        id: BUILD_JOB_ID,
-        name: 'build',
-        status: 'succeeded',
-        steps: [
-          workflowStepDto({
-            id: CHECKOUT_STEP_ID,
-            name: 'checkout',
-            status: 'succeeded',
-            source_location: {start_line: 2, end_line: 3},
-            attempts: [
-              workflowStepAttemptDto({
-                id: CHECKOUT_ATTEMPT_ID,
-                step_id: CHECKOUT_STEP_ID,
-                status: 'succeeded',
-                exit_code: 0,
-                finished_at: '2026-05-07T01:01:20.000Z',
-              }),
-            ],
-          }),
-        ],
-      }),
-    ],
+function annotationDto(overrides: Partial<AnnotationDto> & {id: string}): AnnotationDto {
+  return {
+    job_id: BUILD_JOB_ID,
+    job_execution_id: BUILD_EXECUTION_ID,
+    origin_step_id: BUILD_STEP_ID,
+    origin_step_attempt: 1,
+    context: 'default',
+    style: 'default',
+    sequence: 1,
+    body: 'Body',
     ...overrides,
-  });
+  };
 }
 
 function workflowRunViewDetailDto(
@@ -1220,7 +375,6 @@ function workflowRunViewDetailDto(
   return workflowRunDetailDto({
     id: RUN_ID,
     project_id: PROJECT_ID,
-    definition_id: DEFINITION_ID,
     name: 'deploy-web',
     status: 'running',
     trigger_payload: {},
@@ -1232,19 +386,24 @@ function workflowRunViewDetailDto(
         run_attempt_id: RUN_ID,
         name: 'build',
         status: 'succeeded',
-        steps: [
-          workflowStepDto({
-            id: CHECKOUT_STEP_ID,
-            key: 'checkout',
-            name: 'checkout',
+        job_executions: [
+          workflowJobExecutionDto({
+            id: BUILD_EXECUTION_ID,
+            job_id: BUILD_JOB_ID,
             status: 'succeeded',
-            attempts: [
-              workflowStepAttemptDto({
-                id: CHECKOUT_ATTEMPT_ID,
-                step_id: CHECKOUT_STEP_ID,
+            steps: [
+              workflowStepDto({
+                id: BUILD_STEP_ID,
+                name: 'checkout',
                 status: 'succeeded',
-                exit_code: 0,
-                finished_at: '2026-05-07T01:01:20.000Z',
+                attempts: [
+                  workflowStepAttemptDto({
+                    id: BUILD_ATTEMPT_ID,
+                    step_id: BUILD_STEP_ID,
+                    attempt: 1,
+                    status: 'succeeded',
+                  }),
+                ],
               }),
             ],
           }),
@@ -1257,14 +416,7 @@ function workflowRunViewDetailDto(
         status: 'running',
         position: 1,
         dependencies: ['build'],
-        job_executions: [
-          workflowJobExecutionDto({
-            job_id: DEPLOY_JOB_ID,
-            name: 'deploy',
-            status: 'running',
-            steps: [workflowStepDto({status: 'running'})],
-          }),
-        ],
+        steps: [workflowStepDto({name: 'deploy', status: 'running'})],
       }),
     ],
     ...overrides,