@cat-factory/app 0.256.3 → 0.257.0

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

@@ -1,4 +1,12 @@
-import { mediaTypeSchema, normalizeMediaType } from '@cat-factory/contracts'
+import {
+  binaryReferenceImageSchema,
+  mediaTypeSchema,
+  normalizeMediaType,
+  requiredBinaryCapabilities,
+  type BinaryGenerationOptions,
+  type BinaryGeneratorCapability,
+  type BinaryReferenceImage,
+} from '@cat-factory/contracts'
 import * as v from 'valibot'
 
 // The pure half of BinaryOutputStepPicker: reading a free-text FORMAT requirement, and telling
@@ -53,3 +61,86 @@ export function sameFormats(
 ): boolean {
   return (a ?? []).join(',') === (b ?? []).join(',')
 }
+
+/** A parsed reference-image list: what the step will carry, and what was refused on the way in. */
+export interface ParsedReferenceImages {
+  /** Well-formed entries, in the order typed: exactly what gets stored. */
+  usable: BinaryReferenceImage[]
+  /** Lines that are not `role|location[|service]`, kept VERBATIM so the warning can quote them. */
+  unusable: string[]
+}
+
+/**
+ * Read a reference-image list from the one-per-line `role|location[|service]` text the builder
+ * accepts.
+ *
+ * Free TEXT rather than a picker, for the reason the format requirement beside it is: what a
+ * reference points at is an object in the org's own storage or a URL, and neither is a set the
+ * platform can enumerate. The three fields are positional because the shape is small and a
+ * three-input row per reference would dominate a step row that is already dense; the ROLE comes
+ * first because it is the constrained field, so a typo lands on the half the parser can name.
+ *
+ * A refused line is REPORTED, never quietly dropped, exactly as a refused format is: a reference
+ * someone typed and the step does not carry is a generation that silently ignores it.
+ */
+export function parseReferenceImages(text: string): ParsedReferenceImages {
+  const usable: BinaryReferenceImage[] = []
+  const unusable: string[] = []
+  for (const line of text
+    .split('\n')
+    .map((part) => part.trim())
+    .filter(Boolean)) {
+    const [role, location, service] = line.split('|').map((part) => part.trim())
+    const parsed = v.safeParse(binaryReferenceImageSchema, {
+      role,
+      location,
+      ...(service ? { service } : {}),
+    })
+    if (parsed.success) usable.push(parsed.output)
+    else unusable.push(line)
+  }
+  return { usable, unusable }
+}
+
+/** Render a stored reference list back into the text the field shows. */
+export function formatReferenceImages(
+  references: readonly BinaryReferenceImage[] | undefined,
+): string {
+  return (references ?? [])
+    .map((ref) => [ref.role, ref.location, ref.service].filter(Boolean).join('|'))
+    .join('\n')
+}
+
+/**
+ * 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.
+ *
+ * Three rules, and the third is the one that is easy to miss:
+ *
+ *  - An integration that declares NOTHING pins nothing down, so while one is selected (or nothing
+ *    is) every control stays offered and the advisory line says the support is unconfirmed.
+ *    Hiding one would be a claim about a vendor's API that nobody established.
+ *  - Otherwise a control is offered exactly when something selected declares its capability.
+ *  - And a control whose option is ALREADY SET stays offered whatever the selection says. Changing
+ *    the selection does not clear options authored against the old one, so hiding the control on
+ *    the way past strands a stored requirement that refuses the run at admission, under an error
+ *    telling the reader to remove an option whose only control has just disappeared. The platform
+ *    will not silently drop an authored requirement, so the person who stated it needs the control
+ *    that withdraws it. This is the SPA's standing rule that a hidden field must leave behind
+ *    exactly the default it would have shown.
+ *
+ * Returned as a closure over ONE pass across the selection rather than recomputed per capability:
+ * the template asks it once per control, and the sets are the same for all of them.
+ */
+export function generationControlOffer(
+  selected: readonly { capabilities?: readonly BinaryGeneratorCapability[] }[],
+  options: BinaryGenerationOptions | undefined,
+): (capability: BinaryGeneratorCapability) => boolean {
+  const declared = new Set(selected.flatMap((generator) => generator.capabilities ?? []))
+  const undeclared =
+    selected.length === 0 || selected.some((g) => (g.capabilities ?? []).length === 0)
+  // The same derivation admission judges the step by, imported rather than re-implemented, so the
+  // control a person is offered and the requirement the run is refused for cannot disagree.
+  const required = new Set(requiredBinaryCapabilities(options))
+  return (capability) => undeclared || declared.has(capability) || required.has(capability)
+}

