@cat-factory/app 0.258.2 → 0.259.3

package/app/components/outcome/OutcomeSummaryWindow.logic.spec.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest'
+import { readEnvironmentAgainstClock } from './OutcomeSummaryWindow.logic'
+import type { OutcomeEnvironment } from '~/utils/runOutcome'
+
+/**
+ * The one thing the outcome card decides for itself: whether the TTL the payload carries has
+ * lapsed, and what that changes. The reduction behind the card is clock-free on purpose, so this
+ * is the only place a reader is told an environment is past its expiry, and the failure it
+ * guards is the section's worst one: a green "Live" badge and a working-looking button on a row
+ * whose own expiry date is in the past.
+ */
+const NOW = 1_700_000_000_000
+
+const env = (overrides: Partial<OutcomeEnvironment> = {}): OutcomeEnvironment => ({
+  url: 'https://preview.test',
+  state: 'live',
+  origin: 'deployer',
+  expiresAt: null,
+  retained: false,
+  frameId: 'frm_own',
+  environmentId: 'env_1',
+  detail: null,
+  ...overrides,
+})
+
+describe('readEnvironmentAgainstClock', () => {
+  it('offers a live environment whose TTL has not lapsed', () => {
+    const row = readEnvironmentAgainstClock(env({ expiresAt: NOW + 60_000 }), NOW)
+    expect(row).toMatchObject({ state: 'live', lapsed: false, openable: true })
+  })
+
+  it('withholds the link once the TTL has lapsed, and says the environment expired', () => {
+    const row = readEnvironmentAgainstClock(env({ expiresAt: NOW - 1 }), NOW)
+    expect(row).toMatchObject({ state: 'expired', lapsed: true, openable: false })
+    // The URL survives the lapse: it is what names the environment and what an operator greps.
+    expect(row.url).toBe('https://preview.test')
+  })
+
+  // A run with no disposer and no further polls keeps a `provisioning` row forever, and one
+  // whose TTL then lapsed never came up and never will.
+  it('applies the lapse to an environment still coming up', () => {
+    const row = readEnvironmentAgainstClock(env({ state: 'provisioning', expiresAt: NOW - 1 }), NOW)
+    expect(row).toMatchObject({ state: 'expired', lapsed: true, openable: false })
+  })
+
+  // The clock may only answer the question the payload left open. Where a producer already said
+  // WHERE the environment went, that word is the more specific one and it stands.
+  it('never overwrites a state that already names where the environment went', () => {
+    for (const state of ['failed', 'reclaimed', 'reclaiming'] as const) {
+      const row = readEnvironmentAgainstClock(env({ state, expiresAt: NOW - 1 }), NOW)
+      expect(row).toMatchObject({ state, lapsed: false, openable: false })
+    }
+  })
+
+  // `useNowTick` reads 0 until the card mounts, and every instant in history is "past" the epoch.
+  it('makes no clock-derived claim before the card has a clock', () => {
+    const row = readEnvironmentAgainstClock(env({ expiresAt: NOW - 1 }), 0)
+    expect(row).toMatchObject({ state: 'live', lapsed: false, openable: true })
+  })
+
+  it('offers nothing to click for a live environment that has no URL yet', () => {
+    const row = readEnvironmentAgainstClock(env({ url: null }), NOW)
+    expect(row).toMatchObject({ state: 'live', openable: false })
+  })
+
+  // A run that recorded no TTL is not an expired one: absent and lapsed are opposite facts.
+  it('leaves a row carrying no TTL exactly as the payload states it', () => {
+    expect(readEnvironmentAgainstClock(env(), NOW)).toMatchObject({
+      state: 'live',
+      lapsed: false,
+      openable: true,
+    })
+  })
+})

package/app/components/outcome/OutcomeSummaryWindow.logic.ts

