@cat-factory/app 0.271.0 → 0.273.0

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

package/app/stores/bugHunt.spec.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { useBugHuntStore } from '~/stores/bugHunt'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { ApiError } from '~/composables/api/errors'
-import type { TaskSourceKind, TrackerBoardsView } from '~/types/domain'
+import type { BugHuntResult, TaskSourceKind, TrackerBoardsView } from '~/types/domain'
 
 // What the board picker does with a FAILED board read. Only one failure means "this tracker
 // cannot enumerate boards, so type one in"; every other failure has to stay visible as an error,
@@ -23,20 +23,43 @@ const boardsUnsupported = () =>
 function stubApi(): {
   store: ReturnType<typeof useBugHuntStore>
   serve: (fn: () => Promise<unknown>) => void
+  serveHunt: (fn: () => Promise<unknown>) => void
 } {
   let handler: () => Promise<unknown> = () => Promise.resolve({ source: 'jira', boards: [] })
+  let huntHandler: () => Promise<unknown> = () => Promise.resolve(huntResult())
   vi.stubGlobal('useApi', () => ({
     listTrackerBoards: (_ws: string, _source: TaskSourceKind) =>
       handler() as Promise<TrackerBoardsView>,
+    runBugHunt: (_ws: string, _source: TaskSourceKind, _input: unknown) =>
+      huntHandler() as Promise<BugHuntResult>,
   }))
   return {
     store: useBugHuntStore(),
     serve: (fn) => {
       handler = fn
     },
+    serveHunt: (fn) => {
+      huntHandler = fn
+    },
   }
 }
 
