@cat-factory/app 0.270.3 → 0.272.0

package/app/components/panels/AgentStepDetail.vue

@@ -13,7 +13,7 @@ import StepFragmentAdherence from '~/components/panels/StepFragmentAdherence.vue
 import BinaryOutputReport from '~/components/binaryOutput/BinaryOutputReport.vue'
 import EnvironmentStatusPanel from '~/components/environments/EnvironmentStatusPanel.vue'
 import FrontendBindingsResolved from '~/components/panels/inspector/FrontendBindingsResolved.vue'
-import { UI_TESTER_AGENT_KIND } from '@cat-factory/contracts'
+import { UI_TESTER_AGENT_KIND, blockingReviewComments } from '@cat-factory/contracts'
 import type { GateApprovalRefusal } from '@cat-factory/contracts'
 import ProvisioningLogsDrawer from '~/components/provisioning/ProvisioningLogsDrawer.vue'
 import IterationCapPrompt from '~/components/pipeline/IterationCapPrompt.vue'
@@ -171,10 +171,31 @@ const proposalEditable = computed(() => step.value?.outputIsRendered !== true)
 // approve/request-changes/reject rail, it shows the shared iteration-cap prompt
 // (one more round / proceed / stop & reset), resolved through its own endpoint.
 const companionExceeded = computed(() => approvalPending.value && !!step.value?.companion?.exceeded)
+/**
+ * The must-fix findings the reviewer left open on its last round.
+ *
+ * They are why the cap prompts read differently, and the difference is not cosmetic: a cap
+ * reached on the rating alone is the loop reporting that this is as good as it got, while an open
+ * blocker is the reviewer saying the work must not go on as it stands. That second one is also the
+ * park no risk policy will answer, so the person reading it is the only route past it and should
+ * be told what they are being asked to overrule.
+ */
+const blockingFindings = computed(() => blockingReviewComments(latestVerdict.value?.comments))
 // The SAME park, reached for the opposite reason: the loop was abandoned with rounds still on the
 // budget because the producer handed back the work it was asked to change and the rating did not
 // move. The three choices are identical, so this only picks the wording — the cap copy states a
 // spent limit, which is a false claim about this park (`companion.stalled`).
+//
+// It can hold TOGETHER with `blockingFindings`, and that pair is what splits the wording across
+// the two slots rather than ranking them: the HEADING says how the loop ended (a stalled one did
+// not reach its limit, so only it may say so) and the DETAIL says what this person is being asked
+// to decide (an open blocker outranks a bar that went unmet, and its copy claims nothing about
+// rounds). Neither slot can then state something untrue of the park it is describing.
+//
+// Which is why the stalled heading claims nothing about the RATING either. Standing still is
+// unchanged output at an unmoved rating (`companionLoopStalled`), never a rating under the bar: a
+// round held by an open blocker fails at a rating that cleared it, and the copy said "the rating
+// held below the 80% bar" over a 95% one. What the number was is on the verdict card above.
 const companionStalled = computed(() => companionExceeded.value && !!step.value?.companion?.stalled)
 // A park a DEDICATED window owns (fork choice / follow-up triage): the generic approve
 // resolver refuses these server-side, so the rail is replaced by a redirect to that window.
@@ -492,10 +513,12 @@ async function copyOutput() {
                 :step-index="ctx?.stepIndex ?? null"
               />
 
-              <!-- companion rework budget spent, OR the loop abandoned early as unproductive:
-                   the shared iteration-cap decision (one more round / proceed with the current
-                   output / stop & reset). One prompt, two headings — the choices are the same but
-                   the reason is not, and the spent-limit wording is untrue of a stalled loop. -->
+              <!-- companion rework budget spent, OR the loop abandoned early as unproductive,
+                   with or without must-fix findings still open: the shared iteration-cap decision
+                   (one more round / proceed with the current output / stop & reset). One prompt,
+                   and the two slots are picked on different facts — the choices are the same but
+                   the reason is not, the spent-limit wording is untrue of a stalled loop, and an
+                   open blocker is what the person is actually being asked to overrule. -->
               <IterationCapPrompt
                 v-if="companionExceeded"
                 :heading="
@@ -504,18 +527,29 @@ async function copyOutput() {
                         agent: agent.label,
                         attempts: step.companion?.attempts,
                         maxAttempts: step.companion?.maxAttempts,
-                        threshold: pctOf(latestVerdict?.threshold ?? 0),
-                      })
-                    : t('panels.stepDetail.companionCapHeading', {
-                        agent: agent.label,
-                        attempts: step.companion?.maxAttempts,
-                        threshold: pctOf(latestVerdict?.threshold ?? 0),
                       })
