@cat-factory/app 0.257.0 → 0.258.0

package/app/stores/pipelines/draftStepConfig.ts

@@ -1,41 +1,19 @@
-import type { BinaryOutputConfig, StepOptions } from '@cat-factory/contracts'
 import type { ConsensusStepConfig } from '~/types/consensus'
 import { defaultConsensusConfig, type PipelinesContext } from './context'
 
 /**
  * The pipeline-builder draft's PER-STEP CONFIG toggles: consensus (inline panel and the workspace
  * consensus-GROUP tier set), the human approval gate, the estimate gate on a companion step, the
- * follow-up and test-QC companions, the per-step enable flag, and the `StepOptions` bag
- * (requirements auto-recommendation, the picked skill, the picked agent-kind variant, the
- * per-step output-token ceiling, the binary-output storage/context selection). The step's GATE
- * configuration is the sibling `./draftGateConfig`, which explains why it is not here.
+ * follow-up and test-QC companions, and the per-step enable flag — every toggle that writes a
+ * PARALLEL ARRAY. The `StepOptions` bag accessors are the sibling `./draftStepOptions`, and the
+ * step's GATE configuration `./draftGateConfig`; each is split along the state it writes rather
+ * than an arbitrary line count.
  *
  * Split out of `./draftActions`, which owns the draft's STRUCTURE (insert / remove / reorder /
  * units). Every function here reads and writes one of the parallel per-step arrays at an index and
  * touches nothing else, which is what makes the two independent; both are spread into the store,
  * so the store's API is unchanged.
  */
-/**
- * Write ONE field of the step's `StepOptions` bag at `index`, merging into whatever else that step
- * carries and normalizing an emptied bag back to `null`. `undefined` CLEARS the field.
- *
- * Every per-step option below goes through this rather than repeating the clone/assign/normalize
- * dance, because the two halves that are easy to get wrong are shared by all of them: replacing
- * the bag loses the neighbouring options a step may also carry, and leaving a `{}` behind makes a
- * step that is back on every default persist a shape it never had.
- */
-function patchStepOption<K extends keyof StepOptions>(
-  draftStepOptions: PipelinesContext['draftStepOptions'],
-  index: number,
-  key: K,
-  value: StepOptions[K] | undefined,
-) {
-  const next: StepOptions = { ...draftStepOptions.value[index] }
-  if (value === undefined) delete next[key]
-  else next[key] = value
-  draftStepOptions.value[index] = Object.keys(next).length ? next : null
-}
-
 export function createPipelineStepConfigActions(ctx: PipelinesContext) {
   const {
     draftGates,
@@ -44,7 +22,6 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     draftGating,
     draftFollowUps,
     draftTesterQuality,
-    draftStepOptions,
   } = ctx
 
   /** Toggle estimate gating on/off for the (companion) step at `index`. */
@@ -128,128 +105,6 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     draftEnabled.value[index] = draftEnabled.value[index] === false
   }
 
