@cat-factory/app 0.256.3 → 0.257.0

package/app/stores/binaryCandidates.ts

@@ -0,0 +1,89 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { KeepBinaryCandidatesInput } from '@cat-factory/contracts'
+import type { BinaryCandidateStepState } from '~/types/execution'
+import { useApi } from '~/composables/useApi'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useExecutionStore } from '~/stores/execution'
+
+/**
+ * The generated-candidate action surface. The live state lives on the run's step
+ * (`step.binaryCandidates`) and the execution stream keeps it fresh, so the window reads it
+ * straight off the execution store; this store only wraps the `keep` action (plus a warm-up
+ * `load`), tracks the in-flight state so the window can disable its controls, and echoes the
+ * returned state back so the UI settles without waiting for the stream. Shaped exactly like the
+ * fork-decision store, which is the same park one subject over.
+ */
+export const useBinaryCandidatesStore = defineStore('binaryCandidates', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+  const execution = useExecutionStore()
+
+  /** True while a keep call is in flight (drives the button spinner / disabled state). */
+  const keeping = ref(false)
+  /** The last error message from an action, surfaced inline; cleared on the next action. */
+  const error = ref<string | null>(null)
+
+  /**
+   * Apply an authoritative candidate state to the run's step.
+   *
+   * A pipeline may carry more than one generating step, so target the step this decision is
+   * ABOUT rather than the first that happens to hold candidate state: prefer the one still
+   * awaiting a choice, then the current step, and only then any step carrying state. Without
+   * that order a run whose earlier generator already settled would have its finished record
+   * overwritten by the live one.
+   *
+   * Only ever called through {@link ExecutionStore.echoAfter}, which drops the echo when the
+   * event stream already delivered a newer revision.
+   */
+  function assign(
+    instance: ReturnType<typeof execution.getInstance> & object,
+    state: BinaryCandidateStepState,
+  ): void {
+    const current = instance.steps[instance.currentStep]
+    const step =
+      instance.steps.find((s) => s.binaryCandidates?.status === 'awaiting_choice') ??
+      (current?.binaryCandidates ? current : undefined) ??
+      instance.steps.find((s) => s.binaryCandidates)
+    if (step) step.binaryCandidates = state
+  }
+
+  /** Warm the live state from the GET (the stream also keeps it fresh). Best-effort. */
+  async function load(executionId: string): Promise<void> {
+    error.value = null
+    try {
+      await execution.echoAfter(
+        executionId,
+        () => api.getBinaryCandidates(workspace.requireId(), executionId),
+        (state, instance) => {
+          if (state) assign(instance, state as BinaryCandidateStepState)
+        },
+      )
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to load'
+    }
+  }
+
+  /**
+   * Keep the chosen candidates (each with the id it is to be stored under) and discard the rest.
+   * The step then re-runs to deliver exactly what survived.
+   */
+  async function keep(executionId: string, input: KeepBinaryCandidatesInput): Promise<void> {
+    error.value = null
+    keeping.value = true
+    try {
+      await execution.echoAfter(
+        executionId,
+        () => api.keepBinaryCandidates(workspace.requireId(), executionId, input),
+        (state, instance) => assign(instance, state as BinaryCandidateStepState),
+      )
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to keep candidates'
+      throw e
+    } finally {
+      keeping.value = false
+    }
+  }
+
+  return { keeping, error, load, keep }
+})

package/app/stores/ui/resultViews.ts

