@cat-factory/app 0.257.0 → 0.258.0

package/app/components/binaryOutput/BinaryOutputReport.vue

@@ -186,6 +186,22 @@ const state = computed(() => {
           </UBadge>
           <span v-if="row.entity">{{ row.entity }}</span>
           <span v-if="row.contentType" class="font-mono">{{ row.contentType }}</span>
+          <!-- What was actually DELIVERED, beside the media type it was delivered as. Rendered
+               whenever the artifact reported it, not only on a step that asked for a size: it is
+               a recorded fact about the asset, and it is the one the counted warning below is
+               made of. Without it that warning gives a number and no way to tell WHICH. -->
+          <span v-if="row.dimensions" class="font-mono" data-testid="binary-output-dimensions"
+            >{{ row.dimensions.width }}×{{ row.dimensions.height }}</span
+          >
+          <UBadge
+            v-if="row.missized"
+            color="warning"
+            variant="subtle"
+            size="sm"
+            data-testid="binary-output-missized-badge"
+          >
+            {{ t('binaryOutput.missizedBadge') }}
+          </UBadge>
         </div>
         <p v-if="row.description" class="mt-1 text-[11px] leading-relaxed text-slate-400">
           {{ row.description }}
@@ -260,6 +276,32 @@ const state = computed(() => {
           )
         }}
       </li>
+      <!-- The same judgement one axis over, on the requirement whose whole point is the delivered
+           pixels. The two size lines stay apart because an artifact that reported no dimensions
+           is not one that came back wrong: only the first can be fixed by asking the step to
+           report, and only the second is evidence the asset is unusable. -->
+      <li v-if="view.missized && view.requiredSize" data-testid="binary-output-missized">
+        {{
+          t(
+            'binaryOutput.warning.missized',
+            {
+              count: view.missized,
+              width: view.requiredSize.width,
+              height: view.requiredSize.height,
+            },
+            view.missized,
+          )
+        }}
+      </li>
+      <li v-if="view.sizeUnreported" data-testid="binary-output-size-unreported">
+        {{
+          t(
+            'binaryOutput.warning.sizeUnreported',
+            { count: view.sizeUnreported },
+            view.sizeUnreported,
+          )
+        }}
+      </li>
       <li v-if="view.misdirected" data-testid="binary-output-misdirected-note">
         {{
           t(

package/app/components/board/AddTaskModal.vue

@@ -32,7 +32,11 @@ import RiskPolicyPicker from '~/components/riskPolicy/RiskPolicyPicker.vue'
 import { parseConflict } from '~/composables/usePipelineErrorToast'
 import { apiErrorEnvelope } from '~/composables/api/errors'
 import type { ReviewTargetReason } from '@cat-factory/contracts'
-import { sanitizeDescriptorFields, validateDescriptorFields } from '@cat-factory/contracts'
+import {
+  defaultBuildPipelineId,
+  sanitizeDescriptorFields,
+  validateDescriptorFields,
+} from '@cat-factory/contracts'
 import { defaultDescriptorValues } from '~/utils/descriptorFields'
 import { pipelineAllowedForManualStart } from '~/utils/pipeline'
 import { buildTaskTypePickerRows } from '~/utils/taskTypePicker'
@@ -405,18 +409,38 @@ const DEFAULT_PIPELINE_FOR_TYPE: Partial<Record<TaskTypeChoice, string>> = {
   document: 'pl_document',
   review: 'pl_review',
 }
+/**
+ * The pipeline a task type opens with: a custom type's registered `defaultPipelineId`, else the
+ * built-in map — and for an ordinary IMPLEMENTATION task (feature / bug / chore, which the map
+ * deliberately does not name), the build rung this interface mode defaults to. Basic mode gets the
+ * fixed Standard build, advanced the Adaptive one; `defaultBuildPipelineId` owns that rule so the
+ * create form and the task card's plain "Start" cannot disagree about it. Empty when the resolved
+ * preset is not in this workspace's library (an older seed, or a retired rung).
+ *
+ * ONE definition, read by both the type watcher and the open-reset. They used to compute it
+ * separately, the reset consulting `DEFAULT_PIPELINE_FOR_TYPE` alone and falling to `''` for every
+ * implementation type — so which default a `feature` opened with depended on whether the previous
+ * session had left the modal on a DIFFERENT type: same type ⇒ the watcher never fired and the
+ * picker opened empty, different type ⇒ it fired (asynchronously, after the reset) and filled it in.
+ */
+function defaultPipelineIdFor(type: TaskTypeChoice): string {
+  const custom = customTaskTypes.value.find((tt) => tt.taskType === type)
+  const preset =
+    custom?.defaultPipelineId ??
+    DEFAULT_PIPELINE_FOR_TYPE[type] ??
+    defaultBuildPipelineId(uiMode.isAdvanced)
+  return pipelines.pipelines.some((p) => p.id === preset) ? preset : ''
+}
+
 watch(taskType, (next) => {
   const custom = customTaskTypes.value.find((tt) => tt.taskType === next)
   // A custom type owns a fresh field bag on every switch (its descriptors differ per type), seeded
   // to whatever defaults the new type declares.
   customFieldValues.value = defaultDescriptorValues(custom?.fields ?? [])
-  // Pre-select the type's default pipeline: a custom type's registered `defaultPipelineId`, else
-  // the built-in map. (For a custom type with no default, `BoardService` applies the registry
-  // default at creation, so leaving the picker unset is fine.)
-  const preset = custom?.defaultPipelineId ?? DEFAULT_PIPELINE_FOR_TYPE[next]
-  if (!preset) return
-  const match = pipelines.pipelines.find((p) => p.id === preset)
-  if (match) pipelineId.value = match.id
+  // An unresolvable preset leaves the current selection alone rather than blanking it: a type
+  // switch is an edit to a form the user is already filling in, not a reset.
+  const preset = defaultPipelineIdFor(next)
+  if (preset) pipelineId.value = preset
 })
 
 // Task-level agent config contributed by the selected pipeline's agents (e.g. the
@@ -537,10 +561,12 @@ watch(open, (isOpen) => {
     delete docKindFieldValues[key]
   riskPolicyId.value = ''
   modelPresetId.value = ''
-  // Seed the pipeline from the (possibly doc-repo-forced) task type's default, so a document
-  // repo opens with `pl_document` pre-selected rather than empty. This runs AFTER the `taskType`
-  // watcher fired during this reset, so it is the authoritative default (see DEFAULT_PIPELINE_FOR_TYPE).
-  pipelineId.value = DEFAULT_PIPELINE_FOR_TYPE[taskType.value] ?? ''
+  // Seed the pipeline from the (possibly doc-repo-forced) task type's default, so a document repo
+  // opens with `pl_document` pre-selected and an ordinary feature with its build rung. Computed
+  // through the shared helper rather than relying on the `taskType` watcher above having run: that
+  // watcher fires only when the type actually CHANGED (and asynchronously, after this block), so
+  // reopening the modal on the type it was last left on would otherwise open the picker empty.
+  pipelineId.value = defaultPipelineIdFor(taskType.value)
   agentConfigValues.value = {}
   pendingContext.value = []
   // Seed from a prefill when opened from another surface (e.g. "create task from

package/app/components/board/RecurringPipelineModal.vue

@@ -141,17 +141,29 @@ const selectedPipeline = computed(() => pipelines.getPipeline(pipelineId.value))
 // description (and so we know to show the tracker config).
 //
 // Only the pipelines whose SHAPE is specific to one kind of recurring work can be inferred this
-// way. `dep-update` no longer can: its pipeline was retired in the catalog collapse (it was the
-// ordinary build tail under a recurring name), so a dependency-update schedule now runs an ordinary
-// build rung — which is also what every generic schedule runs, so inferring the template from it
-// would mislabel all of them. The template itself survives for an explicit API caller; see
-// `scheduleTemplateSchema`.
-const template = computed<ScheduleTemplate>(() => {
-  if (pipelineId.value === 'pl_tech_debt') return 'tech-debt'
-  if (pipelineId.value === 'pl_bug_triage') return 'bug-triage'
-  return 'custom'
+// way, and `bug-triage` is now the only one: `dep-update` and `tech-debt` were both retired from
+// the catalog (the first was the ordinary build tail under a recurring name, the second that tail
+// behind an audit head), so those schedules now run an ordinary build rung — which is also what
+// every generic schedule runs, so inferring a template from it would mislabel all of them. Both
+// templates survive for an explicit API caller; see `scheduleTemplateSchema`.
+const template = computed<ScheduleTemplate>(() =>
+  pipelineId.value === 'pl_bug_triage' ? 'bug-triage' : 'custom',
+)
+/**
+ * Whether the picked pipeline FILES a ticket (an enabled `tracker` step), so the schedule's first
+ * run has somewhere to file it. Read off the pipeline's SHAPE, exactly as `isBugIntake` below is,
+ * rather than off the inferred template: `pl_tech_debt` — the one preset this used to key on — was
+ * retired, and what replaces it is a schedule pointed at a pipeline someone composed with an
+ * `analysis` + `tracker` head. Keying on the id would have offered the tracker config to exactly
+ * the one pipeline that no longer exists, and to none of the pipelines that now do this work.
+ */
+const filesTicket = computed(() => {
+  const pipeline = selectedPipeline.value
+  if (!pipeline) return false
+  return pipeline.agentKinds.some(
+    (kind, i) => kind === 'tracker' && pipeline.enabled?.[i] !== false,
+  )
 })
-const isTechDebt = computed(() => template.value === 'tech-debt')
 
 // A pipeline whose ENABLED steps include `bug-intake` pulls its work from the tracker board, so
 // the intake config is surfaced + required. Mirrors the backend `pipelineHasEnabledBugIntake`
@@ -343,7 +355,7 @@ async function add() {
   try {
     // Persist the tracker selection first when the tech-debt pipeline needs it, so
     // the very first run can file its ticket.
-    if (isTechDebt.value && trackerKind.value) {
+    if (filesTicket.value && trackerKind.value) {
       await tracker.save({
         tracker: trackerKind.value,
         jiraProjectKey: trackerKind.value === 'jira' ? jiraProjectKey.value.trim() : null,
@@ -434,7 +446,7 @@ async function add() {
 
         <RecurringRecurrenceEditor v-if="!onDemand" v-model="recurrence" />
 
-        <div v-if="isTechDebt" class="space-y-3 rounded-lg border border-slate-800 p-3">
+        <div v-if="filesTicket" class="space-y-3 rounded-lg border border-slate-800 p-3">
           <p class="text-[11px] font-semibold uppercase tracking-wide text-slate-400">
             {{ t('board.recurring.issueTracker') }}
           </p>

package/app/components/board/nodes/TaskCard.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import { defaultBuildPipelineId } from '@cat-factory/contracts'
 import type { Block } from '~/types/domain'
 import { STATUS_META, MODULE_META, taskTypeMeta } from '~/utils/catalog'
 import { composeRunOutcome, hasOutcomeToShow } from '~/utils/runOutcome'
@@ -52,6 +53,8 @@ const { start: startConnect } = useDependencyConnect()
 const deps = computed(() =>
   (task.value?.dependsOn ?? []).map((id) => board.getBlock(id)).filter((b): b is Block => !!b),
 )
+const uiMode = useUiModeStore()
+
 /** Deps that haven't merged yet — these block this task from running. */
 const unmet = computed(() => board.unmetDeps(props.taskId))
 const runnable = computed(() => board.isRunnable(props.taskId))
@@ -60,12 +63,37 @@ const runnable = computed(() => board.isRunnable(props.taskId))
 const { depLabel: labelDep } = useDepLabels()
 const depLabel = (dep: Block) => labelDep(dep, task.value?.parentId)
 
-/** The pipeline a plain "Start" will use: the task's pinned pipeline, else the first. */
-const defaultPipeline = computed(
-  () =>
-    (task.value?.pipelineId ? pipelines.getPipeline(task.value.pipelineId) : undefined) ??
-    pipelines.pipelines[0],
-)
+/**
+ * The pipeline a plain "Start" will use: the task's pinned pipeline, else the build rung this
+ * INTERFACE MODE defaults to (`defaultBuildPipelineId` — the fixed Standard build in basic mode,
+ * the Adaptive one in advanced). The workspace's positional first pipeline remains the last
+ * resort, for a board whose catalog does not carry the rung (an older seed, or a deployment that
+ * retired it).
+ *
+ * A PIN is honoured even when the library holds no row for it, and that branch is the whole reason
+ * this returns a descriptor rather than a `Pipeline`. An INTERNAL pipeline is withheld from the
+ * library on purpose (the platform starts it on its own behalf, so no picker may offer it), and a
+ * task can legitimately be pinned to one — the docs-refresh preset spawns its tasks onto
+ * `pl_code_comments`. Resolving that pin through the library alone answers undefined, and the
+ * fallback below then starts a FULL BUILD on a comment-only task while the button still reads as
+ * an ordinary Start. The fallback chain exists for a task with NO pin; a pin the library cannot
+ * show is still the task's answer, and the backend resolves the id for the run.
+ */
+const defaultPipeline = computed<{ id: string; name: string } | undefined>(() => {
+  const pinnedId = task.value?.pipelineId
+  if (pinnedId) {
+    return (
+      pipelines.getPipeline(pinnedId) ?? {
+        id: pinnedId,
+        // The catalog NAME map spans the whole catalog (unlike the versions map), so an internal
+        // pin still names itself here; the generic label covers a pin to something this build's
+        // catalog does not know at all.
+        name: pipelines.catalogNames[pinnedId] ?? t('board.task.pipelineFallback'),
+      }
+    )
+  }
+  return pipelines.getPipeline(defaultBuildPipelineId(uiMode.isAdvanced)) ?? pipelines.pipelines[0]
+})
 
 /** The PR the implementer agent opened for this task, if any. */
 const pr = computed(() => task.value?.pullRequest)
@@ -85,7 +113,6 @@ const prLabel = computed(() =>
  * every section says "nothing here" would teach people the surface is empty. A task marked done
  * by hand, with no pull request and no run, is that task.
  */
-const uiMode = useUiModeStore()
 const outcomeReadable = computed(() => {
   const block = task.value
   if (!block) return false

package/app/components/panels/InspectorPanel.vue

@@ -7,6 +7,7 @@ import { inspectorPanels } from '~/modular/panels/inspector.logic'
 import IconButton from '~/components/common/IconButton.vue'
 import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentStopButton from '~/components/board/AgentStopButton.vue'
+import { BLUEPRINT_AGENT_KIND } from '@cat-factory/contracts'
 import { VCS_PROVIDER_ICONS } from '~/utils/vcs'
 
 const board = useBoardStore()
@@ -244,6 +245,22 @@ const runMenu = computed(() => {
   ]
 })
 
+// Mapping a service: one run of the mapping agent against this frame, started by KIND (no
+// pipeline). The button owns only its in-flight state — a refusal is already surfaced as a toast
+// by the command, and the run itself then reports through the ordinary board/run projection, so
+// there is nothing for this component to remember about it afterwards.
+const mappingService = ref(false)
+async function mapService() {
+  const id = block.value?.id
+  if (!id) return
+  mappingService.value = true
+  try {
+    await execution.startAgentKind(id, BLUEPRINT_AGENT_KIND)
+  } finally {
+    mappingService.value = false
+  }
+}
+
 // Delegate to the shared confirm-gated deletion so the button and the keyboard shortcut
 // (Delete/Backspace) follow the exact same prompt + optimistic-delete + rollback path.
 const { deleteBlock, archiveBlock } = useBlockDeletion()
@@ -514,6 +531,28 @@ const showOriginalDescription = ref(false)
         {{ t('panels.inspector.viewRequirements') }}
       </UButton>
 
+      <!-- service (frame): (re)map the repository into the service → modules blueprint and
+           populate the board. A SINGLE-KIND run of the mapping agent, not a pipeline — the
+           preset that used to wrap this one step is retired. Needs a linked repo to read, so it
+           is disabled (with the reason) until the frame has one. -->
+      <UButton
+        v-if="isFrame"
+        block
+        color="neutral"
+        variant="soft"
+        size="sm"
+        icon="i-lucide-map"
+        :loading="mappingService"
+        :disabled="!serviceRepo || mappingService"
+        :title="serviceRepo ? undefined : t('panels.inspector.mapServiceNoRepo')"
+        @click="mapService"
+      >
+        {{ t('panels.inspector.mapService') }}
+      </UButton>
+      <p v-if="isFrame && !serviceRepo" class="text-[11px] text-slate-500">
+        {{ t('panels.inspector.mapServiceNoRepo') }}
+      </p>
+
       <!-- The level/type-keyed inspector body: the `inspectorPanels` panel group
            (slice 4 of the modular-vue adoption). `<PanelsOutlet>` renders every
            panel whose `when(block)` matches, ordered, with the selected block

package/app/components/pipeline/BinaryOutputStepPicker.logic.spec.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it } from 'vitest'
+import { MAX_BINARY_PIXEL_EXTENT } from '@cat-factory/contracts'
 import {
+  formatExtent,
   formatReferenceImages,
   generationControlOffer,
+  parseExtent,
   parseMediaTypeRequirement,
   parseReferenceImages,
   sameFormats,
@@ -91,6 +94,32 @@ describe('parseReferenceImages', () => {
   })
 })
 
+describe('parseExtent', () => {
+  it('accepts exactly what the save boundary accepts', () => {
+    expect(parseExtent(' 96 ')).toBe(96)
+    expect(parseExtent(String(MAX_BINARY_PIXEL_EXTENT))).toBe(MAX_BINARY_PIXEL_EXTENT)
+  })
+
+  it('refuses everything the schema would refuse, so a typed size is a saveable one', () => {
+    // Including ZERO, which is the one that mattered: an unset half written as 0 stored a config
+    // the schema rejects, so the step became unsaveable behind an opaque validation error and the
+    // untouched field rendered "0" back at whoever had not touched it.
+    expect(parseExtent('0')).toBeNull()
+    expect(parseExtent('-8')).toBeNull()
+    expect(parseExtent('96.5')).toBeNull()
+    expect(parseExtent('wide')).toBeNull()
+    expect(parseExtent(String(MAX_BINARY_PIXEL_EXTENT + 1))).toBeNull()
+  })
+
+  it('reads a blank field as nothing typed', () => {
+    expect(parseExtent('')).toBeNull()
+    expect(parseExtent('   ')).toBeNull()
+    // And the round trip holds: what a stored size renders as is what parses back to it.
+    expect(parseExtent(formatExtent(96))).toBe(96)
+    expect(formatExtent(undefined)).toBe('')
+  })
+})
+
 describe('generationControlOffer', () => {
   const declaring = (...capabilities: string[]) => ({ capabilities }) as never
 

package/app/components/pipeline/BinaryOutputStepPicker.logic.ts

@@ -1,5 +1,6 @@
 import {
   binaryReferenceImageSchema,
+  MAX_BINARY_PIXEL_EXTENT,
   mediaTypeSchema,
   normalizeMediaType,
   requiredBinaryCapabilities,
@@ -111,6 +112,28 @@ export function formatReferenceImages(
     .join('\n')
 }
 
+/**
+ * Read one half of an exact output size out of the field, or null when what is typed is not a
+ * pixel extent the step could carry.
+ *
+ * Held to the SAME bounds the schema holds it to, {@link MAX_BINARY_PIXEL_EXTENT} imported rather
+ * than repeated, so a number this accepts is one the save accepts. Blank is null like anything
+ * else here: the caller's job is to tell "nothing typed yet" from "typed and unusable", and it has
+ * the raw text to do it with.
+ */
+export function parseExtent(raw: string): number | null {
+  const text = raw.trim()
+  if (!text) return null
+  const value = Number(text)
+  if (!Number.isInteger(value) || value < 1 || value > MAX_BINARY_PIXEL_EXTENT) return null
+  return value
+}
+
+/** Render a stored extent back into the text its field shows; absent is an empty field. */
+export function formatExtent(value: number | undefined): string {
+  return value === undefined ? '' : String(value)
+}
+
 /**
  * Build the predicate that decides whether the control for a generation option is OFFERED, given
  * what the step's selected integrations declare and what its stored options already require.

package/app/components/pipeline/BinaryOutputStepPicker.vue

@@ -29,11 +29,14 @@ import {
   type BinaryGeneratorCapability,
   type BinaryModality,
   type BinaryOutputConfig,
+  type ConflictingOutputSizeOption,
 } from '@cat-factory/contracts'
 import { binaryOutputPickIssues, type BinaryOutputPickIssue } from '~/utils/binaryOutput'
 import {
+  formatExtent,
   formatReferenceImages,
   generationControlOffer,
+  parseExtent,
   parseMediaTypeRequirement,
   parseReferenceImages,
   sameFormats,
@@ -262,12 +265,24 @@ const CAPABILITY_LABELS: Record<BinaryGeneratorCapability, () => string> = {
   'negative-prompt': () => t('pipeline.builder.binaryCapability.negative-prompt'),
   seed: () => t('pipeline.builder.binaryCapability.seed'),
   'aspect-ratio': () => t('pipeline.builder.binaryCapability.aspect-ratio'),
+  'exact-size': () => t('pipeline.builder.binaryCapability.exact-size'),
   'candidate-batch': () => t('pipeline.builder.binaryCapability.candidate-batch'),
   upscale: () => t('pipeline.builder.binaryCapability.upscale'),
   'transparent-background': () => t('pipeline.builder.binaryCapability.transparent-background'),
   tileable: () => t('pipeline.builder.binaryCapability.tileable'),
 }
 
+/**
+ * The options that restate a delivered size, named by the FIELD LABEL each one carries in this
+ * form, so the refusal points at a control the reader can see. Static literal keys, the
+ * enum-keyed-set rule again; the union is closed here (not a persisted vocabulary a stale step
+ * could carry a retired member of), so the lookup needs no membership guard.
+ */
+const SIZE_CONFLICT_LABELS: Record<ConflictingOutputSizeOption, () => string> = {
+  aspectRatio: () => t('pipeline.builder.binaryAspectRatio'),
+  upscale: () => t('pipeline.builder.binaryUpscale'),
+}
+
 /**
  * A capability in the reader's language, INCLUDING one this build does not define.
  *
@@ -322,6 +337,44 @@ function setGeneration(fields: Partial<BinaryGenerationOptions>) {
   })
 }
 
+/**
+ * The size fields' own text, held locally like {@link referenceText} and for the same reason: a
+ * control has to render what is being typed, and the step must not store what is being typed.
+ *
+ * The pair is ONE requirement, so it reaches the step only once BOTH halves read as a pixel
+ * extent. Writing the unset half as 0 while the first number is typed would store a value the
+ * schema refuses (the minimum is 1), which makes the step unsaveable behind an opaque validation
+ * error and renders "0" back into a field nobody touched. A half-entered pair is instead simply
+ * not stored, and {@link outputSizeIncomplete} says so where it is being typed.
+ */
+const outputSizeText = ref({
+  width: formatExtent(config.value?.generation?.outputSize?.width),
+  height: formatExtent(config.value?.generation?.outputSize?.height),
+})
+
+watch(
+  () => config.value?.generation?.outputSize,
+  (size) => {
+    outputSizeText.value = { width: formatExtent(size?.width), height: formatExtent(size?.height) }
+  },
+)
+
+/** One half is filled and the other is not, so nothing is stored and the composer is told why. */
+const outputSizeIncomplete = computed(() => {
+  const filled = [outputSizeText.value.width, outputSizeText.value.height].filter(
+    (half) => half.trim() !== '',
+  )
+  return filled.length === 1
+})
+
+/** Patch ONE half of the exact output size, committing the pair only once both halves read. */
+function setOutputSize(axis: 'width' | 'height', raw: string) {
+  outputSizeText.value = { ...outputSizeText.value, [axis]: raw }
+  const width = parseExtent(outputSizeText.value.width)
+  const height = parseExtent(outputSizeText.value.height)
+  setGeneration({ outputSize: width !== null && height !== null ? { width, height } : undefined })
+}
+
 /** The reference-image field's text, and the lines it refused (see `parseReferenceImages`). */
 const referenceText = ref(formatReferenceImages(config.value?.generation?.referenceImages))
 const unusableReferences = ref<string[]>([])
@@ -582,6 +635,48 @@ const declaredFormats = computed(() => {
         />
       </div>
 
+      <!-- Two numbers rather than one free-text "WxH": the requirement is a pair of integers and
+           a parser over a string is a second place for it to be wrong. Offered only where an
+           integration declares `exact-size`, because a bucketed endpoint cannot be asked for
+           dimensions at all and a control implying otherwise is the misconception this axis
+           exists to remove. -->
+      <div v-if="offers('exact-size')" class="flex flex-col gap-1">
+        <div class="flex items-center gap-2">
+          <span class="text-[10px] text-slate-500">{{
+            t('pipeline.builder.binaryOutputSize')
+          }}</span>
+          <UInput
+            class="w-24"
+            type="number"
+            size="xs"
+            :model-value="outputSizeText.width"
+            :placeholder="t('pipeline.builder.binaryOutputSizeWidth')"
+            data-testid="binary-output-size-width"
+            @change="setOutputSize('width', ($event.target as HTMLInputElement).value)"
+          />
+          <span class="text-[10px] text-slate-500">×</span>
+          <UInput
+            class="w-24"
+            type="number"
+            size="xs"
+            :model-value="outputSizeText.height"
+            :placeholder="t('pipeline.builder.binaryOutputSizeHeight')"
+            data-testid="binary-output-size-height"
+            @change="setOutputSize('height', ($event.target as HTMLInputElement).value)"
+          />
+        </div>
+        <!-- Nothing is stored until both halves read, so the half-entered state is stated where
+             it is being typed. Silence there would be a field that looks filled in and a step
+             that does not carry the requirement. -->
+        <p
+          v-if="outputSizeIncomplete"
+          class="text-[10px] text-amber-400"
+          data-testid="binary-output-size-incomplete"
+        >
+          {{ t('pipeline.builder.binaryOutputSizeIncomplete') }}
+        </p>
+      </div>
+
       <div v-if="offers('seed')" class="flex items-center gap-2">
         <span class="text-[10px] text-slate-500">{{ t('pipeline.builder.binarySeed') }}</span>
         <UInput
@@ -786,6 +881,20 @@ const declaredFormats = computed(() => {
         })
       }}
     </p>
+    <!-- A refusal the SAVE makes on the step's own fields, so it is stated here rather than
+         waited for: all three controls are offered together, and the remedy is deleting one of
+         two values on this form. -->
+    <p
+      v-if="has('output_size_ambiguous')"
+      class="text-[10px] text-amber-400"
+      data-testid="binary-output-size-ambiguous"
+    >
+      {{
+        t('pipeline.builder.binaryOutputSizeAmbiguous', {
+          options: pick.conflictingSizeOptions.map((o) => SIZE_CONFLICT_LABELS[o]()).join(', '),
+        })
+      }}
+    </p>
     <!-- ADVISORY, grouped with the other two: an integration that declared no capabilities has
          said only that they are unknown, and every integration registered before this axis
          existed is in exactly that state. Styling it as a refusal would flag most working

package/app/components/pipeline/PipelineBuilder.vue

@@ -12,11 +12,20 @@ import BinaryOutputStepPicker from '~/components/pipeline/BinaryOutputStepPicker
 import { ESTIMATE_AXES, ESTIMATE_AXIS_FIELD, type EstimateAxis } from '~/utils/estimateGating'
 import { showOverrideField } from '~/utils/uiMode'
 import { narrowPipelineLibrary } from '~/utils/pipelineLibrary'
+import { CONDITION_MARKERS, stepConditionsAt } from '~/utils/pipeline'
+
+/** The cycle button's icon per state — the two condition markers, plus the unconditional one. */
+const CONDITION_ICONS = {
+  always: 'i-lucide-infinity',
+  frontend: CONDITION_MARKERS.frontend.icon,
+  backend: CONDITION_MARKERS.backend.icon,
+} as const
 import {
   agentKindMeta,
   companionForProducer,
   isConsensusEligibleKind,
   isTesterKind,
+  mayCarrySkipAxis,
 } from '~/utils/catalog'
 import type { ConsensusStrategy } from '~/types/consensus'
 
@@ -611,6 +620,31 @@ async function clone(p: Pipeline) {
                     "
                     @click="toggleEnabled(unit)"
                   />
+                  <!-- Run condition: restrict this step to tasks that change a frontend
+                     service, or to tasks that change anything else. Cycles through the three
+                     states (see `cycleDraftStepCondition`). Shown in BOTH interface tiers, and
+                     not behind `showOverrideField`: cloning a built-in carries the tester pair's
+                     conditions in, so a control that hid them by default would leave a basic-mode
+                     editor saving a step whose "when does this run" they were never shown.
+
+                     Offered only where the step MAY be skipped at all. A condition is a skip axis,
+                     so the engine holds it to the same gatability rule as an estimate gate
+                     (`assertValidRunConditions`) — without this the builder invited a condition on
+                     `merger` and answered the save with a 422. -->
+                  <UButton
+                    v-if="mayCarrySkipAxis(unit.kind)"
+                    :icon="CONDITION_ICONS[pipelines.draftStepCondition(unit.index) ?? 'always']"
+                    :color="pipelines.draftStepCondition(unit.index) ? 'info' : 'neutral'"
+                    variant="ghost"
+                    size="xs"
+                    :title="
+                      t(
+                        `pipeline.builder.condition.${pipelines.draftStepCondition(unit.index) ?? 'always'}`,
+                      )
+                    "
+                    data-testid="pipeline-step-condition"
+                    @click="pipelines.cycleDraftStepCondition(unit.index)"
+                  />
                   <!-- Approval gate: pause after this step so a human reviews (and
                      can edit) its proposal before the next step runs. -->
                   <UButton
@@ -1308,6 +1342,16 @@ async function clone(p: Pipeline) {
                     i + 1
                   }}</span>
                   <AgentKindIcon :kind="k" show-label />
+                  <!-- A step that does not run on every task says so HERE, in the library, because
+                       this list is what a reader compares two pipelines by: a preset whose testers
+                       are conditional and one whose testers always run look identical otherwise. -->
+                  <UIcon
+                    v-for="c in stepConditionsAt(p, i)"
+                    :key="c"
+                    :name="CONDITION_MARKERS[c].icon"
+                    class="h-3 w-3 shrink-0 text-sky-400"
+                    :title="t(CONDITION_MARKERS[c].key)"
+                  />
                 </li>
               </ol>
             </li>