@cat-factory/app 0.305.0 → 0.307.0

package/app/components/guidedReview/GuidedReview.logic.spec.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest'
+import { GUIDED_REVIEW_POST_LEASE_MS } from '@cat-factory/contracts'
 import {
   GUIDED_REVIEW_FAILURE_REASONS,
   guidedReviewDroppedDraftReasonSchema,
@@ -6,6 +7,9 @@ import {
 import en from '../../../i18n/locales/en.json'
 import {
   NEW_THREAD_TAB,
+  draftEdit,
+  isEditableDraft,
+  postableSelection,
   canAsk,
   citationLabel,
   draftAnchor,
@@ -121,3 +125,55 @@ describe('isStale', () => {
     expect(isStale('a', null)).toBe(false)
   })
 })
+
+describe('draft editing and posting', () => {
+  it('treats proposed and failed drafts as still editable', () => {
+    expect(
+      ['proposed', 'failed', 'posting', 'posted', 'discarded'].map((status) =>
+        isEditableDraft({ status: status as never }),
+      ),
+    ).toEqual([true, true, false, false, false])
+  })
+
+  it('posts only the selected drafts that are still postable, in list order', () => {
+    const drafts = [
+      { id: 'a', status: 'proposed' as const, updatedAt: 0 },
+      { id: 'b', status: 'posted' as const, updatedAt: 0 },
+      { id: 'c', status: 'failed' as const, updatedAt: 0 },
+    ]
+    expect(postableSelection(drafts, new Set(['c', 'b', 'a']), 1)).toEqual(['a', 'c'])
+  })
+
+  it('offers a posting draft again only once its claim outlives the lease', () => {
+    const stranded = [{ id: 'p', status: 'posting' as const, updatedAt: 1_000 }]
+    const selected = new Set(['p'])
+    expect(postableSelection(stranded, selected, 1_000 + GUIDED_REVIEW_POST_LEASE_MS)).toEqual([])
+    expect(postableSelection(stranded, selected, 1_001 + GUIDED_REVIEW_POST_LEASE_MS)).toEqual([
+      'p',
+    ])
+  })
+
+  it('sends only what an edit changed, and nothing for an untouched form', () => {
+    const draft = { body: 'Bound the retries.', line: 3, startLine: null, side: 'RIGHT' as const }
+    expect(draftEdit(draft, { body: ' Bound the retries. ', line: 3, side: 'RIGHT' })).toEqual({})
+    expect(draftEdit(draft, { body: 'Cap at three.', line: 4, side: 'RIGHT' })).toEqual({
+      body: 'Cap at three.',
+      line: 4,
+    })
+  })
+
+  it('drops the start of a multi-line draft only when the edit moves it', () => {
+    const span = { body: 'Span.', line: 8, startLine: 5, side: 'RIGHT' as const }
+    expect(draftEdit(span, { body: 'Reworded.', line: 8, side: 'RIGHT' })).toEqual({
+      body: 'Reworded.',
+    })
+    expect(draftEdit(span, { body: 'Span.', line: 3, side: 'RIGHT' })).toEqual({
+      line: 3,
+      startLine: null,
+    })
+    expect(draftEdit(span, { body: 'Span.', line: 8, side: 'LEFT' })).toEqual({
+      startLine: null,
+      side: 'LEFT',
+    })
+  })
+})

package/app/components/guidedReview/GuidedReview.logic.ts

@@ -1,5 +1,10 @@
-import { resolvePrNumber, type GuidedReviewFailureReason } from '@cat-factory/contracts'
+import {
+  isPostableDraft,
+  resolvePrNumber,
+  type GuidedReviewFailureReason,
+} from '@cat-factory/contracts'
 import type {
+  GuidedReviewCommentDraft,
   GuidedReviewMessage,
   GuidedReviewSessionView,
   OpenGuidedReviewInput,
@@ -106,3 +111,36 @@ export function isStale(
 ): boolean {
   return !!latestHeadSha && latestHeadSha !== reviewedHeadSha
 }
+
+/** A draft the reviewer may still edit, discard or post: `proposed`, or a `failed` post. */
+export function isEditableDraft(draft: Pick<GuidedReviewCommentDraft, 'status'>): boolean {
+  return draft.status === 'proposed' || draft.status === 'failed'
+}
+
+/** The selected drafts a post may claim at `now`, in the order they are listed. */
+export function postableSelection(
+  drafts: Pick<GuidedReviewCommentDraft, 'id' | 'status' | 'updatedAt'>[],
+  selected: ReadonlySet<string>,
+  now: number,
+): string[] {
+  return drafts.filter((d) => selected.has(d.id) && isPostableDraft(d, now)).map((d) => d.id)
+}
+
+/**
+ * The fields an inline edit actually changed, against the draft as loaded. Empty when nothing
+ * moved, so the editor saves nothing rather than bumping the draft's revision for no change. The
+ * editor places a single line, so moving a multi-line draft drops its start: the server would
+ * otherwise keep the old start against the new line and refuse the span.
+ */
+export function draftEdit(
+  draft: Pick<GuidedReviewCommentDraft, 'body' | 'line' | 'startLine' | 'side'>,
+  form: { body: string; line: number; side: 'LEFT' | 'RIGHT' },
+): { body?: string; line?: number; startLine?: null; side?: 'LEFT' | 'RIGHT' } {
+  const moved = form.line !== draft.line || form.side !== draft.side
+  return {
+    ...(form.body.trim() !== draft.body ? { body: form.body.trim() } : {}),
+    ...(form.line !== draft.line ? { line: form.line } : {}),
+    ...(moved && draft.startLine !== null ? { startLine: null } : {}),
+    ...(form.side !== draft.side ? { side: form.side } : {}),
+  }
+}

package/app/components/guidedReview/GuidedReviewDraftCard.vue

@@ -0,0 +1,145 @@
+<script setup lang="ts">
+// One comment draft: its anchor, body and rationale, with selection for posting and an inline
+// editor. Only a `proposed` or `failed` draft is editable, though a `posting` one whose poster died
+// can be selected for posting again; the server refuses a stale edit as
+// `draft_conflict` and a line outside the diff, both reported through the error funnel.
+import type { GuidedReviewCommentDraft } from '~/types/domain'
+import MarkdownProse from '~/components/common/MarkdownProse.vue'
+import {
+  draftAnchor,
+  draftEdit,
+  isEditableDraft,
+} from '~/components/guidedReview/GuidedReview.logic'
+
+const props = defineProps<{
+  sessionId: string
+  draft: GuidedReviewCommentDraft
+  selected: boolean
+  /** Whether a post may claim this draft now, including a stranded `posting` one. */
+  postable: boolean
+}>()
+const emit = defineEmits<{ 'update:selected': [value: boolean] }>()
+const { t } = useI18n()
+const store = useGuidedReviewStore()
+const { present } = usePipelineErrorToast()
+
+const editing = ref(false)
+const saving = ref(false)
+const form = reactive({ body: '', line: 1, side: 'RIGHT' as 'LEFT' | 'RIGHT' })
+const editable = computed(() => isEditableDraft(props.draft))
+const STATUS_COLOR = {
+  proposed: 'neutral',
+  posting: 'info',
+  posted: 'success',
+  failed: 'error',
+  discarded: 'neutral',
+} as const
+
+function startEdit(): void {
+  form.body = props.draft.body
+  form.line = props.draft.line
+  form.side = props.draft.side
+  editing.value = true
+}
+
+async function save(): Promise<void> {
+  const changes = draftEdit(props.draft, form)
+  if (Object.keys(changes).length === 0) {
+    editing.value = false
+    return
+  }
+  saving.value = true
+  try {
+    await store.editDraft(props.sessionId, props.draft.id, { rev: props.draft.rev, ...changes })
+    editing.value = false
+  } catch (error) {
+    present(error, 'guidedReview.errors.editDraft')
+  } finally {
+    saving.value = false
+  }
+}
+
+async function discard(): Promise<void> {
+  saving.value = true
+  try {
+    await store.editDraft(props.sessionId, props.draft.id, { rev: props.draft.rev, discard: true })
+    emit('update:selected', false)
+  } catch (error) {
+    present(error, 'guidedReview.errors.editDraft')
+  } finally {
+    saving.value = false
+  }
+}
+</script>
+
+<template>
+  <div
+    class="rounded-md border border-default p-2 text-sm"
+    :class="{ 'opacity-60': draft.status === 'discarded' }"
+    data-testid="guided-review-draft"
+  >
+    <div class="flex items-center gap-2">
+      <UCheckbox
+        v-if="postable"
+        :model-value="selected"
+        :aria-label="t('guidedReview.drafts.select')"
+        @update:model-value="emit('update:selected', $event === true)"
+      />
+      <p class="flex-1 text-xs text-dimmed">
+        {{ draftAnchor(draft) }} ({{ t(`guidedReview.drafts.side.${draft.side}`) }})
+      </p>
+      <UBadge size="sm" variant="subtle" :color="STATUS_COLOR[draft.status]">
+        {{ t(`guidedReview.drafts.status.${draft.status}`) }}
+      </UBadge>
+    </div>
+
+    <div v-if="editing" class="mt-2 space-y-2">
+      <UTextarea v-model="form.body" :rows="3" autoresize class="w-full" />
+      <div class="flex flex-wrap items-center gap-2">
+        <UInputNumber
+          v-model="form.line"
+          :min="1"
+          size="sm"
+          :aria-label="t('guidedReview.drafts.line')"
+        />
+        <USelect
+          v-model="form.side"
+          size="sm"
+          :items="[
+            { label: t('guidedReview.drafts.side.RIGHT'), value: 'RIGHT' },
+            { label: t('guidedReview.drafts.side.LEFT'), value: 'LEFT' },
+          ]"
+          :aria-label="t('guidedReview.drafts.sideLabel')"
+        />
+        <UButton size="sm" color="primary" :loading="saving" @click="save">
+          {{ t('guidedReview.drafts.save') }}
+        </UButton>
+        <UButton size="sm" variant="ghost" :disabled="saving" @click="editing = false">
+          {{ t('guidedReview.drafts.cancel') }}
+        </UButton>
+      </div>
+    </div>
+    <template v-else>
+      <MarkdownProse class="mt-1" :text="draft.body" />
+      <p v-if="draft.rationale" class="mt-1 text-xs text-muted">{{ draft.rationale }}</p>
+      <p v-if="draft.status === 'failed' && draft.postError" class="mt-1 text-xs text-error">
+        {{ t('guidedReview.drafts.postFailed') }}: {{ draft.postError }}
+      </p>
+      <div v-if="editable" class="mt-2 flex gap-2">
+        <UButton size="xs" variant="ghost" icon="i-lucide-pencil" @click="startEdit">
+          {{ t('guidedReview.drafts.edit') }}
+        </UButton>
+        <UButton
+          size="xs"
+          variant="ghost"
+          color="neutral"
+          icon="i-lucide-trash-2"
+          :loading="saving"
+          @click="discard"
+        >
+          {{ t('guidedReview.drafts.discard') }}
+        </UButton>
+      </div>
+    </template>
+  </div>
+</template>

package/app/components/guidedReview/GuidedReviewThread.vue

@@ -1,16 +1,18 @@
 <script setup lang="ts">
 // One exploration thread: its messages, the comment drafts it produced, and a composer. While its
 // own answer is pending the composer waits; other threads are unaffected.
+import { isPostableDraft } from '@cat-factory/contracts'
 import type { GuidedReviewCommentDraft, GuidedReviewThreadView } from '~/types/domain'
 import MarkdownProse from '~/components/common/MarkdownProse.vue'
 import GuidedReviewFailure from '~/components/guidedReview/GuidedReviewFailure.vue'
+import GuidedReviewDraftCard from '~/components/guidedReview/GuidedReviewDraftCard.vue'
 import {
   canAsk,
   citationLabel,
-  draftAnchor,
   droppedAnchor,
   isLive,
   keptDrafts,
+  postableSelection,
 } from '~/components/guidedReview/GuidedReview.logic'
 
 const props = defineProps<{
@@ -25,6 +27,7 @@ const store = useGuidedReviewStore()
 const { present } = usePipelineErrorToast()
 
 const prompt = ref('')
+const deep = ref(false)
 const sending = ref(false)
 const messages = computed(() => props.view?.messages ?? [])
 const ready = computed(() => canAsk(messages.value) && !sending.value)
@@ -35,10 +38,11 @@ async function send(): Promise<void> {
   const content = prompt.value.trim()
   sending.value = true
   try {
+    const question = { content, ...(deep.value ? { depth: 'deep' as const } : {}) }
     if (props.view) {
-      await store.ask(props.sessionId, props.view.thread.id, { content })
+      await store.ask(props.sessionId, props.view.thread.id, question)
     } else {
-      const created = await store.openThread(props.sessionId, { question: { content } })
+      const created = await store.openThread(props.sessionId, { question })
       emit('created', created.thread.id)
     }
     prompt.value = ''
@@ -49,6 +53,49 @@ async function send(): Promise<void> {
   }
 }
 
+const selected = ref(new Set<string>())
+const summary = ref('')
+const posting = ref(false)
+const postResult = ref<{
+  posted: number
+  failed: number
+  skipped: number
+  summaryError: string | null
+} | null>(null)
+// A `posting` draft becomes postable again once its claim outlives the lease, so the clock only
+// runs while one is on screen.
+const now = useNowTick(30_000, () => props.drafts.some((d) => d.status === 'posting'))
+const toPost = computed(() => postableSelection(props.drafts, selected.value, now.value))
+
+function setSelected(id: string, value: boolean): void {
+  const next = new Set(selected.value)
+  if (value) next.add(id)
+  else next.delete(id)
+  selected.value = next
+}
+
+async function post(): Promise<void> {
+  if (!toPost.value.length) return
+  posting.value = true
+  try {
+    const result = await store.postDrafts(props.sessionId, toPost.value, summary.value)
+    const summaryFailed = result.summary.posted === false
+    postResult.value = {
+      posted: result.posted,
+      failed: result.failed,
+      skipped: result.skipped.length,
+      summaryError: summaryFailed ? (result.summary.error ?? '') : null,
+    }
+    selected.value = new Set()
+    // A summary the host refused stays in the box, so the reviewer can post it with a retry.
+    if (!summaryFailed) summary.value = ''
+  } catch (error) {
+    present(error, 'guidedReview.errors.postDrafts')
+  } finally {
+    posting.value = false
+  }
+}
+
 async function draftComments(): Promise<void> {
   if (!props.view || !ready.value) return
   sending.value = true
@@ -83,7 +130,11 @@ async function draftComments(): Promise<void> {
         </template>
         <p v-else-if="isLive(m)" class="flex items-center gap-2 text-muted">
           <UIcon name="i-lucide-loader-circle" class="h-4 w-4 animate-spin" />
-          {{ t('guidedReview.thread.waiting') }}
+          {{
+            m.depth === 'deep'
+              ? t('guidedReview.thread.investigating')
+              : t('guidedReview.thread.waiting')
+          }}
         </p>
         <GuidedReviewFailure v-else-if="m.status === 'failed' && m.failure" :failure="m.failure" />
         <template v-else-if="m.kind === 'answer'">
@@ -126,13 +177,45 @@ async function draftComments(): Promise<void> {
         <h4 class="text-xs font-semibold uppercase text-dimmed">
           {{ t('guidedReview.drafts.title') }}
         </h4>
-        <div v-for="d in drafts" :key="d.id" class="rounded-md border border-default p-2 text-sm">
-          <p class="text-xs text-dimmed">
-            {{ draftAnchor(d) }}
-            ({{ t(`guidedReview.drafts.side.${d.side}`) }})
-          </p>
-          <MarkdownProse :text="d.body" />
-          <p v-if="d.rationale" class="mt-1 text-xs text-muted">{{ d.rationale }}</p>
+        <GuidedReviewDraftCard
+          v-for="d in drafts"
+          :key="d.id"
+          :session-id="sessionId"
+          :draft="d"
+          :selected="selected.has(d.id)"
+          :postable="isPostableDraft(d, now)"
+          @update:selected="setSelected(d.id, $event)"
+        />
+        <div class="space-y-2 rounded-md bg-elevated p-2" data-testid="guided-review-post">
+          <UTextarea
+            v-model="summary"
+            :rows="2"
+            autoresize
+            class="w-full"
+            :placeholder="t('guidedReview.drafts.summaryPlaceholder')"
+          />
+          <div class="flex flex-wrap items-center gap-2">
+            <UButton
+              color="primary"
+              icon="i-lucide-upload"
+              :loading="posting"
+              :disabled="!toPost.length"
+              data-testid="guided-review-post-drafts"
+              @click="post"
+            >
+              {{ t('guidedReview.drafts.post', { count: toPost.length }) }}
+            </UButton>
+            <p v-if="postResult" class="text-xs text-muted" data-testid="guided-review-post-result">
+              {{ t('guidedReview.drafts.postResult', postResult) }}
+            </p>
+            <p
+              v-if="postResult && postResult.summaryError !== null"
+              class="text-xs text-error"
+              data-testid="guided-review-post-summary-error"
+            >
+              {{ t('guidedReview.drafts.summaryFailed') }}: {{ postResult.summaryError }}
+            </p>
+          </div>
         </div>
       </div>
     </div>
@@ -151,6 +234,13 @@ async function draftComments(): Promise<void> {
         @keydown.enter.ctrl.prevent="send"
       />
       <div class="flex flex-wrap items-center gap-2">
+        <USwitch
+          v-model="deep"
+          size="sm"
+          :label="t('guidedReview.thread.deep')"
+          :description="t('guidedReview.thread.deepHint')"
+          data-testid="guided-review-deep"
+        />
         <UButton
           color="primary"
           icon="i-lucide-send"

package/app/composables/api/guidedReview.ts

@@ -1,16 +1,20 @@
 import {
   askGuidedReviewContract,
   deleteGuidedReviewContract,
+  editGuidedReviewDraftContract,
   getGuidedReviewContract,
   getGuidedReviewThreadContract,
   listGuidedReviewsContract,
   openGuidedReviewContract,
   openGuidedReviewThreadContract,
+  postGuidedReviewDraftsContract,
   refreshGuidedReviewContract,
   requestGuidedReviewDraftsContract,
 } from '@cat-factory/contracts'
 import type {
   AskGuidedReviewInput,
+  EditGuidedReviewDraftInput,
+  PostGuidedReviewDraftsInput,
   OpenGuidedReviewInput,
   OpenGuidedReviewThreadInput,
 } from '~/types/domain'
@@ -76,5 +80,28 @@ export function guidedReviewApi({ send, ws }: ApiContext) {
         pathParams: { sessionId, threadId },
         body: { instructions },
       }),
+
+    editGuidedReviewDraft: (
+      workspaceId: string,
+      sessionId: string,
+      draftId: string,
+      body: EditGuidedReviewDraftInput,
+    ) =>
+      send(editGuidedReviewDraftContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { sessionId, draftId },
+        body,
+      }),
+
+    postGuidedReviewDrafts: (
+      workspaceId: string,
+      sessionId: string,
+      body: PostGuidedReviewDraftsInput,
+    ) =>
+      send(postGuidedReviewDraftsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { sessionId },
+        body,
+      }),
   }
 }

package/app/composables/usePipelineErrorToast.ts

@@ -175,6 +175,14 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
     titleKey: 'errors.conflict.title.thread_busy',
     descriptionKey: 'errors.conflict.description.thread_busy',
   },
+  draft_conflict: {
+    titleKey: 'errors.conflict.title.draft_conflict',
+    descriptionKey: 'errors.conflict.description.draft_conflict',
+  },
+  session_stale: {
+    titleKey: 'errors.conflict.title.session_stale',
+    descriptionKey: 'errors.conflict.description.session_stale',
+  },
   task_limit_reached: {
     titleKey: 'errors.conflict.title.task_limit_reached',
     descriptionKey: 'errors.conflict.description.task_limit_reached',

package/app/stores/guidedReview.ts

@@ -2,6 +2,9 @@ import { defineStore } from 'pinia'
 import { ref } from 'vue'
 import type {
   AskGuidedReviewInput,
+  EditGuidedReviewDraftInput,
+  GuidedReviewCommentDraft,
+  GuidedReviewPostResult,
   GuidedReviewChange,
   GuidedReviewSessionView,
   GuidedReviewThreadView,
@@ -112,6 +115,29 @@ export const useGuidedReviewStore = defineStore('guidedReview', () => {
     await Promise.all([loadThread(sessionId, threadId), loadSession(sessionId)])
   }
 
+  async function editDraft(
+    sessionId: string,
+    draftId: string,
+    input: EditGuidedReviewDraftInput,
+  ): Promise<GuidedReviewCommentDraft> {
+    const draft = await api.editGuidedReviewDraft(workspace.requireId(), sessionId, draftId, input)
+    await loadSession(sessionId)
+    return draft
+  }
+
+  async function postDrafts(
+    sessionId: string,
+    draftIds: string[],
+    summary?: string,
+  ): Promise<GuidedReviewPostResult> {
+    const result = await api.postGuidedReviewDrafts(workspace.requireId(), sessionId, {
+      draftIds,
+      ...(summary?.trim() ? { summary } : {}),
+    })
+    await loadSession(sessionId)
+    return result
+  }
+
   function forget(sessionId: string) {
     delete sessions.value[sessionId]
     delete refetchFailures.value[sessionId]
@@ -193,6 +219,8 @@ export const useGuidedReviewStore = defineStore('guidedReview', () => {
     openThread,
     ask,
     requestDrafts,
+    editDraft,
+    postDrafts,
     applyChange,
     resync,
     reset,

package/app/types/guided-review.ts

@@ -2,6 +2,9 @@
 // these through `~/types/domain` like every other domain type.
 export type {
   AskGuidedReviewInput,
+  EditGuidedReviewDraftInput,
+  GuidedReviewPostResult,
+  PostGuidedReviewDraftsInput,
   GuidedReviewChange,
   GuidedReviewCommentDraft,
   GuidedReviewDraftReport,

package/i18n/locales/de.json

@@ -4648,7 +4648,10 @@
       "placeholder": "Stell eine Frage zur Änderung",
       "busy": "Warte auf die Antwort auf die vorherige Frage",
       "send": "Fragen",
-      "draftRequest": "Review-Kommentare angefordert"
+      "draftRequest": "Review-Kommentare angefordert",
+      "deep": "Tiefenanalyse",
+      "deepHint": "Antwort aus einem Checkout des Repositorys: langsamer, kann aber den ganzen Baum durchsuchen.",
+      "investigating": "Untersuchung in einem Checkout des Repositorys. Das kann einige Minuten dauern."
     },
     "drafts": {
       "title": "Kommentarentwürfe",
@@ -4657,7 +4660,26 @@
       "side": {
         "RIGHT": "neuer Code",
         "LEFT": "alter Code"
-      }
+      },
+      "select": "Diesen Entwurf zum Posten auswählen",
+      "status": {
+        "proposed": "Entwurf",
+        "posting": "Wird gepostet",
+        "posted": "Gepostet",
+        "failed": "Nicht gepostet",
+        "discarded": "Verworfen"
+      },
+      "edit": "Bearbeiten",
+      "save": "Speichern",
+      "cancel": "Abbrechen",
+      "discard": "Verwerfen",
+      "line": "Zeile",
+      "sideLabel": "Seite",
+      "postFailed": "Der Host hat diesen Kommentar abgelehnt",
+      "summaryPlaceholder": "Optionaler Zusammenfassungskommentar für den Pull Request",
+      "summaryFailed": "Der Host hat den Zusammenfassungskommentar abgelehnt",
+      "post": "{count} im Pull Request posten",
+      "postResult": "{posted} gepostet, {failed} nicht gepostet, {skipped} bereits erledigt."
     },
     "errors": {
       "load": "Das Review konnte nicht geladen werden",
@@ -4665,7 +4687,9 @@
       "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"
+      "refresh": "Das Review konnte nicht aktualisiert werden",
+      "editDraft": "Der Entwurf konnte nicht gespeichert werden",
+      "postDrafts": "Die Entwürfe konnten nicht gepostet werden"
     }
   },
   "pipeline": {
@@ -6392,7 +6416,9 @@
         "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",
-        "thread_busy": "Dieser Thread antwortet noch"
+        "thread_busy": "Dieser Thread antwortet noch",
+        "draft_conflict": "Dieser Entwurf hat sich geändert",
+        "session_stale": "Der Pull Request hat sich weiterentwickelt"
       },
       "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.",
@@ -6450,7 +6476,9 @@
         "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.",
-        "thread_busy": "Die vorherige Frage in diesem Thread ist noch nicht beantwortet. Warte auf die Antwort oder frag in einem anderen Thread."
+        "thread_busy": "Die vorherige Frage in diesem Thread ist noch nicht beantwortet. Warte auf die Antwort oder frag in einem anderen Thread.",
+        "draft_conflict": "Dieser Kommentarentwurf wurde seit dem Laden bearbeitet, gepostet oder verworfen. Lade die Entwürfe neu und nimm deine Änderung erneut vor.",
+        "session_stale": "Nach der Vorbereitung dieser Review kamen neue Commits hinzu, daher zeigen die Entwürfe möglicherweise auf falsche Zeilen. Aktualisiere die Review, prüfe die Entwürfe und poste dann."
       },
       "action": {
         "connectGitHub": "GitHub verbinden",