-  /** Whether auto-recommendation is on for the draft (requirements-review) step at `index`. */
-  function draftAutoRecommendEnabled(index: number): boolean {
-    return draftStepOptions.value[index]?.autoRecommend !== false
-  }
-
-  /**
-   * Toggle the requirements-review auto-recommendation on the draft step at `index`. It is on by
-   * default, so we store ONLY the opt-out (`{ autoRecommend: false }`); toggling back drops the
-   * flag. Merges with any other future StepOptions fields rather than clobbering the whole bag.
-   */
-  function toggleDraftAutoRecommend(index: number) {
-    const off = draftAutoRecommendEnabled(index) ? false : undefined
-    patchStepOption(draftStepOptions, index, 'autoRecommend', off)
-  }
-
-  /**
-   * Whether the draft `deployer` step at `index` declares that its environments outlive the run
-   * (its `stepOptions.retainEnvironment`). OFF by default: the everyday shape is a run that
-   * reclaims what it stood up, and the save boundary refuses a Deployer that does neither.
-   */
-  function draftRetainEnvironment(index: number): boolean {
-    return draftStepOptions.value[index]?.retainEnvironment === true
-  }
-
-  /**
-   * Toggle the retain declaration on the draft `deployer` step at `index`. It is off by default,
-   * so we store ONLY the opt-in (the mirror of `toggleDraftAutoRecommend`, which stores only the
-   * opt-out); toggling back drops the flag and, if the bag empties, the whole entry.
-   */
-  function toggleDraftRetainEnvironment(index: number) {
-    const on = draftRetainEnvironment(index) ? undefined : true
-    patchStepOption(draftStepOptions, index, 'retainEnvironment', on)
-  }
-
-  /** The skill picked for the draft `skill` step at `index` (its `stepOptions.skillId`). */
-  function draftSkillId(index: number): string | undefined {
-    return draftStepOptions.value[index]?.skillId
-  }
-
-  /**
-   * Set (or clear) the picked skill on the draft `skill` step at `index`. Merges into the
-   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
-   * bag empties, the whole entry (so it normalizes away like the other options).
-   */
-  function setDraftSkillId(index: number, skillId: string | undefined) {
-    patchStepOption(draftStepOptions, index, 'skillId', skillId || undefined)
-  }
-
-  /**
-   * The agent-kind VARIANT picked for the draft step at `index` (its
-   * `stepOptions.agentVariantId`), or undefined when it runs the kind's shipped prompt.
-   */
-  function draftAgentVariantId(index: number): string | undefined {
-    return draftStepOptions.value[index]?.agentVariantId
-  }
-
-  /**
-   * Set (or clear) the picked variant on the draft step at `index`. Merges into the step's
-   * `StepOptions` bag rather than clobbering it; clearing drops the field and, if the bag
-   * empties, the whole entry — exactly like the other options here, so a step back on the
-   * shipped prompt persists nothing.
-   */
-  function setDraftAgentVariantId(index: number, agentVariantId: string | undefined) {
-    patchStepOption(draftStepOptions, index, 'agentVariantId', agentVariantId || undefined)
-  }
-
-  /**
-   * The binary-output SELECTION on the draft step at `index` (its `stepOptions.binaryOutput`) —
-   * the foundational storage service a generator kind's artifacts are stored through, plus any
-   * services consulted for the generation's scope. Undefined on every step of every stock
-   * pipeline; required on a step whose kind carries the `binary-output` trait.
-   */
-  function draftBinaryOutput(index: number): BinaryOutputConfig | undefined {
-    return draftStepOptions.value[index]?.binaryOutput
-  }
-
-  /**
-   * Set (or clear) the binary-output selection on the draft step at `index`. Merges into the
-   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
-   * bag empties, the whole entry — exactly like the other options here, so a step that never
-   * used it persists the shape it always did.
-   *
-   * An EMPTY `contextServiceIds` is dropped rather than stored, for the reason the consensus
-   * tier set drops its own empty array: the field's absence means "no scope service was
-   * selected", while `[]` reads as "context was considered and rejected" — a different claim,
-   * and one the brief renderer would repeat to the agent. `generatorIds` and `modalities` take
-   * the same treatment for the same reason: an absent `generatorIds` means the step generates
-   * through whatever its agent already has, and an absent `modalities` imposes no delivery
-   * requirement — both of which the brief STATES, so persisting `[]` would have it state the
-   * wrong thing.
-   */
-  function setDraftBinaryOutput(index: number, config: BinaryOutputConfig | undefined) {
-    const { storageServiceId, contextServiceIds, generatorIds, modalities } = config ?? {}
-    const selection = storageServiceId
-      ? {
-          storageServiceId,
-          ...(contextServiceIds?.length ? { contextServiceIds } : {}),
-          ...(generatorIds?.length ? { generatorIds } : {}),
-          ...(modalities?.length ? { modalities } : {}),
-        }
-      : undefined
-    patchStepOption(draftStepOptions, index, 'binaryOutput', selection)
-  }
-
-  /**
-   * The output-token ceiling pinned on the draft step at `index`, or undefined when the step
-   * inherits (the workspace's per-kind setting, else the deployment default).
-   */
-  function draftMaxOutputTokens(index: number): number | undefined {
-    return draftStepOptions.value[index]?.maxOutputTokens
-  }
-
-  /**
-   * Set (or clear) this step's own output-token ceiling. Merges into the step's `StepOptions`
-   * bag rather than clobbering it; clearing drops the field and, if the bag empties, the whole
-   * entry — so a step back on the inherited budget persists no options at all, exactly like the
-   * other fields here.
-   */
-  function setDraftMaxOutputTokens(index: number, maxOutputTokens: number | undefined) {
-    patchStepOption(draftStepOptions, index, 'maxOutputTokens', maxOutputTokens ?? undefined)
-  }
-
   return {
     toggleDraftGating,
     toggleDraftConsensus,
@@ -260,17 +115,5 @@ export function createPipelineStepConfigActions(ctx: PipelinesContext) {
     toggleDraftTesterQuality,
     toggleDraftTesterQualityGating,
     toggleDraftEnabled,
-    draftAutoRecommendEnabled,
-    toggleDraftAutoRecommend,
-    draftRetainEnvironment,
-    toggleDraftRetainEnvironment,
-    draftSkillId,
-    setDraftSkillId,
-    draftAgentVariantId,
-    setDraftAgentVariantId,
-    draftBinaryOutput,
-    setDraftBinaryOutput,
-    draftMaxOutputTokens,
-    setDraftMaxOutputTokens,
   }
 }