+                    : blockingFindings.length
+                      ? t(
+                          'panels.stepDetail.companionCapBlockedHeading',
+                          {
+                            agent: agent.label,
+                            attempts: step.companion?.maxAttempts,
+                            count: blockingFindings.length,
+                          },
+                          blockingFindings.length,
+                        )
+                      : t('panels.stepDetail.companionCapHeading', {
+                          agent: agent.label,
+                          attempts: step.companion?.maxAttempts,
+                          threshold: pctOf(latestVerdict?.threshold ?? 0),
+                        })
                 "
                 :detail="
-                  companionStalled
-                    ? t('panels.stepDetail.companionStalledDetail')
-                    : t('panels.stepDetail.companionCapDetail')
+                  blockingFindings.length
+                    ? t('panels.stepDetail.companionCapBlockedDetail')
+                    : companionStalled
+                      ? t('panels.stepDetail.companionStalledDetail')
+                      : t('panels.stepDetail.companionCapDetail')
                 "
                 :loading="resolvingCap"
                 @resolve="resolveCompanionCap"

package/app/components/panels/StepMetadataCard.vue

@@ -1,6 +1,12 @@
 <script setup lang="ts">
 import { computed } from 'vue'
+import {
+  bySeverityWorstFirst,
+  isReviewCommentSeverity,
+  type ReviewCommentSeverity,
+} from '@cat-factory/contracts'
 import type { AgentState, PipelineStep, CompanionVerdict, StepApproval } from '~/types/execution'
+import type { BadgeColor } from '~/utils/badge'
 import { subtaskIconClass } from '~/utils/pipelineRender'
 import StepModelActivity from '~/components/observability/StepModelActivity.vue'
 import StepContainerStatus from '~/components/panels/StepContainerStatus.vue'