@@ -0,0 +1,63 @@
+// What the outcome card's environment rows say once a CLOCK is applied to them, extracted from
+// `OutcomeSummaryWindow.vue` so the rule can be asserted without mounting the card (see
+// `OutcomeSummaryWindow.logic.spec.ts`).
+//
+// The reduction that produces those rows (`composeRunOutcome`) is deliberately clock-free: the
+// SPA composes it live off its own store and `GET /api/v1/runs/:runId/outcome` composes it
+// server-side, and a rule that read a clock would let the two disagree about one run for as long
+// as their clocks differ. What the payload carries instead is the TTL INSTANT.
+//
+// Somebody still has to say what that instant means now, and it has to be the surface with the
+// clock. Left unapplied, a run whose environment the TTL sweep reclaimed hours ago renders a
+// green "Live" badge and an enabled Open button beside an expiry date in the past: three claims
+// on one row, of which the date is the only true one.
+
+import type { OutcomeEnvironment, OutcomeEnvironmentState } from '~/utils/runOutcome'
+
+/**
+ * The states that describe an environment still STANDING, and so the only ones a lapsed TTL
+ * changes what they say.
+ *
+ * `failed`, `reclaimed` and `reclaiming` already name where the environment went or what is
+ * happening to it. A clock may not overwrite those with a less specific word: an environment
+ * that never came up did not then expire, and saying so would send a reader looking for a TTL
+ * where a provisioning failure is the thing to fix.
+ */
+const STANDING_ENVIRONMENT_STATES = new Set<OutcomeEnvironmentState>(['live', 'provisioning'])
+
+/** One environment row as the card renders it: the payload's own fields, read against a clock. */
+export interface OutcomeEnvironmentRow extends OutcomeEnvironment {
+  /** True when the row's TTL has lapsed against `nowMs` while it still claimed to be standing. */
+  lapsed: boolean
+  /** Whether the card offers the row as something to click. */
+  openable: boolean
+}
+
+/**
+ * Apply the reader's clock to one environment row.
+ *
+ * `nowMs` of 0 means the card has not ticked yet (`useNowTick` reads 0 until mounted). No clock
+ * means no clock-derived claim: the row reads exactly as the payload states it rather than
+ * having every TTL lapse against the epoch.
+ */
+export function readEnvironmentAgainstClock(
+  entry: OutcomeEnvironment,
+  nowMs: number,
+): OutcomeEnvironmentRow {
+  const lapsed =
+    nowMs > 0 &&
+    entry.expiresAt != null &&
+    entry.expiresAt <= nowMs &&
+    STANDING_ENVIRONMENT_STATES.has(entry.state)
+  const state = lapsed ? 'expired' : entry.state
+  return {
+    ...entry,
+    state,
+    lapsed,
+    // A link is offered ONLY for a `live` row: an environment that has been reclaimed, has
+    // expired or never came up still shows its URL (an operator greps for it, and it says which
+    // environment the row is about) and must not be something a designer clicks expecting to see
+    // the change.
+    openable: state === 'live' && Boolean(entry.url),
+  }
+}

package/app/components/outcome/OutcomeSummaryWindow.vue

