@cat-factory/app 0.158.3 → 0.159.1

package/app/components/judge/JudgeResultView.vue

@@ -0,0 +1,300 @@
+<script setup lang="ts">
+// Judge window — the dedicated surface for a JUDGE step (the fourth step-taxonomy bucket),
+// opened via the universal result-view host (the same seam the gate window and the test report
+// use). ONE window serves EVERY registered judge: it reads the rubric name, the score, the
+// per-task threshold and the findings straight off `step.judge`, so a deployment that registers
+// a rubric gets a real result window with no frontend code at all.
+//
+// When the verdict parked the run it also owns the decision: proceed anyway, bounce the work
+// back to the producing step for rework (with optional extra guidance), or stop the run.
+import { computed, ref } from 'vue'
+import { agentKindMeta } from '~/utils/catalog'
+import type { JudgeFinding, JudgeStepState } from '~/types/execution'
+import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
+import CopyButton from '~/components/common/CopyButton.vue'
+
+const board = useBoardStore()
+const execution = useExecutionStore()
+const judgeStore = useJudgeStore()
+const { t, n } = useI18n()
+const access = useWorkspaceAccess()
+
+// Synchronous window: it reads its state straight off the execution step, so there is nothing
+// to fetch on open. `ResultWindowShell` owns Escape (and focus trap + scroll lock + stacking).
+const { open, blockId, instanceId, stepIndex, close } = useResultView('judge')
+const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))
+
+const instance = computed(() =>
+  instanceId.value === null ? null : (execution.getInstance(instanceId.value) ?? null),
+)
+const step = computed(() => {
+  if (instance.value === null || stepIndex.value === null) return null
+  return instance.value.steps[stepIndex.value] ?? null
+})
+const judge = computed<JudgeStepState | null>(() => step.value?.judge ?? null)
+const meta = computed(() => agentKindMeta(step.value?.agentKind ?? 'judge'))
+
+const rubricName = computed(() => judge.value?.rubricName ?? meta.value.label)
+const headerTitle = computed(
+  () => `${rubricName.value}${block.value ? ` — ${block.value.title}` : ''}`,
+)
+
+const verdict = computed(() => judge.value?.verdict ?? null)
+const score = computed(() => verdict.value?.score ?? null)
+const threshold = computed(() => judge.value?.threshold ?? null)
+const awaiting = computed(() => judge.value?.status === 'awaiting_decision')
+const rounds = computed(() => [...(judge.value?.rounds ?? [])].reverse())
+
+// Severity-ordered, worst first — the same order the rework brief hands the producer, so the
+// window and the bounced agent agree on what matters.
+const SEVERITY_RANK: Record<JudgeFinding['severity'], number> = {
+  critical: 3,
+  high: 2,
+  medium: 1,
+  low: 0,
+}
+const findings = computed(() =>
+  [...(verdict.value?.findings ?? [])].sort(
+    (a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity],
+  ),
+)
+
+// Exhaustive maps keyed off the wire unions, so adding a status/severity/disposition upstream
+// fails the typecheck here rather than leaking a raw key at runtime (the tier-2 drift guard).
+const STATUS_META = computed<
+  Record<
+    NonNullable<JudgeStepState['status']>,
+    { label: string; badge: 'success' | 'warning' | 'error' | 'neutral' }
+  >
+>(() => ({
+  evaluating: { label: t('judge.status.evaluating'), badge: 'neutral' },
+  awaiting_decision: { label: t('judge.status.awaitingDecision'), badge: 'warning' },
+  bouncing: { label: t('judge.status.bouncing'), badge: 'warning' },
+  passed: { label: t('judge.status.passed'), badge: 'success' },
+  failed: { label: t('judge.status.failed'), badge: 'error' },
+  skipped: { label: t('judge.status.skipped'), badge: 'neutral' },
+}))
+
+const SEVERITY_LABELS = computed<Record<JudgeFinding['severity'], string>>(() => ({
+  low: t('judge.severity.low'),
+  medium: t('judge.severity.medium'),
+  high: t('judge.severity.high'),
+  critical: t('judge.severity.critical'),
+}))
+
+const SEVERITY_CLASSES: Record<JudgeFinding['severity'], string> = {
+  low: 'border-slate-700 text-slate-300',
+  medium: 'border-amber-500/40 text-amber-300',
+  high: 'border-orange-500/40 text-orange-300',
+  critical: 'border-rose-500/40 text-rose-300',
+}
+
+const DISPOSITION_LABELS = computed<
+  Record<NonNullable<NonNullable<JudgeStepState['disposition']>>, string>
+>(() => ({
+  pass: t('judge.disposition.pass'),
+  park: t('judge.disposition.park'),
+  bounce: t('judge.disposition.bounce'),
+  fail: t('judge.disposition.fail'),
+}))
+
+const feedback = ref('')
+const busy = computed(() => judgeStore.resolving)
+const canAct = computed(() => awaiting.value && access.canExecuteRuns.value && !busy.value)
+
+async function act(choice: 'proceed' | 'bounce' | 'stop') {
+  const id = instanceId.value
+  if (!id) return
+  await judgeStore.resolve(id, choice, feedback.value.trim() || undefined)
+  feedback.value = ''
+}
+</script>
+
+<template>
+  <ResultWindowShell
+    :open="open"
+    :icon="meta.icon"
+    icon-class="bg-amber-500/15 text-amber-300"
+    :title="headerTitle"
+    :subtitle="t('judge.subtitle')"
+    :step-ref="{ instanceId, stepIndex }"
+    width="3xl"
+    @close="close"
+  >
+    <template #header-extras>
+      <UBadge
+        v-if="judge"
+        :color="STATUS_META[judge.status].badge"
+        variant="subtle"
+        size="sm"
+        data-testid="judge-status"
+      >
+        {{ STATUS_META[judge.status].label }}
+      </UBadge>
+    </template>
+
+    <div class="min-w-0 flex-1 overflow-y-auto px-5 py-4">
+      <div
+        v-if="!judge"
+        class="flex h-full flex-col items-center justify-center gap-2 text-center text-slate-400"
+      >
+        <UIcon :name="meta.icon" class="h-8 w-8 opacity-40" />
+        <p class="text-sm">{{ t('judge.empty') }}</p>
+      </div>
+
+      <template v-else>
+        <!-- The score against the task's threshold — the whole verdict in one line. -->
+        <div
+          class="flex flex-wrap items-center gap-x-3 gap-y-1 rounded-lg border border-slate-800 bg-slate-950/40 px-3 py-2.5"
+          data-testid="judge-score"
+        >
+          <span class="text-[13px] font-semibold text-slate-100">
+            {{ score === null ? t('judge.notScored') : n(score, 'percent') }}
+          </span>
+          <span v-if="threshold !== null" class="text-[12px] text-slate-400">
+            {{ t('judge.threshold', { threshold: n(threshold, 'percent') }) }}
+          </span>
+          <span v-if="judge.disposition" class="text-[12px] text-slate-400">
+            · {{ DISPOSITION_LABELS[judge.disposition] }}
+          </span>
+          <span v-if="judge.rubricOverridden" class="text-[11px] text-violet-300">
+            · {{ t('judge.rubricOverridden') }}
+          </span>
+          <span v-if="(judge.maxBounces ?? 0) > 0" class="text-[11px] text-slate-500">
+            ·
+            {{ t('judge.reworkRounds', { spent: judge.bounces ?? 0, budget: judge.maxBounces }) }}
+          </span>
+        </div>
+
+        <!-- Why the judge did nothing, when it did nothing. A skipped judge must never read
+             like a clean pass. -->
+        <p
+          v-if="judge.note"
+          class="mt-2 rounded-md border border-slate-800 bg-slate-950/40 px-3 py-2 text-[12px] leading-relaxed text-slate-400"
+        >
+          {{ judge.note }}
+        </p>
+
+        <div v-if="verdict?.summary" class="relative mt-3">
+          <CopyButton :text="verdict.summary" class="absolute end-1 top-1" />
+          <p class="whitespace-pre-wrap pe-8 text-[13px] leading-relaxed text-slate-200">
+            {{ verdict.summary }}
+          </p>
+        </div>
+
+        <section v-if="findings.length" class="mt-4">
+          <h3 class="mb-2 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+            {{ t('judge.findingsHeading') }}
+          </h3>
+          <ul class="flex flex-col gap-2">
+            <li
+              v-for="(finding, i) in findings"
+              :key="`${finding.title}-${i}`"
+              class="rounded-md border border-slate-800 bg-slate-950/40 px-3 py-2"
+              data-testid="judge-finding"
+            >
+              <div class="flex flex-wrap items-center gap-2">
+                <span
+                  class="rounded border px-1.5 py-0.5 text-[10px] uppercase tracking-wide"
+                  :class="SEVERITY_CLASSES[finding.severity]"
+                >
+                  {{ SEVERITY_LABELS[finding.severity] }}
+                </span>
+                <span class="text-[13px] font-medium text-slate-100">{{ finding.title }}</span>
+                <code v-if="finding.where" class="text-[11px] text-slate-500">{{
+                  finding.where
+                }}</code>
+              </div>
+              <p
+                v-if="finding.detail"
+                class="mt-1 whitespace-pre-wrap text-[12px] leading-relaxed text-slate-400"
+              >
+                {{ finding.detail }}
+              </p>
+            </li>
+          </ul>
+        </section>
+
+        <!-- The decision. Only shown while the run is actually parked on this verdict. -->
+        <section v-if="awaiting" class="mt-5" data-testid="judge-decision">
+          <h3 class="mb-1.5 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+            {{ t('judge.decisionHeading') }}
+          </h3>
+          <p class="mb-2 text-[11px] leading-relaxed text-slate-500">
+            {{ t('judge.decisionDescription') }}
+          </p>
+          <textarea
+            v-model="feedback"
+            rows="3"
+            :disabled="busy"
+            :placeholder="t('judge.feedbackPlaceholder')"
+            class="w-full resize-y rounded-md border border-slate-800 bg-slate-950/60 px-3 py-2 text-[13px] text-slate-200 placeholder:text-slate-600 focus:border-amber-500/60 focus:outline-none focus-visible:ring-2 focus-visible:ring-amber-500/60"
+          />
+          <p v-if="judgeStore.error" class="mt-2 text-[12px] text-rose-300">
+            {{ judgeStore.error }}
+          </p>
+          <div class="mt-2 flex flex-wrap justify-end gap-2">
+            <UButton
+              size="sm"
+              color="neutral"
+              variant="ghost"
+              icon="i-lucide-octagon-x"
+              :loading="busy"
+              :disabled="!canAct"
+              :title="access.canExecuteRuns.value ? undefined : t('access.noRunExecute')"
+              data-testid="judge-stop"
+              @click="act('stop')"
+            >
+              {{ t('judge.stop') }}
+            </UButton>
+            <UButton
+              size="sm"
+              color="warning"
+              icon="i-lucide-undo-2"
+              :loading="busy"
+              :disabled="!canAct"
+              :title="access.canExecuteRuns.value ? undefined : t('access.noRunExecute')"
+              data-testid="judge-bounce"
+              @click="act('bounce')"
+            >
+              {{ t('judge.bounce') }}
+            </UButton>
+            <UButton
+              size="sm"
+              color="primary"
+              icon="i-lucide-circle-check"
+              :loading="busy"
+              :disabled="!canAct"
+              :title="access.canExecuteRuns.value ? undefined : t('access.noRunExecute')"
+              data-testid="judge-proceed"
+              @click="act('proceed')"
+            >
+              {{ t('judge.proceed') }}
+            </UButton>
+          </div>
+        </section>
+
+        <!-- The round history: a looping judge must not be a black box (the gate-attempt rule). -->
+        <section v-if="rounds.length > 1" class="mt-5">
+          <h3 class="mb-2 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+            {{ t('judge.roundsHeading') }}
+          </h3>
+          <ul class="flex flex-col gap-1.5">
+            <li
+              v-for="round in rounds"
+              :key="round.round"
+              class="flex flex-wrap items-center gap-2 rounded-md border border-slate-800 bg-slate-950/40 px-3 py-1.5 text-[12px] text-slate-300"
+            >
+              <span class="text-slate-500">{{ t('judge.round', { round: round.round }) }}</span>
+              <span class="font-medium text-slate-100">{{
+                n(round.verdict.score, 'percent')
+              }}</span>
+              <span class="text-slate-400">{{ DISPOSITION_LABELS[round.disposition] }}</span>
+              <code v-if="round.model" class="text-[11px] text-slate-500">{{ round.model }}</code>
+            </li>
+          </ul>
+        </section>
+      </template>
+    </div>
+  </ResultWindowShell>
+</template>

