@cat-factory/app 0.162.2 → 0.164.0

package/app/composables/api/bugHunt.ts

@@ -0,0 +1,40 @@
+import {
+  adoptBugHuntCandidateContract,
+  listTrackerBoardsContract,
+  runBugHuntContract,
+} from '@cat-factory/contracts'
+import type { RunBugHuntInput, TaskSourceKind } from '~/types/domain'
+import type { ApiContext } from './context'
+
+/** Bug hunt: list a tracker's boards, rank a board's open unassigned bugs, adopt one. */
+export function bugHuntApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
+  return {
+    // The boards a hunt can run against (Jira projects / Linear teams / GitHub repos). Errors
+    // when the source can't enumerate them, which the modal turns into a free-text board field.
+    listTrackerBoards: (workspaceId: string, source: TaskSourceKind) =>
+      send(listTrackerBoardsContract, { pathPrefix: ws(workspaceId), pathParams: { source } }),
+
+    // Scan the board for open, unassigned bugs and rank them by impact vs complexity. A live
+    // external call plus a model call, so it can take a while — the modal shows progress.
+    runBugHunt: (workspaceId: string, source: TaskSourceKind, body: RunBugHuntInput) =>
+      send(runBugHuntContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
+        body,
+      }),
+
+    // Adopt the confirmed candidate as a bug task and start its run. Carries the personal
+    // password header when the pipeline resolves an individual-usage model, like every start.
+    adoptBugHuntCandidate: (
+      workspaceId: string,
+      source: TaskSourceKind,
+      body: { externalId: string; containerId: string; pipelineId?: string },
+      password?: string,
+    ) =>
+      sendWith(pwHeaders(password), adoptBugHuntCandidateContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
+        body,
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -44,6 +44,7 @@ import { reviewsApi } from './api/reviews'
 import { slackApi } from './api/slack'
 import { specApi } from './api/spec'
 import { tasksApi } from './api/tasks'
+import { bugHuntApi } from './api/bugHunt'
 import { testSecretsApi } from './api/testSecrets'
 import { userSecretsApi } from './api/userSecrets'
 import { userSettingsApi } from './api/userSettings'
@@ -119,6 +120,7 @@ export function useApi() {
     ...executionApi(ctx),
     ...documentsApi(ctx),
     ...tasksApi(ctx),
+    ...bugHuntApi(ctx),
     ...reviewsApi(ctx),
     ...followUpsApi(ctx),
     ...forkDecisionApi(ctx),

package/app/pages/index.vue

@@ -45,6 +45,7 @@ const TaskSourceConnectModal = defineAsyncComponent(
   () => import('~/components/tasks/TaskSourceConnectModal.vue'),
 )
 const TaskImportModal = defineAsyncComponent(() => import('~/components/tasks/TaskImportModal.vue'))
+const BugHuntModal = defineAsyncComponent(() => import('~/components/tasks/BugHuntModal.vue'))
 const RecurringPipelineModal = defineAsyncComponent(
   () => import('~/components/board/RecurringPipelineModal.vue'),
 )
@@ -398,6 +399,7 @@ watch(
            first open (its own chunk) rather than bloating the initial bundle. -->
       <TaskSourceConnectModal v-if="ui.taskConnect" />
       <TaskImportModal v-if="ui.taskImport" />
+      <BugHuntModal v-if="ui.bugHunt" />
       <RecurringPipelineModal v-if="ui.addRecurringFrameId" />
       <ObservabilityPanel v-if="ui.observabilityInstanceId" />
       <OperatorDashboardPanel v-if="ui.operatorDashboardOpen" />

package/app/stores/bugHunt.spec.ts

@@ -0,0 +1,103 @@
+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'
+
+// 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,
+// or a tracker outage silently wears the same clothes as an unsupported provider.
+
+function apiError(statusCode: number, code: string, details?: Record<string, unknown>): ApiError {
+  return new ApiError(statusCode, { error: { code, message: 'nope', details } })
+}
+
+/** The unsupported-source refusal `BugHuntService.listBoards` raises. */
+const boardsUnsupported = () =>
+  Promise.reject(apiError(400, 'validation', { reason: 'boards_unsupported' }))
+
+/**
+ * Stub `useApi` ONCE, behind a handler the test can swap. The store resolves `useApi()` at setup,
+ * so re-stubbing after `useBugHuntStore()` would leave it holding the first stub for ever.
+ */
+function stubApi(): {
+  store: ReturnType<typeof useBugHuntStore>
+  serve: (fn: () => Promise<unknown>) => void
+} {
+  let handler: () => Promise<unknown> = () => Promise.resolve({ source: 'jira', boards: [] })
+  vi.stubGlobal('useApi', () => ({
+    listTrackerBoards: (_ws: string, _source: TaskSourceKind) =>
+      handler() as Promise<TrackerBoardsView>,
+  }))
+  return {
+    store: useBugHuntStore(),
+    serve: (fn) => {
+      handler = fn
+    },
+  }
+}
+
+describe('bug hunt store — board listing failures', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('keeps the backend reason so the picker can offer free text for an unsupported source', async () => {
+    const { store, serve } = stubApi()
+    serve(boardsUnsupported)
+
+    await store.loadBoards('jira')
+
+    expect(store.boards).toEqual([])
+    expect(store.boardsErrorReason).toBe('boards_unsupported')
+    expect(store.boardsError).toBeTruthy()
+  })
+
+  it('records NO reason for a failure that is simply an unreachable tracker', async () => {
+    const { store, serve } = stubApi()
+    serve(() => Promise.reject(apiError(502, 'upstream')))
+
+    await store.loadBoards('jira')
+
+    // The modal keys its free-text fallback on the reason, so a null one keeps this an error.
+    expect(store.boardsErrorReason).toBeNull()
+    expect(store.boardsError).toBeTruthy()
+  })
+
+  it('clears a previous failure when a later source lists its boards fine', async () => {
+    const { store, serve } = stubApi()
+    serve(boardsUnsupported)
+    await store.loadBoards('jira')
+
+    serve(() =>
+      Promise.resolve({ source: 'linear', boards: [{ id: 't1', name: 'Eng', key: 'ENG' }] }),
+    )
+    await store.loadBoards('linear')
+
+    expect(store.boardsError).toBeNull()
+    expect(store.boardsErrorReason).toBeNull()
+    expect(store.boards.map((b) => b.id)).toEqual(['t1'])
+  })
+
+  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
+    serve(
+      () =>
+        new Promise((_res, rej) => {
+          rejectJira = rej
+        }),
+    )
+    const inFlight = store.loadBoards('jira')
+
+    serve(() => Promise.resolve({ source: 'linear', boards: [] }))
+    await store.loadBoards('linear')
+    rejectJira(apiError(400, 'validation', { reason: 'boards_unsupported' }))
+    await inFlight
+
+    // The slower tracker's refusal must not flip the newer tracker's picker to free text.
+    expect(store.boardsSource).toBe('linear')
+    expect(store.boardsErrorReason).toBeNull()
+    expect(store.boardsError).toBeNull()
+  })
+})