package/app/stores/pipelines/draftStepOptions.ts

@@ -0,0 +1,204 @@
+import type { BinaryOutputConfig, StepOptions, StepServiceScope } from '@cat-factory/contracts'
+import type { PipelinesContext } from './context'
+
+/**
+ * The pipeline-builder draft's `StepOptions` BAG accessors: every per-step parameter that lives in
+ * the one extensible options object rather than in a parallel array of its own — the requirements
+ * auto-recommendation, the Deployer's retain declaration, the step's run CONDITION, the picked
+ * skill, the picked agent-kind variant, the binary-output selection, and the per-step output-token
+ * ceiling.
+ *
+ * Its own module for the reason `./draftGateConfig` is: the sibling `./draftStepConfig` owns the
+ * per-step TOGGLES that each write a parallel array, while every function here reads and writes
+ * one FIELD of one bag through {@link patchStepOption}. The split is along that seam rather than
+ * an arbitrary line count, so a new per-step knob has an obvious home — and since the bag is the
+ * declared home for every NEW knob, this is the half that keeps growing.
+ */
+
+/**
+ * Write ONE field of the step's `StepOptions` bag at `index`, merging into whatever else that step
+ * carries and normalizing an emptied bag back to `null`. `undefined` CLEARS the field.
+ *
+ * Every per-step option below goes through this rather than repeating the clone/assign/normalize
+ * dance, because the two halves that are easy to get wrong are shared by all of them: replacing
+ * the bag loses the neighbouring options a step may also carry, and leaving a `{}` behind makes a
+ * step that is back on every default persist a shape it never had.
+ */
+function patchStepOption<K extends keyof StepOptions>(
+  draftStepOptions: PipelinesContext['draftStepOptions'],
+  index: number,
+  key: K,
+  value: StepOptions[K] | undefined,
+) {
+  const next: StepOptions = { ...draftStepOptions.value[index] }
+  if (value === undefined) delete next[key]
+  else next[key] = value
+  draftStepOptions.value[index] = Object.keys(next).length ? next : null
+}
+
+export function createPipelineStepOptionActions(ctx: PipelinesContext) {
+  const { draftStepOptions } = ctx
+
+  /** Whether auto-recommendation is on for the draft (requirements-review) step at `index`. */
+  function draftAutoRecommendEnabled(index: number): boolean {
+    return draftStepOptions.value[index]?.autoRecommend !== false
+  }
+
+  /**
+   * Toggle the requirements-review auto-recommendation on the draft step at `index`. It is on by
+   * default, so we store ONLY the opt-out (`{ autoRecommend: false }`); toggling back drops the
+   * flag. Merges with any other future StepOptions fields rather than clobbering the whole bag.
+   */
+  function toggleDraftAutoRecommend(index: number) {
+    const off = draftAutoRecommendEnabled(index) ? false : undefined
+    patchStepOption(draftStepOptions, index, 'autoRecommend', off)
+  }
+
+  /**
+   * Whether the draft `deployer` step at `index` declares that its environments outlive the run
+   * (its `stepOptions.retainEnvironment`). OFF by default: the everyday shape is a run that
+   * reclaims what it stood up, and the save boundary refuses a Deployer that does neither.
+   */
+  function draftRetainEnvironment(index: number): boolean {
+    return draftStepOptions.value[index]?.retainEnvironment === true
+  }
+
+  /**
+   * Toggle the retain declaration on the draft `deployer` step at `index`. It is off by default,
+   * so we store ONLY the opt-in (the mirror of `toggleDraftAutoRecommend`, which stores only the
+   * opt-out); toggling back drops the flag and, if the bag empties, the whole entry.
+   */
+  function toggleDraftRetainEnvironment(index: number) {
+    const on = draftRetainEnvironment(index) ? undefined : true
+    patchStepOption(draftStepOptions, index, 'retainEnvironment', on)
+  }
+
+  /**
+   * The RUN CONDITION on the draft step at `index` — the service scope it applies to, or
+   * `undefined` when it runs on every task (`stepOptions.condition`).
+   */
+  function draftStepCondition(index: number): StepServiceScope | undefined {
+    return draftStepOptions.value[index]?.condition?.serviceScope
+  }
+
+  /**
+   * Cycle the draft step's run condition: unconditional → frontend-only → backend-only →
+   * unconditional.
+   *
+   * A CYCLE rather than a picker because the states are three and mutually exclusive, and the
+   * control has to live in a dense per-step icon row beside eight others. It cycles back to
+   * unconditional deliberately: a condition arrives on a step by CLONING a built-in (the tester
+   * pair), so the state a user most needs to reach from here is the one that clears it.
+   */
+  function cycleDraftStepCondition(index: number) {
+    const current = draftStepCondition(index)
+    const next: StepServiceScope | undefined =
+      current === undefined ? 'frontend' : current === 'frontend' ? 'backend' : undefined
+    patchStepOption(draftStepOptions, index, 'condition', next ? { serviceScope: next } : undefined)
+  }
+
+  /** The skill picked for the draft `skill` step at `index` (its `stepOptions.skillId`). */
+  function draftSkillId(index: number): string | undefined {
+    return draftStepOptions.value[index]?.skillId
+  }
+
+  /**
+   * Set (or clear) the picked skill on the draft `skill` step at `index`. Merges into the
+   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
+   * bag empties, the whole entry (so it normalizes away like the other options).
+   */
+  function setDraftSkillId(index: number, skillId: string | undefined) {
+    patchStepOption(draftStepOptions, index, 'skillId', skillId || undefined)
+  }
+
+  /**
+   * The agent-kind VARIANT picked for the draft step at `index` (its
+   * `stepOptions.agentVariantId`), or undefined when it runs the kind's shipped prompt.
+   */
+  function draftAgentVariantId(index: number): string | undefined {
+    return draftStepOptions.value[index]?.agentVariantId
+  }
+
+  /**
+   * Set (or clear) the picked variant on the draft step at `index`. Merges into the step's
+   * `StepOptions` bag rather than clobbering it; clearing drops the field and, if the bag
+   * empties, the whole entry — exactly like the other options here, so a step back on the
+   * shipped prompt persists nothing.
+   */
+  function setDraftAgentVariantId(index: number, agentVariantId: string | undefined) {
+    patchStepOption(draftStepOptions, index, 'agentVariantId', agentVariantId || undefined)
+  }
+
+  /**
+   * The binary-output SELECTION on the draft step at `index` (its `stepOptions.binaryOutput`) —
+   * the foundational storage service a generator kind's artifacts are stored through, plus any
+   * services consulted for the generation's scope. Undefined on every step of every stock
+   * pipeline; required on a step whose kind carries the `binary-output` trait.
+   */
+  function draftBinaryOutput(index: number): BinaryOutputConfig | undefined {
+    return draftStepOptions.value[index]?.binaryOutput
+  }
+
+  /**
+   * Set (or clear) the binary-output selection on the draft step at `index`. Merges into the
+   * step's `StepOptions` bag rather than clobbering it; clearing drops the field and, if the
+   * bag empties, the whole entry — exactly like the other options here, so a step that never
+   * used it persists the shape it always did.
+   *
+   * An EMPTY `contextServiceIds` is dropped rather than stored, for the reason the consensus
+   * tier set drops its own empty array: the field's absence means "no scope service was
+   * selected", while `[]` reads as "context was considered and rejected" — a different claim,
+   * and one the brief renderer would repeat to the agent. `generatorIds` and `modalities` take
+   * the same treatment for the same reason: an absent `generatorIds` means the step generates
+   * through whatever its agent already has, and an absent `modalities` imposes no delivery
+   * requirement — both of which the brief STATES, so persisting `[]` would have it state the
+   * wrong thing.
+   */
+  function setDraftBinaryOutput(index: number, config: BinaryOutputConfig | undefined) {
+    const { storageServiceId, contextServiceIds, generatorIds, modalities } = config ?? {}
+    const selection = storageServiceId
+      ? {
+          storageServiceId,
+          ...(contextServiceIds?.length ? { contextServiceIds } : {}),
+          ...(generatorIds?.length ? { generatorIds } : {}),
+          ...(modalities?.length ? { modalities } : {}),
+        }
+      : undefined
+    patchStepOption(draftStepOptions, index, 'binaryOutput', selection)
+  }
+
+  /**
+   * The output-token ceiling pinned on the draft step at `index`, or undefined when the step
+   * inherits (the workspace's per-kind setting, else the deployment default).
+   */
+  function draftMaxOutputTokens(index: number): number | undefined {
+    return draftStepOptions.value[index]?.maxOutputTokens
+  }
+
+  /**
+   * Set (or clear) this step's own output-token ceiling. Merges into the step's `StepOptions`
+   * bag rather than clobbering it; clearing drops the field and, if the bag empties, the whole
+   * entry — so a step back on the inherited budget persists no options at all, exactly like the
+   * other fields here.
+   */
+  function setDraftMaxOutputTokens(index: number, maxOutputTokens: number | undefined) {
+    patchStepOption(draftStepOptions, index, 'maxOutputTokens', maxOutputTokens ?? undefined)
+  }
+
+  return {
+    draftAutoRecommendEnabled,
+    toggleDraftAutoRecommend,
+    draftRetainEnvironment,
+    toggleDraftRetainEnvironment,
+    draftStepCondition,
+    cycleDraftStepCondition,
+    draftSkillId,
+    setDraftSkillId,
+    draftAgentVariantId,
+    setDraftAgentVariantId,
+    draftBinaryOutput,
+    setDraftBinaryOutput,
+    draftMaxOutputTokens,
+    setDraftMaxOutputTokens,
+  }
+}

