@cat-factory/app 0.256.3 → 0.258.0

package/app/utils/binaryOutput.ts

@@ -1,12 +1,19 @@
 import {
   ASSET_STORAGE_CAPABILITY,
+  binaryCapabilityCoverage,
   binaryFormatCoverage,
   binaryModalityOverlaps,
+  conflictingOutputSizeOptions,
+  isBinaryModality,
+  modalityCarriesPixelDimensions,
   normalizeMediaType,
+  requiredBinaryCapabilities,
 } from '@cat-factory/contracts'
 import type {
+  BinaryGeneratorCapability,
   BinaryModality,
   BinaryModalityOverlap,
+  ConflictingOutputSizeOption,
   RegisteredBinaryGenerator,
 } from '@cat-factory/contracts'
 import type {
@@ -82,6 +89,35 @@ export interface BinaryOutputRow extends BinaryOutputArtifact {
    * state (a model with native image output generates without a registered integration).
    */
   generatorUnknown: boolean
+  /**
+   * The artifact reports pixel dimensions that are not the exact size the step asked for.
+   *
+   * FALSE when the step asked for no size, false when the size does not cover this artifact (see
+   * {@link sizeRequirementCovers}), and false when the artifact reports no dimensions: the last
+   * is "not stated", which is why {@link BinaryOutputView.sizeUnreported} counts it separately
+   * instead of letting an absent measurement read as a passing one.
+   */
+  missized: boolean
+}
+
+/**
+ * Whether the step's exact size is a statement about THIS artifact.
+ *
+ * A size covers what is measured in pixels, which is the contracts rule
+ * {@link modalityCarriesPixelDimensions} and not a judgement made here: a step selecting an image
+ * generator beside an audio one states one size, means it about the images, and counting the audio
+ * against it would warn permanently about a step that delivered exactly what was asked.
+ *
+ * An artifact whose content type the platform could not classify is COVERED, because absent is not
+ * "not an image": the row may well be one, and excluding it would turn an unclassifiable artifact
+ * into a silent pass on the one axis this requirement exists to check. A RETIRED modality reads the
+ * same way for the same reason, which is why the membership guard runs before the lookup rather
+ * than a bare index that would throw on it.
+ */
+function sizeRequirementCovers(artifact: BinaryOutputArtifact): boolean {
+  const modality = artifact.modality
+  if (modality === undefined || !isBinaryModality(modality)) return true
+  return modalityCarriesPixelDimensions(modality)
 }
 
 /** The whole surface's read model: one state, the join, and every loss the report counted. */
@@ -149,6 +185,31 @@ export interface BinaryOutputView {
    * report with formats required and none reported says so rather than passing.
    */
   undeliveredMediaTypes: readonly string[]
+  /**
+   * The exact pixel size the step asked its pixel-measured generations to be delivered at
+   * (`stepOptions.binaryOutput.generation.outputSize`), or null when it asked for none, which
+   * stays the ordinary case. Which artifacts it covers is {@link sizeRequirementCovers}.
+   */
+  requiredSize: { width: number; height: number } | null
+  /**
+   * How many of {@link rows} reported dimensions OTHER than {@link requiredSize}.
+   *
+   * The delivery-side half of the size requirement, and the reason the requirement is worth
+   * declaring at all. Admission checks what the selected integrations can be ASKED for; only
+   * this checks what came back, exactly as {@link undeliveredMediaTypes} does one axis over and
+   * from the same kind of self-report. Derived in code from the step's own two records, never
+   * read off the agent's prose.
+   */
+  missized: number
+  /**
+   * How many of the COVERED {@link rows} reported no dimensions on a step that required a size.
+   *
+   * Its own number rather than folded into {@link missized}, for the rule this whole feature
+   * runs on: an unmeasured artifact and a wrong-sized one are the same value and opposite facts.
+   * Counting them together would let a run that reported nothing read as a run that delivered
+   * everything wrong, and hiding them would let it read as a clean one.
+   */
+  sizeUnreported: number
   /**
    * Integration ids the AGENT named that the deployment does not register. The generative twin of
    * {@link unknownDeclaredServices}, and it needs no exclusion to stay disjoint from anything —
@@ -200,6 +261,7 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
   const generators = config?.generatorIds ?? []
   const modalities = config?.modalities ?? []
   const mediaTypes = config?.mediaTypes ?? []
+  const requiredSize = config?.generation?.outputSize ?? null
   if (!report) {
     return {
       // A step still queued has not had the chance to record anything, which is a different
@@ -214,6 +276,9 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
       modalities,
       mediaTypes,
       undeliveredMediaTypes: [],
+      requiredSize,
+      missized: 0,
+      sizeUnreported: 0,
       unknownDeclaredGenerators: [],
       generatorsUnverified: false,
       invalidEntries: 0,
@@ -231,6 +296,14 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
     unknown: unknown.has(artifact.service),
     // An UNATTRIBUTED row (no `generator` claimed) is not unknown — see the field's own note.
     generatorUnknown: artifact.generator !== undefined && unknownGenerators.has(artifact.generator),
+    // An UNMEASURED row is not missized either: absent dimensions are counted by
+    // `sizeUnreported`, never folded in here.
+    missized:
+      requiredSize !== null &&
+      sizeRequirementCovers(artifact) &&
+      artifact.dimensions !== undefined &&
+      (artifact.dimensions.width !== requiredSize.width ||
+        artifact.dimensions.height !== requiredSize.height),
   }))
 
   return {
@@ -244,6 +317,12 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
     modalities,
     mediaTypes,
     undeliveredMediaTypes: undeliveredMediaTypes(mediaTypes, rows),
+    requiredSize,
+    missized: rows.filter((row) => row.missized).length,
+    sizeUnreported:
+      requiredSize === null
+        ? 0
+        : rows.filter((row) => row.dimensions === undefined && sizeRequirementCovers(row)).length,
     unknownDeclaredGenerators: report.unknownGenerators,
     generatorsUnverified: report.generatorsUnverified === true,
     invalidEntries: report.invalidEntries,
@@ -359,6 +438,8 @@ export function binaryOutputHasWarnings(view: BinaryOutputView): boolean {
     view.unknownDeclaredGenerators.length > 0 ||
     view.generatorsUnverified ||
     view.undeliveredMediaTypes.length > 0 ||
+    view.missized > 0 ||
+    view.sizeUnreported > 0 ||
     view.invalidEntries > 0 ||
     view.omitted > 0 ||
     view.misdirected > 0
@@ -437,6 +518,31 @@ 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'
+  /**
+   * The step states an exact output size AND another option that restates the delivered
+   * dimensions (`aspectRatio`, `upscale`). A refusal, mirroring `assertUnambiguousOutputSize` at
+   * pipeline save.
+   *
+   * Unlike every member above it this needs no catalog and no registry: it is a fact about the
+   * step's own fields, which is exactly why it belongs here. The builder offers all three controls
+   * at once, so without this line the only report of the conflict is a failed round trip carrying
+   * backend prose, on a surface where the fix is deleting one of two visible fields.
+   */
+  | 'output_size_ambiguous'
 
 /** What the builder found wrong with one step's selection, and which ids to name. */
 export interface BinaryOutputPickState {
@@ -457,6 +563,14 @@ 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[]
+  /** The options restating the delivered dimensions beside an exact size, for the line that names
+   *  which field to delete. Computed through contracts' own rule, so this cannot come to a
+   *  different answer from the save that refuses it. */
+  conflictingSizeOptions: readonly ConflictingOutputSizeOption[]
 }
 
 /**
@@ -482,7 +596,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 +608,8 @@ function generatorPickIssues(
   uncoveredMediaTypes: string[]
   unverifiableMediaTypes: string[]
   overlaps: BinaryModalityOverlap[]
+  unsupportedCapabilities: BinaryGeneratorCapability[]
+  unverifiableCapabilities: BinaryGeneratorCapability[]
 } {
   const none = {
     unknownGeneratorIds: [],
@@ -498,6 +617,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 +639,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 +661,8 @@ function generatorPickIssues(
     uncoveredMediaTypes: format.uncovered,
     unverifiableMediaTypes: format.unverifiable,
     overlaps,
+    unsupportedCapabilities: capability.uncovered,
+    unverifiableCapabilities: capability.unverifiable,
   }
 }
 
@@ -565,7 +697,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.
@@ -578,6 +713,12 @@ export function binaryOutputPickIssues(
   // generative fault too. Reporting them one round at a time is exactly the fix-and-retry cycle
   // this function returns every issue to avoid.
   const generative = generatorPickIssues(config, generators, generatorsUnavailable)
+  // Judged beside the generative half and before the storage early return, because it depends on
+  // neither registry: a step holding two statements of its own dimensions is mis-configured whether
+  // or not its storage pick resolved, and reporting it only on the second pass would cost the
+  // fix-and-retry cycle every other issue here is returned together to avoid.
+  const conflictingSizeOptions = conflictingOutputSizeOptions(config?.generation)
+  if (conflictingSizeOptions.length) issues.push('output_size_ambiguous')
   const noStorageService =
     resolved && !catalog.some((s) => s.capabilities.includes(ASSET_STORAGE_CAPABILITY))
   if (available === false) issues.push('catalog_unavailable')
@@ -594,6 +735,9 @@ export function binaryOutputPickIssues(
       uncoveredMediaTypes: generative.uncoveredMediaTypes,
       unverifiableMediaTypes: generative.unverifiableMediaTypes,
       generatorOverlaps: generative.overlaps,
+      unsupportedCapabilities: generative.unsupportedCapabilities,
+      unverifiableCapabilities: generative.unverifiableCapabilities,
+      conflictingSizeOptions,
     }
   }
 
@@ -618,5 +762,8 @@ export function binaryOutputPickIssues(
     uncoveredMediaTypes: generative.uncoveredMediaTypes,
     unverifiableMediaTypes: generative.unverifiableMediaTypes,
     generatorOverlaps: generative.overlaps,
+    unsupportedCapabilities: generative.unsupportedCapabilities,
+    unverifiableCapabilities: generative.unverifiableCapabilities,
+    conflictingSizeOptions,
   }
 }

package/app/utils/catalog.spec.ts

@@ -12,6 +12,7 @@ import {
   SYSTEM_AGENT_META,
   agentKindMeta,
   blockTypeMeta,
+  mayCarrySkipAxis,
   uid,
 } from '~/utils/catalog'
 
@@ -213,3 +214,26 @@ describe('catalog', () => {
     expect(uid('blk')).not.toBe(uid('blk'))
   })
 })
+
+describe('mayCarrySkipAxis', () => {
+  it('refuses the kinds the run structurally needs', () => {
+    // The builder offers a run condition off this predicate, and the engine refuses the same set
+    // (`assertValidRunConditions`). A condition on `merger` would drop the merge on every run
+    // outside its scope while the pipeline still finished reporting success.
+    for (const kind of ['merger', 'coder', 'ci', 'conflicts', 'deployer']) {
+      expect(mayCarrySkipAxis(kind), kind).toBe(false)
+    }
+  })
+
+  it('allows the kinds whose result later steps read as context', () => {
+    for (const kind of ['tester-ui', 'tester-api', 'architect', 'reviewer']) {
+      expect(mayCarrySkipAxis(kind), kind).toBe(true)
+    }
+  })
+
+  it('allows a DEPLOYMENT-registered kind, whose flag this build cannot see', () => {
+    // Over-offering costs a 422 with an explanatory message; under-offering silently removes a
+    // capability the deployment declared, with nothing on screen to say why.
+    expect(mayCarrySkipAxis('org:auditor')).toBe(true)
+  })
+})

package/app/utils/catalog.ts

@@ -8,6 +8,7 @@ import type {
   TaskTypeMeta,
 } from '~/types/domain'
 import type { BadgeColor } from '~/utils/badge'
+import { isBuiltinGatableKind } from '@cat-factory/contracts'
 
 /** Simple unique id helper (fine for a client-only prototype). */
 export function uid(prefix = 'id'): string {
@@ -153,8 +154,8 @@ export const AGENT_ARCHETYPES: AgentArchetype[] = [
     // Authors the service's in-repo specification from the clarified requirements, so it sits
     // beside the design kinds and ahead of the architect that reads what it wrote. Registered on
     // the backend so it also arrives via the workspace manifest, and modelled statically here for
-    // the same reason `pr-reviewer` is: a `pl_bugfix` / `pl_spec` timeline must name the step
-    // before the manifest hydrates. Mirrors the backend `presentation` in `spec-blueprints.ts`.
+    // the same reason `pr-reviewer` is: a `pl_bugfix` timeline must name the step before the
+    // manifest hydrates. Mirrors the backend `presentation` in `spec-blueprints.ts`.
     kind: 'spec-writer',
     tier: 'intermediate',
     label: 'Spec Writer',
@@ -180,8 +181,8 @@ export const AGENT_ARCHETYPES: AgentArchetype[] = [
   },
   {
     // Refreshes the service → modules map the board projects. Statically modelled beside its
-    // backend `presentation` for the same reason the Spec Writer is: `pl_blueprint` timelines
-    // render before the manifest hydrates.
+    // backend `presentation` for the same reason the Spec Writer is: the single-kind run behind
+    // the board's "Map service" action renders its timeline before the manifest hydrates.
     kind: 'blueprints',
     tier: 'intermediate',
     label: 'Blueprinter',
@@ -864,6 +865,22 @@ export function agentKindMeta(kind: string): AgentArchetype {
   )
 }
 
+/**
+ * Whether the builder may offer a SKIP AXIS (an estimate gate, a run condition) on this kind:
+ * false only where this build KNOWS the answer is no.
+ *
+ * A built-in kind is answered by the shared `BUILTIN_GATABLE_KINDS`. A DEPLOYMENT-registered kind
+ * carries its own `gatable` flag in the agent-kind registry, which the SPA cannot see, so it is
+ * offered rather than withheld — the same direction the pipeline-health advisory takes the
+ * asymmetry, and for the sharper reason: over-offering costs a 422 with an explanatory message at
+ * save, while under-offering silently removes a capability the deployment declared, with no route
+ * to it and nothing on screen to say why.
+ */
+export function mayCarrySkipAxis(kind: string): boolean {
+  const isBuiltin = kind in AGENT_BY_KIND || kind in SYSTEM_AGENT_META
+  return isBuiltin ? isBuiltinGatableKind(kind) : true
+}
+
 /**
  * Whether an agent kind is actually known to this build — a built-in palette
  * archetype or companion ({@link AGENT_BY_KIND}), an engine system/gate kind

package/app/utils/pipeline.spec.ts

@@ -15,6 +15,7 @@ import type { Block, Pipeline } from '~/types/domain'
 import {
   pipelineAllowedForManualStart,
   pipelineAllowedForSchedule,
+  pipelineConditionalCount,
   pipelineDisplaySteps,
   pipelineGateCount,
 } from '~/utils/pipeline'
@@ -43,12 +44,43 @@ describe('pipelineDisplaySteps', () => {
       gates: [false, true, false],
     })
     expect(pipelineDisplaySteps(p)).toEqual([
-      { kind: 'task-estimator', gated: false },
-      { kind: 'coder', gated: true },
-      { kind: 'reviewer', gated: false },
+      { kind: 'task-estimator', gated: false, conditions: [] },
+      { kind: 'coder', gated: true, conditions: [] },
+      { kind: 'reviewer', gated: false, conditions: [] },
     ])
   })
 
+  it('names every reason a step may be skipped, on the step itself', () => {
+    // The two causes are reported separately because a reader acts on them differently: an
+    // estimate gate is a knob on the pipeline, a service condition is a fact about the task.
+    const p = pipeline({
+      agentKinds: ['task-estimator', 'tester-api', 'tester-ui'],
+      gating: [null, { enabled: true, minRisk: 0.3, onMissingEstimate: 'run' }, null],
+      stepOptions: [
+        null,
+        { condition: { serviceScope: 'backend' } },
+        { condition: { serviceScope: 'frontend' } },
+      ],
+    })
+    expect(pipelineDisplaySteps(p).map((s) => s.conditions)).toEqual([
+      [],
+      ['estimate', 'backend'],
+      ['frontend'],
+    ])
+    expect(pipelineConditionalCount(p)).toBe(2)
+  })
+
+  it('LISTS a conditional step rather than filtering it out', () => {
+    // Which conditional steps run is a fact about the TASK, and this preview is read while
+    // choosing a pipeline — before there is a task to answer it. Hiding them understates the
+    // pipeline; listing them silently overstates it, which is what `conditions` fixes.
+    const p = pipeline({
+      agentKinds: ['coder', 'tester-ui'],
+      stepOptions: [null, { condition: { serviceScope: 'frontend' } }],
+    })
+    expect(pipelineDisplaySteps(p).map((s) => s.kind)).toEqual(['coder', 'tester-ui'])
+  })
+
   it('drops steps disabled by default — they never run, so listing them would misdescribe it', () => {
     // The short `enabled` array also pins "no entry ⇒ enabled": `tester` has none and stays.
     const p = pipeline({ agentKinds: ['architect', 'coder', 'tester'], enabled: [false, true] })

package/app/utils/pipeline.ts

@@ -6,18 +6,50 @@ import {
 } from '@cat-factory/contracts'
 import type { AgentKind, Block, BlockLevel, Pipeline } from '~/types/domain'
 
+/**
+ * Why a step in a preview might NOT run on a given task. A step is unconditional when both are
+ * absent, which is the ordinary case.
+ *
+ *  - `estimate`  — an estimate gate (`gating[i]`): the step runs only on a task the earlier
+ *                  `task-estimator` scores above its thresholds.
+ *  - `frontend` / `backend` — a run condition (`stepOptions[i].condition`): the step runs only
+ *                  where the task changes a service of that kind.
+ *
+ * They are DISTINCT rather than one `conditional` flag because a reader acts on them differently:
+ * an estimate gate is a knob on the pipeline (raise the bar, or clear it), while a service
+ * condition is a fact about the task, and nothing about the pipeline will change it.
+ */
+export type StepConditionKind = 'estimate' | 'frontend' | 'backend'
+
 /** One agent step of a pipeline as shown in a preview: its kind + whether it's a human-gated step. */
 export interface PipelineDisplayStep {
   kind: AgentKind
   /** A human approval gate pauses the run after this step (`gates[i]`). */
   gated: boolean
+  /** Every reason this step may be skipped on a given task; empty ⇒ it always runs. */
+  conditions: StepConditionKind[]
+}
+
+/** The reasons the step at `i` may be skipped, in the order a reader meets them. */
+export function stepConditionsAt(pipeline: Pipeline, i: number): StepConditionKind[] {
+  const conditions: StepConditionKind[] = []
+  if (pipeline.gating?.[i]?.enabled) conditions.push('estimate')
+  const scope = pipeline.stepOptions?.[i]?.condition?.serviceScope
+  if (scope) conditions.push(scope)
+  return conditions
 }
 
 /**
  * The steps a pipeline preview should render: the ENABLED steps in order (a step disabled by
  * default — `enabled[i] === false` — is skipped at run, so it would misrepresent the pipeline to
- * list it), each flagged when it carries a human approval gate. Companions are included as their
- * own chips, mirroring how the run timeline lists every step.
+ * list it), each flagged when it carries a human approval gate and with every reason it may be
+ * skipped on a given task. Companions are included as their own chips, mirroring how the run
+ * timeline lists every step.
+ *
+ * A CONDITIONAL step is listed like any other, and says so, rather than being filtered out: which
+ * of them run is a fact about the task, and this preview is read while choosing a pipeline —
+ * before there is a task to answer it. Hiding them would understate what the pipeline does; a
+ * silent full list would overstate it.
  */
 export function pipelineDisplaySteps(pipeline: Pipeline): PipelineDisplayStep[] {
   return pipeline.agentKinds
@@ -25,9 +57,28 @@ export function pipelineDisplaySteps(pipeline: Pipeline): PipelineDisplayStep[]
       kind,
       enabled: pipeline.enabled?.[i] !== false,
       gated: pipeline.gates?.[i] === true,
+      conditions: stepConditionsAt(pipeline, i),
     }))
     .filter((s) => s.enabled)
-    .map(({ kind, gated }) => ({ kind, gated }))
+    .map(({ kind, gated, conditions }) => ({ kind, gated, conditions }))
+}
+
+/**
+ * The marker each condition renders as: its own icon and its own i18n key. Not one shared
+ * "conditional" badge, because the two causes send a reader to different places — an estimate gate
+ * is a knob on the pipeline, a service condition is a fact about the task — and a merged badge
+ * would name neither. Lives here rather than in a component so the builder library and the picker
+ * preview cannot label the same step differently.
+ */
+export const CONDITION_MARKERS: Record<StepConditionKind, { icon: string; key: string }> = {
+  estimate: { icon: 'i-lucide-gauge', key: 'pipeline.preview.conditionEstimate' },
+  frontend: { icon: 'i-lucide-monitor', key: 'pipeline.preview.conditionFrontend' },
+  backend: { icon: 'i-lucide-server', key: 'pipeline.preview.conditionBackend' },
+}
+
+/** How many of a pipeline's displayed steps are conditional (the preview's headline count). */
+export function pipelineConditionalCount(pipeline: Pipeline): number {
+  return pipelineDisplaySteps(pipeline).filter((s) => s.conditions.length > 0).length
 }
 
 /**

package/app/utils/pipelineRender.spec.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect } from 'vitest'
+import { binaryCandidateStatusSchema, stepSkipReasonSchema } 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, stepSkipReasonKey } 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,102 @@ 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)
+  })
+})
+
+describe('stepSkipReasonKey', () => {
+  const skipped = (over: Partial<PipelineStep>): PipelineStep =>
+    ({ agentKind: 'tester-ui', state: 'done', skipped: true, ...over }) as PipelineStep
+
+  it('answers null for a step that ran', () => {
+    expect(stepSkipReasonKey(step({ state: 'done' }))).toBeNull()
+  })
+
+  it('names the axis, and narrows a condition by the scope still on the step', () => {
+    expect(stepSkipReasonKey(skipped({ skipReason: 'gated' }))).toBe(
+      'pipeline.progress.skipped.gated',
+    )
+    expect(stepSkipReasonKey(skipped({ skipReason: 'producer_skipped' }))).toBe(
+      'pipeline.progress.skipped.producerSkipped',
+    )
+    // The condition case reads the scope off the step's own `stepOptions`, so the copy and the
+    // scope it names cannot disagree.
+    expect(
+      stepSkipReasonKey(
+        skipped({
+          skipReason: 'condition',
+          stepOptions: { condition: { serviceScope: 'frontend' } },
+        } as Partial<PipelineStep>),
+      ),
+    ).toBe('pipeline.progress.skipped.conditionFrontend')
+    expect(
+      stepSkipReasonKey(
+        skipped({
+          skipReason: 'condition',
+          stepOptions: { condition: { serviceScope: 'backend' } },
+        } as Partial<PipelineStep>),
+      ),
+    ).toBe('pipeline.progress.skipped.conditionBackend')
+  })
+
+  it('still states the SKIP for a reason this build does not know', () => {
+    // A stored run can name a member since retired, and a browser can be older than the member it
+    // reads. Losing the reason is acceptable; rendering nothing (so the step reads as one that ran
+    // and said nothing) is not, and neither is guessing onto a current member.
+    // Cast through `unknown`: the type is CLOSED, so a retired member is unrepresentable at compile
+    // time and only reachable from persisted data — which is exactly the case being pinned.
+    expect(
+      stepSkipReasonKey(
+        skipped({ skipReason: 'retired_axis' } as unknown as Partial<PipelineStep>),
+      ),
+    ).toBe('pipeline.progress.skipped.unknown')
+    expect(stepSkipReasonKey(skipped({}))).toBe('pipeline.progress.skipped.unknown')
+  })
+
+  it('every reason it can name has copy in the catalog', () => {
+    // Derived from the vocabulary the engine writes rather than a hand-listed set, so a member
+    // added to the picklist is covered here the day it lands instead of falling outside a stale
+    // literal list. The `condition` member fans out into two keys (one per service scope).
+    const keys = stepSkipReasonSchema.options.flatMap((reason) =>
+      reason === 'condition'
+        ? [
+            stepSkipReasonKey(
+              skipped({
+                skipReason: reason,
+                stepOptions: { condition: { serviceScope: 'frontend' } },
+              } as unknown as Partial<PipelineStep>),
+            )!,
+            stepSkipReasonKey(
+              skipped({
+                skipReason: reason,
+                stepOptions: { condition: { serviceScope: 'backend' } },
+              } as unknown as Partial<PipelineStep>),
+            )!,
+          ]
+        : [stepSkipReasonKey(skipped({ skipReason: reason }))!],
+    )
+    expect(keys).toHaveLength(stepSkipReasonSchema.options.length + 1)
+    expect(missingI18nKeys([...keys, 'pipeline.progress.skipped.unknown'])).toEqual([])
+  })
+})