@cat-factory/app 0.256.3 → 0.258.0

package/app/components/binaryCandidates/BinaryCandidatesWindow.vue

@@ -0,0 +1,284 @@
+<script setup lang="ts">
+// Generated-candidate comparison window: the dedicated surface for a binary-output step that
+// generated several candidates rather than committing to one producer unobserved
+// (docs/initiatives/binary-output-foundational-storage.md).
+//
+// It reads the live state straight off the run's step (`step.binaryCandidates`, kept fresh by the
+// execution stream) and lets a human KEEP one candidate, or several under distinct ids. Keeping
+// re-runs the same step to deliver exactly what survived and clear the rest.
+//
+// Two properties the surface has to hold on to, both of which are the reason this feature exists:
+//
+//  - A candidate WITHOUT a preview is still a candidate. An org's asset store may issue no public
+//    link, and the platform will not invent one, so such a row renders its details and says the
+//    preview is unavailable rather than disappearing or showing a broken image.
+//  - It doubles as the RECORD. Once the choice is made the window keeps rendering, marking what
+//    was kept and under which id, because the decision is the only place the run's own rationale
+//    lives. An AUTOMATIC keep says so: nobody looked at it.
+import { computed, ref, watch } from 'vue'
+import { useResultView } from '~/composables/useResultView'
+import { useExecutionStore } from '~/stores/execution'
+import { useBoardStore } from '~/stores/board'
+import { useBinaryCandidatesStore } from '~/stores/binaryCandidates'
+import {
+  BINARY_CANDIDATE_NO_CHOICE_KEYS,
+  binaryCandidateHasWarnings,
+  binaryCandidateView,
+} from '~/utils/binaryCandidates'
+import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
+
+const execution = useExecutionStore()
+const board = useBoardStore()
+const candidates = useBinaryCandidatesStore()
+const access = useWorkspaceAccess()
+const { t } = useI18n()
+
+// The warm-up read is keyed by the RUN, not the block: `load` calls
+// `GET /workspaces/:ws/executions/:executionId/binary-candidates`, and a block id put in that
+// position resolves to no run at all, so the fetch quietly returns nothing and the window shows
+// whatever the stream happened to deliver. `instanceId` is nullable (a view can be opened without
+// a resolved run), so the guard is the same one `PrReviewWindow` makes.
+const { open, blockId, instanceId, stepIndex, close } = useResultView('binary-candidates', {
+  onOpen: ({ instanceId }) => {
+    if (instanceId) void candidates.load(instanceId)
+  },
+})
+
+const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))
+const headerTitle = computed(() =>
+  block.value
+    ? t('binaryCandidates.titleWithBlock', { title: block.value.title })
+    : t('binaryCandidates.title'),
+)
+const instance = computed(() =>
+  instanceId.value === null ? null : (execution.getInstance(instanceId.value) ?? null),
+)
+const step = computed(() => {
+  if (instance.value === null || stepIndex.value === null) return null
+  return instance.value.steps[stepIndex.value] ?? null
+})
+const view = computed(() => binaryCandidateView(step.value))
+const warnings = computed(() => (view.value ? binaryCandidateHasWarnings(view.value) : false))
+const noChoiceKey = computed(() => {
+  const reason = view.value?.state.noChoiceReason
+  return reason ? BINARY_CANDIDATE_NO_CHOICE_KEYS[reason] : null
+})
+
+/** The ids the human has ticked, and the id each is to be stored under. */
+const selected = ref<string[]>([])
+const aliases = ref<Record<string, string>>({})
+const note = ref('')
+
+// Default the selection to the first candidate of the first subject whenever the candidate set
+// changes. Something ticked is the honest default for a single-select comparison (the person is
+// choosing between options, not deciding whether to have one) and it keeps the primary button
+// meaningful from the first render.
+watch(
+  () => view.value?.state.candidates.map((c) => c.id).join(','),
+  () => {
+    const first = view.value?.groups[0]?.rows[0]?.id
+    if (selected.value.some((id) => view.value?.state.candidates.some((c) => c.id === id))) return
+    selected.value = first ? [first] : []
+  },
+  { immediate: true },
+)
+
+function toggle(id: string): void {
+  if (!view.value?.awaiting) return
+  if (view.value.multiSelect) {
+    selected.value = selected.value.includes(id)
+      ? selected.value.filter((existing) => existing !== id)
+      : [...selected.value, id]
+    return
+  }
+  selected.value = [id]
+}
+
+/**
+ * Whether the request would be accepted. Mirrors the backend's own refusals rather than only
+ * disabling on emptiness: keeping several candidates under one name would store one artifact and
+ * report several, so the alias requirement is stated here, where it can be fixed, instead of
+ * arriving as a 422.
+ */
+const missingAliases = computed(() =>
+  selected.value.length > 1 ? selected.value.filter((id) => !(aliases.value[id] ?? '').trim()) : [],
+)
+const duplicateAliases = computed(() => {
+  const used = selected.value.map((id) => (aliases.value[id] ?? '').trim()).filter(Boolean)
+  return new Set(used).size !== used.length
+})
+const canKeep = computed(
+  () =>
+    view.value?.awaiting === true &&
+    !candidates.keeping &&
+    selected.value.length > 0 &&
+    missingAliases.value.length === 0 &&
+    !duplicateAliases.value,
+)
+
+async function onKeep() {
+  const id = instanceId.value
+  if (!id || !canKeep.value) return
+  const keep = selected.value.map((candidateId) => {
+    const alias = (aliases.value[candidateId] ?? '').trim()
+    return alias ? { candidateId, storeAs: alias } : { candidateId }
+  })
+  const text = note.value.trim()
+  await candidates.keep(id, { keep, ...(text ? { note: text } : {}) }).catch(() => {})
+}
+</script>
+
+<template>
+  <ResultWindowShell
+    :open="open"
+    icon="i-lucide-images"
+    icon-class="bg-sky-500/15 text-sky-300"
+    :title="headerTitle"
+    :subtitle="t('binaryCandidates.subtitle')"
+    width="5xl"
+    testid="binary-candidates-window"
+    @close="close"
+  >
+    <div v-if="view" class="min-h-0 flex-1 overflow-y-auto px-5 py-4">
+      <!-- Why there was nothing to choose between. Its own line per reason: a model that never
+           declared its candidates and one whose block was unreadable need different fixes. -->
+      <p
+        v-if="noChoiceKey"
+        class="mb-3 rounded border border-amber-500/30 bg-amber-500/5 px-3 py-2 text-xs text-amber-200"
+        data-testid="binary-candidates-no-choice"
+      >
+        {{ t(noChoiceKey) }}
+      </p>
+
+      <!-- An automatic keep is NOT a review, and must never render as one. -->
+      <p
+        v-if="view.automatic"
+        class="mb-3 rounded border border-slate-600/40 bg-slate-800/40 px-3 py-2 text-xs text-slate-300"
+        data-testid="binary-candidates-automatic"
+      >
+        {{ t('binaryCandidates.automatic') }}
+      </p>
+
+      <!-- Every loss the parse counted, so a comparison over three of five cannot read as one
+           over all five. -->
+      <p
+        v-if="warnings"
+        class="mb-3 text-xs text-amber-300"
+        data-testid="binary-candidates-warnings"
+      >
+        <span v-if="view.state.omitted">{{
+          t('binaryCandidates.warning.omitted', { count: view.state.omitted })
+        }}</span>
+        <span v-if="view.state.invalidEntries">
+          {{ t('binaryCandidates.warning.invalid', { count: view.state.invalidEntries }) }}</span
+        >
+        <span v-if="view.state.unusablePreviews">
+          {{ t('binaryCandidates.warning.previews', { count: view.state.unusablePreviews }) }}</span
+        >
+      </p>
+
+      <div v-for="group in view.groups" :key="group.subject ?? '·'" class="mb-6">
+        <h3 class="mb-2 text-xs font-medium text-slate-400">
+          {{ group.subject ?? t('binaryCandidates.unlabelledSubject') }}
+        </h3>
+        <div class="grid grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-3">
+          <div
+            v-for="row in group.rows"
+            :key="row.id"
+            class="rounded border p-2 transition"
+            :class="
+              selected.includes(row.id) || row.kept
+                ? 'border-sky-400/60 bg-sky-500/5'
+                : 'border-slate-700/60'
+            "
+            data-testid="binary-candidate-card"
+            @click="toggle(row.id)"
+          >
+            <img
+              v-if="row.previewUrl"
+              :src="row.previewUrl"
+              :alt="row.label ?? row.id"
+              class="mb-2 max-h-56 w-full rounded object-contain"
+              data-testid="binary-candidate-preview"
+            />
+            <!-- No preview is ORDINARY (a private asset store issues no link), so it is stated
+                 rather than left as an empty frame the reader reads as a failed generation. -->
+            <p
+              v-else
+              class="mb-2 flex h-24 items-center justify-center rounded bg-slate-800/60 px-2 text-center text-[10px] text-slate-400"
+              data-testid="binary-candidate-no-preview"
+            >
+              {{ t('binaryCandidates.noPreview') }}
+            </p>
+            <p class="text-xs text-slate-200">
+              {{
+                row.generator
+                  ? t('binaryCandidates.fromGenerator', { generator: row.generator })
+                  : t('binaryCandidates.unattributed')
+              }}
+            </p>
+            <p v-if="row.note" class="mt-1 text-[11px] text-slate-400">{{ row.note }}</p>
+            <p class="mt-1 break-all text-[10px] text-slate-500">{{ row.location }}</p>
+            <p v-if="row.contentType" class="text-[10px] text-slate-500">{{ row.contentType }}</p>
+            <p v-if="row.kept" class="mt-1 text-[11px] text-emerald-300">
+              {{
+                row.storeAs
+                  ? t('binaryCandidates.keptAs', { id: row.storeAs })
+                  : t('binaryCandidates.kept')
+              }}
+            </p>
+            <!-- The ALTERNATE ID, shown only where it is load-bearing: keeping two candidates
+                 under one name stores one artifact and reports two. -->
+            <UInput
+              v-if="view.awaiting && view.multiSelect && selected.includes(row.id)"
+              class="mt-2"
+              size="xs"
+              :model-value="aliases[row.id] ?? ''"
+              :placeholder="t('binaryCandidates.storeAsPlaceholder')"
+              data-testid="binary-candidate-store-as"
+              @click.stop
+              @update:model-value="aliases[row.id] = String($event)"
+            />
+          </div>
+        </div>
+      </div>
+
+      <div v-if="view.awaiting" class="mt-2">
+        <UTextarea
+          v-model="note"
+          :rows="2"
+          size="xs"
+          :placeholder="t('binaryCandidates.notePlaceholder')"
+          data-testid="binary-candidates-note"
+        />
+        <p
+          v-if="missingAliases.length"
+          class="mt-1 text-[11px] text-amber-300"
+          data-testid="binary-candidates-missing-alias"
+        >
+          {{ t('binaryCandidates.missingAlias') }}
+        </p>
+        <p
+          v-else-if="duplicateAliases"
+          class="mt-1 text-[11px] text-amber-300"
+          data-testid="binary-candidates-duplicate-alias"
+        >
+          {{ t('binaryCandidates.duplicateAlias') }}
+        </p>
+        <p v-if="candidates.error" class="mt-1 text-[11px] text-red-300">{{ candidates.error }}</p>
+        <div class="mt-2 flex justify-end">
+          <UButton
+            size="xs"
+            :disabled="!canKeep || !access.canExecuteRuns.value"
+            :title="access.canExecuteRuns.value ? undefined : t('access.noRunExecute')"
+            :loading="candidates.keeping"
+            data-testid="binary-candidates-keep"
+            @click="onKeep"
+          >
+            {{ t('binaryCandidates.keepAction', { count: selected.length }) }}
+          </UButton>
+        </div>
+      </div>
+    </div>
+  </ResultWindowShell>
+</template>