package/app/components/layout/NotificationsInbox.vue

@@ -71,6 +71,7 @@ const META: Record<Notification['type'], { icon: string; color: Accent }> = {
   // the title opens the fork-decision window (see `reveal`); "act" just marks it read (the
   // choice is made in that window — pick a fork / enter a custom approach — not here).
   fork_decision_pending: { icon: 'i-lucide-git-fork', color: 'warning' },
+  judge_review: { icon: 'i-lucide-scale', color: 'warning' },
   // The PR reviewer surfaced findings to triage. Clicking the title opens the PR-review window
   // (see `reveal`); "act" just marks it read (findings are selected in that window, not here).
   pr_review_ready: { icon: 'i-lucide-clipboard-check', color: 'primary' },
@@ -107,6 +108,7 @@ const ACTION_KEYS: Record<Notification['type'], string> = {
   human_review: 'layout.notifications.action.human_review',
   followup_pending: 'layout.notifications.action.followup_pending',
   fork_decision_pending: 'layout.notifications.action.fork_decision_pending',
+  judge_review: 'layout.notifications.action.judge_review',
   pr_review_ready: 'layout.notifications.action.pr_review_ready',
   initiative: 'layout.notifications.action.initiative',
   platform_health: 'layout.notifications.action.platform_health',
@@ -232,6 +234,7 @@ function reveal(n: Notification) {
   else if (n.type === 'human_review') revealHumanReview(n)
   else if (n.type === 'followup_pending') revealFollowUps(n)
   else if (n.type === 'fork_decision_pending') revealForkDecision(n)
+  else if (n.type === 'judge_review') revealJudge(n)
   else if (n.type === 'pr_review_ready') revealPrReview(n)
   else if (n.type === 'initiative') ui.openInitiativeTracker(n.blockId)
   else ui.select(n.blockId)
@@ -267,6 +270,18 @@ function revealForkDecision(n: Notification) {
   else if (n.blockId) ui.select(n.blockId)
 }
 
+/**
+ * Open the judge window for a run parked on a rubric verdict: find the step carrying the parked
+ * verdict and open it through the universal step dispatch (a registered judge declares the
+ * `judge` result view). Falls back to focusing the block when the run isn't loaded.
+ */
+function revealJudge(n: Notification) {
+  const instance = n.executionId ? execution.getInstance(n.executionId) : undefined
+  const idx = instance?.steps.findIndex((s) => s.judge?.status === 'awaiting_decision') ?? -1
+  if (instance && idx >= 0) ui.openStepDetail(instance.id, idx)
+  else if (n.blockId) ui.select(n.blockId)
+}
+
 /**
  * Open the PR deep-review window for a run parked awaiting a finding selection.
  * Falls back to focusing the block when the run isn't loaded.

package/app/components/panels/inspector/ServiceTestConfig.vue

@@ -297,6 +297,7 @@ const ENV_TEST_CONFLICT_KEYS: Record<Extract<ConflictReason, `env_test_${string}
   env_test_infraless: 'errors.conflict.title.env_test_infraless',
   env_test_not_provisionable: 'errors.conflict.title.env_test_not_provisionable',
   env_test_no_vcs: 'errors.conflict.title.env_test_no_vcs',
+  env_test_connection_failed: 'errors.conflict.title.env_test_connection_failed',
 }
 
 function buildEnvTestError(e: unknown): EnvTestError {
@@ -317,6 +318,18 @@ function buildEnvTestError(e: unknown): EnvTestError {
       configurable: true,
     }
   }
+  // The handler resolved but its live connection probe failed. The provider's OWN message is the
+  // actionable part ("Kargo project 'X' was not found"), so wrap it in localized prose rather than
+  // replacing it with a generic sentence — and offer the same jump, since the fix is in the
+  // handler's connection config.
+  if (reason === 'env_test_connection_failed' && parsed?.message) {
+    return {
+      text: t('errors.conflict.description.env_test_connection_failed_detail', {
+        detail: parsed.message,
+      }),
+      configurable: true,
+    }
+  }
   const key =
     reason && reason in ENV_TEST_CONFLICT_KEYS
       ? ENV_TEST_CONFLICT_KEYS[reason as keyof typeof ENV_TEST_CONFLICT_KEYS]

package/app/components/slack/SlackPanel.vue

@@ -68,6 +68,7 @@ const routes = reactive<Record<NotificationType, SlackRoute>>({
   human_review: { enabled: false, channel: '' },
   followup_pending: { enabled: false, channel: '' },
   fork_decision_pending: { enabled: false, channel: '' },
+  judge_review: { enabled: false, channel: '' },
   pr_review_ready: { enabled: false, channel: '' },
   initiative: { enabled: false, channel: '' },
   platform_health: { enabled: false, channel: '' },

package/app/composables/api/judge.ts

@@ -0,0 +1,28 @@
+import { getJudgeDecisionContract, resolveJudgeContract } from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * JUDGE steps (the fourth step-taxonomy bucket): a rubric scores the run's work and, when the
+ * verdict misses the task's threshold, the run parks. These endpoints read the verdict and
+ * resolve the park — proceed anyway, bounce the work back to the producing step for rework, or
+ * stop the run. The read returns null when no step carries judge state.
+ */
+export function judgeApi({ send, ws }: ApiContext) {
+  return {
+    // The live judge state for a run (null when no step carries one).
+    getJudgeState: (workspaceId: string, executionId: string) =>
+      send(getJudgeDecisionContract, { pathPrefix: ws(workspaceId), pathParams: { executionId } }),
+
+    // Resolve a parked verdict: proceed / bounce for rework / stop the run.
+    resolveJudge: (
+      workspaceId: string,
+      executionId: string,
+      body: { choice: 'proceed' | 'bounce' | 'stop'; feedback?: string | null },
+    ) =>
+      send(resolveJudgeContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+        body,
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -10,6 +10,7 @@ import { documentsApi } from './api/documents'
 import { executionApi } from './api/execution'
 import { followUpsApi } from './api/followUps'
 import { forkDecisionApi } from './api/forkDecision'
+import { judgeApi } from './api/judge'
 import { prReviewApi } from './api/prReview'
 import { fragmentsApi } from './api/fragments'
 import { skillsApi } from './api/skills'
@@ -119,6 +120,7 @@ export function useApi() {
     ...reviewsApi(ctx),
     ...followUpsApi(ctx),
     ...forkDecisionApi(ctx),
+    ...judgeApi(ctx),
     ...prReviewApi(ctx),
     ...humanTestApi(ctx),
     ...visualConfirmApi(ctx),

package/app/composables/usePipelineErrorToast.ts

@@ -166,6 +166,15 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
       run: (ui) => ui.openGitHub(),
     },
   },
+  env_test_connection_failed: {
+    titleKey: 'errors.conflict.title.env_test_connection_failed',
+    descriptionKey: 'errors.conflict.description.env_test_connection_failed',
+    action: {
+      labelKey: 'errors.conflict.action.configureInfrastructure',
+      icon: 'i-lucide-settings',
+      run: (ui) => ui.openProviderConnection('environment'),
+    },
+  },
   // Opt-in review-debt friction. In the normal task-create flow AddTaskModal intercepts these
   // 409s and opens the friction dialog (which can retry with an acknowledgement), so these entries
   // are the last-resort toast fallback for any OTHER caller — a generic, param-free title +

package/app/modular/result-views.ts

@@ -19,6 +19,7 @@ import InitiativeTrackerWindow from '~/components/initiative/InitiativeTrackerWi
 import InitiativePlanningWindow from '~/components/initiative/InitiativePlanningWindow.vue'
 import DocInterviewWindow from '~/components/docs/DocInterviewWindow.vue'
 import RalphLoopResultView from '~/components/ralph/RalphLoopResultView.vue'
+import JudgeResultView from '~/components/judge/JudgeResultView.vue'
 import type { ResultViewContribution } from './slots'
 
 /**
@@ -83,6 +84,9 @@ const BUILT_IN_RESULT_VIEWS: Record<ResultViewId, Component> = {
   'doc-interview': DocInterviewWindow,
   // The Ralph loop: the retry-until-done iteration history + the validation command + its output.
   'ralph-loop': RalphLoopResultView,
+  // Shared by EVERY registered judge (the fourth step-taxonomy bucket): the rubric verdict's
+  // score vs the task threshold, its findings, the round history, and the park's decision.
+  judge: JudgeResultView,
 }
 
 /**

package/app/stores/judge.ts

@@ -0,0 +1,83 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { JudgeStepState } from '~/types/execution'
+import { useApi } from '~/composables/useApi'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useExecutionStore } from '~/stores/execution'
+
+/**
+ * The JUDGE action surface (the fourth step-taxonomy bucket). The live verdict lives on the
+ * run's judge step (`step.judge`) and is kept fresh by the execution stream, so the window reads
+ * it straight off the execution store — this store only wraps the `resolve` action (and a
+ * warm-up `load`), tracks the in-flight state so the window can disable its controls, and
+ * reflects the returned state back onto the execution store so the UI updates immediately even
+ * before the stream echoes the change. Keyed by executionId, mirroring the fork-decision store.
+ */
+export const useJudgeStore = defineStore('judge', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+  const execution = useExecutionStore()
+
+  /** True while a resolve call is in flight (drives the buttons' spinner / disabled state). */
+  const resolving = ref(false)
+  /** The last error message from an action, surfaced inline; cleared on the next action. */
+  const error = ref<string | null>(null)
+
+  /**
+   * Reflect an authoritative judge state onto the run's judge step. A pipeline may place more
+   * than one judge, so target the step this verdict is about rather than the first one holding
+   * judge state: prefer the step still awaiting a decision, then the current step, and only then
+   * fall back to the first step carrying judge state. The stream corrects any mismatch; this
+   * keeps the immediate optimistic echo on the right step.
+   */
+  function reflect(executionId: string, state: JudgeStepState | null): void {
+    if (!state) return
+    const instance = execution.getInstance(executionId)
+    if (!instance) return
+    const current = instance.steps[instance.currentStep]
+    const step =
+      instance.steps.find((s) => s.judge?.status === 'awaiting_decision') ??
+      (current?.judge ? current : undefined) ??
+      instance.steps.find((s) => s.judge)
+    if (step) step.judge = state
+  }
+
+  /** Warm the live state from the GET (the stream also keeps it fresh). Best-effort. */
+  async function load(executionId: string): Promise<void> {
+    error.value = null
+    try {
+      const state = await api.getJudgeState(workspace.requireId(), executionId)
+      reflect(executionId, state as JudgeStepState | null)
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to load'
+    }
+  }
+
+  /**
+   * Resolve the parked verdict: `proceed` advances the run despite the score, `bounce` sends the
+   * work back to the producing step with the findings (plus any extra guidance) as rework, and
+   * `stop` fails the run.
+   */
+  async function resolve(
+    executionId: string,
+    choice: 'proceed' | 'bounce' | 'stop',
+    feedback?: string,
+  ): Promise<void> {
+    error.value = null
+    resolving.value = true
+    try {
+      const state = await api.resolveJudge(workspace.requireId(), executionId, {
+        choice,
+        ...(feedback ? { feedback } : {}),
+      })
+      reflect(executionId, state as JudgeStepState)
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to resolve'
+      throw e
+    } finally {
+      resolving.value = false
+    }
+  }
+
+  return { resolving, error, load, resolve }
+})

package/app/types/execution.ts

@@ -43,6 +43,13 @@ export type {
   ForkDecisionStatus,
   ForkChoice,
   ForkDecisionStepState,
+  JudgeVerdict,
+  JudgeFinding,
+  JudgeFindingSeverity,
+  JudgeDisposition,
+  JudgeStatus,
+  JudgeRound,
+  JudgeStepState,
   PrReviewStepState,
   PrReviewFinding,
   PrReviewFindingChallenge,

package/i18n/locales/de.json

@@ -1831,6 +1831,7 @@
         "initiative": "Als gelesen markieren",
         "markRead": "Als gelesen markieren",
         "fork_decision_pending": "Als gelesen markieren",
+        "judge_review": "Als gelesen markieren",
         "pr_review_ready": "Als gelesen markieren",
         "budget_paused": "Als gelesen markieren",
         "key_drift": "Veraltete Zugangsdaten entfernen",
@@ -4162,7 +4163,8 @@
         "env_test_not_a_frame": "Kein Dienst",
         "env_test_infraless": "Nichts zu testen",
         "env_test_not_provisionable": "Umgebungs-Handler nicht konfiguriert",
-        "env_test_no_vcs": "Git-Anbieter nicht verbunden"
+        "env_test_no_vcs": "Git-Anbieter nicht verbunden",
+        "env_test_connection_failed": "Umgebungsverbindung fehlgeschlagen"
       },
       "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.",
@@ -4184,7 +4186,9 @@
         "env_test_not_provisionable": "Dieser Service hat einen Bereitstellungstyp, aber es ist noch kein Workspace-Handler dafür verfügbar, sodass die Bereitstellung nicht laufen kann. Konfiguriere einen Umgebungs-Handler.",
         "env_test_not_provisionable_no_handler": "Für den Bereitstellungstyp dieses Service ist kein Workspace-Umgebungs-Handler konfiguriert. Registriere in Infrastruktur → Testumgebungen einen — für einen benutzerdefinierten Anbieter einen Custom (remote-custom)-Handler, dessen akzeptierte manifest id mit der übereinstimmt, die dieser Service festlegt.",
         "env_test_not_provisionable_type_mismatch": "Mehr als ein Umgebungs-Handler könnte auf den Bereitstellungstyp dieses Service passen. Lege für diesen Service eine manifest id fest, sodass genau einer aufgelöst wird, oder entferne den überlappenden Handler in Infrastruktur → Testumgebungen.",
-        "env_test_no_vcs": "Der Selbsttest benötigt einen Git-Anbieter, um seinen Wegwerf-Branch zu erstellen und zu löschen, aber dieser Workspace ist mit keinem verbunden."
+        "env_test_no_vcs": "Der Selbsttest benötigt einen Git-Anbieter, um seinen Wegwerf-Branch zu erstellen und zu löschen, aber dieser Workspace ist mit keinem verbunden.",
+        "env_test_connection_failed": "Der Umgebungs-Handler dieses Dienstes hat seinen Verbindungstest nicht bestanden. Prüfen Sie Endpunkt, Anmeldedaten und Projekteinstellungen und testen Sie die Verbindung erneut.",
+        "env_test_connection_failed_detail": "Der Umgebungs-Handler dieses Dienstes hat seinen Verbindungstest nicht bestanden: {detail}. Prüfen Sie Endpunkt, Anmeldedaten und Projekteinstellungen und testen Sie die Verbindung erneut."
       },
       "action": {
         "connectGitHub": "GitHub verbinden",
@@ -4373,6 +4377,43 @@
       "footer": "Ein Gate führt eine programmatische Vorprüfung aus und startet den {helper} nur, wenn sie fehlschlägt; eine grüne Prüfung fährt fort, ohne dass etwas gestartet wird."
     }
   },
+  "judge": {
+    "subtitle": "Bewertet die Arbeit dieses Laufs anhand eines Bewertungsrasters und fährt fort, fragt nach oder schickt sie zurück",
+    "empty": "Dieser Schritt hat noch kein Urteil erzeugt.",
+    "notScored": "Nicht bewertet",
+    "threshold": "Schwellenwert {threshold}",
+    "rubricOverridden": "Raster des Arbeitsbereichs",
+    "reworkRounds": "Überarbeitung {spent}/{budget}",
+    "findingsHeading": "Was das Bewertungsraster beanstandet hat",
+    "roundsHeading": "Prüfrunden",
+    "round": "Runde {round}",
+    "decisionHeading": "Ihre Entscheidung",
+    "decisionDescription": "Trotzdem fortfahren, die Arbeit zur Überarbeitung zurückschicken oder den Lauf stoppen.",
+    "feedbackPlaceholder": "Optionale Hinweise, die beim Zurückschicken mitgegeben werden…",
+    "proceed": "Trotzdem fortfahren",
+    "bounce": "Zur Überarbeitung zurückschicken",
+    "stop": "Lauf stoppen",
+    "status": {
+      "evaluating": "Wird geprüft",
+      "awaitingDecision": "Entscheidung nötig",
+      "bouncing": "Wird überarbeitet",
+      "passed": "Bestanden",
+      "failed": "Fehlgeschlagen",
+      "skipped": "Übersprungen"
+    },
+    "severity": {
+      "low": "Niedrig",
+      "medium": "Mittel",
+      "high": "Hoch",
+      "critical": "Kritisch"
+    },
+    "disposition": {
+      "pass": "Bestanden",
+      "park": "Nachfrage an einen Menschen",
+      "bounce": "Zur Überarbeitung zurückgeschickt",
+      "fail": "Lauf fehlgeschlagen"
+    }
+  },
   "consensus": {
     "titlePrefix": "Konsens",
     "participantCount": "keine Teilnehmer | ein Teilnehmer | {count} Teilnehmer",