package/app/types/domain.ts

@@ -164,6 +164,12 @@ export interface AgentArchetype {
    * which is every built-in kind.
    */
   binaryOutput?: boolean
+  /**
+   * The platform dispatches this kind for a flow of its own, so the builder palette never offers
+   * it as a placeable block (`narrowAgentPalette` drops it). It still resolves through
+   * `agentKindMeta`, because a run of it has to RENDER. Absent ⇒ an ordinary palette block.
+   */
+  internal?: boolean
 }
 
 /**

package/app/utils/agentPalette.spec.ts

@@ -33,6 +33,32 @@ const CATALOG: AgentArchetype[] = [
   archetype('acme-auditor'),
 ]
 
+describe('narrowAgentPalette — internal kinds', () => {
+  // An INTERNAL kind is one the platform dispatches for a flow of its own (the environment
+  // analyst, which hands its draft to the setup wizard). It is not hidden by a dial, it is not a
+  // palette block at all.
+  const internal: AgentArchetype = {
+    ...archetype('environment-analyst', 'design', 'basic'),
+    internal: true,
+  }
+  const catalog = [archetype('architect', 'design', 'basic'), internal]
+
+  it('never offers one, at any purpose or tier', () => {
+    for (const tier of ['basic', 'intermediate', 'advanced'] as const) {
+      const { offered } = narrowAgentPalette(catalog, 'build', tier)
+      expect(offered.map((a) => a.kind)).toEqual(['architect'])
+    }
+  })
+
+  it('counts one against NEITHER dial, so no hint promises a control that would reveal it', () => {
+    // The whole point of the counts is "relax THIS dial and you get n more". An internal kind is
+    // revealed by neither, so counting it would send a reader chasing a control that cannot help.
+    const { hiddenByPurpose, hiddenByTier } = narrowAgentPalette(catalog, 'review', 'basic')
+    expect(hiddenByPurpose).toBe(1) // the architect alone: a review pipeline designs nothing
+    expect(hiddenByTier).toBe(0)
+  })
+})
+
 describe('narrowAgentPalette', () => {
   it('narrows nothing for a build pipeline at the widest tier', () => {
     const { offered, hiddenByPurpose, hiddenByTier } = narrowAgentPalette(

package/app/utils/agentPalette.ts

@@ -44,14 +44,19 @@ export interface NarrowedAgentPalette<T> {
  * nothing behaves, and none of them is a reason to drop it from the catalog.
  */
 export function narrowAgentPalette<