package/app/components/binaryOutput/BinaryOutputReport.vue

@@ -14,6 +14,7 @@
 import { computed } from 'vue'
 import type { PipelineStep } from '~/types/execution'
 import { BINARY_OUTPUT_STATE_KEYS, binaryOutputView } from '~/utils/binaryOutput'
+import { binaryCandidateView } from '~/utils/binaryCandidates'
 import CopyButton from '~/components/common/CopyButton.vue'
 
 // Two callers, one renderer — the same split `StepEffortReport` makes: the generic step-detail
@@ -27,6 +28,16 @@ const { t } = useI18n()
 
 const view = computed(() => binaryOutputView(props.step))
 
+/**
+ * The CANDIDATE decision, when this step compared before delivering.
+ *
+ * Rendered here rather than left to the comparison window, because that window is reachable only
+ * while the run is PARKED on it: once the choice is made, a step click routes to the kind's own
+ * result view and the record of what was compared, and by whom, would have nowhere to live. This
+ * is the same placement rule the artifacts above it follow, one decision earlier.
+ */
+const candidates = computed(() => binaryCandidateView(props.step))
+
 /**
  * The outcome's own copy, from the shared exhaustive map — shared so the collapsed section row
  * above this panel and the sentence inside it can never claim different outcomes. `stored`
@@ -55,6 +66,28 @@ const state = computed(() => {
       <span>{{ t('binaryOutput.heading') }}</span>
     </div>
 
+    <!-- The CANDIDATE decision, when this step compared before delivering. It sits ABOVE the
+         delivery outcome because it happened first, and because "which of four was this" is the
+         question the artifacts below cannot answer. An AUTOMATIC keep says so: nobody looked. -->
+    <p
+      v-if="candidates && candidates.state.candidates.length > 0"
+      class="text-[12px] leading-relaxed text-slate-300"
+      data-testid="binary-output-candidate-decision"
+    >
+      {{
+        candidates.automatic
+          ? t('binaryOutput.candidates.automatic', { total: candidates.state.candidates.length })
+          : candidates.state.choice
+            ? t('binaryOutput.candidates.chosen', {
+                kept: candidates.state.choice.kept.length,
+                total: candidates.state.candidates.length,
+              })
+            : t('binaryOutput.candidates.awaiting', {
+                total: candidates.state.candidates.length,
+              })
+      }}
+    </p>
+
     <!-- What happened, in one sentence, before any list. Four of the five states have no list
          at all, and the fifth still needs its qualifications read alongside it. -->
     <p
@@ -153,6 +186,22 @@ const state = computed(() => {
           </UBadge>
           <span v-if="row.entity">{{ row.entity }}</span>
           <span v-if="row.contentType" class="font-mono">{{ row.contentType }}</span>
+          <!-- What was actually DELIVERED, beside the media type it was delivered as. Rendered
+               whenever the artifact reported it, not only on a step that asked for a size: it is
+               a recorded fact about the asset, and it is the one the counted warning below is
+               made of. Without it that warning gives a number and no way to tell WHICH. -->
+          <span v-if="row.dimensions" class="font-mono" data-testid="binary-output-dimensions"
+            >{{ row.dimensions.width }}×{{ row.dimensions.height }}</span
+          >
+          <UBadge
+            v-if="row.missized"
+            color="warning"
+            variant="subtle"
+            size="sm"
+            data-testid="binary-output-missized-badge"
+          >
+            {{ t('binaryOutput.missizedBadge') }}
+          </UBadge>
         </div>
         <p v-if="row.description" class="mt-1 text-[11px] leading-relaxed text-slate-400">
           {{ row.description }}
@@ -227,6 +276,32 @@ const state = computed(() => {
           )
         }}
       </li>
+      <!-- The same judgement one axis over, on the requirement whose whole point is the delivered
+           pixels. The two size lines stay apart because an artifact that reported no dimensions
+           is not one that came back wrong: only the first can be fixed by asking the step to
+           report, and only the second is evidence the asset is unusable. -->
+      <li v-if="view.missized && view.requiredSize" data-testid="binary-output-missized">
+        {{
+          t(
+            'binaryOutput.warning.missized',
+            {
+              count: view.missized,
+              width: view.requiredSize.width,
+              height: view.requiredSize.height,
+            },
+            view.missized,
+          )
+        }}
+      </li>
+      <li v-if="view.sizeUnreported" data-testid="binary-output-size-unreported">
+        {{
+          t(
+            'binaryOutput.warning.sizeUnreported',
+            { count: view.sizeUnreported },
+            view.sizeUnreported,
+          )
+        }}
+      </li>
       <li v-if="view.misdirected" data-testid="binary-output-misdirected-note">
         {{
           t(

package/app/components/board/AddTaskModal.vue

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

package/app/components/board/RecurringPipelineModal.vue

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

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

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

package/app/components/forkDecision/ForkDecisionWindow.vue

@@ -26,7 +26,9 @@ const { t } = useI18n()
 // Hybrid: state rides the coder step (like follow-ups), but warm it from the GET on open too.
 // No `stepRef`: this is a pre-run decision, so there's no "restart from here".
 const { open, blockId, instanceId, stepIndex, close } = useResultView('fork-decision', {
-  onOpen: ({ blockId }) => void forkDecision.load(blockId),
+  onOpen: ({ instanceId }) => {
+    if (instanceId) void forkDecision.load(instanceId)
+  },
 })
 
 const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))