+/** An empty but well-formed scan result, so a success case asserts on the store, not the shape. */
+function huntResult(): BugHuntResult {
+  return {
+    source: 'github',
+    board: 'acme/web',
+    analysisStatus: 'empty',
+    model: null,
+    candidates: [],
+    scanned: 0,
+    truncated: false,
+  }
+}
+
+/** The one scan input shape the modal builds; the store only passes it through. */
+const SCAN = { containerId: 'blk_auth', board: null }
+
 describe('bug hunt store — board listing failures', () => {
   beforeEach(() => {
     useWorkspaceStore().workspaceId = 'ws1'
@@ -79,6 +102,22 @@ describe('bug hunt store — board listing failures', () => {
     expect(store.boards.map((b) => b.id)).toEqual(['t1'])
   })
 
+  it('drops the previous tracker failure when the next one has no board to list', async () => {
+    // A repo-backed tracker renders no board field at all, so a stale "boards could not be
+    // loaded" warning would sit under a control that is not there, blaming this tracker for the
+    // last one's outage.
+    const { store, serve } = stubApi()
+    serve(() => Promise.reject(apiError(502, 'upstream')))
+    await store.loadBoards('jira')
+
+    store.dropBoards('github')
+
+    expect(store.boardsSource).toBe('github')
+    expect(store.boards).toEqual([])
+    expect(store.boardsError).toBeNull()
+    expect(store.boardsErrorReason).toBeNull()
+  })
+
   it('a source switch mid-flight never lands the older tracker failure on the newer one', async () => {
     const { store, serve } = stubApi()
     let rejectJira!: (e: unknown) => void
@@ -100,4 +139,86 @@ describe('bug hunt store — board listing failures', () => {
     expect(store.boardsErrorReason).toBeNull()
     expect(store.boardsError).toBeNull()
   })
+
+  it('leaves nothing loading when the next tracker has no board to list', async () => {
+    // The abandoned listing's own `finally` will not run until it settles, which for a hanging
+    // tracker is never. A picker (or a Hunt button) gated on the flag would wait on a request
+    // nobody is waiting for.
+    const { store, serve } = stubApi()
+    serve(() => new Promise(() => {}))
+    void store.loadBoards('jira')
+    expect(store.boardsLoading).toBe(true)
+
+    store.dropBoards('github')
+
+    expect(store.boardsLoading).toBe(false)
+  })
+
+  it('a superseded listing never reports the tracker now loading as done', async () => {
+    const { store, serve } = stubApi()
+    let settleJira!: (v: unknown) => void
+    serve(() => new Promise((res) => (settleJira = res)))
+    const inFlight = store.loadBoards('jira')
+
+    serve(() => new Promise(() => {}))
+    void store.loadBoards('linear')
+    settleJira({ source: 'jira', boards: [] })
+    await inFlight
+
+    expect(store.boardsSource).toBe('linear')
+    expect(store.boardsLoading).toBe(true)
+  })
+})
+
+describe('bug hunt store — scan failures', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('keeps the backend reason for the one failure the surface words itself', async () => {
+    // `repo_not_linked` names something fixable on this board, so the modal states it beside the
+    // scope it invalidates instead of raising a toast. That routing reads ONLY this field.
+    const { store, serveHunt } = stubApi()
+    serveHunt(() => Promise.reject(apiError(422, 'validation', { reason: 'repo_not_linked' })))
+
+    expect(await store.hunt('github', SCAN)).toBe(false)
+
+    expect(store.huntErrorReason).toBe('repo_not_linked')
+    expect(store.huntError).toBeTruthy()
+    expect(store.result).toBeNull()
+  })
+
+  it('records NO reason for a scan that simply failed, so it stays a toast', async () => {
+    const { store, serveHunt } = stubApi()
+    serveHunt(() => Promise.reject(apiError(502, 'upstream')))
+
+    expect(await store.hunt('jira', { containerId: 'blk_auth', board: 'PROJ' })).toBe(false)
+
+    expect(store.huntErrorReason).toBeNull()
+    expect(store.huntError).toBeTruthy()
+  })
+
+  it('clears a previous scan failure once a later scan succeeds', async () => {
+    const { store, serveHunt } = stubApi()
+    serveHunt(() => Promise.reject(apiError(422, 'validation', { reason: 'repo_not_linked' })))
+    await store.hunt('github', SCAN)
+
+    serveHunt(() => Promise.resolve(huntResult()))
+    expect(await store.hunt('github', SCAN)).toBe(true)
+
+    expect(store.huntError).toBeNull()
+    expect(store.huntErrorReason).toBeNull()
+    expect(store.result?.board).toBe('acme/web')
+  })
+
+  it('drops the reason on reset, so a re-opened hunt never re-states the old refusal', async () => {
+    const { store, serveHunt } = stubApi()
+    serveHunt(() => Promise.reject(apiError(422, 'validation', { reason: 'repo_not_linked' })))
+    await store.hunt('github', SCAN)
+
+    store.reset()
+
+    expect(store.huntErrorReason).toBeNull()
+    expect(store.huntError).toBeNull()
+  })
 })

package/app/stores/bugHunt.ts

@@ -38,6 +38,13 @@ export const useBugHuntStore = defineStore('bugHunt', () => {
   const result = ref<BugHuntResult | null>(null)
   const hunting = ref(false)
   const huntError = ref<string | null>(null)
+  /**
+   * The backend's machine-readable reason for a failed scan, kept for the same reason
+   * {@link boardsErrorReason} is: `repo_not_linked` says the service this hunt is scoped to has
+   * no repository to read issues from, which is a state the person can fix on the board and the
+   * only one the surface words itself. Every other failure stays a toast.
+   */
+  const huntErrorReason = ref<string | null>(null)
   /** The candidate currently being adopted, so only its own row shows a spinner. */
   const adopting = ref<string | null>(null)
 
@@ -62,20 +69,44 @@ export const useBugHuntStore = defineStore('bugHunt', () => {
       boardsError.value = e instanceof Error ? e.message : String(e)
       boardsErrorReason.value = apiErrorReason(e)
     } finally {
-      boardsLoading.value = false
+      // Only the listing the picker is still showing owns the flag. A superseded one clearing it
+      // unconditionally would report the tracker now being loaded as done, which is the same
+      // mistake in the opposite direction from the one `dropBoards` avoids.
+      if (boardsSource.value === source) boardsLoading.value = false
     }
   }
 
+  /**
+   * Forget the board listing, because the tracker now in the picker has none to offer: its board
+   * is the chosen service's repository, resolved server-side. Called INSTEAD of `loadBoards`, so a
+   * previous tracker's list (or its failure, which the surface renders as a warning) cannot sit
+   * under a tracker that has no board field at all. `boardsSource` moves with it, so a listing
+   * still in flight for that previous tracker lands on nothing rather than reviving the picker.
+   */
+  function dropBoards(source: TaskSourceKind): void {
+    boardsSource.value = source
+    boards.value = []
+    boardsError.value = null
+    boardsErrorReason.value = null
+    // The listing in flight belongs to the tracker being left, and its `finally` will not run
+    // until it settles — indefinitely, if that tracker hangs. Clearing the flag with the rest of
+    // the state is what makes "land on nothing" true of the WHOLE listing rather than of four of
+    // its five fields, so a reader gating on it cannot wait on a request nobody is waiting for.
+    boardsLoading.value = false
+  }
+
   /** Run a hunt and keep its ranked result. Returns false when the scan itself failed. */
   async function hunt(source: TaskSourceKind, input: RunBugHuntInput): Promise<boolean> {
     hunting.value = true
     huntError.value = null
+    huntErrorReason.value = null
     try {
       result.value = await api.runBugHunt(workspace.requireId(), source, input)
       return true
     } catch (e) {
       result.value = null
       huntError.value = e instanceof Error ? e.message : String(e)
+      huntErrorReason.value = apiErrorReason(e)
       return false
     } finally {
       hunting.value = false
@@ -117,6 +148,7 @@ export const useBugHuntStore = defineStore('bugHunt', () => {
   function reset(): void {
     result.value = null
     huntError.value = null
+    huntErrorReason.value = null
     adopting.value = null
   }
 
@@ -131,8 +163,10 @@ export const useBugHuntStore = defineStore('bugHunt', () => {
     hasResult,
     hunting,
     huntError,
+    huntErrorReason,
     adopting,
     loadBoards,
+    dropBoards,
     hunt,
     adopt,
     reset,

package/app/stores/tasks.spec.ts

@@ -34,6 +34,8 @@ const jiraDescriptor: TaskSourceState = {
   enabled: true,
   supportsIntake: true,
   ignoredIntakePredicates: [],
+  // Jira issues belong to a project, not a repository, so a hunt on it picks a board.
+  repoBacked: false,
   // Jira carries its own credentials, so it rides no VCS connection.
   ridesVcsProvider: null,
 }

package/app/utils/failureKinds.ts

@@ -26,6 +26,7 @@ export const FAILURE_KIND_KEYS: Record<AgentFailureKind, string> = {
   dispatch: 'platformObservability.failureKind.dispatch',
   environment: 'platformObservability.failureKind.environment',
   evicted: 'platformObservability.failureKind.evicted',
+  harness_shutdown: 'platformObservability.failureKind.harness_shutdown',
   timeout: 'platformObservability.failureKind.timeout',
   agent: 'platformObservability.failureKind.agent',
   job_failed: 'platformObservability.failureKind.job_failed',

package/app/utils/intakePredicates.spec.ts

@@ -14,6 +14,7 @@ function state(ignored: TaskSourceState['ignoredIntakePredicates']): TaskSourceS
     enabled: true,
     ridesVcsProvider: 'gitlab',
     supportsIntake: true,
+    repoBacked: true,
     ignoredIntakePredicates: ignored,
   }
 }

package/i18n/locales/de.json

@@ -3848,6 +3848,7 @@
       "dispatch": "Zustellung",
       "environment": "Umgebung",
       "evicted": "Verdrängt",
+      "harness_shutdown": "Harness beendet",
       "timeout": "Zeitüberschreitung",
       "agent": "Agent",
       "job_failed": "Job fehlgeschlagen",
@@ -4296,7 +4297,9 @@
     "tracker": "Tracker",
     "board": "Board",
     "pickBoard": "Board auswählen",
-    "boardPlaceholder": "Projektschlüssel, Team-ID oder owner/repo",
+    "boardPlaceholder": "Projektschlüssel oder Team-ID",
+    "boardFromService": "Das mit diesem Service verknüpfte Repository",
+    "boardNeedsRepo": "Mit diesem Service ist kein Repository verknüpft, es gibt also keine Tickets zu durchsuchen. Verknüpfe eines im Service-Panel.",
     "boardsFailed": "Boards konnten nicht geladen werden: {reason}",
     "issueType": "Vorgangstyp",
     "issueTypeHelp": "Standard ist bug. Wird von Trackern ohne Vorgangstypen ignoriert.",
@@ -4305,6 +4308,8 @@
     "labelsHelp": "Durch Komma getrennt. Alle müssen vorhanden sein.",
     "adoptInto": "Ausgewählten Fehler hinzufügen zu",
     "adoptingInto": "Der ausgewählte Fehler landet in {container}",
+    "huntIn": "Zu durchsuchender Service",
+    "huntingIn": "Durchsucht wird das mit {container} verknüpfte Repository; dort landet auch der ausgewählte Fehler.",
     "run": "Jagen",
     "running": "Board wird gelesen und die Funde werden bewertet…",
     "huntFailed": "Die Jagd ist fehlgeschlagen",
@@ -4317,6 +4322,7 @@
     "noCandidates": "Auf diesem Board gab es keine offenen, nicht zugewiesenen Fehler.",
     "ratings": "Auswirkung {impact}/5, Aufwand {complexity}/5, Konfidenz {confidence}",
     "viaModel": "Bewertet von {model}.",
+    "scannedBoard": "{board} durchsucht.",
     "truncated": "Es wurden nur die ersten {count} passenden Fehler geprüft; dieses Board enthält mehr.",
     "comments": "{count} Kommentar | {count} Kommentare",
     "confidence": {
@@ -4330,6 +4336,10 @@
       "failed": "Die Bewertung konnte nicht abgeschlossen werden, daher sind diese unbewertet.",
       "over_budget": "Dieser Arbeitsbereich hat sein Ausgabenbudget überschritten, daher wurden diese nicht bewertet.",
       "empty": "Nichts zu bewerten."
+    },
+    "refusal": {
+      "boardFromService": "Dieser Tracker durchsucht das Repository, mit dem der gewählte Service verknüpft ist, und hat daher kein eigenes Board.",
+      "missingBoard": "Wähle das Board aus, auf dem gesucht werden soll."
     }
   },
   "pipeline": {

package/i18n/locales/en.json

@@ -1892,6 +1892,7 @@
       "dispatch": "Dispatch",
       "environment": "Environment",
       "evicted": "Evicted",
+      "harness_shutdown": "Harness shut down",
       "timeout": "Timeout",
       "agent": "Agent",
       "job_failed": "Job failed",
@@ -4897,7 +4898,9 @@
     "tracker": "Tracker",
     "board": "Board",
     "pickBoard": "Pick a board",
-    "boardPlaceholder": "Project key, team id or owner/repo",
+    "boardPlaceholder": "Project key or team id",
+    "boardFromService": "The repository this service is linked to",
+    "boardNeedsRepo": "This service has no repository linked, so it has no issues to hunt. Link one from the service panel.",
     "boardsFailed": "Boards could not be loaded: {reason}",
     "issueType": "Issue type",
     "issueTypeHelp": "Defaults to bug. Ignored by trackers with no issue types.",
@@ -4906,6 +4909,8 @@
     "labelsHelp": "Comma separated. All of them must be present.",
     "adoptInto": "Add the picked bug to",
     "adoptingInto": "The picked bug lands in {container}",
+    "huntIn": "Service to hunt",
+    "huntingIn": "Hunting the repository linked to {container}; the picked bug lands there too.",
     "run": "Hunt",
     "running": "Reading the board and rating what it finds…",
     "huntFailed": "The hunt failed",
@@ -4918,6 +4923,7 @@
     "noCandidates": "No open, unassigned bugs matched on this board.",
     "ratings": "Impact {impact}/5, complexity {complexity}/5, {confidence} confidence",
     "viaModel": "Rated by {model}.",
+    "scannedBoard": "Scanned {board}.",
     "truncated": "Only the first {count} matching bugs were scanned; this board holds more.",
     "comments": "{count} comment | {count} comments",
     "@comments": {
@@ -4934,6 +4940,10 @@
       "failed": "The rating could not be completed, so these are unrated.",
       "over_budget": "This workspace is over its spend budget, so these were not rated.",
       "empty": "Nothing to rate."
+    },
+    "refusal": {
+      "boardFromService": "This tracker scans the repository the chosen service is linked to, so it has no board of its own.",
+      "missingBoard": "Pick the board to hunt on."
     }
   },
   "pipeline": {

package/i18n/locales/es.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Despacho",
       "environment": "Entorno",
       "evicted": "Desalojada",
+      "harness_shutdown": "Harness detenido",
       "timeout": "Tiempo agotado",
       "agent": "Agente",
       "job_failed": "Trabajo fallido",
@@ -4739,7 +4740,9 @@
     "tracker": "Gestor de incidencias",
     "board": "Tablero",
     "pickBoard": "Elige un tablero",
-    "boardPlaceholder": "Clave de proyecto, id de equipo o owner/repo",
+    "boardPlaceholder": "Clave de proyecto o id de equipo",
+    "boardFromService": "El repositorio vinculado a este servicio",
+    "boardNeedsRepo": "Este servicio no tiene ningún repositorio vinculado, así que no hay incidencias que explorar. Vincula uno desde el panel del servicio.",
     "boardsFailed": "No se pudieron cargar los tableros: {reason}",
     "issueType": "Tipo de incidencia",
     "issueTypeHelp": "Por defecto bug. Se ignora en gestores sin tipos de incidencia.",
@@ -4748,6 +4751,8 @@
     "labelsHelp": "Separadas por comas. Todas deben estar presentes.",
     "adoptInto": "Añadir el error elegido a",
     "adoptingInto": "El error elegido se añade a {container}",
+    "huntIn": "Servicio a explorar",
+    "huntingIn": "Se explora el repositorio vinculado a {container}; el error elegido también se añade ahí.",
     "run": "Cazar",
     "running": "Leyendo el tablero y valorando lo que encuentra…",
     "huntFailed": "La caza ha fallado",
@@ -4760,6 +4765,7 @@
     "noCandidates": "No hay errores abiertos y sin asignar que coincidan en este tablero.",
     "ratings": "Impacto {impact}/5, complejidad {complexity}/5, confianza {confidence}",
     "viaModel": "Valorado por {model}.",
+    "scannedBoard": "Explorado {board}.",
     "truncated": "Solo se han explorado los primeros {count} errores coincidentes; este tablero contiene más.",
     "comments": "{count} comentario | {count} comentarios",
     "confidence": {
@@ -4773,6 +4779,10 @@
       "failed": "No se ha podido completar la valoración, así que están sin valorar.",
       "over_budget": "Este espacio de trabajo ha superado su presupuesto de gasto, así que no se han valorado.",
       "empty": "Nada que valorar."
+    },
+    "refusal": {
+      "boardFromService": "Este rastreador analiza el repositorio al que está vinculado el servicio elegido, así que no tiene un tablero propio.",
+      "missingBoard": "Elige el tablero en el que buscar."
     }
   },
   "pipeline": {

package/i18n/locales/fr.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Envoi",
       "environment": "Environnement",
       "evicted": "Évincée",
+      "harness_shutdown": "Harness arrêté",
       "timeout": "Délai dépassé",
       "agent": "Agent",
       "job_failed": "Tâche échouée",
@@ -4739,7 +4740,9 @@
     "tracker": "Gestionnaire de tickets",
     "board": "Tableau",
     "pickBoard": "Choisir un tableau",
-    "boardPlaceholder": "Clé de projet, id d'équipe ou owner/repo",
+    "boardPlaceholder": "Clé de projet ou id d'équipe",
+    "boardFromService": "Le dépôt lié à ce service",
+    "boardNeedsRepo": "Aucun dépôt n'est lié à ce service : il n'y a donc pas de tickets à explorer. Liez-en un depuis le panneau du service.",
     "boardsFailed": "Impossible de charger les tableaux : {reason}",
     "issueType": "Type de ticket",
     "issueTypeHelp": "Par défaut bug. Ignoré par les gestionnaires sans types de tickets.",
@@ -4748,6 +4751,8 @@
     "labelsHelp": "Séparées par des virgules. Toutes doivent être présentes.",
     "adoptInto": "Ajouter le bug retenu à",
     "adoptingInto": "Le bug retenu est ajouté à {container}",
+    "huntIn": "Service à explorer",
+    "huntingIn": "Exploration du dépôt lié à {container} ; le bug retenu y est ajouté.",
     "run": "Chasser",
     "running": "Lecture du tableau et évaluation des résultats…",
     "huntFailed": "La chasse a échoué",
@@ -4760,6 +4765,7 @@
     "noCandidates": "Aucun bug ouvert et non assigné ne correspond sur ce tableau.",
     "ratings": "Impact {impact}/5, complexité {complexity}/5, confiance {confidence}",
     "viaModel": "Évalué par {model}.",
+    "scannedBoard": "{board} exploré.",
     "truncated": "Seuls les {count} premiers bugs correspondants ont été parcourus ; ce tableau en contient davantage.",
     "comments": "{count} commentaire | {count} commentaires",
     "confidence": {
@@ -4773,6 +4779,10 @@
       "failed": "L'évaluation n'a pas pu aboutir, ils sont donc non évalués.",
       "over_budget": "Cet espace de travail a dépassé son budget de dépenses, ces bogues n'ont donc pas été évalués.",
       "empty": "Rien à évaluer."
+    },
+    "refusal": {
+      "boardFromService": "Ce traqueur analyse le dépôt auquel le service choisi est lié : il n'a donc pas de tableau propre.",
+      "missingBoard": "Choisissez le tableau sur lequel chercher."
     }
   },
   "pipeline": {

package/i18n/locales/he.json

@@ -1794,6 +1794,7 @@
       "dispatch": "שיגור",
       "environment": "סביבה",
       "evicted": "פונתה",
+      "harness_shutdown": "כיבוי ה-Harness",
       "timeout": "פסק זמן",
       "agent": "סוכן",
       "job_failed": "המשימה נכשלה",
@@ -4739,7 +4740,9 @@
     "tracker": "מערכת מעקב",
     "board": "לוח",
     "pickBoard": "בחר לוח",
-    "boardPlaceholder": "מפתח פרויקט, מזהה צוות או owner/repo",
+    "boardPlaceholder": "מפתח פרויקט או מזהה צוות",
+    "boardFromService": "המאגר המקושר לשירות הזה",
+    "boardNeedsRepo": "לשירות הזה לא מקושר מאגר, ולכן אין בו תקלות לסרוק. קשר מאגר מתוך פאנל השירות.",
     "boardsFailed": "לא ניתן היה לטעון את הלוחות: {reason}",
     "issueType": "סוג הפנייה",
     "issueTypeHelp": "ברירת המחדל היא bug. מתעלמים ממנו במערכות ללא סוגי פניות.",
@@ -4748,6 +4751,8 @@
     "labelsHelp": "מופרדות בפסיקים. כולן חייבות להופיע.",
     "adoptInto": "הוסף את הבאג הנבחר אל",
     "adoptingInto": "הבאג הנבחר יתווסף ל-{container}",
+    "huntIn": "השירות לסריקה",
+    "huntingIn": "נסרק המאגר המקושר ל-{container}; הבאג הנבחר יתווסף לשם.",
     "run": "צוד",
     "running": "קורא את הלוח ומעריך את מה שנמצא…",
     "huntFailed": "הציד נכשל",
@@ -4760,6 +4765,7 @@
     "noCandidates": "אין בלוח הזה באגים פתוחים ולא משויכים שתואמים.",
     "ratings": "השפעה {impact}/5, מורכבות {complexity}/5, רמת ודאות {confidence}",
     "viaModel": "הוערך על ידי {model}.",
+    "scannedBoard": "נסרק {board}.",
     "truncated": "נסרקו רק {count} הבאגים התואמים הראשונים; בלוח הזה יש עוד.",
     "comments": "תגובה אחת | שתי תגובות | {count} תגובות",
     "confidence": {
@@ -4773,6 +4779,10 @@
       "failed": "לא ניתן היה להשלים את ההערכה, ולכן אלה אינם מדורגים.",
       "over_budget": "סביבת העבודה חרגה מתקציב ההוצאות, ולכן הבאגים האלה לא דורגו.",
       "empty": "אין מה להעריך."
+    },
+    "refusal": {
+      "boardFromService": "הגששן סורק את המאגר שאליו מקושר השירות שנבחר, ולכן אין לו לוח משלו.",
+      "missingBoard": "בחרו את הלוח שבו לחפש."
     }
   },
   "pipeline": {

package/i18n/locales/it.json

@@ -3848,6 +3848,7 @@
       "dispatch": "Invio",
       "environment": "Ambiente",
       "evicted": "Sfrattata",
+      "harness_shutdown": "Harness arrestato",
       "timeout": "Timeout",
       "agent": "Agente",
       "job_failed": "Job fallito",
@@ -4296,7 +4297,9 @@
     "tracker": "Tracker",
     "board": "Bacheca",
     "pickBoard": "Scegli una bacheca",
-    "boardPlaceholder": "Chiave progetto, id team oppure owner/repo",
+    "boardPlaceholder": "Chiave progetto o id team",
+    "boardFromService": "Il repository collegato a questo servizio",
+    "boardNeedsRepo": "A questo servizio non è collegato alcun repository, quindi non ci sono issue da cercare. Collegane uno dal pannello del servizio.",
     "boardsFailed": "Impossibile caricare le board: {reason}",
     "issueType": "Tipo di ticket",
     "issueTypeHelp": "Per impostazione predefinita bug. Ignorato dai tracker senza tipi di ticket.",
@@ -4305,6 +4308,8 @@
     "labelsHelp": "Separate da virgole. Devono essere tutte presenti.",
     "adoptInto": "Aggiungi il bug scelto a",
     "adoptingInto": "Il bug scelto viene aggiunto a {container}",
+    "huntIn": "Servizio da esaminare",
+    "huntingIn": "Viene esaminato il repository collegato a {container}; il bug scelto viene aggiunto lì.",
     "run": "Cerca",
     "running": "Lettura della bacheca e valutazione di quanto trovato…",
     "huntFailed": "La caccia non è riuscita",
@@ -4317,6 +4322,7 @@
     "noCandidates": "Nessun bug aperto e non assegnato corrisponde su questa bacheca.",
     "ratings": "Impatto {impact}/5, complessità {complexity}/5, confidenza {confidence}",
     "viaModel": "Valutato da {model}.",
+    "scannedBoard": "Esaminato {board}.",
     "truncated": "Sono stati esaminati solo i primi {count} bug corrispondenti; questa bacheca ne contiene altri.",
     "comments": "{count} commento | {count} commenti",
     "confidence": {
@@ -4330,6 +4336,10 @@
       "failed": "La valutazione non è stata completata, quindi non sono valutati.",
       "over_budget": "Questo spazio di lavoro ha superato il budget di spesa, quindi non sono stati valutati.",
       "empty": "Nulla da valutare."
+    },
+    "refusal": {
+      "boardFromService": "Questo tracker analizza il repository a cui è collegato il servizio scelto, quindi non ha una board propria.",
+      "missingBoard": "Scegli la board su cui cercare."
     }
   },
   "pipeline": {

package/i18n/locales/ja.json

@@ -1794,6 +1794,7 @@
       "dispatch": "ディスパッチ",
       "environment": "環境",
       "evicted": "退避",
+      "harness_shutdown": "Harness 停止",
       "timeout": "タイムアウト",
       "agent": "エージェント",
       "job_failed": "ジョブ失敗",
@@ -4739,7 +4740,9 @@
     "tracker": "トラッカー",
     "board": "ボード",
     "pickBoard": "ボードを選択",
-    "boardPlaceholder": "プロジェクトキー、チーム ID または owner/repo",
+    "boardPlaceholder": "プロジェクトキーまたはチーム ID",
+    "boardFromService": "このサービスにリンクされたリポジトリ",
+    "boardNeedsRepo": "このサービスにはリポジトリがリンクされていないため、探索できる課題がありません。サービスパネルからリンクしてください。",
     "boardsFailed": "ボードを読み込めませんでした: {reason}",
     "issueType": "課題タイプ",
     "issueTypeHelp": "既定は bug です。課題タイプを持たないトラッカーでは無視されます。",
@@ -4748,6 +4751,8 @@
     "labelsHelp": "カンマ区切り。すべて付いている必要があります。",
     "adoptInto": "選んだバグの追加先",
     "adoptingInto": "選んだバグは {container} に追加されます",
+    "huntIn": "探索するサービス",
+    "huntingIn": "{container} にリンクされたリポジトリを探索します。選んだバグもそこに追加されます。",
     "run": "ハント",
     "running": "ボードを読み取り、見つかったものを評価しています…",
     "huntFailed": "ハントに失敗しました",
@@ -4760,6 +4765,7 @@
     "noCandidates": "このボードには条件に合う未割り当ての未解決バグがありません。",
     "ratings": "影響度 {impact}/5、複雑さ {complexity}/5、確信度 {confidence}",
     "viaModel": "{model} による評価です。",
+    "scannedBoard": "{board} を走査しました。",
     "truncated": "一致したバグのうち最初の {count} 件のみを走査しました。このボードにはさらにあります。",
     "comments": "コメント {count} 件 | コメント {count} 件",
     "confidence": {
@@ -4773,6 +4779,10 @@
       "failed": "評価を完了できなかったため、未評価のまま表示しています。",
       "over_budget": "このワークスペースは利用予算を超えているため、評価は行われませんでした。",
       "empty": "評価する対象がありません。"
+    },
+    "refusal": {
+      "boardFromService": "このトラッカーは選択したサービスにリンクされたリポジトリを走査するため、独自のボードはありません。",
+      "missingBoard": "調査するボードを選択してください。"
     }
   },
   "pipeline": {

package/i18n/locales/pl.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Wysłanie",
       "environment": "Środowisko",
       "evicted": "Usunięte",
+      "harness_shutdown": "Harness zatrzymany",
       "timeout": "Przekroczono czas",
       "agent": "Agent",
       "job_failed": "Zadanie nieudane",
@@ -4739,7 +4740,9 @@
     "tracker": "System zgłoszeń",
     "board": "Tablica",
     "pickBoard": "Wybierz tablicę",
-    "boardPlaceholder": "Klucz projektu, identyfikator zespołu lub owner/repo",
+    "boardPlaceholder": "Klucz projektu lub identyfikator zespołu",
+    "boardFromService": "Repozytorium powiązane z tą usługą",
+    "boardNeedsRepo": "Ta usługa nie ma powiązanego repozytorium, więc nie ma w niej zgłoszeń do przeszukania. Powiąż je w panelu usługi.",
     "boardsFailed": "Nie udało się wczytać tablic: {reason}",
     "issueType": "Typ zgłoszenia",
     "issueTypeHelp": "Domyślnie bug. Ignorowane przez systemy bez typów zgłoszeń.",
@@ -4748,6 +4751,8 @@
     "labelsHelp": "Oddzielone przecinkami. Wszystkie muszą występować.",
     "adoptInto": "Dodaj wybrany błąd do",
     "adoptingInto": "Wybrany błąd trafi do {container}",
+    "huntIn": "Usługa do przeszukania",
+    "huntingIn": "Przeszukiwane jest repozytorium powiązane z {container}; tam też trafi wybrany błąd.",
     "run": "Poluj",
     "running": "Odczytywanie tablicy i ocenianie znalezionych zgłoszeń…",
     "huntFailed": "Polowanie nie powiodło się",
@@ -4760,6 +4765,7 @@
     "noCandidates": "Na tej tablicy nie ma pasujących otwartych, nieprzypisanych błędów.",
     "ratings": "Wpływ {impact}/5, złożoność {complexity}/5, pewność {confidence}",
     "viaModel": "Ocenione przez {model}.",
+    "scannedBoard": "Przeszukano {board}.",
     "truncated": "Przeszukano tylko pierwsze pasujące zgłoszenia w liczbie {count}; ta tablica zawiera ich więcej.",
     "comments": "{count} komentarz | {count} komentarze | {count} komentarzy",
     "confidence": {
@@ -4773,6 +4779,10 @@
       "failed": "Nie udało się dokończyć oceny, więc te zgłoszenia są nieocenione.",
       "over_budget": "Ta przestrzeń robocza przekroczyła budżet wydatków, więc nie zostały ocenione.",
       "empty": "Nie ma czego oceniać."
+    },
+    "refusal": {
+      "boardFromService": "Ten tracker przeszukuje repozytorium powiązane z wybraną usługą, więc nie ma własnej tablicy.",
+      "missingBoard": "Wybierz tablicę, na której chcesz szukać."
     }
   },
   "pipeline": {

package/i18n/locales/tr.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Gönderim",
       "environment": "Ortam",
       "evicted": "Tahliye edildi",
+      "harness_shutdown": "Harness kapatıldı",
       "timeout": "Zaman aşımı",
       "agent": "Aracı",
       "job_failed": "İş başarısız",
@@ -4739,7 +4740,9 @@
     "tracker": "Takip aracı",
     "board": "Pano",
     "pickBoard": "Bir pano seçin",
-    "boardPlaceholder": "Proje anahtarı, takım kimliği veya owner/repo",
+    "boardPlaceholder": "Proje anahtarı veya takım kimliği",
+    "boardFromService": "Bu servise bağlı depo",
+    "boardNeedsRepo": "Bu servise bağlı bir depo yok, dolayısıyla taranacak kayıt da yok. Servis panelinden bir depo bağlayın.",
     "boardsFailed": "Panolar yüklenemedi: {reason}",
     "issueType": "Kayıt türü",
     "issueTypeHelp": "Varsayılan olarak bug. Kayıt türü olmayan araçlarda yok sayılır.",
@@ -4748,6 +4751,8 @@
     "labelsHelp": "Virgülle ayrılır. Hepsinin bulunması gerekir.",
     "adoptInto": "Seçilen hatayı şuraya ekle",
     "adoptingInto": "Seçilen hata {container} içine eklenir",
+    "huntIn": "Taranacak servis",
+    "huntingIn": "{container} servisine bağlı depo taranıyor; seçilen hata da oraya eklenir.",
     "run": "Avla",
     "running": "Pano okunuyor ve bulunanlar değerlendiriliyor…",
     "huntFailed": "Av başarısız oldu",
@@ -4760,6 +4765,7 @@
     "noCandidates": "Bu panoda eşleşen açık ve atanmamış hata yok.",
     "ratings": "Etki {impact}/5, karmaşıklık {complexity}/5, güven {confidence}",
     "viaModel": "{model} tarafından değerlendirildi.",
+    "scannedBoard": "{board} tarandı.",
     "truncated": "Yalnızca eşleşen ilk {count} hata tarandı; bu panoda daha fazlası var.",
     "comments": "{count} yorum | {count} yorum",
     "confidence": {
@@ -4773,6 +4779,10 @@
       "failed": "Değerlendirme tamamlanamadı, bu yüzden bunlar değerlendirilmedi.",
       "over_budget": "Bu çalışma alanı harcama bütçesini aştığı için bunlar değerlendirilmedi.",
       "empty": "Değerlendirilecek bir şey yok."
+    },
+    "refusal": {
+      "boardFromService": "Bu izleyici, seçilen hizmete bağlı depoyu tarar; bu yüzden kendine ait bir panosu yoktur.",
+      "missingBoard": "Aranacak panoyu seçin."
     }
   },
   "pipeline": {

package/i18n/locales/uk.json

@@ -1794,6 +1794,7 @@
       "dispatch": "Відправлення",
       "environment": "Середовище",
       "evicted": "Витіснено",
+      "harness_shutdown": "Harness зупинено",
       "timeout": "Час вичерпано",
       "agent": "Агент",
       "job_failed": "Завдання не виконано",
@@ -4739,7 +4740,9 @@
     "tracker": "Трекер",
     "board": "Дошка",
     "pickBoard": "Оберіть дошку",
-    "boardPlaceholder": "Ключ проєкту, ідентифікатор команди або owner/repo",
+    "boardPlaceholder": "Ключ проєкту або ідентифікатор команди",
+    "boardFromService": "Репозиторій, пов'язаний із цим сервісом",
+    "boardNeedsRepo": "Із цим сервісом не пов'язано жодного репозиторію, тож у ньому немає задач для перегляду. Пов'яжіть репозиторій на панелі сервісу.",
     "boardsFailed": "Не вдалося завантажити дошки: {reason}",
     "issueType": "Тип запиту",
     "issueTypeHelp": "Типово bug. Ігнорується трекерами без типів запитів.",
@@ -4748,6 +4751,8 @@
     "labelsHelp": "Через кому. Усі мають бути присутні.",
     "adoptInto": "Додати обрану помилку до",
     "adoptingInto": "Обрана помилка додається до {container}",
+    "huntIn": "Сервіс для перегляду",
+    "huntingIn": "Переглядається репозиторій, пов'язаний із {container}; туди ж потрапить обрана помилка.",
     "run": "Полювати",
     "running": "Читаємо дошку та оцінюємо знайдене…",
     "huntFailed": "Полювання не вдалося",
@@ -4760,6 +4765,7 @@
     "noCandidates": "На цій дошці немає відкритих і не призначених помилок, що відповідають умовам.",
     "ratings": "Вплив {impact}/5, складність {complexity}/5, впевненість {confidence}",
     "viaModel": "Оцінено моделлю {model}.",
+    "scannedBoard": "Переглянуто {board}.",
     "truncated": "Переглянуто лише перші відповідні помилки в кількості {count}; на цій дошці їх більше.",
     "comments": "{count} коментар | {count} коментарі | {count} коментарів",
     "confidence": {
@@ -4773,6 +4779,10 @@
       "failed": "Не вдалося завершити оцінювання, тому ці помилки не оцінено.",
       "over_budget": "Цей робочий простір перевищив бюджет витрат, тому їх не оцінено.",
       "empty": "Нема чого оцінювати."
+    },
+    "refusal": {
+      "boardFromService": "Цей трекер сканує репозиторій, з яким пов’язано вибраний сервіс, тож власної дошки не має.",
+      "missingBoard": "Виберіть дошку, на якій шукати."
     }
   },
   "pipeline": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.271.0",
+  "version": "0.273.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
     "@modular-vue/vue": "^1.4.1",
     "@nuxt/ui": "^4.10.0",
     "@nuxtjs/i18n": "^10.6.0",
-    "@pinia/nuxt": "^1.0.1",
+    "@pinia/nuxt": "^1.0.2",
     "@toad-contracts/core": "0.4.0",
     "@toad-contracts/frontend-http-client": "0.3.2",
     "@toad-contracts/valibot": "0.5.0",
@@ -35,12 +35,12 @@
     "@vue-flow/node-resizer": "^1.5.1",
     "@vueuse/core": "^14.4.0",
     "markdown-it": "^15.0.0",
-    "pinia": "^4.0.2",
+    "pinia": "^4.0.3",
     "pinia-plugin-persistedstate": "^4.7.1",
     "valibot": "^1.4.2",
     "vue": "3.5.41",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.310.0"
+    "@cat-factory/contracts": "0.312.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",