@@ -16,9 +16,12 @@
 // judged against, which turns the tester's requirement IDS into the TITLES a reader came for.
 import { computed, onUnmounted, ref, watch } from 'vue'
 import type {
+  EnvironmentsGap,
   OutcomeCheckKind,
   OutcomeCheckState,
   OutcomeDisposition,
+  OutcomeEnvironmentOrigin,
+  OutcomeEnvironmentState,
   OutcomeSource,
   OutcomeSpecJoin,
   OutcomeVisual,
@@ -35,6 +38,8 @@ import { REPRODUCTION_STATUS_KEYS } from '~/utils/reproduction'
 import type { RequirementVerdictStatus, TestConcernSeverity } from '~/types/domain'
 import type { TestEnvironment } from '@cat-factory/contracts'
 import { useArtifactBlobs } from '~/composables/useArtifactBlobs'
+import { useNowTick } from '~/composables/useStepTimer'
+import { readEnvironmentAgainstClock } from '~/components/outcome/OutcomeSummaryWindow.logic'
 import ArtifactLightbox from '~/components/media/ArtifactLightbox.vue'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 import MarkdownProse from '~/components/common/MarkdownProse.vue'
@@ -46,7 +51,12 @@ const documents = useDocumentsStore()
 const execution = useExecutionStore()
 const serviceSpec = useServiceSpecStore()
 const ui = useUiStore()
-const { t } = useI18n()
+const { t, d } = useI18n()
+
+// The wall clock this card reads a TTL against. Coarse on purpose: an environment's expiry is
+// the only thing here that moves with time, and a per-second tick would re-render the whole card
+// for a boundary that matters at minute granularity.
+const nowTick = useNowTick(30_000)
 
 // Per-window blob cache for the captured views; revoked on unmount so the (large) image bytes
 // don't outlive the card.
@@ -136,6 +146,38 @@ const SOURCES_GAP_KEYS: Record<SourcesGap, string> = {
   run_unavailable: RUN_UNAVAILABLE_KEY,
   none_linked: 'outcome.sources.gap.none_linked',
 }
+const ENVIRONMENTS_GAP_KEYS: Record<EnvironmentsGap, string> = {
+  run_unavailable: RUN_UNAVAILABLE_KEY,
+  no_environment_step: 'outcome.environments.gap.no_environment_step',
+  not_provisioned: 'outcome.environments.gap.not_provisioned',
+  infraless: 'outcome.environments.gap.infraless',
+}
+const ENVIRONMENT_STATE_KEYS: Record<OutcomeEnvironmentState, string> = {
+  live: 'outcome.environments.state.live',
+  provisioning: 'outcome.environments.state.provisioning',
+  failed: 'outcome.environments.state.failed',
+  reclaiming: 'outcome.environments.state.reclaiming',
+  reclaimed: 'outcome.environments.state.reclaimed',
+  expired: 'outcome.environments.state.expired',
+}
+const ENVIRONMENT_STATE_COLOR: Record<OutcomeEnvironmentState, BadgeColor> = {
+  live: 'success',
+  provisioning: 'info',
+  failed: 'error',
+  reclaiming: 'neutral',
+  reclaimed: 'neutral',
+  expired: 'neutral',
+}
+/**
+ * Where the row came from, said out loud. `projected` is the one that changes what a reader
+ * should conclude (nothing has settled yet, so this row can still move), and the three are
+ * mapped exhaustively so a new producer cannot ship as a blank line.
+ */
+const ENVIRONMENT_ORIGIN_KEYS: Record<OutcomeEnvironmentOrigin, string> = {
+  deployer: 'outcome.environments.origin.deployer',
+  human_test: 'outcome.environments.origin.human_test',
+  projected: 'outcome.environments.origin.projected',
+}
 const VISUALS_GAP_KEYS: Record<VisualsGap, string> = {
   run_unavailable: RUN_UNAVAILABLE_KEY,
   no_visual_step: 'outcome.visuals.gap.no_visual_step',
@@ -337,6 +379,28 @@ const sourceRows = computed(() => {
   }))
 })
 
