@cat-factory/app 0.257.0 → 0.258.0

package/app/utils/binaryOutput.ts

@@ -3,6 +3,9 @@ import {
   binaryCapabilityCoverage,
   binaryFormatCoverage,
   binaryModalityOverlaps,
+  conflictingOutputSizeOptions,
+  isBinaryModality,
+  modalityCarriesPixelDimensions,
   normalizeMediaType,
   requiredBinaryCapabilities,
 } from '@cat-factory/contracts'
@@ -10,6 +13,7 @@ import type {
   BinaryGeneratorCapability,
   BinaryModality,
   BinaryModalityOverlap,
+  ConflictingOutputSizeOption,
   RegisteredBinaryGenerator,
 } from '@cat-factory/contracts'
 import type {
@@ -85,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. */
@@ -152,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 —
@@ -203,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
@@ -217,6 +276,9 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
       modalities,
       mediaTypes,
       undeliveredMediaTypes: [],
+      requiredSize,
+      missized: 0,
+      sizeUnreported: 0,
       unknownDeclaredGenerators: [],
       generatorsUnverified: false,
       invalidEntries: 0,
@@ -234,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 {
@@ -247,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,
@@ -362,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
@@ -454,6 +532,17 @@ export type BinaryOutputPickIssue =
    * 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 {
@@ -478,6 +567,10 @@ export interface BinaryOutputPickState {
   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[]
 }
 
 /**
@@ -620,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')
@@ -638,6 +737,7 @@ export function binaryOutputPickIssues(
       generatorOverlaps: generative.overlaps,
       unsupportedCapabilities: generative.unsupportedCapabilities,
       unverifiableCapabilities: generative.unverifiableCapabilities,
+      conflictingSizeOptions,
     }
   }
 
@@ -664,5 +764,6 @@ export function binaryOutputPickIssues(
     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,8 +1,8 @@
 import { describe, it, expect } from 'vitest'
-import { binaryCandidateStatusSchema } from '@cat-factory/contracts'
+import { binaryCandidateStatusSchema, stepSkipReasonSchema } from '@cat-factory/contracts'
 import type { ExecutionInstance, PipelineStep } from '~/types/execution'
 import { missingI18nKeys } from '../../test/i18nKeys'
-import { REDIRECT_PARK_PRESENTATION, dedicatedParkView } from './pipelineRender'
+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 =>
@@ -153,3 +153,79 @@ describe('REDIRECT_PARK_PRESENTATION', () => {
     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([])
+  })
+})

package/app/utils/pipelineRender.ts

@@ -3,6 +3,7 @@
 // in one place rather than being re-derived as inline ternaries per component.
 
 import type { AgentState, ExecutionInstance, PipelineStep } from '~/types/execution'
+import { isStepSkipReason } from '@cat-factory/contracts'
 
 /**
  * Visual state of a conditionally-run companion attached to a gate step (today the
@@ -266,6 +267,48 @@ export function containerPhaseLabel(
   return i18n.te(key) ? i18n.t(key) : phase
 }
 
+/**
+ * The i18n key naming WHY a skipped step was skipped, or null when the step ran.
+ *
+ * The engine records a machine-readable {@link StepSkipReason} rather than a sentence, so the
+ * sentence is composed here where it can be translated. The `condition` case narrows further off
+ * the step's own `stepOptions.condition.serviceScope` — the condition stays on the step, so the
+ * copy and the scope it names are read from one place and cannot drift.
+ *
+ * An UNRECOGNISED reason (a stored run naming a member this bundle no longer knows, or a browser
+ * older than the member it reads) falls back to the bare "skipped" line rather than rendering
+ * nothing or guessing onto a current member: what a reader must not lose is that the step did not
+ * run. A `skipped` step with NO reason is the same case — runs predating the field.
+ */
+export function stepSkipReasonKey(step: PipelineStep): string | null {
+  if (!step.skipped) return null
+  if (!isStepSkipReason(step.skipReason)) return 'pipeline.progress.skipped.unknown'
+  switch (step.skipReason) {
+    case 'gated':
+      return 'pipeline.progress.skipped.gated'
+    case 'producer_skipped':
+      return 'pipeline.progress.skipped.producerSkipped'
+    case 'run_complete':
+      return 'pipeline.progress.skipped.runComplete'
+    case 'condition':
+      return step.stepOptions?.condition?.serviceScope === 'frontend'
+        ? 'pipeline.progress.skipped.conditionFrontend'
+        : 'pipeline.progress.skipped.conditionBackend'
+    default:
+      return describeUnhandledSkipReason(step.skipReason)
+  }
+}
+
+/**
+ * The `never` sink that keeps {@link stepSkipReasonKey}'s switch total: adding a member to
+ * `stepSkipReasonSchema` fails the build here until it has copy, while the runtime narrowing above
+ * still renders a RETIRED member honestly.
+ */
+function describeUnhandledSkipReason(reason: never): string {
+  void reason
+  return 'pipeline.progress.skipped.unknown'
+}
+
 /**
  * Tailwind classes for a subtask-item status icon. An in-progress item spins only
  * while the run is live: once the run has failed, a step left mid-flight (its item

package/i18n/locales/de.json

@@ -2116,6 +2116,8 @@
       "priorDocHint": "Aus der vorherigen Prüfung. Verwende es als Basis: bearbeite die Beschreibung oben und reiche erneut ein.",
       "bootstrapping": "Wird initialisiert…",
       "viewRequirements": "Anforderungen anzeigen",
+      "mapService": "Service kartieren",
+      "mapServiceNoRepo": "Verknüpfen Sie zuerst ein Repository mit diesem Service — es gibt noch nichts zu kartieren.",
       "reRun": "Erneut ausführen",
       "run": "Ausführen",
       "focus": "Fokussieren",
@@ -4164,7 +4166,11 @@
     "preview": {
       "stepCount": "{count} Schritt | {count} Schritte",
       "gateCount": "{count} Freigabe | {count} Freigaben",
-      "gated": "Manuelle Freigabe nach diesem Schritt"
+      "gated": "Manuelle Freigabe nach diesem Schritt",
+      "conditionalCount": "{count} bedingter Schritt | {count} bedingte Schritte",
+      "conditionEstimate": "Läuft nur, wenn die Aufwandsschätzung die Schwellenwerte dieses Schritts erreicht",
+      "conditionFrontend": "Läuft nur, wenn die Aufgabe einen Frontend-Service ändert",
+      "conditionBackend": "Läuft nur, wenn die Aufgabe einen Nicht-Frontend-Service ändert"
     },
     "picker": {
       "noneHint": "Keine Standard-Pipeline. Du wählst beim Ausführen der Aufgabe eine aus.",
@@ -4254,6 +4260,11 @@
         "body": "\"{name}\" wird entfernt. Dies kann nicht rückgängig gemacht werden."
       },
       "disabledStepTooltip": "Deaktiviert, wird beim Lauf übersprungen",
+      "condition": {
+        "always": "Läuft bei jeder Aufgabe — klicken, um eine Bedingung zu setzen",
+        "frontend": "Läuft nur bei Aufgaben, die einen Frontend-Service ändern",
+        "backend": "Läuft nur bei Aufgaben, die einen Nicht-Frontend-Service ändern"
+      },
       "cancelEdit": "Bearbeitung abbrechen",
       "clear": "Leeren",
       "update": "Pipeline aktualisieren",
@@ -4339,6 +4350,7 @@
         "negative-prompt": "Negativer Prompt",
         "seed": "Fester Seed",
         "aspect-ratio": "Seitenverhältnis",
+        "exact-size": "Exakte Größe",
         "candidate-batch": "Mehrere Kandidaten pro Aufruf",
         "upscale": "Hochskalierung",
         "transparent-background": "Transparenter Hintergrund",
@@ -4360,6 +4372,11 @@
       "binaryNegativePromptPlaceholder": "was vermieden werden soll",
       "binaryAspectRatio": "Seitenverhältnis",
       "binaryAspectRatioPlaceholder": "16:9",
+      "binaryOutputSize": "Ausgabegröße",
+      "binaryOutputSizeWidth": "Breite",
+      "binaryOutputSizeHeight": "Höhe",
+      "binaryOutputSizeIncomplete": "Nicht gespeichert: eine exakte Größe braucht Breite und Höhe.",
+      "binaryOutputSizeAmbiguous": "Eine exakte Ausgabegröße lässt sich nicht mit {options} kombinieren: beides gibt die gelieferten Maße ein zweites Mal an. Behalte das, was die Anforderung ist.",
       "binarySeed": "Seed",
       "binarySeedPlaceholder": "fester Seed",
       "binaryTransparent": "Transparenter Hintergrund",
@@ -4421,6 +4438,14 @@
       "elapsedTooltip": "Verstrichene Zeit für diesen Schritt",
       "prReview": {
         "review": "Befunde prüfen"
+      },
+      "skipped": {
+        "gated": "Übersprungen: Die Aufgabenschätzung lag unter den Schwellenwerten dieses Schritts.",
+        "conditionFrontend": "Übersprungen: Diese Aufgabe ändert keinen Frontend-Dienst, es gibt also keine Oberfläche zu prüfen.",
+        "conditionBackend": "Übersprungen: Diese Aufgabe ändert nur einen Frontend-Dienst, es gibt also keine API dahinter zu prüfen.",
+        "producerSkipped": "Übersprungen: Der geprüfte Schritt wurde übersprungen, es gibt nichts zu bewerten.",
+        "runComplete": "Übersprungen: Der Lauf endete vor diesem Schritt, es blieb nichts zu tun.",
+        "unknown": "Übersprungen: Dieser Schritt wurde nicht ausgeführt."
       }
     },
     "health": {
@@ -5061,6 +5086,8 @@
       "unknownServices": "Nennt einen Dienst, den der Katalog nicht enthält: {ids}. Der Eintrag bleibt wie angegeben erhalten; prüfe die Kennung gegen den Katalog des Boards. | Nennt Dienste, die der Katalog nicht enthält: {ids}. Die Einträge bleiben wie angegeben erhalten; prüfe die Kennungen gegen den Katalog des Boards.",
       "targetUnknown": "Der Katalog enthält den eigenen Speicherdienst dieses Schritts nicht mehr ({id}), deshalb konnte nichts unten dagegen geprüft werden. Registriere ihn erneut, oder verweise den Schritt auf einen anderen Dienst.",
       "undeliveredMediaTypes": "Dieser Schritt sollte {formats} liefern, und kein Artefakt unten meldet dieses Format. | Dieser Schritt sollte {formats} liefern, und kein Artefakt unten meldet diese Formate.",
+      "missized": "1 Artefakt wurde in einer anderen Größe als {width}×{height} geliefert. | {count} Artefakte wurden in einer anderen Größe als {width}×{height} geliefert.",
+      "sizeUnreported": "1 Artefakt meldet keine Abmessungen, daher konnte seine Größe nicht geprüft werden. | {count} Artefakte melden keine Abmessungen, daher konnten ihre Größen nicht geprüft werden.",
       "misdirected": "1 Artefakt ging an einen anderen Dienst als {target}. | {count} Artefakte gingen an einen anderen Dienst als {target}.",
       "invalidEntries": "1 angegebener Eintrag wurde verworfen: er nannte weder Dienst noch Ablageort. | {count} angegebene Einträge wurden verworfen: sie nannten weder Dienst noch Ablageort.",
       "omitted": "1 weiteres Artefakt wurde jenseits der Berichtsgrenze angegeben und ist nicht aufgeführt. | {count} weitere Artefakte wurden jenseits der Berichtsgrenze angegeben und sind nicht aufgeführt.",
@@ -5068,6 +5095,7 @@
       "generatorsUnverified": "Die generativen Integrationen dieser Installation konnten beim Abschluss des Schritts nicht gelesen werden, daher wurden die unten genannten Integrationen nicht dagegen geprüft. Die Einträge bleiben wie angegeben erhalten."
     },
     "unknownGeneratorBadge": "Nicht registriert",
+    "missizedBadge": "Falsche Größe",
     "candidates": {
       "automatic": "{total} Kandidat wurde erzeugt und ohne Prüfung automatisch behalten.",
       "chosen": "{kept} von {total} erzeugten Kandidaten wurden behalten.",