@@ -164,12 +164,13 @@ export function createUiResultViews() {
   // The run-scoped openers (a caller that knows only the RUN, so the step index has to be
   // resolved) live in a sibling module: they share one shape and one hazard, and lifting them out
   // keeps this factory inside its per-function line budget. Their two seams are bound here.
-  const { openFollowUps, openForkDecision, openPrReview, openTestEvidence } = createRunStepOpeners({
-    dispatchStepView: (instanceId, stepIndex) => dispatchStepView(instanceId, stepIndex),
-    setResultView: (view, instance, stepIndex) => {
-      resultView.value = { view, blockId: instance.blockId, instanceId: instance.id, stepIndex }
-    },
-  })
+  const { openFollowUps, openForkDecision, openBinaryCandidates, openPrReview, openTestEvidence } =
+    createRunStepOpeners({
+      dispatchStepView: (instanceId, stepIndex) => dispatchStepView(instanceId, stepIndex),
+      setResultView: (view, instance, stepIndex) => {
+        resultView.value = { view, blockId: instance.blockId, instanceId: instance.id, stepIndex }
+      },
+    })
 
   function closeResultView() {
     resultView.value = null
@@ -209,6 +210,7 @@ export function createUiResultViews() {
     openInitiativePlanning,
     openFollowUps,
     openForkDecision,
+    openBinaryCandidates,
     openPrReview,
     openTestEvidence,
     openOutcome,

package/app/stores/ui/runStepOpeners.ts

@@ -93,6 +93,28 @@ export function createRunStepOpeners(deps: RunStepOpenerDeps) {
     )
   }
 
+  // Open the generated-candidate comparison window for a run's binary-output step (from the
+  // pipeline chip / inspector rail / step overlay). Resolves the step index from the run when not
+  // given, preferring the step parked awaiting a choice.
+  //
+  // Resolved by the CANDIDATE STATE rather than by an agent kind, unlike its neighbours: any kind
+  // carrying the `binary-output` trait can run a comparison, and a deployment's own kinds are
+  // exactly the ones a hard-coded kind list here would never name.
+  function openBinaryCandidates(instanceId: string, stepIndex: number | null = null) {
+    withStep(
+      instanceId,
+      stepIndex,
+      (instance) => {
+        const awaiting = indexOf(instance, (s) => s.binaryCandidates?.status === 'awaiting_choice')
+        if (awaiting >= 0) return awaiting
+        const current = instance.steps[instance.currentStep]
+        if (current?.binaryCandidates) return instance.currentStep
+        return indexOf(instance, (s) => !!s.binaryCandidates)
+      },
+      (instance, idx) => deps.setResultView('binary-candidates', instance, idx),
+    )
+  }
+
   // Open the PR deep-review window for a run's `pr-reviewer` step (from the `pr_review_ready`
   // notification / the step). Resolves the step index from the run when not given, preferring
   // the step parked awaiting a finding selection.
@@ -139,5 +161,5 @@ export function createRunStepOpeners(deps: RunStepOpenerDeps) {
     )
   }
 
-  return { openFollowUps, openForkDecision, openPrReview, openTestEvidence }
+  return { openFollowUps, openForkDecision, openBinaryCandidates, openPrReview, openTestEvidence }
 }

package/app/types/execution.ts