package/app/stores/bugHunt.ts

@@ -0,0 +1,148 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { BugHuntResult, RunBugHuntInput, TaskSourceKind, TrackerBoard } from '~/types/domain'
+import { apiErrorEnvelope } from '~/composables/api/errors'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
+
+/** The backend's `error.details.reason` code, when it sent one (see `useApi`'s error envelope). */
+function errorReasonOf(error: unknown): string | null {
+  const details = apiErrorEnvelope(error)?.details
+  if (!details || typeof details !== 'object') return null
+  const reason = (details as Record<string, unknown>).reason
+  return typeof reason === 'string' ? reason : null
+}
+
+/**
+ * Bug-hunt state: the boards of the tracker being browsed, the last hunt's ranked candidates,
+ * and the actions behind the three steps (list boards → run the hunt → adopt one candidate).
+ *
+ * Nothing here is persisted server-side — a hunt is a live read plus a ranking, so the store
+ * holds the whole feature's state and a page reload starts a fresh hunt. That is deliberate:
+ * a stale ranking of a board that has since moved on is worse than no ranking.
+ */
+export const useBugHuntStore = defineStore('bugHunt', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** Boards of the last source `loadBoards` was called for, keyed so a source switch re-fetches. */
+  const boards = ref<TrackerBoard[]>([])
+  const boardsSource = ref<TaskSourceKind | null>(null)
+  const boardsLoading = ref(false)
+  /**
+   * Why board listing failed, if it did. Kept rather than swallowed: a source whose provider
+   * can't enumerate boards is a normal, actionable state (type the board in yourself), and an
+   * empty picker alone doesn't say that.
+   */
+  const boardsError = ref<string | null>(null)
+  /**
+   * The backend's machine-readable reason for that failure. Only `boards_unsupported` means
+   * "this tracker cannot enumerate boards, so type one in"; every other failure (an unreachable
+   * site, an expired token) is a real error and must be shown as one — offering a free-text
+   * field there would just move the same failure to the next click.
+   */
+  const boardsErrorReason = ref<string | null>(null)
+
+  const result = ref<BugHuntResult | null>(null)
+  const hunting = ref(false)
+  const huntError = ref<string | null>(null)
+  /** The candidate currently being adopted, so only its own row shows a spinner. */
+  const adopting = ref<string | null>(null)
+
+  const candidates = computed(() => result.value?.candidates ?? [])
+  const hasResult = computed(() => result.value !== null)
+
+  /** Load the boards a hunt can run against for one source. */
+  async function loadBoards(source: TaskSourceKind): Promise<void> {
+    boardsLoading.value = true
+    boardsError.value = null
+    boardsErrorReason.value = null
+    boardsSource.value = source
+    try {
+      const view = await api.listTrackerBoards(workspace.requireId(), source)
+      // A source switch mid-flight would otherwise land the slower response over the newer
+      // one, leaving the picker showing another tracker's boards.
+      if (boardsSource.value !== source) return
+      boards.value = view.boards
+    } catch (e) {
+      if (boardsSource.value !== source) return
+      boards.value = []
+      boardsError.value = e instanceof Error ? e.message : String(e)
+      boardsErrorReason.value = errorReasonOf(e)
+    } finally {
+      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
+    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)
+      return false
+    } finally {
+      hunting.value = false
+    }
+  }
+
+  /**
+   * Adopt a candidate as a bug task and start its run. Rides the personal password like every
+   * other run start, so an individual-usage model prompts here rather than failing the start.
+   * Returns the new block's id on success, null when the user cancelled the credential prompt.
+   */
+  async function adopt(
+    source: TaskSourceKind,
+    externalId: string,
+    containerId: string,
+    pipelineId?: string,
+  ): Promise<string | null> {
+    const personal = usePersonalSubscriptionsStore()
+    adopting.value = externalId
+    try {
+      let blockId: string | null = null
+      const ok = await personal.withCredential(async (password) => {
+        const adopted = await api.adoptBugHuntCandidate(
+          workspace.requireId(),
+          source,
+          { externalId, containerId, ...(pipelineId ? { pipelineId } : {}) },
+          password,
+        )
+        blockId = adopted.block.id
+        await workspace.refresh()
+      })
+      return ok ? blockId : null
+    } finally {
+      adopting.value = null
+    }
+  }
+
+  /** Drop the last hunt (on close, or when the source/board changes under it). */
+  function reset(): void {
+    result.value = null
+    huntError.value = null
+    adopting.value = null
+  }
+
+  return {
+    boards,
+    boardsSource,
+    boardsLoading,
+    boardsError,
+    boardsErrorReason,
+    result,
+    candidates,
+    hasResult,
+    hunting,
+    huntError,
+    adopting,
+    loadBoards,
+    hunt,
+    adopt,
+    reset,
+  }
+})