-  T extends Pick<AgentArchetype, 'tier' | 'category' | 'purposes'>,
+  T extends Pick<AgentArchetype, 'tier' | 'category' | 'purposes' | 'internal'>,
 >(archetypes: readonly T[], purpose: PipelinePurpose, tier: AgentTier): NarrowedAgentPalette<T> {
+  // INTERNAL kinds are removed BEFORE either dial, and are counted by neither. They are not
+  // hidden, they are not placeable at all: the platform dispatches them for a flow of its own
+  // (the environment analyst hands its draft to the setup wizard), so counting one as
+  // "3 more at the widest tier" would send a reader to a dial that will never reveal it.
+  const placeable = archetypes.filter((a) => !a.internal)
   const relevant = (a: T) => purposeSuggestsAgentKind(purpose, a)
   const inTier = (a: T) => agentTierVisibleAt(a.tier, tier)
   return {
-    offered: archetypes.filter((a) => relevant(a) && inTier(a)),
-    hiddenByPurpose: archetypes.filter((a) => inTier(a) && !relevant(a)).length,
-    hiddenByTier: archetypes.filter((a) => relevant(a) && !inTier(a)).length,
+    offered: placeable.filter((a) => relevant(a) && inTier(a)),
+    hiddenByPurpose: placeable.filter((a) => inTier(a) && !relevant(a)).length,
+    hiddenByTier: placeable.filter((a) => relevant(a) && !inTier(a)).length,
   }
 }
 