@@ -65,6 +71,71 @@ const ITEM_ICON: Record<string, string> = {
 
 const pctOf = (n: number) => `${Math.round(n * 100)}%`
 
+/**
+ * The colour each finding grade renders at. `ungraded` is its own member rather than a fallback
+ * arm: a person's comment carries no severity and neither does a verdict recorded before reviewers
+ * graded anything, and painting either of those `major` would put a level on the screen that
+ * nobody chose. `unrecognized` is the same argument for the other direction (see
+ * {@link findingGrade}). An exhaustive `Record` so a severity added to the contract fails to
+ * compile here, typed against the shared `BadgeColor` rather than a hand-picked subset of it.
+ */
+const SEVERITY_COLOR: Record<ReviewCommentSeverity | 'ungraded' | 'unrecognized', BadgeColor> = {
+  blocker: 'error',
+  major: 'warning',
+  minor: 'neutral',
+  ungraded: 'neutral',
+  unrecognized: 'neutral',
+}
+
+/**
+ * How one finding's grade renders: the level itself, or which of the two NON-levels it is.
+ *
+ * `unrecognized` is what a level this build has retired reads as. The severity vocabulary is closed
+ * but persisted, and a stored verdict is mapped onto the type rather than re-parsed, so the schema's
+ * `major` fallback never runs on this path (contracts' `isReviewCommentSeverity` states the rule).
+ * Left unnarrowed the value indexes both maps and comes back `undefined`, which renders an unstyled
+ * badge over a raw i18n key; guessed onto a current level it would show an urgency nobody graded, on
+ * the panel asking a person to act on it. So it is NAMED, and the copy carries the stored value.
+ */
+function findingGrade(severity: string | undefined): {
+  key: ReviewCommentSeverity | 'ungraded' | 'unrecognized'
+  level: string
+} {
+  if (severity === undefined) return { key: 'ungraded', level: '' }
+  if (isReviewCommentSeverity(severity)) return { key: severity, level: severity }
+  return { key: 'unrecognized', level: severity }
+}
+
+/**
+ * Each round paired with its findings, worst first (the order the reviewer's asks should be worked
+ * in) and each finding with its resolved grade.
+ *
+ * A `computed` rather than methods the template calls, because a run panel re-renders on every
+ * pushed instance update while the template needs the list twice per round (the `v-if` and the
+ * `v-for`) and the grade three times per finding: as methods that is a copy, a sort and a narrowing
+ * per reader per push, all off state that only changes when a verdict lands.
+ */
+const verdictRounds = computed(() =>
+  props.companionVerdicts.map((verdict) => ({
+    verdict,
+    findings: bySeverityWorstFirst(verdict.comments ?? []).map((finding) => ({
+      body: finding.body,
+      grade: findingGrade(finding.severity),
+    })),
+  })),
+)
+
+/**
+ * Whether this round's rating actually reached its bar.
+ *
+ * Distinct from the verdict's own `passed`, which is what the ENGINE decided and can be `false` at a
+ * rating well above the threshold: an open `blocker` holds the step whatever the number says. The
+ * two were one expression, so the panel printed a false inequality over the findings that explained
+ * it. `>=` matches kernel's `disposeCompanionVerdict`, where a threshold typed by an operator must be
+ * met exactly by a rating equal to it.
+ */
+const ratingMeetsBar = (verdict: CompanionVerdict) => verdict.rating >= verdict.threshold
+
 const APPROVAL_STATUS_KEYS: Record<StepApproval['status'], string> = {
   pending: 'panels.stepMeta.approvalStatus.pending',
   approved: 'panels.stepMeta.approvalStatus.approved',
@@ -278,17 +349,23 @@ async function copyRunId() {
         <span class="text-[11px] uppercase tracking-wide text-slate-500">
           {{ t('panels.stepMeta.companionReview') }}
         </span>
+        <!-- The COLOUR is the verdict (`passed`) and the GLYPH is the arithmetic, which are no
+             longer the same fact: a round holding an open `blocker` fails at a rating that cleared
+             its bar, and reading the inequality off `passed` printed "95% < 80%" over the findings
+             explaining why. -->
         <UBadge :color="latestVerdict?.passed ? 'success' : 'warning'" variant="subtle" size="sm">
           {{ pctOf(latestVerdict!.rating) }}
-          {{ latestVerdict?.passed ? '≥' : '<' }} {{ pctOf(latestVerdict!.threshold) }}
+          {{ ratingMeetsBar(latestVerdict!) ? '≥' : '<' }} {{ pctOf(latestVerdict!.threshold) }}
         </UBadge>
       </div>
-      <!-- One card per correction round: the score on its own line, then the reviewer's
-           challenge as rendered markdown. The feedback used to trail the score inside the same
-           line, which turned a multi-point review into one unreadable run of text. -->
+      <!-- One card per correction round: the score on its own line, then the reviewer's verdict
+           as rendered markdown, then its graded findings worst first. The feedback used to trail
+           the score inside the same line, which turned a multi-point review into one unreadable
+           run of text; the findings used not to be rendered at all, so a "must fix" holding the
+           run was invisible to the person being asked to resolve it. -->
       <ol class="mt-2 space-y-2">
         <li
-          v-for="(v, i) in companionVerdicts"
+          v-for="({ verdict: v, findings }, i) in verdictRounds"
           :key="i"
           data-testid="companion-verdict"
           class="relative rounded-lg border border-slate-800 bg-slate-900/60 px-3 py-2"
@@ -304,14 +381,36 @@ async function copyRunId() {
               {{ i + 1 }}
             </span>
             <span :class="v.passed ? 'text-emerald-300' : 'text-amber-300'">
-              {{ pctOf(v.rating) }} {{ v.passed ? '≥' : '<' }} {{ pctOf(v.threshold) }}
+              {{ pctOf(v.rating) }} {{ ratingMeetsBar(v) ? '≥' : '<' }} {{ pctOf(v.threshold) }}
             </span>
           </div>
           <MarkdownProse
             v-if="v.feedback"
             :text="v.feedback"
+            data-testid="companion-verdict-summary"
             class="mt-1.5 pe-6 text-[12px] leading-relaxed text-slate-300"
           />
+          <ul v-if="findings.length" class="mt-2 space-y-1.5">
+            <li
+              v-for="(finding, fi) in findings"
+              :key="fi"
+              data-testid="companion-finding"
+              class="flex gap-2"
+            >
+              <UBadge
+                :color="SEVERITY_COLOR[finding.grade.key]"
+                variant="subtle"
+                size="sm"
+                class="mt-px h-4 shrink-0"
+              >
+                {{ t(`panels.stepMeta.findingSeverity.${finding.grade.key}`, finding.grade) }}
+              </UBadge>
+              <MarkdownProse
+                :text="finding.body"
+                class="min-w-0 text-[12px] leading-relaxed text-slate-300"
+              />
+            </li>
+          </ul>
         </li>
       </ol>
       <p v-if="companionVerdicts.length > 1" class="mt-1 text-[11px] text-slate-500">

package/app/components/tasks/BugHuntModal.logic.spec.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest'
+import type { TaskSourceState } from '@cat-factory/contracts'
+import { boardFromService, huntRequest } from './BugHuntModal.logic'
+
+// What scopes a hunt. The rule is small and the failures are silent in both directions: a
+// repo-backed tracker that sends a board would be refused on submit, and one that sent an empty
+// string instead of an explicit null would read as a board named as blank.
+
+function state(overrides: Partial<TaskSourceState> = {}): TaskSourceState {
+  return {
+    source: 'github',
+    label: 'GitHub Issues',
+    icon: 'i-lucide-github',
+    credentialFields: [],
+    refLabel: 'Issue URL',
+    refPlaceholder: 'acme/web#123',
+    available: true,
+    enabled: true,
+    ridesVcsProvider: 'github',
+    supportsIntake: true,
+    ignoredIntakePredicates: [],
+    repoBacked: true,
+    ...overrides,
+  }
+}
+
+const FORM = { containerId: 'blk-1', board: '', issueType: '', labels: '' }
+
+describe('boardFromService', () => {
+  it('follows what the SOURCE declares, not which source it is', () => {
+    expect(boardFromService(state({ source: 'acme:forge' }))).toBe(true)
+    expect(boardFromService(state({ source: 'jira', repoBacked: false }))).toBe(false)
+  })
+
+  it('treats an unresolved source as having a board, so a control is still rendered', () => {
+    expect(boardFromService(undefined)).toBe(false)
+  })
+})
+
+describe('huntRequest', () => {
+  it('sends an explicit null board for a repo-backed tracker, whatever was typed before', () => {
+    const request = huntRequest({ ...FORM, source: state(), board: 'someone-else/web' })
+
+    // Null, never '' and never the stale text: the backend REFUSES a board named for such a
+    // source, so a hunt that carried one would be rejected rather than scoped.
+    expect(request).toEqual({ containerId: 'blk-1', board: null })
+  })
+
+  it('sends the trimmed board a repo-less tracker names', () => {
+    const source = state({ source: 'jira', repoBacked: false })
+
+    expect(huntRequest({ ...FORM, source, board: '  PROJ  ' })).toEqual({
+      containerId: 'blk-1',
+      board: 'PROJ',
+    })
+  })
+
+  it('describes no scan until a repo-less tracker has a board', () => {
+    const source = state({ source: 'jira', repoBacked: false })
+
+    expect(huntRequest({ ...FORM, source, board: '   ' })).toBeNull()
+  })
+
+  it('describes no scan without a container, which decides the repository too', () => {
+    expect(huntRequest({ ...FORM, source: state(), containerId: undefined })).toBeNull()
+  })
+
+  it('carries only the predicates that were actually filled in', () => {
+    const request = huntRequest({
+      ...FORM,
+      source: state(),
+      issueType: ' defect ',
+      labels: 'regression, , checkout ',
+    })
+
+    expect(request).toEqual({
+      containerId: 'blk-1',
+      board: null,
+      issueType: 'defect',
+      labels: ['regression', 'checkout'],
+    })
+  })
+})

package/app/components/tasks/BugHuntModal.logic.ts

@@ -0,0 +1,54 @@
+import type { RunBugHuntInput, TaskSourceState } from '@cat-factory/contracts'
+
+// The pure half of BugHuntModal: what SCOPES a hunt. Extracted for the reason every `*.logic.ts`
+// here is (a decision worth a test should not need a mounted component to reach), and this one
+// carries the whole rule the surface exists to enforce: a repo-backed tracker hunts the
+// repository of the service the bug will land in, and names no board of its own.
+
+/**
+ * Whether this tracker's board is the chosen service's repository rather than a choice.
+ *
+ * Read off the source's declared `repoBacked`, never its id: a deployment that registers its own
+ * repo-backed source, or one running GitLab instead of GitHub, must behave identically, and a
+ * source list compared here would be a second authority that drifts from the backend's.
+ * An unresolved source (still loading, or one this workspace no longer offers) is NOT repo-backed:
+ * the answer decides which control to render, and rendering none is the option a user cannot
+ * correct.
+ */
+export function boardFromService(source: TaskSourceState | undefined): boolean {
+  return source?.repoBacked === true
+}
+
+/**
+ * The scan request, or null when the form does not yet name one.
+ *
+ * `board` is explicitly `null` for a repo-backed tracker rather than an empty string: the backend
+ * REFUSES a board named for such a source instead of ignoring it, so the difference between "no
+ * board to name" and "a board named as blank" has to survive this far. The container is required
+ * either way: it is where an adopted bug lands, and on a repo-backed tracker it is also what
+ * decides which repository is read at all.
+ */
+export function huntRequest(input: {
+  source: TaskSourceState | undefined
+  containerId: string | undefined
+  board: string
+  issueType: string
+  labels: string
+}): RunBugHuntInput | null {
+  const { containerId } = input
+  if (!input.source || !containerId) return null
+  const fromService = boardFromService(input.source)
+  const board = input.board.trim()
+  if (!fromService && !board) return null
+  const issueType = input.issueType.trim()
+  const labels = input.labels
+    .split(',')
+    .map((label) => label.trim())
+    .filter((label) => label.length > 0)
+  return {
+    containerId,
+    board: fromService ? null : board,
+    ...(issueType ? { issueType } : {}),
+    ...(labels.length ? { labels } : {}),
+  }
+}

package/app/components/tasks/BugHuntModal.vue

@@ -1,7 +1,14 @@
 <script setup lang="ts">
-// Bug hunt: pick a connected tracker, pick one of its boards, and let the platform rank that
-// board's open, UNASSIGNED bugs by impact against implementation complexity. Confirming a
-// candidate adopts it as a bug task in the chosen container and starts the bug-fix pipeline.
+// Bug hunt: pick a connected tracker, scope the scan, and let the platform rank that board's
+// open, UNASSIGNED bugs by impact against implementation complexity. Confirming a candidate
+// adopts it as a bug task in the chosen container and starts the bug-fix pipeline.
+//
+// What SCOPES the scan depends on the tracker, and the source states which (`repoBacked`): a
+// repo-backed one (GitHub Issues, GitLab Issues) hunts the repository the chosen service is
+// linked to and offers NO board control, because its issues live in one repo per service and the
+// only honest answer is the one the backend resolves. Every other tracker names a board of its
+// own. Never a picker either way that could aim a hunt at a repository this board holds no
+// service for.
 //
 // The interactive dual of the recurring bug-triage schedule: same reading and same pipeline,
 // but a human picks the bug instead of the oldest match being claimed unattended.
@@ -37,11 +44,14 @@ import {
 } from '~/utils/sourcePicker'
 import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
 import { appliesIntakePredicate } from '~/utils/intakePredicates'
+import { boardFromService as isBoardFromService, huntRequest } from './BugHuntModal.logic'
 
 const { t, d, n } = useI18n()
 const ui = useUiStore()
 const tasks = useTasksStore()
 const hunt = useBugHuntStore()
+const board = useBoardStore()
+const github = useGitHubStore()
 const toast = useToast()
 const { present } = usePipelineErrorToast()
 
@@ -130,6 +140,36 @@ const boardItems = computed(() =>
   })),
 )
 
+/** This tracker's board is the chosen service's own repository (see the logic module). */
+const boardFromService = computed(() => isBoardFromService(descriptor.value))
+
+/**
+ * WHICH repository a repo-backed hunt will read, named before it runs.
+ *
+ * The premise of this whole branch is that the platform picks the board on the user's behalf, so
+ * withholding the value until the results block (`scannedBoard`) states it only after a billable
+ * scan has already been paid for. Resolved the way the backend resolves it — walk the chosen
+ * container up to its service frame, read that frame's repo link — so the two cannot name
+ * different repositories. Null while the projection is still loading or the service holds no
+ * link; the field then says what it always said, and the not-linked case stays the backend's to
+ * refuse (`boardNeedsRepo`), since an unloaded projection and an unlinked service look identical
+ * from here.
+ */
+const scopedRepo = computed(() => {
+  const container = containerId.value ? board.getBlock(containerId.value) : undefined
+  const frame = container ? board.serviceOf(container) : undefined
+  const repo = frame ? github.repoForBlock(frame.id) : undefined
+  return repo ? `${repo.owner}/${repo.name}` : null
+})
+
+/**
+ * The service this hunt is scoped to has no repository linked, so it has no issues to read. The
+ * one scan failure worded here instead of in a toast: it names something to fix on this board,
+ * and it belongs beside the scope it invalidates.
+ */
+const REPO_NOT_LINKED: TaskSourceReadReason = 'repo_not_linked'
+const huntNeedsRepo = computed(() => hunt.huntErrorReason === REPO_NOT_LINKED)
+
 /**
  * The tracker CANNOT enumerate boards, so the user types the scope in themselves. Keyed on the
  * backend's reason code, not on "any error": an unreachable tracker or an expired token would
@@ -140,10 +180,30 @@ const boardIsFreeText = computed(
   () => !hunt.boardsLoading && hunt.boardsErrorReason === BOARDS_UNSUPPORTED,
 )
 
+/**
+ * The refusals this surface words ITSELF, keyed on the backend's reason.
+ *
+ * The backend does not localize prose, so a reason with no entry here renders the server's
+ * untranslated English — the honest last resort for a cause this modal was not built to explain,
+ * and the wrong answer for one it was. Both entries are reachable only from a client that
+ * disagrees with the backend about which sources are repo-backed (a stale SPA build, a raced
+ * `repoBacked` read), which is exactly when a user is least served by raw backend prose.
+ * `repo_not_linked` is deliberately absent: it is not a message but a warning rendered beside the
+ * scope it invalidates.
+ */
+const REFUSAL_KEYS: Partial<Record<TaskSourceReadReason, string>> = {
+  board_from_service: 'bugHunt.refusal.boardFromService',
+  missing_board: 'bugHunt.refusal.missingBoard',
+}
+function refusalText(reason: string | null, fallback: string | null): string | null {
+  const key = reason ? REFUSAL_KEYS[reason as TaskSourceReadReason] : undefined
+  return key ? t(key) : fallback
+}
+
 /** A board read that failed for a reason the user has to fix — shown, never silently swallowed. */
 const boardsFailure = computed(() =>
   !hunt.boardsLoading && hunt.boardsError !== null && !boardIsFreeText.value
-    ? hunt.boardsError
+    ? refusalText(hunt.boardsErrorReason, hunt.boardsError)
     : null,
 )
 
@@ -157,7 +217,17 @@ function createdAtDate(createdAt: string): Date | null {
   return Number.isNaN(parsed.getTime()) ? null : parsed
 }
 
-const canHunt = computed(() => !!source.value && boardId.value.trim().length > 0)
+/** The scan this form currently describes, or null while it does not describe one. */
+const request = computed(() =>
+  huntRequest({
+    source: descriptor.value,
+    containerId: containerId.value,
+    board: boardId.value,
+    issueType: issueType.value,
+    labels: labels.value,
+  }),
+)
+const canHunt = computed(() => request.value !== null)
 
 watch(open, (isOpen) => {
   if (!isOpen) return
@@ -168,7 +238,7 @@ watch(open, (isOpen) => {
   awaitingConnect.value = null
   source.value = ui.bugHunt?.source ?? tasks.offeredSources[0]?.source ?? undefined
   resetContainer()
-  if (source.value) hunt.loadBoards(source.value)
+  loadBoardsFor(source.value)
 })
 
 // Switching tracker invalidates both the board list and any ranking already on screen: the
@@ -176,24 +246,40 @@ watch(open, (isOpen) => {
 watch(source, (next) => {
   boardId.value = ''
   hunt.reset()
-  if (next) hunt.loadBoards(next)
+  loadBoardsFor(next)
 })
 
+// For a repo-backed tracker the service IS the board, so moving the hunt to another service moves
+// it to another repository: the shortlist on screen belongs to the old one and must go with it.
+// A repo-less tracker keeps its results, since the container only decides where an adopted bug
+// lands and the scan is still of the board that was asked for.
+watch(containerId, () => {
+  if (boardFromService.value) hunt.reset()
+})
+
+/**
+ * Boards are listed only for a tracker that HAS a board to choose; asking otherwise is refused
+ * server-side. The other branch is not a no-op: the previous tracker's list (or the warning its
+ * failed listing left behind) has to go, or it renders under a tracker with no board field.
+ */
+function loadBoardsFor(next: TaskSourceKind | undefined) {
+  if (!next) return
+  if (isBoardFromService(tasks.descriptorFor(next))) {
+    hunt.dropBoards(next)
+    // The repo projection is lazy and nothing on the board opens it, so the field that names the
+    // repository this hunt will read asks for it here — only on the branch that has one.
+    void github.ensureLoaded().catch(() => {})
+  } else hunt.loadBoards(next)
+}
+
 async function runHunt() {
-  if (!source.value || !canHunt.value) return
-  const parsedLabels = labels.value
-    .split(',')
-    .map((l) => l.trim())
-    .filter((l) => l.length > 0)
-  const ok = await hunt.hunt(source.value, {
-    board: boardId.value.trim(),
-    ...(issueType.value.trim() ? { issueType: issueType.value.trim() } : {}),
-    ...(parsedLabels.length ? { labels: parsedLabels } : {}),
-  })
-  if (!ok) {
+  const input = request.value
+  if (!source.value || !input) return
+  const ok = await hunt.hunt(source.value, input)
+  if (!ok && !huntNeedsRepo.value) {
     toast.add({
       title: t('bugHunt.huntFailed'),
-      description: hunt.huntError ?? undefined,
+      description: refusalText(hunt.huntErrorReason, hunt.huntError) ?? undefined,
       icon: 'i-lucide-triangle-alert',
       color: 'error',
     })
@@ -306,10 +392,21 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
           </UFormField>
 
           <UFormField :label="t('bugHunt.board')">
+            <!-- This tracker's issues belong to one repository per service, so the board is
+                 STATED rather than asked: the repository the service below is linked to. No
+                 control at all, because every value one could offer here is either that repo
+                 (nothing to choose) or another one this board holds no service for. -->
+            <p
+              v-if="boardFromService"
+              class="flex items-center gap-1.5 py-1 text-sm text-slate-300"
+            >
+              <UIcon name="i-lucide-folder-git-2" class="h-4 w-4 shrink-0" />
+              <span class="truncate">{{ scopedRepo ?? t('bugHunt.boardFromService') }}</span>
+            </p>
             <!-- A tracker that can't enumerate its boards gets a free-text field rather than
                  an empty picker, so the hunt is still usable. -->
             <UInput
-              v-if="boardIsFreeText"
+              v-else-if="boardIsFreeText"
               v-model="boardId"
               :placeholder="t('bugHunt.boardPlaceholder')"
               class="w-full"
@@ -322,9 +419,14 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
               :placeholder="t('bugHunt.pickBoard')"
               class="w-full"
             />
+            <!-- The service holds no repository, so there are no issues to read. Said here
+                 rather than in a toast: it invalidates the scope named right above it. -->
+            <p v-if="huntNeedsRepo" class="mt-1 text-xs text-amber-400">
+              {{ t('bugHunt.boardNeedsRepo') }}
+            </p>
             <!-- A board read that failed for a fixable reason (unreachable site, expired
                  token): named, so the user isn't left with an empty picker and no cause. -->
-            <p v-if="boardsFailure" class="mt-1 text-xs text-amber-400">
+            <p v-else-if="boardsFailure" class="mt-1 text-xs text-amber-400">
               {{ t('bugHunt.boardsFailed', { reason: boardsFailure }) }}
             </p>
           </UFormField>
@@ -347,16 +449,32 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
           </UFormField>
         </div>
 
-        <!-- Where an adopted bug lands. Stated when the frame this hunt was opened from is the
-             only legal target; a choice (scoped to that frame) when it has modules, or over the
-             whole board when the hunt was opened standalone. -->
+        <!-- Where an adopted bug lands, and on a repo-backed tracker WHICH REPOSITORY is
+             scanned, so the wording says both rather than leaving the scope unexplained. Stated
+             when the frame this hunt was opened from is the only legal target; a choice (scoped
+             to that frame) when it has modules, or over the whole board when the hunt was opened
+             standalone. -->
+        <!-- Two blocks rather than one with a computed `keypath`: the i18n extractor reads a
+             bound keypath as the key itself, so a dynamic one is a key missing from every
+             locale. Every other `<i18n-t>` in the SPA names its key statically for that reason. -->
         <p v-if="containerStated" class="text-xs text-slate-400">
-          <i18n-t keypath="bugHunt.adoptingInto" tag="span" scope="global">
+          <i18n-t v-if="boardFromService" keypath="bugHunt.huntingIn" tag="span" scope="global">
+            <template #container>
+              <span class="font-medium text-slate-200">{{ pinnedContainer!.title }}</span>
+            </template>
+          </i18n-t>
+          <i18n-t v-else keypath="bugHunt.adoptingInto" tag="span" scope="global">
             <template #container>
               <span class="font-medium text-slate-200">{{ pinnedContainer!.title }}</span>
             </template>
           </i18n-t>
         </p>
+        <!-- Two fields rather than one with a computed key, for the reason the two blocks above
+             are two: the i18n extractor reads a bound key as the key itself, so a dynamic one
+             leaves BOTH real keys unreferenced and a dead-key sweep prunes them. -->
+        <UFormField v-else-if="boardFromService" :label="t('bugHunt.huntIn')">
+          <USelect v-model="containerId" :items="containerItems" class="w-full" />
+        </UFormField>
         <UFormField v-else :label="t('bugHunt.adoptInto')">
           <USelect v-model="containerId" :items="containerItems" class="w-full" />
         </UFormField>
@@ -379,6 +497,12 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
         <!-- Results -->
         <div v-if="hunt.hasResult" class="space-y-3 border-t border-slate-800 pt-3">
           <p class="text-xs text-slate-400">
+            <!-- The board the scan actually ran against, named because on a repo-backed tracker
+                 the platform resolved it: the person reading the shortlist should not have to
+                 infer which repository it came out of. -->
+            <span class="text-slate-500">
+              {{ t('bugHunt.scannedBoard', { board: hunt.result!.board }) }}
+            </span>
             {{ t(STATUS_KEYS[hunt.result!.analysisStatus]) }}
             <span v-if="hunt.result!.model" class="text-slate-500">
               {{ t('bugHunt.viaModel', { model: hunt.result!.model }) }}