@cat-factory/app 0.303.4 → 0.305.0

package/app/stores/guidedReview.spec.ts

@@ -0,0 +1,148 @@
+import { describe, expect, it, vi } from 'vitest'
+import { ApiError } from '~/composables/api/errors'
+import { useGuidedReviewStore } from '~/stores/guidedReview'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+function view(sessionId: string, title: string) {
+  return {
+    session: { id: sessionId, prTitle: title },
+    threads: [],
+    drafts: [],
+  } as never
+}
+
+function threadView(threadId: string, messages: number) {
+  return {
+    thread: { id: threadId, sessionId: 's1' },
+    messages: Array.from({ length: messages }, (_, i) => ({ id: `m${i}` })),
+  } as never
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((r) => (resolve = r))
+  return { promise, resolve }
+}
+
+describe('guided review store', () => {
+  it('refetches only what this client has loaded when a change arrives', async () => {
+    const getGuidedReview = vi.fn(async (_ws: string, id: string) => view(id, 'fresh'))
+    const getGuidedReviewThread = vi.fn(async () => threadView('t1', 2))
+    vi.stubGlobal('useApi', () => ({ getGuidedReview, getGuidedReviewThread }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+
+    await store.applyChange({ sessionId: 'elsewhere', scope: 'thread', threadId: 't9' })
+    expect(getGuidedReview).not.toHaveBeenCalled()
+    expect(getGuidedReviewThread).not.toHaveBeenCalled()
+
+    await store.loadSession('s1')
+    await store.loadThread('s1', 't1')
+    getGuidedReview.mockClear()
+    getGuidedReviewThread.mockClear()
+    await store.applyChange({ sessionId: 's1', scope: 'thread', threadId: 't1' })
+    expect(getGuidedReview).toHaveBeenCalledTimes(1)
+    expect(getGuidedReviewThread).toHaveBeenCalledTimes(1)
+  })
+
+  it('drops a slow reply that a newer fetch overtook', async () => {
+    const slow = deferred<never>()
+    const replies = [slow.promise, Promise.resolve(view('s1', 'newer'))]
+    vi.stubGlobal('useApi', () => ({ getGuidedReview: vi.fn(() => replies.shift()) }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+
+    const first = store.loadSession('s1')
+    await store.loadSession('s1')
+    slow.resolve(view('s1', 'stale'))
+    await first
+    expect(store.sessions.s1?.session.prTitle).toBe('newer')
+  })
+
+  it('lets a refresh win over a load that started before it', async () => {
+    const slow = deferred<never>()
+    vi.stubGlobal('useApi', () => ({
+      getGuidedReview: vi.fn(() => slow.promise),
+      refreshGuidedReview: vi.fn(async () => view('s1', 'refreshed')),
+    }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+
+    const load = store.loadSession('s1')
+    await store.refresh('s1')
+    slow.resolve(view('s1', 'stale'))
+    await load
+    expect(store.sessions.s1?.session.prTitle).toBe('refreshed')
+  })
+
+  it('does not bring back a deleted session through a load still in flight', async () => {
+    const slow = deferred<never>()
+    vi.stubGlobal('useApi', () => ({ getGuidedReview: vi.fn(() => slow.promise) }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+
+    const load = store.loadSession('s1')
+    await store.applyChange({ sessionId: 's1', scope: 'deleted' })
+    slow.resolve(view('s1', 'stale'))
+    await load
+    expect(store.sessions.s1).toBeUndefined()
+  })
+
+  it('refetches the thread a drafts change names', async () => {
+    const getGuidedReview = vi.fn(async (_ws: string, id: string) => view(id, 'x'))
+    const getGuidedReviewThread = vi.fn(async () => threadView('t1', 3))
+    vi.stubGlobal('useApi', () => ({ getGuidedReview, getGuidedReviewThread }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+    await store.loadSession('s1')
+    await store.loadThread('s1', 't1')
+    getGuidedReviewThread.mockClear()
+    await store.applyChange({ sessionId: 's1', scope: 'drafts', threadId: 't1' })
+    expect(getGuidedReviewThread).toHaveBeenCalledTimes(1)
+  })
+
+  it('records a failed background refetch and clears it when the session lands again', async () => {
+    const failure = new ApiError(503, { error: { code: 'unavailable' } })
+    const getGuidedReview = vi
+      .fn()
+      .mockResolvedValueOnce(view('s1', 'x'))
+      .mockRejectedValueOnce(failure)
+      .mockResolvedValueOnce(view('s1', 'y'))
+    vi.stubGlobal('useApi', () => ({ getGuidedReview }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+    await store.loadSession('s1')
+    await store.applyChange({ sessionId: 's1', scope: 'session' })
+    expect(store.sessions.s1?.session.prTitle).toBe('x')
+    expect(store.refetchFailures.s1).toBe(failure)
+    await store.applyChange({ sessionId: 's1', scope: 'session' })
+    expect(store.refetchFailures.s1).toBeUndefined()
+  })
+
+  it('forgets a session whose refetch answers 404', async () => {
+    const getGuidedReview = vi
+      .fn()
+      .mockResolvedValueOnce(view('s1', 'x'))
+      .mockRejectedValueOnce(new ApiError(404, { error: { code: 'not_found' } }))
+    vi.stubGlobal('useApi', () => ({ getGuidedReview }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+    await store.loadSession('s1')
+    await store.applyChange({ sessionId: 's1', scope: 'session' })
+    expect(store.sessions.s1).toBeUndefined()
+  })
+
+  it('forgets a deleted session and its threads', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getGuidedReview: vi.fn(async () => view('s1', 'x')),
+      getGuidedReviewThread: vi.fn(async () => threadView('t1', 1)),
+    }))
+    useWorkspaceStore().workspaceId = 'ws_1'
+    const store = useGuidedReviewStore()
+    await store.loadSession('s1')
+    await store.loadThread('s1', 't1')
+    await store.applyChange({ sessionId: 's1', scope: 'deleted' })
+    expect(store.sessions.s1).toBeUndefined()
+    expect(store.threads.t1).toBeUndefined()
+  })
+})

package/app/stores/guidedReview.ts

@@ -0,0 +1,200 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type {
+  AskGuidedReviewInput,
+  GuidedReviewChange,
+  GuidedReviewSessionView,
+  GuidedReviewThreadView,
+  OpenGuidedReviewInput,
+  OpenGuidedReviewThreadInput,
+} from '~/types/domain'
+import { ApiError } from '~/composables/api/errors'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Guided PR review sessions and the threads a window has opened, loaded on demand and kept live
+ * by `guidedReview` stream events. An event carries ids only, so `applyChange` refetches what is
+ * loaded here and ignores the rest. Every fetch and every write takes a ticket, and a fetch lands
+ * only while its ticket is the newest for its key, so a change that arrives mid-fetch is never
+ * lost to a stale reply and a forgotten session is never brought back by one.
+ */
+export const useGuidedReviewStore = defineStore('guidedReview', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  const sessions = ref<Record<string, GuidedReviewSessionView>>({})
+  const threads = ref<Record<string, GuidedReviewThreadView>>({})
+  /**
+   * The last error of a background refetch per session, cleared when that session or one of its
+   * threads lands again, so a window can say its view may be out of date.
+   */
+  const refetchFailures = ref<Record<string, unknown>>({})
+  // One counter for every key and never reset, so a key dropped by `forget` or `reset` is never
+  // landed on by a fetch that was in flight when it went.
+  let issued = 0
+  const newest = new Map<string, number>()
+
+  const sessionKey = (sessionId: string) => `s:${sessionId}`
+  const threadKey = (sessionId: string, threadId: string) => `t:${sessionId}:${threadId}`
+
+  function claim(key: string): number {
+    issued += 1
+    newest.set(key, issued)
+    return issued
+  }
+
+  /** Run `fetch` for `key`, landing its result only if no newer fetch or write for it started. */
+  async function latest<T>(key: string, fetch: () => Promise<T>, land: (value: T) => void) {
+    const ticket = claim(key)
+    const value = await fetch()
+    if (newest.get(key) === ticket) land(value)
+  }
+
+  function putSession(view: GuidedReviewSessionView) {
+    sessions.value[view.session.id] = view
+    delete refetchFailures.value[view.session.id]
+  }
+
+  function putThread(view: GuidedReviewThreadView) {
+    threads.value[view.thread.id] = view
+    delete refetchFailures.value[view.thread.sessionId]
+  }
+
+  function loadSession(sessionId: string): Promise<void> {
+    const ws = workspace.requireId()
+    return latest(sessionKey(sessionId), () => api.getGuidedReview(ws, sessionId), putSession)
+  }
+
+  function loadThread(sessionId: string, threadId: string): Promise<void> {
+    const ws = workspace.requireId()
+    return latest(
+      threadKey(sessionId, threadId),
+      () => api.getGuidedReviewThread(ws, sessionId, threadId),
+      putThread,
+    )
+  }
+
+  async function open(input: OpenGuidedReviewInput): Promise<GuidedReviewSessionView> {
+    const view = await api.openGuidedReview(workspace.requireId(), input)
+    claim(sessionKey(view.session.id))
+    putSession(view)
+    return view
+  }
+
+  function refresh(sessionId: string): Promise<void> {
+    const ws = workspace.requireId()
+    return latest(sessionKey(sessionId), () => api.refreshGuidedReview(ws, sessionId), putSession)
+  }
+
+  async function remove(sessionId: string): Promise<void> {
+    await api.deleteGuidedReview(workspace.requireId(), sessionId)
+    forget(sessionId)
+  }
+
+  async function openThread(
+    sessionId: string,
+    input: OpenGuidedReviewThreadInput,
+  ): Promise<GuidedReviewThreadView> {
+    const view = await api.openGuidedReviewThread(workspace.requireId(), sessionId, input)
+    claim(threadKey(sessionId, view.thread.id))
+    putThread(view)
+    await loadSession(sessionId)
+    return view
+  }
+
+  async function ask(sessionId: string, threadId: string, input: AskGuidedReviewInput) {
+    await api.askGuidedReview(workspace.requireId(), sessionId, threadId, input)
+    await Promise.all([loadThread(sessionId, threadId), loadSession(sessionId)])
+  }
+
+  async function requestDrafts(sessionId: string, threadId: string, instructions = '') {
+    await api.requestGuidedReviewDrafts(workspace.requireId(), sessionId, threadId, instructions)
+    await Promise.all([loadThread(sessionId, threadId), loadSession(sessionId)])
+  }
+
+  function forget(sessionId: string) {
+    delete sessions.value[sessionId]
+    delete refetchFailures.value[sessionId]
+    newest.delete(sessionKey(sessionId))
+    const threadPrefix = threadKey(sessionId, '')
+    for (const key of newest.keys()) {
+      if (key.startsWith(threadPrefix)) newest.delete(key)
+    }
+    for (const [id, view] of Object.entries(threads.value)) {
+      if (view.thread.sessionId === sessionId) delete threads.value[id]
+    }
+  }
+
+  /** Drop everything on a board switch; fetches still in flight for the old board never land. */
+  function reset() {
+    sessions.value = {}
+    threads.value = {}
+    refetchFailures.value = {}
+    newest.clear()
+  }
+
+  /**
+   * A refetch nobody awaits (a live event, a reconnect). A session that answers 404 is gone and
+   * is forgotten; any other failure keeps the last view and is recorded in `refetchFailures`.
+   */
+  async function follow(sessionId: string, load: () => Promise<void>): Promise<void> {
+    try {
+      await load()
+    } catch (error) {
+      if (error instanceof ApiError && error.statusCode === 404) {
+        forget(sessionId)
+        return
+      }
+      if (sessions.value[sessionId]) refetchFailures.value[sessionId] = error
+    }
+  }
+
+  /** Follow a live `guidedReview` event: refetch what this client has loaded, nothing else. */
+  async function applyChange(change: GuidedReviewChange): Promise<void> {
+    if (change.scope === 'deleted') {
+      forget(change.sessionId)
+      return
+    }
+    const { sessionId } = change
+    const loads: Promise<void>[] = []
+    // A thread change also moves the session's summary (its pending answer), so both refetch.
+    if (sessions.value[sessionId]) {
+      loads.push(follow(sessionId, () => loadSession(sessionId)))
+    }
+    if (change.scope === 'thread' || change.scope === 'drafts') {
+      const { threadId } = change
+      if (threads.value[threadId]) {
+        loads.push(follow(sessionId, () => loadThread(sessionId, threadId)))
+      }
+    }
+    await Promise.all(loads)
+  }
+
+  /** Refetch everything loaded here, for events missed while the stream was disconnected. */
+  async function resync(): Promise<void> {
+    const loads = [
+      ...Object.keys(sessions.value).map((id) => follow(id, () => loadSession(id))),
+      ...Object.values(threads.value).map(({ thread }) =>
+        follow(thread.sessionId, () => loadThread(thread.sessionId, thread.id)),
+      ),
+    ]
+    await Promise.all(loads)
+  }
+
+  return {
+    sessions,
+    threads,
+    refetchFailures,
+    loadSession,
+    loadThread,
+    open,
+    refresh,
+    remove,
+    openThread,
+    ask,
+    requestDrafts,
+    applyChange,
+    resync,
+    reset,
+  }
+})

package/app/stores/ui/modals.ts

@@ -1,5 +1,10 @@
 import { ref } from 'vue'
-import type { DocumentSourceKind, InfraSetupArea, TaskSourceKind } from '~/types/domain'
+import type {
+  DocumentSourceKind,
+  InfraSetupArea,
+  OpenGuidedReviewInput,
+  TaskSourceKind,
+} from '~/types/domain'
 import type {
   InfrastructureScrollTarget,
   InfrastructureTab,
@@ -185,6 +190,12 @@ function createMiscModals() {
   return { builderOpen, decisionContext, openBuilder, openDecision, closeDecision }
 }
 
+/** What the guided review window opens on: a session, a pull request, or neither (the picker). */
+export interface GuidedReviewOpen {
+  sessionId: string | null
+  target: OpenGuidedReviewInput | null
+}
+
 /**
  * Document- and task-source integration modals (keyed by source), plus the add-task /
  * add-recurring / create-initiative surfaces. The `open*` connect/import handlers reset the hub
@@ -220,6 +231,9 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
   // subject (a turn resolves every name it needs from the board itself), so a plain flag says
   // everything the host needs to know.
   const assistantOpen = ref(false)
+  // Guided PR review: either an existing session to show, or a PR to open one for. Both null
+  // opens the PR picker.
+  const guidedReview = ref<GuidedReviewOpen | 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 →
@@ -305,6 +319,13 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
   function closeAssistant() {
     assistantOpen.value = false
   }
+  function openGuidedReview(open: GuidedReviewOpen = { sessionId: null, target: null }) {
+    resetHubReturn()
+    guidedReview.value = open
+  }
+  function closeGuidedReview() {
+    guidedReview.value = null
+  }
   function openBugHunt(source: TaskSourceKind | null = null, containerId: string | null = null) {
     resetHubReturn()
     bugHunt.value = { source, containerId }
@@ -354,6 +375,7 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     taskConnect,
     taskImport,
     assistantOpen,
+    guidedReview,
     bugHunt,
     startFromDesign,
     addTaskContainerId,
@@ -375,6 +397,8 @@ function createDocumentTaskModals(resetHubReturn: ResetHubReturn) {
     closeTaskImport,
     openAssistant,
     closeAssistant,
+    openGuidedReview,
+    closeGuidedReview,
     openBugHunt,
     closeBugHunt,
     openStartFromDesign,

package/app/stores/workspace/hydrate.ts

@@ -10,6 +10,7 @@ import { useEnvironmentTestStore } from '~/stores/environmentTest'
 import { useExecutionStore } from '~/stores/execution'
 import { useFragmentsStore } from '~/stores/fragments'
 import { useGitHubStore } from '~/stores/github'
+import { useGuidedReviewStore } from '~/stores/guidedReview'
 import { useInitiativesStore } from '~/stores/initiative'
 import { useKaizenStore } from '~/stores/kaizen'
 import { useObservabilityStore } from '~/stores/observability'
@@ -45,6 +46,7 @@ export function resetPerBoardCaches() {
   useGitHubStore().reset()
   useInitiativesStore().reset()
   useDocInterviewStore().reset()
+  useGuidedReviewStore().reset()
   // The per-RUN observability + Kaizen caches. An execution id belongs to the board that owns it
   // and neither store is part of the snapshot, so nothing else ever evicted a key: a session that
   // visited several boards kept every run it had ever opened a panel on.

package/app/types/domain.ts

@@ -258,3 +258,4 @@ export type * from './recurring'
 export type * from './tracker'
 export type * from './initiative'
 export type * from './doc-interview'
+export type * from './guided-review'

package/app/types/guided-review.ts

@@ -0,0 +1,16 @@
+// Guided PR review wire shapes, re-exported from the shared contracts package. The SPA imports
+// these through `~/types/domain` like every other domain type.
+export type {
+  AskGuidedReviewInput,
+  GuidedReviewChange,
+  GuidedReviewCommentDraft,
+  GuidedReviewDraftReport,
+  GuidedReviewFailure,
+  GuidedReviewExchange,
+  GuidedReviewMessage,
+  GuidedReviewSession,
+  GuidedReviewSessionView,
+  GuidedReviewThreadView,
+  OpenGuidedReviewInput,
+  OpenGuidedReviewThreadInput,
+} from '@cat-factory/contracts'

package/i18n/locales/de.json

@@ -2740,6 +2740,7 @@
       "cmd": {
         "newPipeline": "Eine Pipeline bauen",
         "assistant": "Assistenten öffnen",
+        "guidedReview": "Einen Pull Request erkunden",
         "addFromRepo": "Service aus vorhandenem Repo hinzufügen",
         "bootstrapRepo": "Ein neues Repo bootstrappen",
         "githubManage": "GitHub-Verbindung verwalten",
@@ -2768,6 +2769,7 @@
       "keywords": {
         "newPipeline": "pipeline agents chain",
         "assistant": "ki assistent fragen eingabe für mich erledigen",
+        "guidedReview": "geführtes review pull request pr erkunden erklären fragen",
         "addFromRepo": "github import existing",
         "bootstrapRepo": "scaffold create reference architecture",
         "github": "git repos pull requests issues",
@@ -4591,6 +4593,81 @@
       "unresolved_issue_service": "Der Assistent konnte nicht erkennen, unter welchem Service das angelegt werden soll. Nennen Sie den Service in Ihrer Anfrage."
     }
   },
+  "guidedReview": {
+    "title": "Geführtes Review",
+    "titleFor": "{repo} #{number}: {title}",
+    "loading": "Review wird geladen…",
+    "outOfDate": "Live-Updates sind fehlgeschlagen, daher ist diese Ansicht möglicherweise veraltet.",
+    "openFromTask": "Mit geführtem Review erkunden",
+    "picker": {
+      "intro": "Wähle ein Repository und einen Pull Request. Du erhältst einen Überblick über die Änderung und kannst in separaten Threads Fragen dazu stellen.",
+      "loading": "Repositories werden geladen…",
+      "noRepos": "Mit diesem Workspace sind noch keine Repositories verknüpft.",
+      "repo": "Repository",
+      "openPulls": "Offene Pull Requests",
+      "number": "Nummer des Pull Requests",
+      "open": "Review öffnen"
+    },
+    "overview": {
+      "title": "Überblick",
+      "stale": "Der Pull Request hat neue Commits",
+      "refresh": "Aktualisieren",
+      "working": "Überblick wird erstellt…",
+      "intent": "Absicht",
+      "changes": "Wesentliche Änderungen",
+      "consequences": "Folgen",
+      "risks": "Risiken",
+      "focus": "Lohnt einen Blick",
+      "suggested": "Vorgeschlagene Fragen"
+    },
+    "severity": {
+      "low": "Niedrig",
+      "medium": "Mittel",
+      "high": "Hoch"
+    },
+    "failure": {
+      "budget_exhausted": "Dieser Workspace hat sein Modellbudget aufgebraucht.",
+      "model_unavailable": "Für das geführte Review ist kein Modell verfügbar.",
+      "repo_unavailable": "Der Pull Request konnte nicht aus dem Repository gelesen werden.",
+      "generation_failed": "Der Modellaufruf ist fehlgeschlagen.",
+      "unreadable_reply": "Das Modell hat in einer nicht lesbaren Form geantwortet.",
+      "depth_unavailable": "Tiefe Antworten mit einem Checkout sind noch nicht verfügbar.",
+      "head_moved": "Der Pull Request ist über den geprüften Commit hinaus. Aktualisiere, um den neuesten Commit zu prüfen.",
+      "detail": "Details"
+    },
+    "dropped": {
+      "outside_diff": "die Zeile liegt außerhalb des Diffs",
+      "not_in_pr": "die Datei gehört nicht zu diesem Pull Request",
+      "incomplete": "der Vorschlag war unvollständig"
+    },
+    "thread": {
+      "new": "Neuer Thread",
+      "untitled": "Thread ohne Titel",
+      "empty": "Frag alles zu diesem Pull Request.",
+      "waiting": "Antwort wird erstellt…",
+      "placeholder": "Stell eine Frage zur Änderung",
+      "busy": "Warte auf die Antwort auf die vorherige Frage",
+      "send": "Fragen",
+      "draftRequest": "Review-Kommentare angefordert"
+    },
+    "drafts": {
+      "title": "Kommentarentwürfe",
+      "request": "Review-Kommentare entwerfen",
+      "summary": "{kept} von {proposed} vorgeschlagenen Kommentaren als Entwurf behalten.",
+      "side": {
+        "RIGHT": "neuer Code",
+        "LEFT": "alter Code"
+      }
+    },
+    "errors": {
+      "load": "Das Review konnte nicht geladen werden",
+      "repos": "Die verknüpften Repositories konnten nicht geladen werden",
+      "open": "Das Review konnte nicht geöffnet werden",
+      "ask": "Die Frage konnte nicht gestellt werden",
+      "drafts": "Kommentarentwürfe konnten nicht angefordert werden",
+      "refresh": "Das Review konnte nicht aktualisiert werden"
+    }
+  },
   "pipeline": {
     "iterationCap": {
       "extraRound": "Noch eine Runde",
@@ -6173,6 +6250,7 @@
     "commandBar": "Suchen oder einen Befehl ausführen…",
     "create": "Erstellen",
     "assistant": "Assistent",
+    "guidedReview": "Geführtes Review",
     "buildPipeline": "Eine Pipeline erstellen",
     "repositories": "Repositories",
     "addFromRepo": "Aus vorhandenem Repo hinzufügen",
@@ -6313,7 +6391,8 @@
         "no_host_frame": "Diese Expedition liegt unter keinem Service",
         "delegated_executor_unwired": "Externer Executor nicht registriert",
         "delegated_step_async_only": "Dieser Schritt wird abgefragt, nicht abgewartet",
-        "delegated_claim_missing": "Für diesen Schritt gibt es keine externe Arbeit zu prüfen"
+        "delegated_claim_missing": "Für diesen Schritt gibt es keine externe Arbeit zu prüfen",
+        "thread_busy": "Dieser Thread antwortet noch"
       },
       "description": {
         "dependencies_unmet": "Diese Aufgabe hängt von anderen ab, die noch nicht abgeschlossen sind. Schließe sie ab oder gib sie frei und starte dann erneut.",
@@ -6370,7 +6449,8 @@
         "no_host_frame": "Eine Behebungsaufgabe braucht einen Service als Zuhause und ein Repository zum Beheben. Verschieben Sie die Expeditionsaufgabe unter einen Service-Rahmen und versuchen Sie es erneut.",
         "delegated_executor_unwired": "Ein Schritt dieser Pipeline läuft auf einem externen Executor, den diese Installation nicht registriert; es gibt also kein Ziel für die Arbeit. Registriere den Executor im Code oder wähle für den Schritt einen, der hier läuft.",
         "delegated_step_async_only": "Dieser Schritt läuft auf einem externen Executor und kann Stunden dauern. Er wird deshalb angestoßen und danach abgefragt, statt innerhalb einer Anfrage ausgeführt zu werden. Starte den Lauf über das Board; wenn du aus eigenem Code hierherkommst, steuere den Schritt über den asynchronen Pfad.",
-        "delegated_claim_missing": "Der Eintrag des Laufs darüber, was an den externen Executor geschickt wurde, fehlt, also gibt es nichts abzufragen. Am Executor selbst ist nichts falsch. Lade den Lauf neu und starte den Schritt erneut, falls er weiterhin hängt."
+        "delegated_claim_missing": "Der Eintrag des Laufs darüber, was an den externen Executor geschickt wurde, fehlt, also gibt es nichts abzufragen. Am Executor selbst ist nichts falsch. Lade den Lauf neu und starte den Schritt erneut, falls er weiterhin hängt.",
+        "thread_busy": "Die vorherige Frage in diesem Thread ist noch nicht beantwortet. Warte auf die Antwort oder frag in einem anderen Thread."
       },
       "action": {
         "connectGitHub": "GitHub verbinden",