+/**
+ * The environments the run stood up, with everything the row needs resolved once.
+ *
+ * The TTL is applied HERE rather than in the reduction, and that division is deliberate: the
+ * payload is clock-free so the endpoint's answer and this card's live composition cannot
+ * disagree about one run, and this surface is the one with a clock to say what the instant it
+ * carries means now. The rule itself lives in `OutcomeSummaryWindow.logic.ts`, where it is
+ * asserted without mounting the card.
+ *
+ * The frame is named by its BLOCK title where the board has it. A frame id says nothing to the
+ * person this card is for, so an unresolvable one renders as no label rather than as an id.
+ */
+const environmentRows = computed(() => {
+  const environments = outcome.value?.environments
+  if (!environments || environments.status !== 'reported') return []
+  return environments.entries.map((entry, index) => ({
+    ...readEnvironmentAgainstClock(entry, nowTick.value),
+    key: `${index}:${entry.environmentId ?? entry.url ?? entry.frameId ?? 'env'}`,
+    service: entry.frameId ? (board.getBlock(entry.frameId)?.title ?? null) : null,
+  }))
+})
+
 /** Drill into the full test report (this card is the summary, never a replacement for it). */
 function openTestReport() {
   if (instance.value) ui.openTestEvidence(instance.value.id)
@@ -681,6 +745,78 @@ function openTestReport() {
         </template>
       </section>
 
+      <!-- Where to go and look: the running preview, which is the verification a person who does
+           not read diffs starts from. Beside the captured views on purpose: the shots are what
+           this run saw, this is the thing itself. -->
+      <section class="mb-5" data-testid="outcome-environments">
+        <h3 class="mb-1.5 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+          {{ t('outcome.environments.title') }}
+        </h3>
+        <template v-if="outcome.environments.status === 'reported'">
+          <div
+            v-for="row in environmentRows"
+            :key="row.key"
+            class="mb-2 rounded-md border border-slate-800 bg-slate-950/40 px-2.5 py-2 last:mb-0"
+            data-testid="outcome-environment"
+            :data-state="row.state"
+          >
+            <div class="flex flex-wrap items-center gap-2">
+              <UBadge :color="ENVIRONMENT_STATE_COLOR[row.state]" variant="subtle" size="sm">
+                {{ t(ENVIRONMENT_STATE_KEYS[row.state]) }}
+              </UBadge>
+              <span v-if="row.service" class="truncate text-[12px] text-slate-300">
+                {{ row.service }}
+              </span>
+              <span class="text-[11px] text-slate-500">
+                {{ t(ENVIRONMENT_ORIGIN_KEYS[row.origin]) }}
+              </span>
+            </div>
+            <UButton
+              v-if="row.openable"
+              :to="row.url ?? undefined"
+              target="_blank"
+              rel="noopener"
+              external
+              color="primary"
+              variant="soft"
+              size="xs"
+              class="mt-1.5"
+              icon="i-lucide-external-link"
+              data-testid="outcome-environment-open"
+            >
+              {{ t('outcome.environments.open') }}
+            </UButton>
+            <p
+              v-else-if="row.url"
+              class="mt-1.5 break-all text-[12px] text-slate-500"
+              data-testid="outcome-environment-url"
+            >
+              {{ row.url }}
+            </p>
+            <p v-if="row.retained" class="mt-1 text-[11px] text-slate-400">
+              {{ t('outcome.environments.retained') }}
+            </p>
+            <p v-if="row.expiresAt" class="mt-1 text-[11px] text-slate-500">
+              {{
+                row.lapsed
+                  ? t('outcome.environments.expired', { date: d(new Date(row.expiresAt), 'long') })
+                  : t('outcome.environments.expires', { date: d(new Date(row.expiresAt), 'long') })
+              }}
+            </p>
+            <p
+              v-if="row.detail"
+              class="mt-1 break-words text-[12px] leading-relaxed text-slate-500"
+              data-testid="outcome-environment-detail"
+            >
+              {{ row.detail }}
+            </p>
+          </div>
+        </template>
+        <p v-else class="text-[13px] italic leading-relaxed text-slate-500">
+          {{ t(ENVIRONMENTS_GAP_KEYS[outcome.environments.gap]) }}
+        </p>
+      </section>
+
       <!-- The machine checks, listed only where one actually recorded a verdict. -->
       <section v-if="checkRows.length" data-testid="outcome-checks">
         <h3 class="mb-1.5 text-[11px] font-semibold uppercase tracking-wide text-slate-500">

package/app/components/panels/StepToolServers.logic.ts

@@ -32,6 +32,7 @@ export const REASON_KEY: Record<ToolServerUnavailableReason, string> = {
   oauth_not_connected: 'panels.stepDetail.toolServers.reason.oauthNotConnected',
   oauth_token_failed: 'panels.stepDetail.toolServers.reason.oauthTokenFailed',
   over_budget: 'panels.stepDetail.toolServers.reason.overBudget',
+  consensus_panel: 'panels.stepDetail.toolServers.reason.consensusPanel',
 }
 
 /**
@@ -64,6 +65,7 @@ export const REMEDY_KEY: Record<ToolServerUnavailableReason, string> = {
   oauth_not_connected: 'panels.stepDetail.toolServers.remedy.oauthNotConnected',
   oauth_token_failed: 'panels.stepDetail.toolServers.remedy.oauthTokenFailed',
   over_budget: 'panels.stepDetail.toolServers.remedy.overBudget',
+  consensus_panel: 'panels.stepDetail.toolServers.remedy.consensusPanel',
 }
 
 /** The reason vocabulary as the SCHEMA states it: what a parity assertion grades {@link REASON_KEY} against. */

package/app/components/pipeline/BinaryOutputStepPicker.vue

@@ -29,6 +29,7 @@ import {
   type BinaryGeneratorCapability,
   type BinaryModality,
   type BinaryOutputConfig,
+  type BinaryValueOption,
   type ConflictingOutputSizeOption,
 } from '@cat-factory/contracts'
 import { binaryOutputPickIssues, type BinaryOutputPickIssue } from '~/utils/binaryOutput'
@@ -283,6 +284,17 @@ const SIZE_CONFLICT_LABELS: Record<ConflictingOutputSizeOption, () => string> =
   upscale: () => t('pipeline.builder.binaryUpscale'),
 }
 
+/**
+ * A value option named by the FIELD LABEL it carries on this form, so a refusal about a value
+ * points at the control holding it. Closed and compiled-against on both sides of the wire (unlike
+ * a capability, which a newer mothership can name), so the lookup needs no membership guard.
+ */
+const VALUE_OPTION_LABELS: Record<BinaryValueOption, () => string> = {
+  aspectRatio: () => t('pipeline.builder.binaryAspectRatio'),
+  outputSize: () => t('pipeline.builder.binaryOutputSize'),
+  upscale: () => t('pipeline.builder.binaryUpscale'),
+}
+
 /**
  * A capability in the reader's language, INCLUDING one this build does not define.
  *
@@ -881,6 +893,23 @@ const declaredFormats = computed(() => {
         })
       }}
     </p>
+    <!-- A refusal one notch finer than the one above it: the option is supported everywhere and
+         the VALUE is on nobody's list. It names what IS accepted, because a refusal that only
+         says no leaves the reader guessing at a set the picker is already holding. -->
+    <p
+      v-for="value in pick.unacceptedValues"
+      :key="value.option"
+      class="text-[10px] text-amber-400"
+      data-testid="binary-output-value-unaccepted"
+    >
+      {{
+        t('pipeline.builder.binaryOptionValueUnaccepted', {
+          option: VALUE_OPTION_LABELS[value.option](),
+          requested: value.requested,
+          accepted: value.accepted.join(', '),
+        })
+      }}
+    </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. -->
@@ -910,6 +939,36 @@ const declaredFormats = computed(() => {
         })
       }}
     </p>
+    <!-- ADVISORY, and the one of the three the reader can act on precisely: another selected
+         integration DOES accept the value, so the step starts, and the ones that will not take it
+         are named because dropping or re-routing around them is the whole fix. -->
+    <p
+      v-for="value in pick.partiallyAcceptedValues"
+      :key="value.option"
+      class="text-[10px] text-slate-500"
+      data-testid="binary-output-value-partial"
+    >
+      {{
+        t('pipeline.builder.binaryOptionValuePartial', {
+          option: VALUE_OPTION_LABELS[value.option](),
+          requested: value.requested,
+          generators: value.refusedBy.join(', '),
+        })
+      }}
+    </p>
+    <!-- ADVISORY, grouped with the lines above it: one selected integration refuses the value and
+         another has not said what it takes, so the step starts and is served by the second. -->
+    <p
+      v-if="has('option_value_unverifiable')"
+      class="text-[10px] text-slate-500"
+      data-testid="binary-output-value-unverifiable"
+    >
+      {{
+        t('pipeline.builder.binaryOptionValueUnverifiable', {
+          options: pick.unverifiableValues.map((o) => VALUE_OPTION_LABELS[o]()).join(', '),
+        })
+      }}
+    </p>
     <p
       v-if="unusableMediaTypes.length"
       class="text-[10px] text-amber-400"

package/app/utils/binaryOutput.spec.ts

@@ -521,6 +521,91 @@ describe('binaryOutputPickIssues, generative half', () => {
     expect(pick.conflictingSizeOptions).toEqual(['upscale'])
   })
 
+  // The refusal a value axis adds over the capability one: every selected endpoint takes an
+  // aspect ratio and none of them takes THIS ratio. Stated here because the builder is where the
+  // fix is (pick a listed ratio, or select an integration that renders this one), and because the
+  // set it names is already on the snapshot the picker is holding.
+  it('names a value nothing selected accepts, and what they do accept', () => {
+    const pick = binaryOutputPickIssues(
+      { storageServiceId: 'files', generatorIds: ['bucketed'], generation: { aspectRatio: '7:3' } },
+      catalog,
+      true,
+      [
+        {
+          id: 'bucketed',
+          modalities: ['image' as const],
+          capabilities: ['aspect-ratio' as const],
+          accepts: { aspectRatios: ['1:1', '16:9'] },
+        },
+      ],
+    )
+    expect(pick.issues).toContain('option_value_unaccepted')
+    expect(pick.unacceptedValues).toEqual([
+      { option: 'aspectRatio', requested: '7:3', accepted: ['1:1', '16:9'] },
+    ])
+  })
+
+  // ADVISORY, and the state that keeps the refusal above from firing on a working selection: one
+  // integration refuses the ratio and another has not said what it takes.
+  it('advises rather than refuses when a silent declarer might still serve the value', () => {
+    const pick = binaryOutputPickIssues(
+      {
+        storageServiceId: 'files',
+        generatorIds: ['bucketed', 'open'],
+        generation: { aspectRatio: '7:3' },
+      },
+      catalog,
+      true,
+      [
+        {
+          id: 'bucketed',
+          modalities: ['image' as const],
+          capabilities: ['aspect-ratio' as const],
+          accepts: { aspectRatios: ['1:1', '16:9'] },
+        },
+        { id: 'open', modalities: ['image' as const], capabilities: ['aspect-ratio' as const] },
+      ],
+    )
+    expect(pick.issues).toContain('option_value_unverifiable')
+    expect(pick.issues).not.toContain('option_value_unaccepted')
+    expect(pick.unverifiableValues).toEqual(['aspectRatio'])
+  })
+
+  // ADVISORY too, and the one the reader can act on precisely: one selected endpoint takes the
+  // ratio and another has written down that it does not. Naming the second is the whole remedy,
+  // and it is the finding a first-accepting-declarer short-circuit reported as nothing at all.
+  it('names the integrations that enumerated a value away when another accepts it', () => {
+    const pick = binaryOutputPickIssues(
+      {
+        storageServiceId: 'files',
+        generatorIds: ['wide', 'bucketed'],
+        generation: { aspectRatio: '7:3' },
+      },
+      catalog,
+      true,
+      [
+        {
+          id: 'wide',
+          modalities: ['image' as const],
+          capabilities: ['aspect-ratio' as const],
+          accepts: { aspectRatios: ['7:3', '1:1'] },
+        },
+        {
+          id: 'bucketed',
+          modalities: ['image' as const],
+          capabilities: ['aspect-ratio' as const],
+          accepts: { aspectRatios: ['1:1', '16:9'] },
+        },
+      ],
+    )
+    expect(pick.issues).toContain('option_value_partial')
+    expect(pick.issues).not.toContain('option_value_unaccepted')
+    expect(pick.issues).not.toContain('option_value_unverifiable')
+    expect(pick.partiallyAcceptedValues).toEqual([
+      { option: 'aspectRatio', requested: '7:3', refusedBy: ['bucketed'] },
+    ])
+  })
+
   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.

package/app/utils/binaryOutput.ts

@@ -3,6 +3,7 @@ import {
   binaryCapabilityCoverage,
   binaryFormatCoverage,
   binaryModalityOverlaps,
+  binaryValueCoverage,
   conflictingOutputSizeOptions,
   isBinaryModality,
   modalityCarriesPixelDimensions,
@@ -13,6 +14,9 @@ import type {
   BinaryGeneratorCapability,
   BinaryModality,
   BinaryModalityOverlap,
+  BinaryPartiallyAcceptedValue,
+  BinaryUnacceptedValue,
+  BinaryValueOption,
   ConflictingOutputSizeOption,
   RegisteredBinaryGenerator,
 } from '@cat-factory/contracts'
@@ -532,6 +536,28 @@ export type BinaryOutputPickIssue =
    * flag most working selections in the product.
    */
   | 'capability_unverifiable'
+  /**
+   * A generation option every selected integration can be ASKED for and none of them accepts the
+   * step's VALUE at: a `7:3` aspect ratio against endpoints whose picklists offer ten others
+   * (kernel's `option_value_unaccepted` spelling verbatim, like the members above it). A refusal.
+   */
+  | 'option_value_unaccepted'
+  /**
+   * A selected integration ACCEPTS the step's value and another has enumerated it away, so the
+   * step is servable by part of what it selected and the rest would quietly deliver something
+   * else. ADVISORY, and the reason is the same one that makes a capability covered when a single
+   * integration declares it: which endpoint renders which artifact is the agent's call. What is
+   * NOT optional is naming the ones that refuse it, since routing around them is the whole remedy.
+   */
+  | 'option_value_partial'
+  /**
+   * The step's value is on no stated set, and a selected integration that declares the capability
+   * states no set at all, so it may still be served. ADVISORY, for the reason
+   * `capability_unverifiable` is, and it is deliberately silent where NOBODY states a set: that is
+   * the state every registration is in until an endpoint is audited, and a line that fired there
+   * would ride nearly every step carrying an aspect ratio.
+   */
+  | 'option_value_unverifiable'
   /**
    * The step states an exact output size AND another option that restates the delivered
    * dimensions (`aspectRatio`, `upscale`). A refusal, mirroring `assertUnambiguousOutputSize` at
@@ -567,6 +593,14 @@ export interface BinaryOutputPickState {
   unsupportedCapabilities: readonly BinaryGeneratorCapability[]
   /** The ones that could not be judged, kept apart from the refusal above. */
   unverifiableCapabilities: readonly BinaryGeneratorCapability[]
+  /** The requested option values nothing selected accepts, each with what IS accepted, so the
+   *  message names a value the reader can pick instead of only the one they cannot. */
+  unacceptedValues: readonly BinaryUnacceptedValue[]
+  /** The requested values a selected integration accepts and another enumerated away, naming the
+   *  ones that refuse them, since the remedy is dropping or re-routing around those. */
+  partiallyAcceptedValues: readonly BinaryPartiallyAcceptedValue[]
+  /** The ones a silent declarer left open, kept apart from the refusal above. */
+  unverifiableValues: readonly BinaryValueOption[]
   /** 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. */
@@ -598,7 +632,7 @@ function generatorPickIssues(
   config: BinaryOutputConfig | undefined,
   generators: readonly Pick<
     RegisteredBinaryGenerator,
-    'id' | 'modalities' | 'mediaTypes' | 'capabilities'
+    'id' | 'modalities' | 'mediaTypes' | 'capabilities' | 'accepts'
   >[],
   unavailable: boolean,
 ): {
@@ -610,6 +644,9 @@ function generatorPickIssues(
   overlaps: BinaryModalityOverlap[]
   unsupportedCapabilities: BinaryGeneratorCapability[]
   unverifiableCapabilities: BinaryGeneratorCapability[]
+  unacceptedValues: BinaryUnacceptedValue[]
+  partiallyAcceptedValues: BinaryPartiallyAcceptedValue[]
+  unverifiableValues: BinaryValueOption[]
 } {
   const none = {
     unknownGeneratorIds: [],
@@ -619,6 +656,9 @@ function generatorPickIssues(
     overlaps: [],
     unsupportedCapabilities: [],
     unverifiableCapabilities: [],
+    unacceptedValues: [],
+    partiallyAcceptedValues: [],
+    unverifiableValues: [],
   }
   if (unavailable) return { issues: ['generators_unavailable'], ...none }
   const byId = new Map(generators.map((g) => [g.id, g]))
@@ -646,6 +686,10 @@ function generatorPickIssues(
     requiredBinaryCapabilities(config?.generation),
     selected,
   )
+  // One notch finer: the option is supported and the VALUE is not. Imported like every rule
+  // beside it, so the line this surface shows and the refusal the backend raises are one
+  // judgement rather than two that agree until somebody edits one of them.
+  const value = binaryValueCoverage(config?.generation, selected)
   const issues: BinaryOutputPickIssue[] = []
   if (unknownGeneratorIds.length) issues.push('unknown_generator')
   if (uncovered.length) issues.push('modality_uncovered')
@@ -654,6 +698,9 @@ function generatorPickIssues(
   if (overlaps.length) issues.push('generator_overlap')
   if (capability.uncovered.length) issues.push('capability_unsupported')
   if (capability.unverifiable.length) issues.push('capability_unverifiable')
+  if (value.unaccepted.length) issues.push('option_value_unaccepted')
+  if (value.partial.length) issues.push('option_value_partial')
+  if (value.unverifiable.length) issues.push('option_value_unverifiable')
   return {
     issues,
     unknownGeneratorIds,
@@ -663,6 +710,9 @@ function generatorPickIssues(
     overlaps,
     unsupportedCapabilities: capability.uncovered,
     unverifiableCapabilities: capability.unverifiable,
+    unacceptedValues: value.unaccepted,
+    partiallyAcceptedValues: value.partial,
+    unverifiableValues: value.unverifiable,
   }
 }
 
@@ -699,7 +749,7 @@ export function binaryOutputPickIssues(
   // stays a legitimate value rather than a hole.
   generators: readonly Pick<
     RegisteredBinaryGenerator,
-    'id' | 'modalities' | 'mediaTypes' | 'capabilities'
+    'id' | 'modalities' | 'mediaTypes' | 'capabilities' | 'accepts'
   >[] = [],
   // Whether the deployment's integrations could not be READ. Defaulted to `false` — the honest
   // default, since every deployment but a mothership-mode node reads them in-process and cannot
@@ -737,6 +787,9 @@ export function binaryOutputPickIssues(
       generatorOverlaps: generative.overlaps,
       unsupportedCapabilities: generative.unsupportedCapabilities,
       unverifiableCapabilities: generative.unverifiableCapabilities,
+      unacceptedValues: generative.unacceptedValues,
+      partiallyAcceptedValues: generative.partiallyAcceptedValues,
+      unverifiableValues: generative.unverifiableValues,
       conflictingSizeOptions,
     }
   }
@@ -764,6 +817,9 @@ export function binaryOutputPickIssues(
     generatorOverlaps: generative.overlaps,
     unsupportedCapabilities: generative.unsupportedCapabilities,
     unverifiableCapabilities: generative.unverifiableCapabilities,
+    unacceptedValues: generative.unacceptedValues,
+    partiallyAcceptedValues: generative.partiallyAcceptedValues,
+    unverifiableValues: generative.unverifiableValues,
     conflictingSizeOptions,
   }
 }