package/app/components/pipeline/BinaryOutputStepPicker.vue

@@ -23,12 +23,21 @@ import { computed, ref, watch } from 'vue'
 import {
   ASSET_STORAGE_CAPABILITY,
   GENERATION_CONTEXT_CAPABILITY,
+  isBinaryGeneratorCapability,
   isBinaryModality,
+  type BinaryGenerationOptions,
+  type BinaryGeneratorCapability,
   type BinaryModality,
   type BinaryOutputConfig,
 } from '@cat-factory/contracts'
 import { binaryOutputPickIssues, type BinaryOutputPickIssue } from '~/utils/binaryOutput'
-import { parseMediaTypeRequirement, sameFormats } from './BinaryOutputStepPicker.logic'
+import {
+  formatReferenceImages,
+  generationControlOffer,
+  parseMediaTypeRequirement,
+  parseReferenceImages,
+  sameFormats,
+} from './BinaryOutputStepPicker.logic'
 
 const props = defineProps<{ index: number }>()
 
@@ -241,6 +250,131 @@ const overlapSummary = computed(() =>
     .join('; '),
 )
 
+/**
+ * The capability vocabulary, as STATIC literal `t()` keys: one per member, never assembled at
+ * runtime, so the typed-message-key check covers them (the standing rule for an enum-keyed set).
+ */
+const CAPABILITY_LABELS: Record<BinaryGeneratorCapability, () => string> = {
+  'reference-image': () => t('pipeline.builder.binaryCapability.reference-image'),
+  'multi-reference': () => t('pipeline.builder.binaryCapability.multi-reference'),
+  'instruction-edit': () => t('pipeline.builder.binaryCapability.instruction-edit'),
+  'mask-edit': () => t('pipeline.builder.binaryCapability.mask-edit'),
+  'negative-prompt': () => t('pipeline.builder.binaryCapability.negative-prompt'),
+  seed: () => t('pipeline.builder.binaryCapability.seed'),
+  'aspect-ratio': () => t('pipeline.builder.binaryCapability.aspect-ratio'),
+  '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'),
+}
+
+/**
+ * A capability in the reader's language, INCLUDING one this build does not define.
+ *
+ * The `Record` is exhaustive over the union and the lookup is still not total: the integrations
+ * ride the workspace snapshot, and on a mothership-mode deployment that snapshot is served by a
+ * process which may be a build AHEAD of this one. A bare lookup on such a value is a `TypeError`
+ * on the surface where the selection is made. Same guard, same reason, as `modalityLabel`.
+ */
+function capabilityLabel(capability: BinaryGeneratorCapability): string {
+  return isBinaryGeneratorCapability(capability)
+    ? CAPABILITY_LABELS[capability]()
+    : t('pipeline.builder.binaryCapabilityUnknown', { capability: String(capability) })
+}
+
+const generation = computed<BinaryGenerationOptions>(() => config.value?.generation ?? {})
+
+/** The registered integrations this step has selected, in the order the step names them. */
+const selectedGenerators = computed(() => {
+  const byId = new Map(agents.binaryGenerators.map((generator) => [generator.id, generator]))
+  return (config.value?.generatorIds ?? []).flatMap((id) => byId.get(id) ?? [])
+})
+
+/**
+ * Whether to OFFER the control an option belongs to. The rule itself is pure and lives in the
+ * logic sibling, where its three cases (undeclared, declared, already-set) are testable without
+ * mounting this component.
+ */
+const offers = computed(() => generationControlOffer(selectedGenerators.value, generation.value))
+
+/** The edit modes, as static literal keys: the enum-keyed-set rule again. */
+const editModeItems = computed(() => [
+  { label: t('pipeline.builder.binaryEditModeInstruction'), value: 'instruction' },
+  { label: t('pipeline.builder.binaryEditModeMask'), value: 'mask' },
+])
+
+/**
+ * Patch ONE generation option, dropping it when it is cleared.
+ *
+ * A cleared option is REMOVED rather than stored as an empty value, because the two are different
+ * requirements: an absent `seed` means the step does not pin one, while `seed: 0` is a pinned
+ * seed of zero, and admission judges the option's PRESENCE.
+ */
+function setGeneration(fields: Partial<BinaryGenerationOptions>) {
+  const next: Record<string, unknown> = { ...generation.value, ...fields }
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === undefined || value === '' || (Array.isArray(value) && value.length === 0)) {
+      delete next[key]
+    }
+  }
+  patch({
+    generation: Object.keys(next).length > 0 ? (next as BinaryGenerationOptions) : 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[]>([])
+
+watch(
+  () => config.value?.generation?.referenceImages,
+  (references) => {
+    referenceText.value = formatReferenceImages(references)
+  },
+)
+
+function setReferences(text: string) {
+  const { usable, unusable } = parseReferenceImages(text)
+  unusableReferences.value = unusable
+  referenceText.value = formatReferenceImages(usable)
+  setGeneration({ referenceImages: usable })
+}
+
+/**
+ * Turn the candidate comparison on or off. Off DROPS the whole bag rather than storing a disabled
+ * one: the presence of `comparison` is what the engine reads, so a saved "off" object would be a
+ * configuration describing a behaviour the run does not have.
+ */
+function setComparison(on: boolean) {
+  patch({ comparison: on ? (config.value?.comparison ?? {}) : undefined })
+}
+
+function setPerGenerator(value: number) {
+  const current = config.value?.comparison
+  if (!current) return
+  patch({ comparison: { ...current, perGenerator: value } })
+}
+
+function setMultiSelect(on: boolean) {
+  const current = config.value?.comparison
+  if (!current) return
+  patch({
+    comparison: on ? { ...current, multiSelect: true } : { perGenerator: current.perGenerator },
+  })
+}
+
+/**
+ * Whether the step could actually produce a comparison: the SAME rule
+ * `assertComparableCandidates` refuses at save, stated here where it is fixable. Without it a
+ * step saves clean, starts, and keeps its only candidate without ever asking anyone.
+ */
+const comparisonUnreachable = computed(() => {
+  const comparison = config.value?.comparison
+  if (!comparison) return false
+  if ((comparison.perGenerator ?? 1) > 1) return false
+  return (config.value?.generatorIds?.length ?? 0) < 2
+})
+
 /** What the SELECTED integrations say they emit — the discoverable half of the free-text field. */
 const declaredFormats = computed(() => {
   const byId = new Map(agents.binaryGenerators.map((generator) => [generator.id, generator]))
@@ -347,6 +481,199 @@ const declaredFormats = computed(() => {
       }}
     </p>
 
+    <!-- GENERATION OPTIONS. Each control is gated on a capability the selected integrations
+         declare, so a step cannot ask for a reference image from an endpoint that takes no image
+         input. While nothing has DECLARED its capabilities every control stays offered and the
+         advisory line below says the support is unconfirmed: hiding one would be a claim about a
+         vendor's API that nobody established. Both tiers, like the rest of this picker: an
+         option nobody stated is an option the run does not apply. -->
+    <template v-if="config?.storageServiceId">
+      <div v-if="offers('reference-image')" class="flex items-start gap-2">
+        <span class="mt-1 text-[10px] text-slate-500">{{
+          t('pipeline.builder.binaryReferenceImages')
+        }}</span>
+        <UTextarea
+          class="w-56"
+          :rows="2"
+          size="xs"
+          :model-value="referenceText"
+          :placeholder="t('pipeline.builder.binaryReferenceImagesPlaceholder')"
+          data-testid="binary-output-reference-input"
+          @update:model-value="referenceText = String($event)"
+          @change="setReferences(referenceText)"
+        />
+      </div>
+      <p
+        v-if="unusableReferences.length"
+        class="ms-1 text-[10px] text-amber-400"
+        data-testid="binary-output-reference-unusable"
+      >
+        {{
+          t('pipeline.builder.binaryReferenceImagesUnusable', {
+            entries: unusableReferences.join('; '),
+          })
+        }}
+      </p>
+
+      <div v-if="offers('instruction-edit') || offers('mask-edit')" class="flex items-center gap-2">
+        <span class="text-[10px] text-slate-500">{{ t('pipeline.builder.binaryEditMode') }}</span>
+        <USelect
+          class="w-56"
+          size="xs"
+          :model-value="generation.edit?.mode ?? ''"
+          :items="editModeItems"
+          value-key="value"
+          :placeholder="t('pipeline.builder.binaryEditModeNone')"
+          data-testid="binary-output-edit-mode"
+          @update:model-value="
+            setGeneration({
+              edit: $event
+                ? { ...generation.edit, mode: $event as 'instruction' | 'mask' }
+                : undefined,
+            })
+          "
+        />
+      </div>
+      <div v-if="generation.edit" class="flex items-center gap-2">
+        <span class="text-[10px] text-slate-500">{{
+          t('pipeline.builder.binaryEditInstruction')
+        }}</span>
+        <UInput
+          class="w-56"
+          size="xs"
+          :model-value="generation.edit.instruction ?? ''"
+          :placeholder="t('pipeline.builder.binaryEditInstructionPlaceholder')"
+          data-testid="binary-output-edit-instruction"
+          @change="
+            setGeneration({
+              edit: { ...generation.edit!, instruction: ($event.target as HTMLInputElement).value },
+            })
+          "
+        />
+      </div>
+
+      <div v-if="offers('negative-prompt')" class="flex items-center gap-2">
+        <span class="text-[10px] text-slate-500">{{
+          t('pipeline.builder.binaryNegativePrompt')
+        }}</span>
+        <UInput
+          class="w-56"
+          size="xs"
+          :model-value="generation.negativePrompt ?? ''"
+          :placeholder="t('pipeline.builder.binaryNegativePromptPlaceholder')"
+          data-testid="binary-output-negative-prompt"
+          @change="
+            setGeneration({ negativePrompt: ($event.target as HTMLInputElement).value.trim() })
+          "
+        />
+      </div>
+
+      <div v-if="offers('aspect-ratio')" class="flex items-center gap-2">
+        <span class="text-[10px] text-slate-500">{{
+          t('pipeline.builder.binaryAspectRatio')
+        }}</span>
+        <UInput
+          class="w-56"
+          size="xs"
+          :model-value="generation.aspectRatio ?? ''"
+          :placeholder="t('pipeline.builder.binaryAspectRatioPlaceholder')"
+          data-testid="binary-output-aspect-ratio"
+          @change="setGeneration({ aspectRatio: ($event.target as HTMLInputElement).value.trim() })"
+        />
+      </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
+          class="w-56"
+          type="number"
+          size="xs"
+          :model-value="generation.seed === undefined ? '' : String(generation.seed)"
+          :placeholder="t('pipeline.builder.binarySeedPlaceholder')"
+          data-testid="binary-output-seed"
+          @change="
+            setGeneration({
+              seed: ($event.target as HTMLInputElement).value
+                ? Number(($event.target as HTMLInputElement).value)
+                : undefined,
+            })
+          "
+        />
+      </div>
+
+      <div class="flex flex-wrap items-center gap-3">
+        <label v-if="offers('transparent-background')" class="flex items-center gap-1.5">
+          <UCheckbox
+            :model-value="generation.transparentBackground === true"
+            data-testid="binary-output-transparent"
+            @update:model-value="
+              setGeneration({ transparentBackground: $event ? true : undefined })
+            "
+          />
+          <span class="text-[10px] text-slate-500">{{
+            t('pipeline.builder.binaryTransparent')
+          }}</span>
+        </label>
+        <label v-if="offers('tileable')" class="flex items-center gap-1.5">
+          <UCheckbox
+            :model-value="generation.tileable === true"
+            data-testid="binary-output-tileable"
+            @update:model-value="setGeneration({ tileable: $event ? true : undefined })"
+          />
+          <span class="text-[10px] text-slate-500">{{ t('pipeline.builder.binaryTileable') }}</span>
+        </label>
+        <label v-if="offers('upscale')" class="flex items-center gap-1.5">
+          <UCheckbox
+            :model-value="generation.upscale !== undefined"
+            data-testid="binary-output-upscale"
+            @update:model-value="setGeneration({ upscale: $event ? 2 : undefined })"
+          />
+          <span class="text-[10px] text-slate-500">{{ t('pipeline.builder.binaryUpscale') }}</span>
+        </label>
+      </div>
+
+      <!-- CANDIDATE COMPARISON: generate several and let a person choose, rather than letting the
+           agent commit to one producer unobserved. -->
+      <label class="flex items-center gap-1.5">
+        <UCheckbox
+          :model-value="config.comparison !== undefined"
+          data-testid="binary-output-comparison"
+          @update:model-value="setComparison($event === true)"
+        />
+        <span class="text-[10px] text-slate-500">{{ t('pipeline.builder.binaryComparison') }}</span>
+      </label>
+      <div v-if="config.comparison" class="ms-6 flex flex-wrap items-center gap-3">
+        <span class="text-[10px] text-slate-500">{{
+          t('pipeline.builder.binaryPerGenerator')
+        }}</span>
+        <USelect
+          class="w-20"
+          size="xs"
+          :model-value="config.comparison.perGenerator ?? 1"
+          :items="[1, 2, 3, 4]"
+          data-testid="binary-output-per-generator"
+          @update:model-value="setPerGenerator(Number($event))"
+        />
+        <label class="flex items-center gap-1.5">
+          <UCheckbox
+            :model-value="config.comparison.multiSelect === true"
+            data-testid="binary-output-multi-select"
+            @update:model-value="setMultiSelect($event === true)"
+          />
+          <span class="text-[10px] text-slate-500">{{
+            t('pipeline.builder.binaryMultiSelect')
+          }}</span>
+        </label>
+      </div>
+      <p
+        v-if="comparisonUnreachable"
+        class="text-[10px] text-amber-400"
+        data-testid="binary-output-comparison-unreachable"
+      >
+        {{ t('pipeline.builder.binaryComparisonUnreachable') }}
+      </p>
+    </template>
+
     <!-- Every refusal this step would hit, named where it is fixable. Each is its own line
          with its own remedy: an unreachable catalog is not an empty one, a lost service is not
          an untagged one, and a lost CONTEXT service is not a lost storage target. -->
@@ -448,6 +775,32 @@ const declaredFormats = computed(() => {
     >
       {{ t('pipeline.builder.binaryOutputGeneratorOverlap', { overlaps: overlapSummary }) }}
     </p>
+    <p
+      v-if="has('capability_unsupported')"
+      class="text-[10px] text-amber-400"
+      data-testid="binary-output-capability-unsupported"
+    >
+      {{
+        t('pipeline.builder.binaryCapabilityUnsupported', {
+          capabilities: pick.unsupportedCapabilities.map(capabilityLabel).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
+         selections in the product. -->
+    <p
+      v-if="has('capability_unverifiable')"
+      class="text-[10px] text-slate-500"
+      data-testid="binary-output-capability-unverifiable"
+    >
+      {{
+        t('pipeline.builder.binaryCapabilityUnverifiable', {
+          capabilities: pick.unverifiableCapabilities.map(capabilityLabel).join(', '),
+        })
+      }}
+    </p>
     <p
       v-if="unusableMediaTypes.length"
       class="text-[10px] text-amber-400"

package/app/components/pipeline/PipelineProgress.vue

@@ -11,6 +11,7 @@ import {
   FAILED_STEP_META,
   containerPhaseLabel,
   dedicatedParkView,
+  REDIRECT_PARK_PRESENTATION,
 } from '~/utils/pipelineRender'
 import { prReviewPhase } from '~/utils/prReviewProgress'
 import StepMetricsBar from '~/components/observability/StepMetricsBar.vue'
@@ -90,6 +91,17 @@ function prReviewAwaiting(step: PipelineStep): boolean {
   return step.prReview?.status === 'awaiting_selection'
 }
 
+/**
+ * Whether a binary-output step is parked awaiting a human candidate choice. Asked of the shared
+ * park recognizer rather than re-derived from `step.binaryCandidates`, so this chip and the
+ * generic approval gate below (which suppresses itself for exactly the parks that recognizer
+ * names) can never disagree about who owns the park. That disagreement is what leaves a parked
+ * run showing no action at all.
+ */
+function candidatesAwaiting(step: PipelineStep): boolean {
+  return dedicatedParkView(step, props.instance) === 'binary-candidates'
+}
+
 /**
  * Whether a `pr-reviewer` step has a LIVE phase to surface (slicing / reviewing / … ). Drives
  * showing the phase badge in place of the generic subtask count header; a terminal (done/skipped)
@@ -665,6 +677,31 @@ const ITEM_ICON: Record<string, string> = {
             </span>
           </button>
 
+          <!-- A generating step parked between its candidate pass and its delivering pass: a
+               purpose-built chip opening the comparison window, ahead of the generic approval
+               gate (mirrors the fork-decision and pr-review chips above). Without it the step
+               shows no action at all, because the generic gate below is suppressed for every
+               park a dedicated window owns. -->
+          <button
+            v-if="candidatesAwaiting(s)"
+            type="button"
+            data-testid="binary-candidates-open"
+            class="mt-3 flex w-full items-center gap-2 rounded-lg border border-dashed border-cyan-500/50 bg-cyan-500/10 px-2.5 py-1.5 text-start transition followup-blink hover:border-cyan-400/60"
+            @click="ui.openBinaryCandidates(instance.id, i)"
+          >
+            <span
+              class="flex h-6 w-6 shrink-0 items-center justify-center rounded-md border border-cyan-500/40 bg-cyan-500/15"
+            >
+              <UIcon
+                :name="REDIRECT_PARK_PRESENTATION['binary-candidates'].icon"
+                class="h-3 w-3 text-cyan-300"
+              />
+            </span>
+            <span class="min-w-0 flex-1 truncate text-[12px] text-slate-300">
+              {{ t('pipeline.progress.binaryCandidates.choose') }}
+            </span>
+          </button>
+
           <!-- reviewer gate folding/re-reviewing in the background: a working indicator,
                NOT a "Review & approve" gate (the human is summoned only if needed) -->
           <div

package/app/composables/api/binaryCandidates.ts

@@ -0,0 +1,36 @@
+import {
+  getBinaryCandidatesContract,
+  keepBinaryCandidatesContract,
+  type KeepBinaryCandidatesInput,
+} from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * Generated-candidate comparison. A binary-output step configured to COMPARE generates a
+ * candidate from each of its selected integrations, stages them through the step's storage
+ * service, and parks. These endpoints read the staged candidates and record which of them
+ * survive (and under which alternate ids); keeping re-runs the step to deliver exactly those.
+ * The read returns null when no step carries candidate state.
+ */
+export function binaryCandidatesApi({ send, ws }: ApiContext) {
+  return {
+    // The live candidate state for a run (null when no step carries one).
+    getBinaryCandidates: (workspaceId: string, executionId: string) =>
+      send(getBinaryCandidatesContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+      }),
+
+    // Keep the chosen candidates and discard the rest.
+    keepBinaryCandidates: (
+      workspaceId: string,
+      executionId: string,
+      body: KeepBinaryCandidatesInput,
+    ) =>
+      send(keepBinaryCandidatesContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+        body,
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -13,6 +13,7 @@ import { boardApi } from './api/board'
 import { documentsApi } from './api/documents'
 import { executionApi } from './api/execution'
 import { followUpsApi } from './api/followUps'
+import { binaryCandidatesApi } from './api/binaryCandidates'
 import { forkDecisionApi } from './api/forkDecision'
 import { inputGateApi } from './api/inputGate'
 import { judgeApi } from './api/judge'
@@ -131,6 +132,7 @@ export function useApi() {
     ...bugHuntApi(ctx),
     ...reviewsApi(ctx),
     ...followUpsApi(ctx),
+    ...binaryCandidatesApi(ctx),
     ...forkDecisionApi(ctx),
     ...inputGateApi(ctx),
     ...judgeApi(ctx),

package/app/modular/result-views.ts

@@ -13,6 +13,7 @@ import ConsensusSessionWindow from '~/components/consensus/ConsensusSessionWindo
 import GenericStructuredResultView from '~/components/panels/GenericStructuredResultView.vue'
 import ServiceSpecWindow from '~/components/spec/ServiceSpecWindow.vue'
 import FollowUpWindow from '~/components/followUp/FollowUpWindow.vue'
+import BinaryCandidatesWindow from '~/components/binaryCandidates/BinaryCandidatesWindow.vue'
 import ForkDecisionWindow from '~/components/forkDecision/ForkDecisionWindow.vue'
 import PrReviewWindow from '~/components/prReview/PrReviewWindow.vue'
 import MergerResultView from '~/components/panels/MergerResultView.vue'
@@ -77,6 +78,9 @@ const BUILT_IN_RESULT_VIEWS: Record<ResultViewId, Component> = {
   'follow-ups': FollowUpWindow,
   // The implementation-fork decision: the proposer's approaches + the human's pick / custom.
   'fork-decision': ForkDecisionWindow,
+  // The generated-candidate comparison: the candidates a generating step staged, side by side,
+  // and the human's keep/discard decision (with the alternate ids they assigned).
+  'binary-candidates': BinaryCandidatesWindow,
   // The PR deep-review: the reviewer's sliced, prioritized findings + the human's multi-select.
   'pr-review': PrReviewWindow,
   // The merger's verdict: PR complexity/risk/impact scores + the engine's decision (and why).