@@ -95,6 +95,11 @@ export type {
   BinaryOutputArtifact,
   BinaryOutputConfig,
   BinaryOutputReport,
+  // The candidate-comparison set on a step whose selection declares a `comparison`: the staged
+  // candidates, the live park state, and the human's keep/discard decision.
+  BinaryCandidate,
+  BinaryCandidateChoice,
+  BinaryCandidateStepState,
   TesterStepState,
   HumanTestEnvironment,
   RunEnvironment,

package/app/utils/binaryCandidates.spec.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest'
+import type { PipelineStep } from '~/types/execution'
+import { binaryCandidateHasWarnings, binaryCandidateView } from './binaryCandidates'
+
+function step(overrides: Record<string, unknown> = {}): PipelineStep {
+  // The candidate override MERGES into the base state rather than replacing it, so a case that
+  // only cares about one counter does not have to restate the whole candidate list.
+  const { binaryCandidates, ...rest } = overrides
+  return {
+    agentKind: 'imager',
+    state: 'waiting_decision',
+    binaryCandidates: {
+      status: 'awaiting_choice',
+      multiSelect: false,
+      invalidEntries: 0,
+      omitted: 0,
+      unusablePreviews: 0,
+      candidates: [
+        { id: 'c1', service: 's', location: 'a.png', subject: 'anvil', generator: 'flux' },
+        { id: 'c2', service: 's', location: 'b.png', subject: 'anvil', generator: 'retro' },
+        { id: 'c3', service: 's', location: 'c.png', subject: 'hammer' },
+      ],
+      ...(binaryCandidates as Record<string, unknown> | undefined),
+    },
+    ...rest,
+  } as unknown as PipelineStep
+}
+
+describe('binaryCandidateView', () => {
+  // A step that never compared renders nothing at all, exactly as the binary-output section does
+  // for a step that never generated: a row saying "no comparison here" would ride every step.
+  it('is absent for a step with no comparison story', () => {
+    expect(binaryCandidateView({ agentKind: 'coder' } as PipelineStep)).toBeNull()
+    expect(binaryCandidateView(null)).toBeNull()
+  })
+
+  // A person compares one subject at a time; forty subjects is forty comparisons, not one wall of
+  // eighty pictures.
+  it('groups candidates by subject in first-appearance order', () => {
+    const view = binaryCandidateView(step())!
+    expect(view.groups.map((g) => g.subject)).toEqual(['anvil', 'hammer'])
+    expect(view.groups[0]?.rows.map((r) => r.id)).toEqual(['c1', 'c2'])
+  })
+
+  // An unlabelled candidate is not "the same thing" as any labelled one, and filing it under the
+  // first subject would put a picture of something else into a comparison.
+  it('keeps unlabelled candidates in their own group rather than merging them', () => {
+    const view = binaryCandidateView(
+      step({
+        binaryCandidates: {
+          candidates: [
+            { id: 'c1', service: 's', location: 'a.png', subject: 'anvil' },
+            { id: 'c2', service: 's', location: 'b.png' },
+          ],
+        },
+      }),
+    )!
+    expect(view.groups.map((g) => g.subject)).toEqual(['anvil', null])
+  })
+
+  it('marks what was kept and the id it was kept under', () => {
+    const view = binaryCandidateView(
+      step({
+        binaryCandidates: {
+          status: 'chosen',
+          multiSelect: true,
+          choice: {
+            kept: [{ candidateId: 'c2', storeAs: 'anvil-pixel' }],
+            discarded: ['c1', 'c3'],
+            at: 1,
+          },
+        },
+      }),
+    )!
+    const rows = view.groups.flatMap((g) => g.rows)
+    expect(rows.find((r) => r.id === 'c2')).toMatchObject({ kept: true, storeAs: 'anvil-pixel' })
+    expect(rows.find((r) => r.id === 'c1')?.kept).toBe(false)
+    expect(view.awaiting).toBe(false)
+  })
+
+  // An automatic keep is NOT a review. A surface that renders it as a choice tells a reader a
+  // person looked at this and approved it, which is the claim the whole feature exists to make
+  // true.
+  it('reports an automatic keep as its own fact', () => {
+    const view = binaryCandidateView(
+      step({
+        binaryCandidates: {
+          status: 'chosen',
+          choice: { kept: [{ candidateId: 'c1' }], discarded: [], automatic: true, at: 1 },
+        },
+      }),
+    )!
+    expect(view.automatic).toBe(true)
+  })
+
+  it('counts candidates with no renderable preview', () => {
+    expect(binaryCandidateView(step())!.withoutPreview).toBe(3)
+  })
+})
+
+describe('binaryCandidateHasWarnings', () => {
+  // A comparison made over three of five candidates must not read as one made over all five.
+  it('is raised by any counted loss and by nothing else', () => {
+    expect(binaryCandidateHasWarnings(binaryCandidateView(step())!)).toBe(false)
+    for (const field of ['invalidEntries', 'omitted', 'unusablePreviews'] as const) {
+      const view = binaryCandidateView(step({ binaryCandidates: { [field]: 1 } }))!
+      expect(binaryCandidateHasWarnings(view)).toBe(true)
+    }
+  })
+})

package/app/utils/binaryCandidates.ts

@@ -0,0 +1,126 @@
+import type { BinaryCandidate, BinaryCandidateStepState, PipelineStep } from '~/types/execution'
+
+// ---------------------------------------------------------------------------
+// The read model behind the candidate-comparison surface
+// (docs/initiatives/binary-output-foundational-storage.md).
+//
+// A step whose selection declares a `comparison` generates a candidate from each of its selected
+// integrations, stages them, and parks. This module turns that record into what the window
+// renders: the candidates GROUPED BY SUBJECT (which is what a person actually compares), the
+// preview each one does or does not have, and every loss the parse counted.
+//
+// Pure, and reads only the step's own record, which is the rule the sibling binary-output read
+// model follows and for the same reason: the join a human wants is answerable from the step alone, so
+// the surface needs no fetch and reads identically for a finished run.
+// ---------------------------------------------------------------------------
+
+/** One candidate as the window renders it, with the two facts the raw record does not carry. */
+export interface BinaryCandidateRow extends BinaryCandidate {
+  /**
+   * The human kept this one. Meaningful only once a choice exists, which is what lets the window
+   * double as the RECORD of a settled comparison rather than only its control surface.
+   */
+  kept: boolean
+  /** The id it is to be stored under, when the person who kept it assigned one. */
+  storeAs?: string
+}
+
+/** The candidates for one subject, which is the unit a person compares. */
+export interface BinaryCandidateGroup {
+  /**
+   * What these candidates depict, or null when the agent declared no subject. Null is its own
+   * group rather than being merged into another: an unlabelled candidate is not "the same thing"
+   * as any labelled one, and quietly filing it under the first subject would put a picture of
+   * something else into a comparison.
+   */
+  subject: string | null
+  rows: BinaryCandidateRow[]
+}
+
+/** The whole surface's read model. */
+export interface BinaryCandidateView {
+  state: BinaryCandidateStepState
+  /** Candidates grouped by subject, in first-appearance order. */
+  groups: BinaryCandidateGroup[]
+  /** Whether the run is parked on this decision right now (as opposed to showing the record). */
+  awaiting: boolean
+  /** Whether more than one candidate may be kept. */
+  multiSelect: boolean
+  /**
+   * True when the engine kept the only candidate without asking. Its own flag rather than an
+   * absent decider, because a surface that renders it as a choice claims a person looked at this.
+   */
+  automatic: boolean
+  /** How many candidates carry no renderable preview, so the window can say so once. */
+  withoutPreview: number
+}
+
+/**
+ * The step's candidate read model, or null when the step has no comparison story at all.
+ *
+ * A step that never compared renders nothing, exactly as the binary-output section does for a step
+ * that never generated: a row saying "no comparison was configured here" would ride every step of
+ * every run.
+ */
+export function binaryCandidateView(
+  step: PipelineStep | null | undefined,
+): BinaryCandidateView | null {
+  const state = step?.binaryCandidates
+  if (!state) return null
+  const kept = new Map((state.choice?.kept ?? []).map((entry) => [entry.candidateId, entry]))
+  const groups: BinaryCandidateGroup[] = []
+  const bySubject = new Map<string | null, BinaryCandidateGroup>()
+  for (const candidate of state.candidates) {
+    const subject = candidate.subject ?? null
+    let group = bySubject.get(subject)
+    if (!group) {
+      group = { subject, rows: [] }
+      bySubject.set(subject, group)
+      groups.push(group)
+    }
+    const choice = kept.get(candidate.id)
+    group.rows.push({
+      ...candidate,
+      kept: choice !== undefined,
+      ...(choice?.storeAs ? { storeAs: choice.storeAs } : {}),
+    })
+  }
+  return {
+    state,
+    groups,
+    awaiting: state.status === 'awaiting_choice',
+    multiSelect: state.multiSelect === true,
+    automatic: state.choice?.automatic === true,
+    withoutPreview: state.candidates.filter((candidate) => !candidate.previewUrl).length,
+  }
+}
+
+/**
+ * Whether anything about this comparison needs saying beside the candidates: entries the parse
+ * dropped, a truncated list, or preview links it refused.
+ *
+ * Drives the window's warning strip, so a comparison made over three of five candidates cannot
+ * read as one made over all of them. A missing PREVIEW is deliberately not one of these: it is
+ * ordinary (a private asset store issues no public link) and it is stated per candidate, where
+ * the reader can see exactly which one they are judging blind.
+ */
+export function binaryCandidateHasWarnings(view: BinaryCandidateView): boolean {
+  const { invalidEntries = 0, omitted = 0, unusablePreviews = 0 } = view.state
+  return invalidEntries > 0 || omitted > 0 || unusablePreviews > 0
+}
+
+/**
+ * State → the i18n key for the line explaining why no choice was offered.
+ *
+ * An exhaustive `Record` over the reason vocabulary, so a fourth reason fails the typecheck here
+ * rather than rendering a missing key. Every member is a different fault with a different fix,
+ * which is exactly why the engine records the reason instead of leaving the step blank.
+ */
+export const BINARY_CANDIDATE_NO_CHOICE_KEYS: Record<
+  NonNullable<BinaryCandidateStepState['noChoiceReason']>,
+  string
+> = {
+  undeclared: 'binaryCandidates.noChoice.undeclared',
+  parse_failed: 'binaryCandidates.noChoice.parseFailed',
+  no_candidates: 'binaryCandidates.noChoice.noCandidates',
+}

package/app/utils/binaryOutput.ts

@@ -1,10 +1,13 @@
 import {
   ASSET_STORAGE_CAPABILITY,
+  binaryCapabilityCoverage,
   binaryFormatCoverage,
   binaryModalityOverlaps,
   normalizeMediaType,
+  requiredBinaryCapabilities,
 } from '@cat-factory/contracts'
 import type {
+  BinaryGeneratorCapability,
   BinaryModality,
   BinaryModalityOverlap,
   RegisteredBinaryGenerator,
@@ -437,6 +440,20 @@ export type BinaryOutputPickIssue =
    * think to write it; this catches the author.
    */
   | 'generator_overlap'
+  /**
+   * A per-step GENERATION OPTION whose capability no selected integration declares: a reference
+   * image handed to an endpoint that takes no image input, a seed asked of one that has none
+   * (kernel's `capability_unsupported` spelling verbatim, like the members above it). A refusal.
+   */
+  | 'capability_unsupported'
+  /**
+   * A required capability nothing selected declares, where a selected integration declares NO
+   * capabilities at all, so it might be supported and nothing may say otherwise. ADVISORY, like
+   * `media_type_unverifiable` and for the same reason: the step starts. It is the state EVERY
+   * integration registered before capabilities existed is in, so styling it as a refusal would
+   * flag most working selections in the product.
+   */
+  | 'capability_unverifiable'
 
 /** What the builder found wrong with one step's selection, and which ids to name. */
 export interface BinaryOutputPickState {
@@ -457,6 +474,10 @@ export interface BinaryOutputPickState {
    * picker and the brief cannot describe one selection two ways.
    */
   generatorOverlaps: readonly BinaryModalityOverlap[]
+  /** The capabilities the step's generation options need that nothing selected supports. */
+  unsupportedCapabilities: readonly BinaryGeneratorCapability[]
+  /** The ones that could not be judged, kept apart from the refusal above. */
+  unverifiableCapabilities: readonly BinaryGeneratorCapability[]
 }
 
 /**
@@ -482,7 +503,10 @@ export interface BinaryOutputPickState {
  */
 function generatorPickIssues(
   config: BinaryOutputConfig | undefined,
-  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities' | 'mediaTypes'>[],
+  generators: readonly Pick<
+    RegisteredBinaryGenerator,
+    'id' | 'modalities' | 'mediaTypes' | 'capabilities'
+  >[],
   unavailable: boolean,
 ): {
   issues: BinaryOutputPickIssue[]
@@ -491,6 +515,8 @@ function generatorPickIssues(
   uncoveredMediaTypes: string[]
   unverifiableMediaTypes: string[]
   overlaps: BinaryModalityOverlap[]
+  unsupportedCapabilities: BinaryGeneratorCapability[]
+  unverifiableCapabilities: BinaryGeneratorCapability[]
 } {
   const none = {
     unknownGeneratorIds: [],
@@ -498,6 +524,8 @@ function generatorPickIssues(
     uncoveredMediaTypes: [],
     unverifiableMediaTypes: [],
     overlaps: [],
+    unsupportedCapabilities: [],
+    unverifiableCapabilities: [],
   }
   if (unavailable) return { issues: ['generators_unavailable'], ...none }
   const byId = new Map(generators.map((g) => [g.id, g]))
@@ -518,12 +546,21 @@ function generatorPickIssues(
   // one step is the one where neither is the deliverable (an image generated to feed a mesh API),
   // and gating on `modalities` would go silent on exactly that step.
   const overlaps = binaryModalityOverlaps(selected)
+  // The GENERATION OPTIONS, judged against the same resolved selection and through the same
+  // imported rule the brief renders from. The requirement is DERIVED from what the step actually
+  // asks for, so a single reference image is never flagged for lacking `multi-reference`.
+  const capability = binaryCapabilityCoverage(
+    requiredBinaryCapabilities(config?.generation),
+    selected,
+  )
   const issues: BinaryOutputPickIssue[] = []
   if (unknownGeneratorIds.length) issues.push('unknown_generator')
   if (uncovered.length) issues.push('modality_uncovered')
   if (format.uncovered.length) issues.push('media_type_uncovered')
   if (format.unverifiable.length) issues.push('media_type_unverifiable')
   if (overlaps.length) issues.push('generator_overlap')
+  if (capability.uncovered.length) issues.push('capability_unsupported')
+  if (capability.unverifiable.length) issues.push('capability_unverifiable')
   return {
     issues,
     unknownGeneratorIds,
@@ -531,6 +568,8 @@ function generatorPickIssues(
     uncoveredMediaTypes: format.uncovered,
     unverifiableMediaTypes: format.unverifiable,
     overlaps,
+    unsupportedCapabilities: capability.uncovered,
+    unverifiableCapabilities: capability.unverifiable,
   }
 }
 
@@ -565,7 +604,10 @@ export function binaryOutputPickIssues(
   // that registers no integrations cannot satisfy a step that selects one. So a call site that
   // omits this FLAGS a selection rather than passing it — the loud direction — and the default
   // stays a legitimate value rather than a hole.
-  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities' | 'mediaTypes'>[] = [],
+  generators: readonly Pick<
+    RegisteredBinaryGenerator,
+    'id' | 'modalities' | 'mediaTypes' | 'capabilities'
+  >[] = [],
   // Whether the deployment's integrations could not be READ. Defaulted to `false` — the honest
   // default, since every deployment but a mothership-mode node reads them in-process and cannot
   // fail — so an omitting call site judges the list it was given rather than claiming an outage.
@@ -594,6 +636,8 @@ export function binaryOutputPickIssues(
       uncoveredMediaTypes: generative.uncoveredMediaTypes,
       unverifiableMediaTypes: generative.unverifiableMediaTypes,
       generatorOverlaps: generative.overlaps,
+      unsupportedCapabilities: generative.unsupportedCapabilities,
+      unverifiableCapabilities: generative.unverifiableCapabilities,
     }
   }
 
@@ -618,5 +662,7 @@ export function binaryOutputPickIssues(
     uncoveredMediaTypes: generative.uncoveredMediaTypes,
     unverifiableMediaTypes: generative.unverifiableMediaTypes,
     generatorOverlaps: generative.overlaps,
+    unsupportedCapabilities: generative.unsupportedCapabilities,
+    unverifiableCapabilities: generative.unverifiableCapabilities,
   }
 }

package/app/utils/pipelineRender.spec.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect } from 'vitest'
+import { binaryCandidateStatusSchema } from '@cat-factory/contracts'
 import type { ExecutionInstance, PipelineStep } from '~/types/execution'
-import { dedicatedParkView } from './pipelineRender'
+import { missingI18nKeys } from '../../test/i18nKeys'
+import { REDIRECT_PARK_PRESENTATION, dedicatedParkView } from './pipelineRender'
 
 /** A minimal coder step; the predicate only reads approval/followUps/forkDecision. */
 const step = (over: Partial<PipelineStep>): PipelineStep =>
@@ -75,6 +77,26 @@ describe('dedicatedParkView', () => {
     }
   })
 
+  // A generating step parks BETWEEN its candidate pass and its delivering pass. Approving it
+  // generically would mark done a step that has staged files and delivered nothing, so it owns
+  // the park exactly as the fork choice one subject over does.
+  it('owns the candidate park while awaiting a choice', () => {
+    expect(
+      dedicatedParkView(step({ binaryCandidates: { status: 'awaiting_choice' } as never }), run()),
+    ).toBe('binary-candidates')
+  })
+
+  // Derived from the picklist the engine itself writes, rather than a hand-listed set: every
+  // status EXCEPT the parked one must release the step, and a status added to the vocabulary is
+  // then covered here the day it lands instead of quietly falling outside a stale literal list.
+  it('releases the step on every settled status the vocabulary holds', () => {
+    const settled = binaryCandidateStatusSchema.options.filter((s) => s !== 'awaiting_choice')
+    expect(settled.length).toBeGreaterThan(0)
+    for (const status of settled) {
+      expect(dedicatedParkView(step({ binaryCandidates: { status } as never }), run())).toBeNull()
+    }
+  })
+
   it('leaves a plain approval park to the generic rail', () => {
     expect(dedicatedParkView(step({}), run())).toBeNull()
   })
@@ -108,3 +130,26 @@ describe('dedicatedParkView', () => {
     expect(dedicatedParkView(step({ approval: null, state: 'working' }), blocked)).toBeNull()
   })
 })
+
+describe('REDIRECT_PARK_PRESENTATION', () => {
+  // The `Record` over the park vocabulary already proves at COMPILE time that every park has an
+  // entry, which is the whole reason it replaced the ternaries that rendered the fork's copy for
+  // the candidate park. What no type can prove is that an entry still names a key that EXISTS:
+  // a table lookup is invisible to typed message keys and to `i18n:check` alike, so deleting the
+  // catalog entry reads as a clean removal and the button renders its own key path at runtime.
+  it('names catalog keys that resolve', () => {
+    const keys = Object.values(REDIRECT_PARK_PRESENTATION).flatMap((p) => [
+      p.noticeKey,
+      p.actionKey,
+      p.railActionKey,
+    ])
+    expect(missingI18nKeys(keys)).toEqual([])
+  })
+
+  // Two parks pointing at one string is how the bug this table replaced would come back: the
+  // copy would be uniform and wrong again, and every other check would still pass.
+  it('gives each park its own copy', () => {
+    const notices = Object.values(REDIRECT_PARK_PRESENTATION).map((p) => p.noticeKey)
+    expect(new Set(notices).size).toBe(notices.length)
+  })
+})