package/app/stores/ui/modals.ts

@@ -180,6 +180,10 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
   // the create-in target AND scopes the issue search to the frame's linked repo.
   // Null → the unscoped "import an issue" surface (workspace-wide search).
   const taskImport = ref<{ source: TaskSourceKind | null; containerId: string | null } | null>(null)
+  // Bug hunt: pick a tracker + one of its boards, rank its open unassigned bugs, adopt one.
+  // `containerId` (a service frame or module) preselects where an adopted bug lands; null →
+  // opened standalone, and the modal offers every container on the board.
+  const bugHunt = ref<{ source: TaskSourceKind | null; containerId: string | null } | null>(null)
 
   // Add-task modal: the container (service frame or module) a new task is being
   // added to, or null when closed. The user types the title + description; nothing
@@ -255,6 +259,13 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
   function closeTaskImport() {
     taskImport.value = null
   }
+  function openBugHunt(source: TaskSourceKind | null = null, containerId: string | null = null) {
+    resetHubReturn()
+    bugHunt.value = { source, containerId }
+  }
+  function closeBugHunt() {
+    bugHunt.value = null
+  }
   function openAddTask(containerId: string, prefill: AddTaskPrefill | null = null) {
     addTaskPrefill.value = prefill
     addTaskContainerId.value = containerId
@@ -289,6 +300,7 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     spawnPreview,
     taskConnect,
     taskImport,
+    bugHunt,
     addTaskContainerId,
     addTaskPrefill,
     reviewFrictionContext,
@@ -306,6 +318,8 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     closeTaskConnect,
     openTaskImport,
     closeTaskImport,
+    openBugHunt,
+    closeBugHunt,
     openAddTask,
     closeAddTask,
     openReviewFriction,

package/app/types/bugHunt.ts

@@ -0,0 +1,21 @@
+// ---------------------------------------------------------------------------
+// Bug hunt: pick a connected tracker + one of its boards, get its open and
+// unassigned bugs ranked by impact against implementation complexity, then adopt
+// one onto the board and run the bug-fix pipeline on it.
+//
+// The interactive dual of the recurring `bug-intake` step. All wire shapes are
+// sourced from @cat-factory/contracts (single source of truth).
+// ---------------------------------------------------------------------------
+
+export type {
+  TrackerBoard,
+  TrackerBoardsView,
+  BugCandidate,
+  BugHuntAnalysis,
+  BugHuntAnalysisStatus,
+  BugHuntCandidate,
+  BugHuntConfidence,
+  BugHuntResult,
+  RunBugHuntInput,
+  AdoptBugHuntCandidateInput,
+} from '@cat-factory/contracts'

package/app/types/domain.ts

@@ -170,6 +170,7 @@ export type * from './fragments'
 export type * from './skills'
 export type * from './documents'
 export type * from './tasks'
+export type * from './bugHunt'
 export type * from './bootstrap'
 export type * from './envConfigRepair'
 export type * from './github'

package/app/utils/pipeline.spec.ts

@@ -1,13 +1,53 @@
 import { describe, expect, it } from 'vitest'
 import { pipelineAllowedForTaskType, purposeAllowsAgentCategory } from '@cat-factory/contracts'
 import type { Block, Pipeline } from '~/types/domain'
-import { pipelineAllowedForManualStart } from '~/utils/pipeline'
+import {
+  pipelineAllowedForManualStart,
+  pipelineDisplaySteps,
+  pipelineGateCount,
+} from '~/utils/pipeline'
 
 // A minimal pipeline: only the fields the launch/task-type filters read matter here.
 function pipeline(over: Partial<Pipeline> = {}): Pipeline {
   return { id: 'pl_x', name: 'X', agentKinds: ['coder'], ...over } as Pipeline
 }
 
+// The data behind every picker's preview pane: the ordered steps a run will actually execute.
+describe('pipelineDisplaySteps', () => {
+  it('keeps the authored order and flags the gated steps', () => {
+    const p = pipeline({
+      agentKinds: ['task-estimator', 'coder', 'reviewer'],
+      gates: [false, true, false],
+    })
+    expect(pipelineDisplaySteps(p)).toEqual([
+      { kind: 'task-estimator', gated: false },
+      { kind: 'coder', gated: true },
+      { kind: 'reviewer', gated: false },
+    ])
+  })
+
+  it('drops steps disabled by default — they never run, so listing them would misdescribe it', () => {
+    // The short `enabled` array also pins "no entry ⇒ enabled": `tester` has none and stays.
+    const p = pipeline({ agentKinds: ['architect', 'coder', 'tester'], enabled: [false, true] })
+    expect(pipelineDisplaySteps(p).map((s) => s.kind)).toEqual(['coder', 'tester'])
+  })
+})
+
+describe('pipelineGateCount', () => {
+  it('counts only the gates that a run can actually stop at', () => {
+    expect(pipelineGateCount(pipeline({ agentKinds: ['coder'] }))).toBe(0)
+    expect(
+      pipelineGateCount(pipeline({ agentKinds: ['coder', 'merger'], gates: [true, true] })),
+    ).toBe(2)
+    // A gate declared on a disabled step gates nothing: the step is skipped at run.
+    expect(
+      pipelineGateCount(
+        pipeline({ agentKinds: ['coder', 'merger'], gates: [true, true], enabled: [true, false] }),
+      ),
+    ).toBe(1)
+  })
+})
+
 describe('pipelineAllowedForTaskType', () => {
   it('a document task offers ONLY document-purpose pipelines', () => {
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'document' }), 'document')).toBe(true)

package/app/utils/pipeline.ts

@@ -29,6 +29,15 @@ export function pipelineDisplaySteps(pipeline: Pipeline): PipelineDisplayStep[]
     .map(({ kind, gated }) => ({ kind, gated }))
 }
 
