@cat-factory/app 0.270.3 → 0.272.0

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/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

@@ -2033,6 +2033,13 @@
       "awaitingChoice": "Wartet auf eine menschliche Wahl",
       "approvalGate": "Freigabe-Gate",
       "companionReview": "Begleiter-Prüfung",
+      "findingSeverity": {
+        "blocker": "Muss behoben werden",
+        "major": "Sollte behoben werden",
+        "minor": "Geringfügig",
+        "ungraded": "Kommentar",
+        "unrecognized": "Unbekannte Stufe ({level})"
+      },
       "correctionIterations": "{count} Korrekturiteration. | {count} Korrekturiterationen.",
       "state": {
         "pending": "Ausstehend",
@@ -2069,7 +2076,9 @@
       "closeEsc": "Schließen (Esc)",
       "companionCapHeading": "{agent} hat sein Überarbeitungslimit von {attempts} Versuchen erreicht, noch unter der {threshold}-Schwelle.",
       "companionCapDetail": "Führe eine weitere automatische Überarbeitungsrunde durch, fahre mit dem nächsten Schritt fort und akzeptiere die aktuelle Ausgabe, oder stoppe und setze die Aufgabe zurück, damit du die Eingaben bearbeiten und erneut einreichen kannst.",
-      "companionStalledHeading": "{agent} hat die Überarbeitungsschleife nach {attempts} von {maxAttempts} Runden gestoppt: Die letzte Überarbeitung kam unverändert zurück und die Bewertung blieb unter der {threshold}-Schwelle.",
+      "companionCapBlockedHeading": "{agent} hat sein Überarbeitungslimit von {attempts} Versuchen erreicht, {count} zwingender Befund ist weiterhin offen. | {agent} hat sein Überarbeitungslimit von {attempts} Versuchen erreicht, {count} zwingende Befunde sind weiterhin offen.",
+      "companionCapBlockedDetail": "Fortfahren akzeptiert die Arbeit mit diesen ungelösten Befunden, deshalb trifft die Risikorichtlinie dieses Laufs diese Wahl nie für dich. Führe eine weitere automatische Überarbeitungsrunde durch, fahre trotzdem mit der aktuellen Ausgabe fort, oder stoppe und setze die Aufgabe zurück, damit du die Eingaben bearbeiten und erneut einreichen kannst.",
+      "companionStalledHeading": "{agent} hat die Überarbeitungsschleife nach {attempts} von {maxAttempts} Runden gestoppt: Die letzte Überarbeitung kam unverändert zurück und die Bewertung hat sich nicht verändert.",
       "companionStalledDetail": "Die restlichen Runden bleiben ungenutzt, weil sie nur ein bereits abgegebenes Urteil wiederholen würden. Führe trotzdem eine weitere Runde durch, fahre mit dem nächsten Schritt fort und akzeptiere die aktuelle Ausgabe, oder stoppe und setze die Aufgabe zurück, damit du die Eingaben bearbeiten und erneut einreichen kannst.",
       "infraAttempts": "Infrastruktur-Versuche",
       "hideInfraAttempts": "Infrastruktur-Versuche ausblenden",
@@ -4287,7 +4296,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.",
@@ -4296,6 +4307,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",
@@ -4308,6 +4321,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": {
@@ -4321,6 +4335,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

@@ -1458,6 +1458,13 @@
       "awaitingChoice": "Awaiting a human choice",
       "approvalGate": "Approval gate",
       "companionReview": "Companion review",
+      "findingSeverity": {
+        "blocker": "Must fix",
+        "major": "Should fix",
+        "minor": "Minor",
+        "ungraded": "Comment",
+        "unrecognized": "Level not recognised ({level})"
+      },
       "correctionIterations": "{count} correction iteration. | {count} correction iterations.",
       "state": {
         "pending": "Pending",
@@ -1494,7 +1501,9 @@
       "closeEsc": "Close (Esc)",
       "companionCapHeading": "{agent} hit its {attempts}-attempt rework limit, still below the {threshold} bar.",
       "companionCapDetail": "Do one more automatic rework round, proceed to the next step accepting the current output, or stop and reset the task so you can edit the inputs and resubmit.",
-      "companionStalledHeading": "{agent} stopped the rework loop after {attempts} of {maxAttempts} rounds: the last revision came back unchanged and the rating held below the {threshold} bar.",
+      "companionCapBlockedHeading": "{agent} hit its {attempts}-attempt rework limit with {count} must-fix finding still open. | {agent} hit its {attempts}-attempt rework limit with {count} must-fix findings still open.",
+      "companionCapBlockedDetail": "Proceeding accepts the work with those findings unfixed, which is why this run’s risk policy will never take that choice for you. Do one more automatic rework round, proceed anyway on the current output, or stop and reset the task so you can edit the inputs and resubmit.",
+      "companionStalledHeading": "{agent} stopped the rework loop after {attempts} of {maxAttempts} rounds: the last revision came back unchanged and its rating did not move.",
       "companionStalledDetail": "The remaining rounds were left unspent because they would only repeat a verdict already given. Do one more round anyway, proceed to the next step accepting the current output, or stop and reset the task so you can edit the inputs and resubmit.",
       "infraAttempts": "Infrastructure attempts",
       "hideInfraAttempts": "Hide infrastructure attempts",
@@ -4888,7 +4897,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.",
@@ -4897,6 +4908,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",
@@ -4909,6 +4922,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": {
@@ -4925,6 +4939,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

@@ -1348,6 +1348,13 @@
       "awaitingChoice": "Esperando una elección humana",
       "approvalGate": "Verificación de aprobación",
       "companionReview": "Revisión del acompañante",
+      "findingSeverity": {
+        "blocker": "Debe corregirse",
+        "major": "Debería corregirse",
+        "minor": "Menor",
+        "ungraded": "Comentario",
+        "unrecognized": "Nivel no reconocido ({level})"
+      },
       "correctionIterations": "{count} iteración de corrección. | {count} iteraciones de corrección.",
       "state": {
         "pending": "Pendiente",
@@ -1403,7 +1410,9 @@
       "closeEsc": "Cerrar (Esc)",
       "companionCapHeading": "{agent} alcanzó su límite de {attempts} intentos de reelaboración, aún por debajo del umbral de {threshold}.",
       "companionCapDetail": "Haz una ronda más de reelaboración automática, avanza al siguiente paso aceptando la salida actual, o detén y restablece la tarea para que puedas editar las entradas y reenviarla.",
-      "companionStalledHeading": "{agent} detuvo el bucle de reelaboración tras {attempts} de {maxAttempts} rondas: la última revisión volvió sin cambios y la puntuación se mantuvo por debajo del umbral de {threshold}.",
+      "companionCapBlockedHeading": "{agent} alcanzó su límite de {attempts} intentos de reelaboración con {count} hallazgo obligatorio aún sin resolver. | {agent} alcanzó su límite de {attempts} intentos de reelaboración con {count} hallazgos obligatorios aún sin resolver.",
+      "companionCapBlockedDetail": "Continuar acepta el trabajo con esos hallazgos sin resolver, por eso la política de riesgo de esta ejecución nunca tomará esa decisión por ti. Haz una ronda más de reelaboración automática, continúa igualmente con la salida actual, o detén y restablece la tarea para que puedas editar las entradas y reenviarla.",
+      "companionStalledHeading": "{agent} detuvo el bucle de reelaboración tras {attempts} de {maxAttempts} rondas: la última revisión volvió sin cambios y la puntuación no se movió.",
       "companionStalledDetail": "Las rondas restantes quedaron sin usar porque solo repetirían un veredicto ya emitido. Haz una ronda más de todos modos, avanza al siguiente paso aceptando la salida actual, o detén y restablece la tarea para que puedas editar las entradas y reenviarla.",
       "infraAttempts": "Intentos de infraestructura",
       "hideInfraAttempts": "Ocultar intentos de infraestructura",
@@ -4730,7 +4739,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.",
@@ -4739,6 +4750,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",
@@ -4751,6 +4764,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": {
@@ -4764,6 +4778,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

@@ -1348,6 +1348,13 @@
       "awaitingChoice": "En attente d'un choix humain",
       "approvalGate": "Gate d'approbation",
       "companionReview": "Revue du compagnon",
+      "findingSeverity": {
+        "blocker": "À corriger absolument",
+        "major": "À corriger",
+        "minor": "Mineur",
+        "ungraded": "Commentaire",
+        "unrecognized": "Niveau non reconnu ({level})"
+      },
       "correctionIterations": "{count} itération de correction. | {count} itérations de correction.",
       "state": {
         "pending": "En attente",
@@ -1403,7 +1410,9 @@
       "closeEsc": "Fermer (Esc)",
       "companionCapHeading": "{agent} a atteint sa limite de {attempts} tentatives de retravail, toujours en dessous du seuil {threshold}.",
       "companionCapDetail": "Effectuer un tour de retravail automatique supplémentaire, passer à l'étape suivante en acceptant la sortie actuelle, ou arrêter et réinitialiser la tâche pour modifier les entrées et la resoumettre.",
-      "companionStalledHeading": "{agent} a arrêté la boucle de retravail après {attempts} tours sur {maxAttempts} : la dernière révision est revenue inchangée et la note est restée sous le seuil {threshold}.",
+      "companionCapBlockedHeading": "{agent} a atteint sa limite de {attempts} tentatives de retravail avec {count} point bloquant encore ouvert. | {agent} a atteint sa limite de {attempts} tentatives de retravail avec {count} points bloquants encore ouverts.",
+      "companionCapBlockedDetail": "Poursuivre revient à accepter le travail avec ces points non corrigés, c’est pourquoi la politique de risque de cette exécution ne prendra jamais cette décision à votre place. Effectuer un tour de retravail automatique supplémentaire, poursuivre malgré tout avec la sortie actuelle, ou arrêter et réinitialiser la tâche pour modifier les entrées et la resoumettre.",
+      "companionStalledHeading": "{agent} a arrêté la boucle de retravail après {attempts} tours sur {maxAttempts} : la dernière révision est revenue inchangée et la note n'a pas bougé.",
       "companionStalledDetail": "Les tours restants n'ont pas été utilisés car ils ne feraient que répéter un verdict déjà rendu. Effectuer tout de même un tour supplémentaire, passer à l'étape suivante en acceptant la sortie actuelle, ou arrêter et réinitialiser la tâche pour modifier les entrées et la resoumettre.",
       "infraAttempts": "Tentatives d'infrastructure",
       "hideInfraAttempts": "Masquer les tentatives d'infrastructure",
@@ -4730,7 +4739,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.",
@@ -4739,6 +4750,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é",
@@ -4751,6 +4764,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": {
@@ -4764,6 +4778,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

@@ -1367,6 +1367,13 @@
       "awaitingChoice": "ממתין לבחירה אנושית",
       "approvalGate": "שער אישור",
       "companionReview": "סקירת מלווה",
+      "findingSeverity": {
+        "blocker": "חובה לתקן",
+        "major": "כדאי לתקן",
+        "minor": "מינורי",
+        "ungraded": "הערה",
+        "unrecognized": "רמה לא מזוהה ({level})"
+      },
       "correctionIterations": "מחזור תיקון אחד. | שני מחזורי תיקון. | {count} מחזורי תיקון.",
       "state": {
         "pending": "ממתין",
@@ -1403,7 +1410,9 @@
       "closeEsc": "סגור (Esc)",
       "companionCapHeading": "{agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, ועדיין מתחת לרף {threshold}.",
       "companionCapDetail": "בצע סבב עיבוד אוטומטי נוסף, המשך לשלב הבא תוך קבלת הפלט הנוכחי, או עצור ואפס את המשימה כדי לערוך את הקלטים ולשלוח מחדש.",
-      "companionStalledHeading": "{agent} עצר את לופ העיבוד מחדש לאחר {attempts} מתוך {maxAttempts} סבבים: הגרסה האחרונה חזרה ללא שינוי והדירוג נשאר מתחת לרף {threshold}.",
+      "companionCapBlockedHeading": "{agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, וממצא חובה אחד עדיין פתוח. | {agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, ושני ממצאי חובה עדיין פתוחים. | {agent} הגיע למגבלת {attempts} ניסיונות עיבוד מחדש, ו-{count} ממצאי חובה עדיין פתוחים.",
+      "companionCapBlockedDetail": "המשך פירושו קבלת העבודה בלי שהממצאים האלה תוקנו, ולכן מדיניות הסיכון של הריצה הזו לעולם לא תבחר בכך במקומך. בצע סבב עיבוד אוטומטי נוסף, המשך בכל זאת עם הפלט הנוכחי, או עצור ואפס את המשימה כדי לערוך את הקלטים ולשלוח מחדש.",
+      "companionStalledHeading": "{agent} עצר את לופ העיבוד מחדש לאחר {attempts} מתוך {maxAttempts} סבבים: הגרסה האחרונה חזרה ללא שינוי והדירוג לא זז.",
       "companionStalledDetail": "הסבבים שנותרו לא נוצלו מפני שהם רק יחזרו על שיפוט שכבר ניתן. אפשר לבצע סבב נוסף בכל זאת, להמשיך לשלב הבא תוך קבלת הפלט הנוכחי, או לעצור ולאפס את המשימה כדי לערוך את הקלטים ולשלוח מחדש.",
       "infraAttempts": "ניסיונות תשתית",
       "hideInfraAttempts": "הסתר ניסיונות תשתית",
@@ -4730,7 +4739,9 @@
     "tracker": "מערכת מעקב",
     "board": "לוח",
     "pickBoard": "בחר לוח",
-    "boardPlaceholder": "מפתח פרויקט, מזהה צוות או owner/repo",
+    "boardPlaceholder": "מפתח פרויקט או מזהה צוות",
+    "boardFromService": "המאגר המקושר לשירות הזה",
+    "boardNeedsRepo": "לשירות הזה לא מקושר מאגר, ולכן אין בו תקלות לסרוק. קשר מאגר מתוך פאנל השירות.",
     "boardsFailed": "לא ניתן היה לטעון את הלוחות: {reason}",
     "issueType": "סוג הפנייה",
     "issueTypeHelp": "ברירת המחדל היא bug. מתעלמים ממנו במערכות ללא סוגי פניות.",
@@ -4739,6 +4750,8 @@
     "labelsHelp": "מופרדות בפסיקים. כולן חייבות להופיע.",
     "adoptInto": "הוסף את הבאג הנבחר אל",
     "adoptingInto": "הבאג הנבחר יתווסף ל-{container}",
+    "huntIn": "השירות לסריקה",
+    "huntingIn": "נסרק המאגר המקושר ל-{container}; הבאג הנבחר יתווסף לשם.",
     "run": "צוד",
     "running": "קורא את הלוח ומעריך את מה שנמצא…",
     "huntFailed": "הציד נכשל",
@@ -4751,6 +4764,7 @@
     "noCandidates": "אין בלוח הזה באגים פתוחים ולא משויכים שתואמים.",
     "ratings": "השפעה {impact}/5, מורכבות {complexity}/5, רמת ודאות {confidence}",
     "viaModel": "הוערך על ידי {model}.",
+    "scannedBoard": "נסרק {board}.",
     "truncated": "נסרקו רק {count} הבאגים התואמים הראשונים; בלוח הזה יש עוד.",
     "comments": "תגובה אחת | שתי תגובות | {count} תגובות",
     "confidence": {
@@ -4764,6 +4778,10 @@
       "failed": "לא ניתן היה להשלים את ההערכה, ולכן אלה אינם מדורגים.",
       "over_budget": "סביבת העבודה חרגה מתקציב ההוצאות, ולכן הבאגים האלה לא דורגו.",
       "empty": "אין מה להעריך."
+    },
+    "refusal": {
+      "boardFromService": "הגששן סורק את המאגר שאליו מקושר השירות שנבחר, ולכן אין לו לוח משלו.",
+      "missingBoard": "בחרו את הלוח שבו לחפש."
     }
   },
   "pipeline": {