@cat-factory/app 0.241.2 → 0.242.0

package/i18n/locales/he.json

@@ -5575,11 +5575,8 @@
       "notCovered": "לא נבדקו: {count}",
       "regressions": "נסיגות: {count}",
       "regressionTag": "נסיגה",
-      "idOnly": "מזהה בלבד",
-      "idOnlyHint": "המזהה הזה לא נמצא במפרט השירות, ולכן אין כותרת להציג עבורו.",
       "spec": {
-        "not_read": "מפרט השירות לא נקרא, ולכן אלה מזהי הדרישות שהבודק דיווח עליהם, בלי הכותרות שלהם.",
-        "unmatched": "אף אחד ממזהי הדרישות האלה לא מופיע במפרט השירות שנקרא, ולכן מוצגים רק המזהים שהבודק דיווח עליהם."
+        "not_read": "מפרט השירות לא נקרא, ולכן הספירות האלה מכסות רק את מה שהבודק הכריע לגביו, לפי מזהה."
       },
       "verdict": {
         "met": "אומת",
@@ -5589,8 +5586,10 @@
       "gap": {
         "no_tester_step": "בצינור הזה אין שלב בדיקות, ולכן שום דרישה לא נבדקה.",
         "tester_not_reported": "הבודק עדיין לא דיווח, ולכן לא הוכרעה שום דרישה.",
-        "no_verdicts": "הבודק דיווח בלי להכריע לגבי אף דרישה במפרט."
-      }
+        "no_verdicts": "הבודק דיווח בלי להכריע לגבי אף דרישה במפרט.",
+        "no_requirements": "במפרט השירות לא רשומות דרישות, ולכן לא היה לבודק על מה להכריע."
+      },
+      "unmatchedVerdicts": "הבודק הכריע גם לגבי {count} מזהים שאינם קיימים במפרט הזה, ולכן הספירה שלו גבוהה מהמספרים שלמעלה."
     },
     "tests": {
       "title": "איך זה נבדק",

package/i18n/locales/it.json

@@ -6131,11 +6131,8 @@
       "notCovered": "Non verificati: {count}",
       "regressions": "Regressioni: {count}",
       "regressionTag": "Regressione",
-      "idOnly": "solo id",
-      "idOnlyHint": "Questo identificatore non è nella specifica del servizio, quindi non c'è alcun titolo da mostrare.",
       "spec": {
-        "not_read": "La specifica del servizio non è stata letta, quindi questi sono gli identificatori dei requisiti riportati dal tester, senza i loro titoli.",
-        "unmatched": "Nessuno di questi identificatori di requisito compare nella specifica del servizio che è stata letta, quindi vengono mostrati solo gli identificatori riportati dal tester."
+        "not_read": "La specifica del servizio non è stata letta, quindi questi conteggi coprono solo ciò su cui il tester si è pronunciato, per identificatore."
       },
       "verdict": {
         "met": "Verificato",
@@ -6145,8 +6142,10 @@
       "gap": {
         "no_tester_step": "Questa pipeline non ha un passo di test, quindi non è stato verificato alcun requisito.",
         "tester_not_reported": "Il tester non ha ancora riportato nulla, quindi nessun requisito è stato deciso.",
-        "no_verdicts": "Il tester ha riportato senza pronunciarsi su alcun requisito della specifica."
-      }
+        "no_verdicts": "Il tester ha riportato senza pronunciarsi su alcun requisito della specifica.",
+        "no_requirements": "La specifica del servizio non registra alcun requisito, quindi non c'era nulla su cui il tester potesse pronunciarsi."
+      },
+      "unmatchedVerdicts": "Il tester si è pronunciato anche su {count} identificatore/i che questa specifica non contiene, quindi il suo conteggio è più alto di quelli sopra."
     },
     "tests": {
       "title": "Come è stato testato",

package/i18n/locales/ja.json

@@ -5575,11 +5575,8 @@
       "notCovered": "未確認: {count}",
       "regressions": "リグレッション: {count}",
       "regressionTag": "リグレッション",
-      "idOnly": "ID のみ",
-      "idOnlyHint": "この ID はサービス仕様に含まれていないため、表示できる名称がありません。",
       "spec": {
-        "not_read": "サービス仕様を読み取っていないため、ここに並ぶのはテスターが報告した要件 ID だけで、その名称はありません。",
-        "unmatched": "読み取ったサービス仕様には、これらの要件 ID がひとつも含まれていません。そのため、テスターが報告した ID のみを表示しています。"
+        "not_read": "サービス仕様を読み取れなかったため、これらの集計はテスターが判定した分だけを ID 単位で数えています。"
       },
       "verdict": {
         "met": "確認済み",
@@ -5589,8 +5586,10 @@
       "gap": {
         "no_tester_step": "このパイプラインにはテスト工程がないため、要件は確認されていません。",
         "tester_not_reported": "テスターがまだ報告していないため、どの要件も判定されていません。",
-        "no_verdicts": "テスターは報告しましたが、仕様のいずれの要件についても判定していません。"
-      }
+        "no_verdicts": "テスターは報告しましたが、仕様のいずれの要件についても判定していません。",
+        "no_requirements": "サービス仕様に要件が記録されていないため、テスターが判定するものはありませんでした。"
+      },
+      "unmatchedVerdicts": "テスターはこの仕様に存在しない ID を {count} 件も判定しているため、テスター自身の集計は上の件数より多くなります。"
     },
     "tests": {
       "title": "テストの内容",

package/i18n/locales/pl.json

@@ -5575,11 +5575,8 @@
       "notCovered": "Niesprawdzone: {count}",
       "regressions": "Regresje: {count}",
       "regressionTag": "Regresja",
-      "idOnly": "sam identyfikator",
-      "idOnlyHint": "Tego identyfikatora nie ma w specyfikacji usługi, więc nie ma nazwy do pokazania.",
       "spec": {
-        "not_read": "Specyfikacja usługi nie została odczytana, więc widoczne są identyfikatory wymagań zgłoszone przez testera, bez ich nazw.",
-        "unmatched": "Żaden z tych identyfikatorów wymagań nie występuje w odczytanej specyfikacji usługi, więc pokazane są tylko identyfikatory zgłoszone przez testera."
+        "not_read": "Specyfikacja usługi nie została odczytana, więc te liczby obejmują tylko to, co tester rozstrzygnął, według identyfikatora."
       },
       "verdict": {
         "met": "Potwierdzone",
@@ -5589,8 +5586,10 @@
       "gap": {
         "no_tester_step": "Ten potok nie ma kroku testowego, więc nie sprawdzono żadnego wymagania.",
         "tester_not_reported": "Tester jeszcze nie zgłosił raportu, więc żadne wymaganie nie zostało rozstrzygnięte.",
-        "no_verdicts": "Tester zgłosił raport, nie rozstrzygając żadnego wymagania ze specyfikacji."
-      }
+        "no_verdicts": "Tester zgłosił raport, nie rozstrzygając żadnego wymagania ze specyfikacji.",
+        "no_requirements": "Specyfikacja usługi nie zawiera żadnych wymagań, więc tester nie miał czego rozstrzygać."
+      },
+      "unmatchedVerdicts": "Tester rozstrzygnął dodatkowo {count} identyfikator(ów), których nie ma w tej specyfikacji, więc jego własne zliczenie jest wyższe niż powyższe."
     },
     "tests": {
       "title": "Jak to przetestowano",

package/i18n/locales/tr.json

@@ -5575,11 +5575,8 @@
       "notCovered": "Denetlenmeyen: {count}",
       "regressions": "Gerilemeler: {count}",
       "regressionTag": "Gerileme",
-      "idOnly": "yalnızca kimlik",
-      "idOnlyHint": "Bu kimlik servis şartnamesinde yer almadığı için gösterilecek bir başlık yok.",
       "spec": {
-        "not_read": "Servis şartnamesi okunmadı; bu nedenle burada test edicinin bildirdiği gereksinim kimlikleri, başlıkları olmadan yer alıyor.",
-        "unmatched": "Okunan servis şartnamesinde bu gereksinim kimliklerinin hiçbiri yok; bu nedenle yalnızca test edicinin bildirdiği kimlikler gösteriliyor."
+        "not_read": "Servis şartnamesi okunamadı; bu sayılar yalnızca testçinin karara bağladıklarını, kimlik bazında kapsıyor."
       },
       "verdict": {
         "met": "Doğrulandı",
@@ -5589,8 +5586,10 @@
       "gap": {
         "no_tester_step": "Bu hatta test adımı yok, bu yüzden hiçbir gereksinim denetlenmedi.",
         "tester_not_reported": "Testçi henüz rapor vermedi, bu yüzden hiçbir gereksinim karara bağlanmadı.",
-        "no_verdicts": "Testçi rapor verdi ancak belirtimdeki hiçbir gereksinim hakkında karar vermedi."
-      }
+        "no_verdicts": "Testçi rapor verdi ancak belirtimdeki hiçbir gereksinim hakkında karar vermedi.",
+        "no_requirements": "Servis şartnamesinde hiçbir gereksinim kayıtlı değil, dolayısıyla testçinin karara bağlayacağı bir şey yoktu."
+      },
+      "unmatchedVerdicts": "Testçi ayrıca bu şartnamede bulunmayan {count} kimlik hakkında karar verdi; bu yüzden kendi sayımı yukarıdakilerden yüksek."
     },
     "tests": {
       "title": "Nasıl test edildi",

package/i18n/locales/uk.json

@@ -5575,11 +5575,8 @@
       "notCovered": "Не перевірено: {count}",
       "regressions": "Регресії: {count}",
       "regressionTag": "Регресія",
-      "idOnly": "лише ідентифікатор",
-      "idOnlyHint": "Цього ідентифікатора немає у специфікації сервісу, тому назви для показу немає.",
       "spec": {
-        "not_read": "Специфікацію сервісу не прочитано, тому тут наведено ідентифікатори вимог, які повідомив тестувальник, без їхніх назв.",
-        "unmatched": "Жодного з цих ідентифікаторів вимог немає у прочитаній специфікації сервісу, тому показано лише ті ідентифікатори, які повідомив тестувальник."
+        "not_read": "Специфікацію сервісу не прочитано, тож ці підрахунки охоплюють лише те, щодо чого тестувальник виніс вердикт, за ідентифікатором."
       },
       "verdict": {
         "met": "Підтверджено",
@@ -5589,8 +5586,10 @@
       "gap": {
         "no_tester_step": "У цьому конвеєрі немає кроку тестування, тож жодну вимогу не перевіряли.",
         "tester_not_reported": "Тестувальник ще не звітував, тож жодну вимогу не вирішено.",
-        "no_verdicts": "Тестувальник прозвітував, не висловившись про жодну вимогу зі специфікації."
-      }
+        "no_verdicts": "Тестувальник прозвітував, не висловившись про жодну вимогу зі специфікації.",
+        "no_requirements": "Специфікація сервісу не містить жодної вимоги, тож тестувальнику не було чого оцінювати."
+      },
+      "unmatchedVerdicts": "Тестувальник виніс вердикт ще щодо {count} ідентифікатор(ів), яких немає в цій специфікації, тож його власний підрахунок вищий за наведений вище."
     },
     "tests": {
       "title": "Як це тестували",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.241.2",
+  "version": "0.242.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.261.1"
+    "@cat-factory/contracts": "0.263.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",

package/app/utils/runOutcome.spec.ts

@@ -1,492 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { Block } from '~/types/domain'
-import type { ExecutionInstance, PipelineStep } from '~/types/execution'
-import type { ServiceSpecView } from '~/types/spec'
-import { composeRunOutcome, hasOutcomeToShow } from '~/utils/runOutcome'
-
-// The composer's whole job is to keep facts that mean different things from rendering the same,
-// so the cases worth pinning are the COLLAPSES: an absent producer vs a producer that found
-// nothing, an aspirational failure vs a regression, a capture nobody reviewed vs a pair a human
-// approved, and a tester that could not run vs one that ran and raised concerns.
-
-function block(overrides: Partial<Block> = {}): Block {
-  return {
-    id: 'blk_1',
-    title: 'Password reset',
-    description: '  Let a signed-out user reset their password by email.  ',
-    status: 'pr_ready',
-    level: 'task',
-    type: 'task',
-    parentId: 'frm_1',
-    position: { x: 0, y: 0 },
-    progress: 0,
-    dependsOn: [],
-    taskType: 'feature',
-    ...overrides,
-  } as Block
-}
-
-function step(overrides: Partial<PipelineStep> = {}): PipelineStep {
-  return {
-    agentKind: 'coder',
-    state: 'done',
-    progress: 1,
-    decision: null,
-    ...overrides,
-  } as PipelineStep
-}
-
-function run(steps: PipelineStep[], overrides: Partial<ExecutionInstance> = {}): ExecutionInstance {
-  return {
-    id: 'exe_1',
-    blockId: 'blk_1',
-    pipelineId: 'pl_1',
-    pipelineName: 'Build',
-    steps,
-    currentStep: 0,
-    status: 'running',
-    ...overrides,
-  } as ExecutionInstance
-}
-
-function testerStep(report: Record<string, unknown>, kind = 'tester-ui'): PipelineStep {
-  return step({
-    agentKind: kind,
-    test: {
-      phase: 'testing',
-      attempts: 0,
-      maxAttempts: 3,
-      lastReport: {
-        greenlight: true,
-        summary: 'Exercised the reset flow end to end.',
-        tested: ['Password reset'],
-        outcomes: [],
-        concerns: [],
-        ...report,
-      },
-    },
-  } as Partial<PipelineStep>)
-}
-
-const spec: ServiceSpecView = {
-  present: true,
-  spec: {
-    service: 'accounts',
-    summary: '',
-    modules: [
-      {
-        name: 'auth',
-        summary: '',
-        groups: [
-          {
-            name: 'login',
-            summary: '',
-            rules: [],
-            requirements: [
-              {
-                id: 'req-reset',
-                title: 'A user can reset their password',
-                statement: 'The system SHALL send a reset link.',
-                kind: 'functional',
-                priority: 'must',
-                state: 'aspirational',
-                acceptance: [],
-                sourceBlockIds: [],
-              },
-              {
-                id: 'req-login',
-                title: 'A user can sign in',
-                statement: 'The system SHALL authenticate a user.',
-                kind: 'functional',
-                priority: 'must',
-                state: 'established',
-                acceptance: [],
-                sourceBlockIds: [],
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  },
-  features: [],
-}
-
-describe('composeRunOutcome', () => {
-  it('carries the ask and every pull request so the diff stays one click away', () => {
-    const outcome = composeRunOutcome({
-      block: block({
-        pullRequest: { url: 'https://host/pr/7', number: 7, branch: 'cat-factory/blk_1' },
-        peerPullRequests: [{ repo: 'acme/api', ref: { url: 'https://host/api/pr/3', number: 3 } }],
-      }),
-      instance: null,
-    })
-
-    expect(outcome.title).toBe('Password reset')
-    expect(outcome.ask).toBe('Let a signed-out user reset their password by email.')
-    expect(outcome.disposition).toBe('awaiting_merge')
-    expect(outcome.pullRequests).toEqual([
-      { url: 'https://host/pr/7', number: 7, branch: 'cat-factory/blk_1', repo: null },
-      { url: 'https://host/api/pr/3', number: 3, branch: null, repo: 'acme/api' },
-    ])
-  })
-
-  it('distinguishes no tester step from a tester that has not reported', () => {
-    const none = composeRunOutcome({ block: block(), instance: run([step()]) })
-    expect(none.tests).toEqual({ status: 'absent', gap: 'no_tester_step' })
-    expect(none.requirements).toEqual({ status: 'absent', gap: 'no_tester_step' })
-
-    const silent = composeRunOutcome({
-      block: block(),
-      instance: run([step({ agentKind: 'tester-api' })]),
-    })
-    expect(silent.tests).toEqual({ status: 'absent', gap: 'tester_not_reported' })
-  })
-
-  it('keeps a tester that could not run apart from one that raised concerns', () => {
-    const aborted = composeRunOutcome({
-      block: block(),
-      instance: run([
-        testerStep({
-          greenlight: false,
-          abort: { reason: 'The preview environment never came up.' },
-        }),
-      ]),
-    })
-    expect(aborted.tests).toMatchObject({
-      status: 'reported',
-      verdict: 'could_not_run',
-      abortReason: 'The preview environment never came up.',
-      concerns: [],
-    })
-
-    const buggy = composeRunOutcome({
-      block: block(),
-      instance: run([
-        testerStep({
-          greenlight: false,
-          concerns: [{ title: 'Reset link expires immediately', detail: '…', severity: 'high' }],
-          outcomes: [
-            { name: 'Reset', status: 'failed' },
-            { name: 'Login', status: 'passed' },
-            { name: 'Rate limit', status: 'skipped' },
-          ],
-        }),
-      ]),
-    })
-    expect(buggy.tests).toMatchObject({
-      verdict: 'concerns',
-      passed: 1,
-      failed: 1,
-      skipped: 1,
-      concerns: [{ title: 'Reset link expires immediately', severity: 'high' }],
-    })
-  })
-
-  it('reports a failing ESTABLISHED requirement as a regression and an aspirational one as not', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        testerStep({
-          requirementVerdicts: [
-            { requirementId: 'req-reset', status: 'not_met', detail: 'Not built yet.' },
-            { requirementId: 'req-login', status: 'not_met', detail: 'Sign-in now 500s.' },
-          ],
-        }),
-      ]),
-      spec,
-    })
-
-    expect(outcome.requirements).toMatchObject({
-      status: 'reported',
-      spec: 'joined',
-      regressions: 1,
-    })
-    if (outcome.requirements.status !== 'reported') throw new Error('expected a reported section')
-    // The regression leads, and both are still counted as failures.
-    expect(outcome.requirements.entries.map((e) => [e.id, e.regression])).toEqual([
-      ['req-login', true],
-      ['req-reset', false],
-    ])
-    expect(outcome.requirements.notMet).toBe(2)
-    expect(outcome.requirements.entries[0]?.title).toBe('A user can sign in')
-  })
-
-  it('says the spec was never read rather than rendering ids as titles', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        testerStep({ requirementVerdicts: [{ requirementId: 'req-reset', status: 'met' }] }),
-      ]),
-    })
-    expect(outcome.requirements).toMatchObject({ status: 'reported', spec: 'not_read' })
-    if (outcome.requirements.status !== 'reported') throw new Error('expected a reported section')
-    expect(outcome.requirements.entries[0]).toMatchObject({
-      id: 'req-reset',
-      title: null,
-      state: null,
-      regression: false,
-    })
-  })
-
-  // A spec that WAS read and names none of the reported ids leaves identical rows behind, and
-  // sends the reader to a different fix: the spec moved on, or the tester keyed its verdicts by
-  // something else. Reporting it as a failed read would send them to fix a read that worked.
-  it('keeps a spec that was never read apart from one that named none of these ids', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        testerStep({ requirementVerdicts: [{ requirementId: 'req-gone', status: 'met' }] }),
-      ]),
-      spec,
-    })
-    expect(outcome.requirements).toMatchObject({ status: 'reported', spec: 'unmatched' })
-  })
-
-  // The partial join is the case a section-level note cannot state: some rows carry titles, and
-  // an id sitting unmarked between them reads as a requirement named after a slug.
-  it('marks the rows the spec did not name while the section as a whole joined', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        testerStep({
-          requirementVerdicts: [
-            { requirementId: 'req-login', status: 'met' },
-            { requirementId: 'req-gone', status: 'met' },
-          ],
-        }),
-      ]),
-      spec,
-    })
-    expect(outcome.requirements).toMatchObject({ status: 'reported', spec: 'joined' })
-    if (outcome.requirements.status !== 'reported') throw new Error('expected a reported section')
-    const rows = outcome.requirements.entries
-    expect(rows.find((e) => e.id === 'req-login')?.title).toBe('A user can sign in')
-    expect(rows.find((e) => e.id === 'req-gone')?.title).toBeNull()
-  })
-
-  it('separates a tester report with no verdicts from a tester that never reported', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([testerStep({ requirementVerdicts: [] })]),
-    })
-    expect(outcome.requirements).toEqual({ status: 'absent', gap: 'no_verdicts' })
-  })
-
-  it('prefers the reviewed visual-confirmation pairs over the tester’s raw captures', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        testerStep({ screenshots: [{ view: 'reset', artifactId: 'art_shot' }] }),
-        step({
-          agentKind: 'visual-confirmation',
-          visualConfirm: {
-            phase: 'approved',
-            attempts: 0,
-            maxAttempts: 2,
-            pairs: [{ view: 'reset', actualArtifactId: 'art_a', referenceArtifactId: 'art_ref' }],
-          },
-        } as Partial<PipelineStep>),
-      ]),
-    })
-    expect(outcome.visuals).toEqual({
-      status: 'reported',
-      source: 'visual_confirm',
-      phase: 'approved',
-      views: [{ view: 'reset', artifactId: 'art_a', referenceArtifactId: 'art_ref' }],
-    })
-  })
-
-  it('falls back to the tester’s captures, and says which gap it hit when there are none', () => {
-    const captured = composeRunOutcome({
-      block: block(),
-      instance: run([testerStep({ screenshots: [{ view: 'reset', artifactId: 'art_shot' }] })]),
-    })
-    expect(captured.visuals).toMatchObject({ status: 'reported', source: 'tester', phase: null })
-
-    // An API tester captures nothing by design: no producer, so nothing was ever meant to be seen.
-    const apiOnly = composeRunOutcome({
-      block: block(),
-      instance: run([testerStep({}, 'tester-api')]),
-    })
-    expect(apiOnly.visuals).toEqual({ status: 'absent', gap: 'no_visual_step', detail: null })
-
-    // A gate that ran and gathered nothing is a different fact, and it recorded why.
-    const degraded = composeRunOutcome({
-      block: block(),
-      instance: run([
-        step({
-          agentKind: 'visual-confirmation',
-          visualConfirm: {
-            phase: 'awaiting_human',
-            attempts: 0,
-            maxAttempts: 2,
-            pairs: [],
-            degradedReason: 'No artifact storage configured.',
-          },
-        } as Partial<PipelineStep>),
-      ]),
-    })
-    expect(degraded.visuals).toEqual({
-      status: 'absent',
-      gap: 'none_captured',
-      detail: 'No artifact storage configured.',
-    })
-  })
-
-  it('lists only the checks that actually recorded a verdict', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        step({
-          agentKind: 'ci',
-          gate: { phase: 'checking', attempts: 0, maxAttempts: 3 },
-        } as Partial<PipelineStep>),
-        step({
-          validation: { passed: false, attempts: 2, maxAttempts: 3, outcomes: [] },
-        } as Partial<PipelineStep>),
-        step({
-          reproduction: {
-            status: 'inconclusive',
-            command: 'pnpm test',
-            testPaths: [],
-            attempts: 1,
-            maxAttempts: 2,
-            at: 1,
-          },
-        } as Partial<PipelineStep>),
-      ]),
-    })
-
-    // The CI gate has not probed yet, so it contributes NOTHING rather than a green row.
-    expect(outcome.checks).toEqual([
-      { kind: 'validation', state: 'fail', reproduction: null },
-      { kind: 'reproduction', state: 'inconclusive', reproduction: 'inconclusive' },
-    ])
-  })
-
-  it('reads the CI gate’s recorded verdict once it has probed', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        step({
-          agentKind: 'ci',
-          gate: { phase: 'checking', attempts: 0, maxAttempts: 3, lastVerdict: 'pass' },
-        } as Partial<PipelineStep>),
-      ]),
-    })
-    expect(outcome.checks).toEqual([{ kind: 'ci', state: 'pass', reproduction: null }])
-  })
-
-  // A block that NAMES a run the caller could not resolve is the trap this whole module is
-  // about: composed from the empty step list it would report a pipeline that ran and produced
-  // nothing, which is the opposite of "nobody could read what it produced".
-  it('says the run could not be read rather than blaming the pipeline for the missing steps', () => {
-    const outcome = composeRunOutcome({
-      block: block({ status: 'done', executionId: 'exe_gone' }),
-      instance: null,
-    })
-
-    expect(outcome.requirements).toEqual({ status: 'absent', gap: 'run_unavailable' })
-    expect(outcome.tests).toEqual({ status: 'absent', gap: 'run_unavailable' })
-    expect(outcome.visuals).toEqual({ status: 'absent', gap: 'run_unavailable', detail: null })
-    expect(outcome.checks).toEqual([])
-    // The block still carries what the block knows.
-    expect(outcome.disposition).toBe('merged')
-    expect(outcome.title).toBe('Password reset')
-  })
-
-  it('keeps a task that never ran apart from one whose run could not be read', () => {
-    const never = composeRunOutcome({ block: block({ status: 'ready' }), instance: null })
-    const unread = composeRunOutcome({
-      block: block({ status: 'ready', executionId: 'exe_gone' }),
-      instance: null,
-    })
-
-    expect(never.disposition).toBe('not_run')
-    expect(never.tests).toEqual({ status: 'absent', gap: 'no_tester_step' })
-    expect(unread.disposition).toBe('unknown')
-    expect(unread.tests).toEqual({ status: 'absent', gap: 'run_unavailable' })
-  })
-
-  // The selected tester is the one that REPORTED, which can be the api half of a pipeline whose
-  // ui half has not. Reading the producer off it would tell a reader looking at a UI pipeline
-  // that nothing in it captures the interface.
-  it('finds the interface producer anywhere in the pipeline, not only on the reporting tester', () => {
-    const outcome = composeRunOutcome({
-      block: block(),
-      instance: run([
-        step({ agentKind: 'tester-ui' }),
-        testerStep({ screenshots: [] }, 'tester-api'),
-      ]),
-    })
-    expect(outcome.visuals).toEqual({ status: 'absent', gap: 'none_captured', detail: null })
-  })
-
-  it('derives the disposition from the block, and from the run only where the block cannot', () => {
-    const dispositions = [
-      composeRunOutcome({ block: block({ status: 'done' }), instance: null }).disposition,
-      composeRunOutcome({ block: block({ status: 'pr_ready' }), instance: null }).disposition,
-      composeRunOutcome({ block: block({ status: 'planned' }), instance: null }).disposition,
-      composeRunOutcome({ block: block({ status: 'in_progress' }), instance: run([step()]) })
-        .disposition,
-      composeRunOutcome({
-        block: block({ status: 'in_progress' }),
-        instance: run([step()], { status: 'failed' }),
-      }).disposition,
-      // `in_progress` is the block's own word for a live run, so it stands with no instance.
-      composeRunOutcome({
-        block: block({ status: 'in_progress', executionId: 'exe_gone' }),
-        instance: null,
-      }).disposition,
-    ]
-    expect(dispositions).toEqual([
-      'merged',
-      'awaiting_merge',
-      'not_run',
-      'in_flight',
-      'needs_attention',
-      'in_flight',
-    ])
-  })
-})
-
-describe('hasOutcomeToShow', () => {
-  it('is false for a run that has produced nothing to read yet', () => {
-    expect(
-      hasOutcomeToShow(composeRunOutcome({ block: block({ status: 'planned' }), instance: null })),
-    ).toBe(false)
-  })
-
-  // The affordance the board card and the inspector both gate on: a task marked done by hand,
-  // carrying no pull request and no readable run, has nothing an outcome card could show.
-  it('is false for a task whose run cannot be read and which carries no pull request', () => {
-    expect(
-      hasOutcomeToShow(
-        composeRunOutcome({
-          block: block({ status: 'done', executionId: 'exe_gone' }),
-          instance: null,
-        }),
-      ),
-    ).toBe(false)
-  })
-
-  it('is true as soon as there is a PR or any recorded evidence', () => {
-    expect(
-      hasOutcomeToShow(
-        composeRunOutcome({
-          block: block({ pullRequest: { url: 'https://host/pr/7', number: 7 } }),
-          instance: null,
-        }),
-      ),
-    ).toBe(true)
-    expect(
-      hasOutcomeToShow(
-        composeRunOutcome({
-          block: block({ status: 'in_progress' }),
-          instance: run([testerStep({})]),
-        }),
-      ),
-    ).toBe(true)
-  })
-})