+/**
+ * How many times a run of `pipeline` will stop for a human. Counted off the DISPLAYED steps, not
+ * `pipeline.gates`, because a gate declared on a step that is disabled by default gates nothing —
+ * that step never runs, so promising a stop there would misstate what the pipeline does.
+ */
+export function pipelineGateCount(pipeline: Pipeline): number {
+  return pipelineDisplaySteps(pipeline).filter((s) => s.gated).length
+}
+
 // Re-exported so a picker can import the task-type gate from the same module as the
 // launch/frame gates it composes with (the classifier itself lives in `@cat-factory/contracts`).
 export { pipelineAllowedForTaskType }

package/i18n/locales/de.json

@@ -1650,7 +1650,8 @@
         "title": "Diesen Dienst archivieren?",
         "body": "„{name}“ und seine Aufgaben werden vom Board ausgeblendet. Du kannst den Dienst jederzeit wiederherstellen."
       },
-      "runBlocked": "Blockiert durch eine unerledigte Abhängigkeit: {names} | Blockiert durch {count} unerledigte Abhängigkeiten: {names}"
+      "runBlocked": "Blockiert durch eine unerledigte Abhängigkeit: {names} | Blockiert durch {count} unerledigte Abhängigkeiten: {names}",
+      "huntBugs": "Fehler jagen"
     }
   },
   "layout": {
@@ -1989,7 +1990,8 @@
         "accountSettings": "Konto-Einstellungen",
         "localModels": "Meine lokalen Runner",
         "sandbox": "Sandbox öffnen",
-        "shortcuts": "Tastenkürzel"
+        "shortcuts": "Tastenkürzel",
+        "bugHunt": "Fehlerjagd"
       },
       "keywords": {
         "newPipeline": "pipeline agents chain",
@@ -2009,7 +2011,8 @@
         "accountSettings": "account team members roles invitations email api keys fragment best practice library context organization personal",
         "localModels": "local model runner ollama lm studio llamacpp vllm endpoint",
         "sandbox": "sandbox prompt model test experiment judge fixture benchmark evaluate",
-        "shortcuts": "keyboard shortcuts keys hotkeys cheatsheet help"
+        "shortcuts": "keyboard shortcuts keys hotkeys cheatsheet help",
+        "bugHunt": "fehler bug jagd triage backlog tracker nicht zugewiesen"
       }
     },
     "shortcuts": {
@@ -2102,6 +2105,10 @@
         },
         "documentTemplates": {
           "label": "Vorlagen & Beispiele"
+        },
+        "bugHunt": {
+          "label": "Fehlerjagd",
+          "description": "Offene, nicht zugewiesene Fehler eines Boards bewerten und einen zum Beheben auswählen"
         }
       }
     },
