@cat-factory/app 0.256.2 → 0.257.0

package/app/components/panels/inspector/TaskExecution.vue

@@ -8,6 +8,8 @@ import {
   isCompanionKind,
   containerPhaseLabel,
   dedicatedParkView,
+  REDIRECT_PARK_PRESENTATION,
+  type RedirectParkView,
 } from '~/utils/pipelineRender'
 import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentFailureHistory from '~/components/board/AgentFailureHistory.vue'
@@ -184,15 +186,28 @@ function openStep(i: number) {
   if (instance.value) ui.openStepDetail(instance.value.id, i)
 }
 
-// Open the implementation-fork decision window for a coder step parked awaiting a choice.
-function openForkFor(i: number) {
-  if (instance.value) ui.openForkDecision(instance.value.id, i)
+/**
+ * The window-owned park holding a step, or null. `input-gate` is filtered out because it has no
+ * window: it is answered by the inline notice this list renders above itself, so offering a
+ * button here would send a human to an overlay that does not exist.
+ */
+function redirectPark(step: PipelineStep): RedirectParkView | null {
+  const park = dedicatedParkView(step, instance.value)
+  return park && park !== 'input-gate' ? park : null
+}
+
+/**
+ * Open the window that resolves a park. A `Record` over the vocabulary, so a park added to it
+ * fails to compile until it names its opener rather than rendering a button that does nothing.
+ */
+const PARK_OPENERS: Record<RedirectParkView, (instanceId: string, stepIndex: number) => void> = {
+  'follow-ups': (id, idx) => ui.openFollowUps(id, idx),
+  'fork-decision': (id, idx) => ui.openForkDecision(id, idx),
+  'binary-candidates': (id, idx) => ui.openBinaryCandidates(id, idx),
 }
 
-// Open the follow-up triage window for a coder step parked on undecided follow-up items
-// (its dedicated chip — the generic approve resolver refuses this park server-side).
-function openFollowUpsFor(i: number) {
-  if (instance.value) ui.openFollowUps(instance.value.id, i)
+function openParkFor(park: RedirectParkView, i: number) {
+  if (instance.value) PARK_OPENERS[park](instance.value.id, i)
 }
 
 // Open the PR deep-review findings-selection window for a pr-reviewer step parked awaiting
@@ -471,38 +486,23 @@ async function mergePr() {
             >
               {{ t('inspector.execution.decide') }}
             </UButton>
-            <!-- A coder step parked on the implementation-fork decision: pick an approach
-                 (or enter a custom one) in the dedicated window, not a plain approval. -->
-            <UButton
-              v-else-if="
-                s.approval &&
-                s.approval.status === 'pending' &&
-                dedicatedParkView(s, instance) === 'fork-decision'
-              "
-              color="primary"
-              variant="soft"
-              size="xs"
-              icon="i-lucide-git-fork"
-              @click="openForkFor(i)"
-            >
-              {{ t('inspector.execution.chooseApproach') }}
-            </UButton>
-            <!-- A coder step parked on undecided follow-up items: triage them (file /
-                 send back / answer / dismiss) in the dedicated window, not a plain
-                 approval — the generic approve resolver refuses this park. -->
+            <!-- A step parked on something a dedicated WINDOW answers: the implementation-fork
+                 choice, undecided follow-up items, or a candidate comparison. None of them is a
+                 plain approval (the generic resolver refuses all three server-side), and all
+                 three present the same way here: one button into the window that can resolve
+                 it. Driven by the shared per-park table rather than a branch each, because a
+                 branch each is how the candidate park shipped with no button at all. -->
             <UButton
-              v-else-if="
-                s.approval &&
-                s.approval.status === 'pending' &&
-                dedicatedParkView(s, instance) === 'follow-ups'
-              "
+              v-else-if="s.approval && s.approval.status === 'pending' && redirectPark(s)"
               color="primary"
               variant="soft"
               size="xs"
-              icon="i-lucide-compass"
-              @click="openFollowUpsFor(i)"
+              :icon="REDIRECT_PARK_PRESENTATION[redirectPark(s)!].icon"
+              :data-park="redirectPark(s)"
+              data-testid="dedicated-park-open"
+              @click="openParkFor(redirectPark(s)!, i)"
             >
-              {{ t('inspector.execution.triageFollowUps') }}
+              {{ t(REDIRECT_PARK_PRESENTATION[redirectPark(s)!].railActionKey) }}
             </UButton>
             <!-- A pr-reviewer step parked awaiting a finding selection: open the dedicated
                  findings-selection window, not the generic approval gate. -->

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

@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { parseMediaTypeRequirement, sameFormats } from './BinaryOutputStepPicker.logic'
+import {
+  formatReferenceImages,
+  generationControlOffer,
+  parseMediaTypeRequirement,
+  parseReferenceImages,
+  sameFormats,
+} from './BinaryOutputStepPicker.logic'
 
 describe('parseMediaTypeRequirement', () => {
   it('stores the reduction the backend compares against, not what was typed', () => {
@@ -56,3 +62,86 @@ describe('sameFormats', () => {
     expect(sameFormats(['a/b', 'c/d'], ['a/b', 'c/d'])).toBe(true)
   })
 })
+
+describe('parseReferenceImages', () => {
+  it('reads the role, the location and the optional service off each line', () => {
+    const { usable, unusable } = parseReferenceImages(
+      ['subject|assets/hero.png|asset-store', 'style|https://cdn.example/palette.png'].join('\n'),
+    )
+    expect(usable).toEqual([
+      { role: 'subject', location: 'assets/hero.png', service: 'asset-store' },
+      { role: 'style', location: 'https://cdn.example/palette.png' },
+    ])
+    expect(unusable).toEqual([])
+  })
+
+  // A reference someone typed and the step does not carry is a generation that silently ignores
+  // it, which is the "absent reads as fine" failure the rest of this surface exists to avoid.
+  it('reports a refused line rather than dropping it', () => {
+    const { usable, unusable } = parseReferenceImages(
+      ['mood|assets/hero.png', 'subject|', 'subject|assets/ok.png'].join('\n'),
+    )
+    expect(usable.map((ref) => ref.location)).toEqual(['assets/ok.png'])
+    expect(unusable).toEqual(['mood|assets/hero.png', 'subject|'])
+  })
+
+  it('round-trips through the text the field shows', () => {
+    const text = 'base|assets/hero.png|asset-store'
+    expect(formatReferenceImages(parseReferenceImages(text).usable)).toBe(text)
+  })
+})
+
+describe('generationControlOffer', () => {
+  const declaring = (...capabilities: string[]) => ({ capabilities }) as never
+
+  it('offers everything while a selected integration has declared nothing', () => {
+    // An integration that pinned nothing down is not a denial: hiding a control would be a claim
+    // about a vendor's API that nobody established. The advisory line says it is unconfirmed.
+    const offers = generationControlOffer([declaring('seed'), declaring()], undefined)
+    expect(offers('seed')).toBe(true)
+    expect(offers('tileable')).toBe(true)
+  })
+
+  it('offers everything when nothing is selected yet', () => {
+    expect(generationControlOffer([], undefined)('upscale')).toBe(true)
+  })
+
+  it('hides a control once every selection has declared and none has the capability', () => {
+    const offers = generationControlOffer([declaring('seed'), declaring('aspect-ratio')], undefined)
+    expect(offers('seed')).toBe(true)
+    expect(offers('aspect-ratio')).toBe(true)
+    expect(offers('tileable')).toBe(false)
+  })
+
+  // The regression this pins. Changing the selection does not clear options authored against the
+  // old one, so a stored option whose capability nothing declares still REFUSES the run at
+  // admission. Hiding its control leaves the reader an error saying to remove an option and no
+  // control that removes it: a step that cannot be run and cannot be fixed from the surface that
+  // configures it.
+  it('keeps offering a control whose option is already SET, whatever the selection declares', () => {
+    const selection = [declaring('seed')]
+    expect(generationControlOffer(selection, {})('tileable')).toBe(false)
+    expect(generationControlOffer(selection, { tileable: true })('tileable')).toBe(true)
+  })
+
+  it('keeps the control for every option shape that carries a requirement', () => {
+    const selection = [declaring('seed')]
+    // Each of these is stored differently (a flag, a number that may be zero, a list, a mode), and
+    // the requirement is derived from the same helper admission uses rather than re-read here.
+    const offers = generationControlOffer(selection, {
+      seed: 0,
+      aspectRatio: '16:9',
+      negativePrompt: 'blurry',
+      edit: { mode: 'mask' },
+      referenceImages: [{ role: 'subject', location: 'assets/hero.png' }],
+    } as never)
+    for (const capability of [
+      'aspect-ratio',
+      'negative-prompt',
+      'mask-edit',
+      'reference-image',
+    ] as const) {
+      expect(offers(capability)).toBe(true)
+    }
+  })
+})

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)
+}