package/app/utils/binaryOutput.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import type { BinaryOutputReport, PipelineStep } from '~/types/execution'
+import type { BinaryOutputArtifact, BinaryOutputReport, PipelineStep } from '~/types/execution'
 import {
   BINARY_OUTPUT_STATE_KEYS,
   binaryOutputHasWarnings,
@@ -371,6 +371,95 @@ describe('the delivered-format check', () => {
   })
 })
 
+// The size axis's delivery-side half. Admission checked what the selected integrations can be
+// ASKED for; only this checks what came back, which is the failure the requirement exists for:
+// an asset stored at the wrong size passes every other check on this panel.
+describe('binaryOutputView, the delivered size', () => {
+  const sized = (
+    outputSize: { width: number; height: number } | undefined,
+    stored: {
+      location: string
+      dimensions?: { width: number; height: number }
+      modality?: BinaryOutputArtifact['modality']
+    }[],
+  ) =>
+    binaryOutputView(
+      step({
+        stepOptions: {
+          binaryOutput: {
+            storageServiceId: 'files',
+            ...(outputSize ? { generation: { outputSize } } : {}),
+          },
+        },
+        binaryOutputs: report({
+          stored: stored.map((entry) => ({ service: 'files', ...entry })),
+        }),
+      }),
+    )
+
+  it('counts an artifact delivered at another size, and marks its row', () => {
+    const view = sized({ width: 96, height: 96 }, [
+      { location: 'a.png', dimensions: { width: 96, height: 96 } },
+      { location: 'b.png', dimensions: { width: 1024, height: 1024 } },
+    ])
+    expect(view?.requiredSize).toEqual({ width: 96, height: 96 })
+    expect(view?.missized).toBe(1)
+    expect(view?.rows.map((row) => row.missized)).toEqual([false, true])
+    expect(binaryOutputHasWarnings(view!)).toBe(true)
+  })
+
+  it('counts an UNMEASURED artifact apart, never as a delivered one', () => {
+    // The rule this whole feature runs on: "we were not told" and "it came back wrong" are the
+    // same value and opposite facts. Folded together, a run that reported nothing would read as
+    // one that delivered everything wrong; dropped, it would read as a clean one.
+    const view = sized({ width: 96, height: 96 }, [{ location: 'a.png' }])
+    expect(view?.missized).toBe(0)
+    expect(view?.sizeUnreported).toBe(1)
+    expect(binaryOutputHasWarnings(view!)).toBe(true)
+  })
+
+  it('judges nothing when the step asked for no size', () => {
+    const view = sized(undefined, [
+      { location: 'a.png', dimensions: { width: 1024, height: 1024 } },
+      { location: 'b.png' },
+    ])
+    expect(view?.requiredSize).toBeNull()
+    expect(view?.missized).toBe(0)
+    expect(view?.sizeUnreported).toBe(0)
+    expect(binaryOutputHasWarnings(view!)).toBe(false)
+  })
+
+  // A size is a statement about what is MEASURED in pixels. A step that generates the icon and
+  // its pickup sound delivered exactly what was asked, and counting the audio as unmeasured
+  // would warn about it forever, on a panel whose whole discipline is that a warning means
+  // something went wrong.
+  it('says nothing about an artifact a size cannot describe', () => {
+    const view = sized({ width: 96, height: 96 }, [
+      { location: 'a.png', modality: 'image', dimensions: { width: 96, height: 96 } },
+      { location: 'a.mp3', modality: 'audio' },
+      { location: 'a.glb', modality: '3d-model' },
+    ])
+    expect(view?.missized).toBe(0)
+    expect(view?.sizeUnreported).toBe(0)
+    expect(binaryOutputHasWarnings(view!)).toBe(false)
+  })
+
+  // The other direction, and the one that must not go quiet: an artifact the platform could not
+  // CLASSIFY may well be an image, so it stays covered. Excluding it would turn an unreadable
+  // content type into a silent pass on the one axis the requirement exists to check, and a
+  // RETIRED modality a stale run carries reads the same way.
+  it('keeps an unclassified artifact under the requirement', () => {
+    const view = sized({ width: 96, height: 96 }, [
+      { location: 'a.bin' },
+      // A modality the union no longer has, which a run saved before the 3D split goes on
+      // carrying. Cast because the TYPE cannot express it and the DATA can, which is the whole
+      // reason the read narrows through `isBinaryModality` before it looks anything up.
+      { location: 'b.bin', modality: '3d' as BinaryOutputArtifact['modality'] },
+    ])
+    expect(view?.sizeUnreported).toBe(2)
+  })
+})
+
 describe('binaryOutputPickIssues, generative half', () => {
   const catalog = [{ id: 'files', capabilities: ['asset-storage'] }]
   const generators = [
@@ -400,6 +489,38 @@ describe('binaryOutputPickIssues, generative half', () => {
     expect(pick.uncoveredModalities).toEqual(['audio'])
   })
 
+  // The builder offers a ratio, an exact size and an upscale together, so the conflict it can
+  // save is one it must state: reported only by the failed round trip, the fix (delete one of two
+  // fields on this form) arrives as backend prose about a step the reader has already left.
+  it('states the save refusal for two statements of one delivered size', () => {
+    const pick = binaryOutputPickIssues(
+      {
+        storageServiceId: 'files',
+        generatorIds: ['retro'],
+        generation: { outputSize: { width: 96, height: 96 }, aspectRatio: '16:9' },
+      },
+      catalog,
+      true,
+      generators,
+    )
+    expect(pick.issues).toContain('output_size_ambiguous')
+    expect(pick.conflictingSizeOptions).toEqual(['aspectRatio'])
+  })
+
+  // A step with no storage pick still gets the whole list: the two halves resolve against
+  // different registries, and reporting them one round at a time is the retry cycle this
+  // function returns every issue together to avoid.
+  it('states it on a step whose storage is not picked either', () => {
+    const pick = binaryOutputPickIssues(
+      { storageServiceId: '', generation: { outputSize: { width: 96, height: 96 }, upscale: 2 } },
+      catalog,
+      true,
+      generators,
+    )
+    expect(pick.issues).toEqual(expect.arrayContaining(['not_selected', 'output_size_ambiguous']))
+    expect(pick.conflictingSizeOptions).toEqual(['upscale'])
+  })
+
   it('reports BOTH faults when an unknown id was the one covering a requirement', () => {
     // One edit should clear the step. Naming only the missing id would leave the user to
     // discover the uncovered requirement on the next round trip.