@@ -3238,7 +3245,11 @@
       "attachByReference": "{ref} per Referenz anhängen",
       "noMatches": "Keine passenden Issues.",
       "emptySearchable": "Nach Titel suchen oder ein importiertes Issue auswählen.",
-      "emptyRefOnly": "Fügen Sie eine Issue-URL oder einen -Schlüssel ein, um es anzuhängen."
+      "emptyRefOnly": "Fügen Sie eine Issue-URL oder einen -Schlüssel ein, um es anzuhängen.",
+      "sourceLabel": "Quelle",
+      "noSource": "Quelle wählen",
+      "connectSource": "{label} verbinden",
+      "enableSource": "{label} aktivieren"
     },
     "contextIssues": {
       "title": "Kontext-Issues",
@@ -3300,6 +3311,49 @@
       "oauthOr": "oder mit einem API-Schlüssel verbinden"
     }
   },
+  "bugHunt": {
+    "title": "Fehlerjagd",
+    "intro": "Durchsuche ein Tracker-Board nach offenen, nicht zugewiesenen Fehlern und bewerte sie nach Auswirkung im Verhältnis zum geschätzten Aufwand. Wähle einen aus, und er wird zu einer Aufgabe, die die Fehlerbehebungs-Pipeline durchläuft.",
+    "connectFirst": "Verbinde oder aktiviere zuerst eine Aufgabenquelle.",
+    "connectSource": "{label} verbinden",
+    "needFrameFirst": "Füge zuerst einen Service-Rahmen zum Board hinzu, damit ein übernommener Fehler irgendwo landen kann.",
+    "tracker": "Tracker",
+    "board": "Board",
+    "pickBoard": "Board auswählen",
+    "boardPlaceholder": "Projektschlüssel, Team-ID oder owner/repo",
+    "boardsFailed": "Boards konnten nicht geladen werden: {reason}",
+    "issueType": "Vorgangstyp",
+    "issueTypeHelp": "Standard ist bug. Wird von Trackern ohne Vorgangstypen ignoriert.",
+    "labels": "Labels",
+    "labelsHelp": "Durch Komma getrennt. Alle müssen vorhanden sein.",
+    "adoptInto": "Ausgewählten Fehler hinzufügen zu",
+    "run": "Jagen",
+    "running": "Board wird gelesen und die Funde werden bewertet…",
+    "huntFailed": "Die Jagd ist fehlgeschlagen",
+    "notAssessed": "Nicht bewertet",
+    "recommended": "Empfohlen",
+    "adopt": "Diesen wählen",
+    "adopted": "{id} übernommen",
+    "adoptedRunning": "Die Fehlerbehebungs-Pipeline läuft dafür.",
+    "adoptFailed": "Dieser Fehler konnte nicht übernommen werden",
+    "noCandidates": "Auf diesem Board gab es keine offenen, nicht zugewiesenen Fehler.",
+    "ratings": "Auswirkung {impact}/5, Aufwand {complexity}/5, Konfidenz {confidence}",
+    "viaModel": "Bewertet von {model}.",
+    "truncated": "Es wurden nur die ersten {count} passenden Fehler geprüft; dieses Board enthält mehr.",
+    "comments": "{count} Kommentar | {count} Kommentare",
+    "confidence": {
+      "high": "hoch",
+      "medium": "mittel",
+      "low": "niedrig"
+    },
+    "status": {
+      "ranked": "Sortiert nach Auswirkung im Verhältnis zum geschätzten Aufwand.",
+      "unavailable": "Es ist kein Bewertungsmodell konfiguriert, daher sind diese unbewertet.",
+      "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."
+    }
+  },
   "pipeline": {
     "iterationCap": {
       "extraRound": "Noch eine Runde",
@@ -3308,10 +3362,12 @@
     },
     "preview": {
       "stepCount": "{count} Schritt | {count} Schritte",
+      "gateCount": "{count} Freigabe | {count} Freigaben",
       "gated": "Manuelle Freigabe nach diesem Schritt"
     },
     "picker": {
-      "noneHint": "Keine Standard-Pipeline. Du wählst beim Ausführen der Aufgabe eine aus."
+      "noneHint": "Keine Standard-Pipeline. Du wählst beim Ausführen der Aufgabe eine aus.",
+      "hoverHint": "Fahre über eine Pipeline, um die Schritte zu sehen, die sie ausführt."
     },
     "builder": {
       "title": "Pipeline-Builder",