@cat-factory/app 0.111.3 → 0.113.0

package/app/components/pipeline/PipelineProgress.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import type { AgentState, ExecutionInstance } from '~/types/domain'
 import type { PipelineStep } from '~/types/execution'
-import { agentKindMeta, FOLLOW_UP_COMPANION_META } from '~/utils/catalog'
+import { agentKindMeta, FOLLOW_UP_COMPANION_META, FORK_DECISION_META } from '~/utils/catalog'
 import {
   subtaskIconClass,
   gateCompanionFor,
@@ -68,6 +68,12 @@ function followUpLabel(step: PipelineStep): string {
     : t('pipeline.progress.followUp.allDecided')
 }
 
+/** The active fork-decision phase status on a coder step (proposing / awaiting a choice). */
+function forkPhase(step: PipelineStep): 'proposing' | 'awaiting_choice' | null {
+  const status = step.forkDecision?.status
+  return status === 'proposing' || status === 'awaiting_choice' ? status : null
+}
+
 // --- restart from a step -----------------------------------------------------
 // Re-run the pipeline from a chosen step onward: the server resets that step +
 // every later step's iteration counters and re-drives a fresh run, keeping the
@@ -543,6 +549,40 @@ const ITEM_ICON: Record<string, string> = {
             </span>
           </button>
 
+          <!-- Implementation-fork decision phase (Coder step): a spinner while the proposer
+               surfaces approaches, then a clickable chip to choose one. -->
+          <button
+            v-if="forkPhase(s)"
+            type="button"
+            class="mt-3 flex w-full items-center gap-2 rounded-lg border border-dashed px-2.5 py-1.5 text-start transition hover:border-violet-400/60"
+            :class="
+              forkPhase(s) === 'awaiting_choice'
+                ? 'border-violet-500/50 bg-violet-500/10 followup-blink'
+                : 'border-slate-700/70 bg-slate-900/40'
+            "
+            :disabled="forkPhase(s) === 'proposing'"
+            @click="ui.openForkDecision(instance.id, i)"
+          >
+            <span
+              class="flex h-6 w-6 shrink-0 items-center justify-center rounded-md border border-violet-500/40 bg-violet-500/15"
+            >
+              <UIcon
+                :name="
+                  forkPhase(s) === 'proposing' ? 'i-lucide-loader-circle' : FORK_DECISION_META.icon
+                "
+                class="h-3 w-3 text-violet-300"
+                :class="forkPhase(s) === 'proposing' ? 'animate-spin' : ''"
+              />
+            </span>
+            <span class="min-w-0 flex-1 truncate text-[12px] text-slate-300">
+              {{
+                forkPhase(s) === 'proposing'
+                  ? t('pipeline.progress.forkDecision.proposing')
+                  : t('pipeline.progress.forkDecision.choose')
+              }}
+            </span>
+          </button>
+
           <!-- reviewer gate folding/re-reviewing in the background: a working indicator,
                NOT a "Review & approve" gate (the human is summoned only if needed) -->
           <div

package/app/components/settings/RiskPolicyPanel.vue

@@ -6,6 +6,7 @@
 // default; it cannot be deleted or un-defaulted (the backend enforces this too).
 import { computed, reactive, ref, watch } from 'vue'
 import type { RiskPolicy, RequirementConcernLevel } from '~/types/merge'
+import type { StepGating } from '@cat-factory/contracts'
 
 const { t } = useI18n()
 
@@ -42,9 +43,32 @@ interface Draft {
   maxRequirementIterations: number
   maxRequirementConcernAllowed: RequirementConcernLevel
   autoMergeEnabled: boolean
+  // Implementation-fork decision gating (edited 0..100, stored 0..1); disabled ⇒ off in `auto`.
+  forkEnabled: boolean
+  forkMinComplexity: number
+  forkMinRisk: number
+  forkMinImpact: number
+  forkOnMissing: 'run' | 'skip'
 }
 const drafts = reactive<Record<string, Draft>>({})
 
+// On-missing-estimate options for the fork gating group (fail toward asking / skipping).
+const ON_MISSING_OPTIONS = computed<{ value: 'run' | 'skip'; label: string }[]>(() => [
+  { value: 'run', label: t('settings.riskPolicy.forkDecision.onMissing.run') },
+  { value: 'skip', label: t('settings.riskPolicy.forkDecision.onMissing.skip') },
+])
+
+/** Build the `StepGating` payload for the fork-decision gate from a draft (or null when off). */
+function forkGating(d: Draft): StepGating {
+  return {
+    enabled: d.forkEnabled,
+    minComplexity: d.forkMinComplexity / 100,
+    minRisk: d.forkMinRisk / 100,
+    minImpact: d.forkMinImpact / 100,
+    onMissingEstimate: d.forkOnMissing,
+  }
+}
+
 function toDraft(p: RiskPolicy): Draft {
   return {
     name: p.name,
@@ -55,6 +79,11 @@ function toDraft(p: RiskPolicy): Draft {
     maxRequirementIterations: p.maxRequirementIterations,
     maxRequirementConcernAllowed: p.maxRequirementConcernAllowed,
     autoMergeEnabled: p.autoMergeEnabled,
+    forkEnabled: p.forkDecision?.enabled ?? false,
+    forkMinComplexity: Math.round((p.forkDecision?.minComplexity ?? 0.5) * 100),
+    forkMinRisk: Math.round((p.forkDecision?.minRisk ?? 0.4) * 100),
+    forkMinImpact: Math.round((p.forkDecision?.minImpact ?? 0.4) * 100),
+    forkOnMissing: p.forkDecision?.onMissingEstimate ?? 'run',
   }
 }
 
@@ -92,6 +121,7 @@ async function save(p: RiskPolicy) {
       maxRequirementIterations: d.maxRequirementIterations,
       maxRequirementConcernAllowed: d.maxRequirementConcernAllowed,
       autoMergeEnabled: d.autoMergeEnabled,
+      forkDecision: forkGating(d),
     })
     toast.add({
       title: t('settings.riskPolicy.toast.saved'),
@@ -146,6 +176,11 @@ const draft = reactive<Draft>({
   maxRequirementIterations: 6,
   maxRequirementConcernAllowed: 'none',
   autoMergeEnabled: true,
+  forkEnabled: false,
+  forkMinComplexity: 50,
+  forkMinRisk: 40,
+  forkMinImpact: 40,
+  forkOnMissing: 'run',
 })
 
 async function create() {
@@ -161,6 +196,7 @@ async function create() {
       maxRequirementIterations: draft.maxRequirementIterations,
       maxRequirementConcernAllowed: draft.maxRequirementConcernAllowed,
       autoMergeEnabled: draft.autoMergeEnabled,
+      forkDecision: forkGating(draft),
     })
     draft.name = ''
     draft.autoMergeEnabled = true
@@ -305,6 +341,61 @@ async function create() {
         </label>
       </div>
 
+      <!-- Implementation-fork decision gate: propose materially different approaches before the
+           Coder writes code (in `auto` tri-state, gated on the task estimate). -->
+      <div class="mt-3 rounded-md border border-slate-800 bg-slate-900/40 p-3">
+        <USwitch
+          v-model="drafts[p.id]!.forkEnabled"
+          size="sm"
+          :label="t('settings.riskPolicy.forkDecision.label')"
+          :description="t('settings.riskPolicy.forkDecision.hint')"
+        />
+        <div v-if="drafts[p.id]!.forkEnabled" class="mt-3 grid grid-cols-2 gap-3 sm:grid-cols-4">
+          <label class="block">
+            <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+              {{ t('settings.riskPolicy.forkDecision.minComplexity') }}
+            </span>
+            <UInput
+              v-model.number="drafts[p.id]!.forkMinComplexity"
+              type="number"
+              size="sm"
+              :min="0"
+              :max="100"
+            />
+          </label>
+          <label class="block">
+            <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+              {{ t('settings.riskPolicy.forkDecision.minRisk') }}
+            </span>
+            <UInput
+              v-model.number="drafts[p.id]!.forkMinRisk"
+              type="number"
+              size="sm"
+              :min="0"
+              :max="100"
+            />
+          </label>
+          <label class="block">
+            <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+              {{ t('settings.riskPolicy.forkDecision.minImpact') }}
+            </span>
+            <UInput
+              v-model.number="drafts[p.id]!.forkMinImpact"
+              type="number"
+              size="sm"
+              :min="0"
+              :max="100"
+            />
+          </label>
+          <label class="block">
+            <span class="mb-1 block text-[10px] uppercase tracking-wide text-slate-500">
+              {{ t('settings.riskPolicy.forkDecision.onMissingLabel') }}
+            </span>
+            <USelect v-model="drafts[p.id]!.forkOnMissing" :items="ON_MISSING_OPTIONS" size="sm" />
+          </label>
+        </div>
+      </div>
+
       <div class="mt-3 flex items-center justify-between gap-3">
         <USwitch
           v-model="drafts[p.id]!.autoMergeEnabled"
@@ -403,6 +494,11 @@ async function create() {
           size="sm"
           :label="t('settings.riskPolicy.field.autoMerge')"
         />
+        <USwitch
+          v-model="draft.forkEnabled"
+          size="sm"
+          :label="t('settings.riskPolicy.forkDecision.label')"
+        />
         <UButton
           color="primary"
           size="sm"

package/app/components/slack/SlackPanel.vue

@@ -56,6 +56,7 @@ const routes = reactive<Record<NotificationType, SlackRoute>>({
   visual_confirmation_ready: { enabled: false, channel: '' },
   human_review: { enabled: false, channel: '' },
   followup_pending: { enabled: false, channel: '' },
+  fork_decision_pending: { enabled: false, channel: '' },
   initiative: { enabled: false, channel: '' },
 })
 const mentionsEnabled = ref(false)

package/app/composables/api/forkDecision.ts

@@ -0,0 +1,29 @@
+import { chooseForkContract, getForkDecisionContract } from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * The implementation-fork decision phase: before the Coder writes code the read-only
+ * proposer surfaces materially different approaches on the run's coder step and the run
+ * parks. These endpoints read the surfaced approaches and record the human's choice (a
+ * proposed fork or their own free-text approach); choosing re-runs the Coder with the chosen
+ * approach folded in. The read returns null when no coder step carries fork state.
+ */
+export function forkDecisionApi({ send, ws }: ApiContext) {
+  return {
+    // The live fork-decision state for a run (null when no coder step carries one).
+    getForkDecision: (workspaceId: string, executionId: string) =>
+      send(getForkDecisionContract, { pathPrefix: ws(workspaceId), pathParams: { executionId } }),
+
+    // Choose an implementation approach — a proposed fork id or a custom approach (+ note).
+    chooseFork: (
+      workspaceId: string,
+      executionId: string,
+      body: { forkId?: string | null; custom?: string | null; note?: string | null },
+    ) =>
+      send(chooseForkContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+        body,
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -8,6 +8,7 @@ import { boardApi } from './api/board'
 import { documentsApi } from './api/documents'
 import { executionApi } from './api/execution'
 import { followUpsApi } from './api/followUps'
+import { forkDecisionApi } from './api/forkDecision'
 import { fragmentsApi } from './api/fragments'
 import { githubApi } from './api/github'
 import { humanReviewApi } from './api/humanReview'
@@ -108,6 +109,7 @@ export function useApi() {
     ...tasksApi(ctx),
     ...reviewsApi(ctx),
     ...followUpsApi(ctx),
+    ...forkDecisionApi(ctx),
     ...humanTestApi(ctx),
     ...visualConfirmApi(ctx),
     ...humanReviewApi(ctx),

package/app/stores/forkDecision.ts

@@ -0,0 +1,84 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { ForkDecisionStepState } from '~/types/execution'
+import { useApi } from '~/composables/useApi'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useExecutionStore } from '~/stores/execution'
+
+/**
+ * The implementation-fork decision action surface. The live fork state lives on the run's
+ * Coder step (`step.forkDecision`) and is kept fresh by the execution stream, so the window
+ * reads it straight off the execution store — this store only wraps the `choose` 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 follow-ups store.
+ */
+export const useForkDecisionStore = defineStore('forkDecision', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+  const execution = useExecutionStore()
+
+  /** True while a choose call is in flight (drives the Choose button spinner / disabled state). */
+  const choosing = 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 fork-decision state onto the run's Coder step. A pipeline may
+   * carry more than one `coder` step, so target the step this decision is about rather than
+   * the first one that happens to hold fork state: prefer the step that is still live
+   * (proposing / awaiting the choice / answering), then the current step, and only then fall
+   * back to the first step carrying fork state. The stream corrects any mismatch, but this
+   * keeps the immediate optimistic echo on the right step.
+   */
+  function reflect(executionId: string, state: ForkDecisionStepState | null): void {
+    if (!state) return
+    const instance = execution.getInstance(executionId)
+    if (!instance) return
+    const isLive = (s: (typeof instance.steps)[number]) =>
+      s.agentKind === 'coder' &&
+      (s.forkDecision?.status === 'awaiting_choice' ||
+        s.forkDecision?.status === 'answering' ||
+        s.forkDecision?.status === 'proposing')
+    const current = instance.steps[instance.currentStep]
+    const step =
+      instance.steps.find(isLive) ??
+      (current?.agentKind === 'coder' && current.forkDecision ? current : undefined) ??
+      instance.steps.find((s) => s.forkDecision)
+    if (step) step.forkDecision = 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.getForkDecision(workspace.requireId(), executionId)
+      reflect(executionId, state as ForkDecisionStepState | null)
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to load'
+    }
+  }
+
+  /**
+   * Choose an implementation approach: a proposed fork id OR a custom free-text approach
+   * (with an optional steering note). The Coder then re-runs with the choice folded in.
+   */
+  async function choose(
+    executionId: string,
+    choice: { forkId?: string; custom?: string; note?: string },
+  ): Promise<void> {
+    error.value = null
+    choosing.value = true
+    try {
+      const state = await api.chooseFork(workspace.requireId(), executionId, choice)
+      reflect(executionId, state as ForkDecisionStepState)
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to choose'
+      throw e
+    } finally {
+      choosing.value = false
+    }
+  }
+
+  return { choosing, error, load, choose }
+})

package/app/stores/ui.ts

@@ -809,6 +809,31 @@ export const useUiStore = defineStore('ui', () => {
       stepIndex: idx,
     }
   }
+  // Open the implementation-fork decision window for a run's coder step (from the inspector /
+  // pipeline chip / `fork_decision_pending` notification). Resolves the coder step index from
+  // the run when not given, preferring the step parked awaiting a choice.
+  function openForkDecision(instanceId: string, stepIndex: number | null = null) {
+    const execution = useExecutionStore()
+    const instance = execution.getInstance(instanceId)
+    if (!instance) return
+    const resolveIdx = () => {
+      const awaiting = instance.steps.findIndex(
+        (s) => s.agentKind === 'coder' && s.forkDecision?.status === 'awaiting_choice',
+      )
+      if (awaiting >= 0) return awaiting
+      const current = instance.steps[instance.currentStep]
+      if (current?.agentKind === 'coder' && current.forkDecision) return instance.currentStep
+      return instance.steps.findIndex((s) => s.agentKind === 'coder' && s.forkDecision)
+    }
+    const idx = stepIndex ?? resolveIdx()
+    if (idx < 0) return
+    resultView.value = {
+      view: 'fork-decision',
+      blockId: instance.blockId,
+      instanceId,
+      stepIndex: idx,
+    }
+  }
   function closeResultView() {
     resultView.value = null
   }
@@ -1006,6 +1031,7 @@ export const useUiStore = defineStore('ui', () => {
     openInitiativeTracker,
     openInitiativePlanning,
     openFollowUps,
+    openForkDecision,
     closeRequirementReview,
     openStepDetail,
     closeStepDetail,

package/app/types/domain.ts

@@ -29,6 +29,7 @@ export type {
   Block,
   PullRequestRef,
   ReferenceRepo,
+  AprioriBranch,
   CloudProvider,
   InstanceSize,
   ProvisionType,

package/app/types/execution.ts

@@ -33,6 +33,11 @@ export type {
   FollowUpItemStatus,
   FollowUpItem,
   FollowUpsStepState,
+  ForkOption,
+  ForkChatMessage,
+  ForkDecisionStatus,
+  ForkChoice,
+  ForkDecisionStepState,
   GateFailingCheck,
   GateAttempt,
   GateStepState,

package/app/utils/catalog.ts

@@ -708,6 +708,17 @@ export const FOLLOW_UP_COMPANION_META = {
   color: '#f472b6',
 }
 
+/**
+ * Display metadata for the implementation-fork decision phase on a Coder step (a per-step
+ * phase, not an agent kind of its own — the read-only `fork-proposer` is never a palette
+ * block). Drives the fork-decision window header + the pipeline phase chip.
+ */
+export const FORK_DECISION_META = {
+  label: 'Implementation-fork decision',
+  icon: 'i-lucide-git-fork',
+  color: '#a78bfa',
+}
+
 /**
  * Whether a Coder step has the Follow-up companion enabled, given the pipeline's per-step
  * `followUps` toggle at index `i`. Enabled by default on a `coder` step (only `false`

package/i18n/locales/de.json

@@ -438,6 +438,18 @@
         "createFailed": "Richtlinie konnte nicht erstellt werden",
         "defaultFailed": "Standard konnte nicht festgelegt werden",
         "deleteFailed": "Richtlinie konnte nicht gelöscht werden"
+      },
+      "forkDecision": {
+        "label": "Implementierungs-Weichenentscheidung",
+        "hint": "Im Auto-Modus grundlegend verschiedene Ansätze vorschlagen (und für eine Wahl pausieren), wenn die Aufgabenschätzung einen Schwellenwert erreicht.",
+        "minComplexity": "Min. Komplexität",
+        "minRisk": "Min. Risiko",
+        "minImpact": "Min. Auswirkung",
+        "onMissingLabel": "Keine Schätzung",
+        "onMissing": {
+          "run": "Trotzdem vorschlagen",
+          "skip": "Überspringen"
+        }
       }
     },
     "observabilityConnection": {
@@ -1161,7 +1173,8 @@
       "companionOf": "{label} (Begleiter)",
       "merged": "Gemergt",
       "open": "Öffnen",
-      "mergePr": "PR mergen"
+      "mergePr": "PR mergen",
+      "chooseApproach": "Ansatz wählen"
     },
     "structure": {
       "title": "Struktur",
@@ -1227,6 +1240,20 @@
       "involvedServicesEmpty": "Keine verbundenen Services. Verbinde Services am Service-Frame, um sie hier auszuwählen.",
       "involvedServiceStale": "Nicht mehr mit dem Service dieser Aufgabe verbunden; wird bei der nächsten Änderung entfernt."
     },
+    "aprioriBranches": {
+      "title": "Vorhandene Branches",
+      "mode": {
+        "reference": "Referenz",
+        "working": "Arbeitsbranch"
+      },
+      "remove": "{branch} entfernen",
+      "searchPlaceholder": "Vorhandenen Branch hinzufügen…",
+      "connectFirst": "Verbinde GitHub, um vorhandene Branches hinzuzufügen.",
+      "protectedWarning": "{branch} ist ein geschützter Branch. Pushes aus dem Lauf werden möglicherweise abgelehnt.",
+      "multiRepoHint": "Der Arbeitsmodus ist nicht verfügbar, solange diese Aufgabe mehr als einen Service umfasst.",
+      "frozenHint": "Der Arbeitsbranch ist gesperrt, da für diese Aufgabe bereits ein Pull Request existiert.",
+      "hint": "Übergib dieser Aufgabe vorhandene Branches ihres Repositorys. Ein Referenzbranch ist schreibgeschützter Kontext, den die Agenten einsehen dürfen; im einzelnen Arbeitsbranch baut der Lauf weiter, statt einen neuen Branch anzulegen."
+    },
     "referenceRepos": {
       "title": "Referenz-Repositories",
       "remove": "{repo} entfernen",
@@ -1649,7 +1676,8 @@
         "human_review": "Als gelesen markieren",
         "followup_pending": "Als gelesen markieren",
         "initiative": "Als gelesen markieren",
-        "markRead": "Als gelesen markieren"
+        "markRead": "Als gelesen markieren",
+        "fork_decision_pending": "Als gelesen markieren"
       }
     },
     "aiProvidersBanner": {
@@ -2979,7 +3007,11 @@
       "subtasksInProgress": "· {count} in Arbeit",
       "clickToRead": "Klicken, um die Ausgabe dieses Agenten zu lesen",
       "reviewApprove": "Vorschlag von {agent} prüfen & freigeben",
-      "resolve": "Klären: {question}"
+      "resolve": "Klären: {question}",
+      "forkDecision": {
+        "proposing": "Ansätze werden vorgeschlagen…",
+        "choose": "Ansatz wählen"
+      }
     },
     "health": {
       "title": "Pipeline-Zustand",
@@ -4551,5 +4583,34 @@
   "palette": {
     "hint": "Klicke auf einen Agenten, um ihn an die Pipeline anzuhängen.",
     "customAgents": "Benutzerdefinierte Agenten"
+  },
+  "forkDecision": {
+    "title": "Implementierungsansatz wählen",
+    "titleWithBlock": "Ansatz für {title} wählen",
+    "subtitle": "Grundlegend verschiedene Wege, diese Aufgabe umzusetzen, bevor Code geschrieben wird.",
+    "seam": "Betroffene Stelle:",
+    "recommended": "Empfohlen",
+    "riskNotes": "Risiko:",
+    "noteLabel": "Hinweis (optional)",
+    "notePlaceholder": "Was die Umsetzung berücksichtigen soll…",
+    "choose": "Diesen Ansatz verwenden",
+    "proposing": {
+      "title": "Ansätze werden ermittelt…",
+      "hint": "Der Code wird gelesen, um die grundlegend verschiedenen Umsetzungswege zu finden."
+    },
+    "singlePath": {
+      "title": "Ein klarer Ansatz"
+    },
+    "chosen": {
+      "title": "Ansatz gewählt",
+      "note": "Hinweis: {note}"
+    },
+    "custom": {
+      "title": "Eigenen Ansatz eingeben",
+      "placeholder": "Beschreibe, wie dies umgesetzt werden soll…"
+    },
+    "empty": {
+      "title": "Nichts zu entscheiden"
+    }
   }
 }

package/i18n/locales/en.json

@@ -911,7 +911,8 @@
       "companionOf": "{label} (companion)",
       "merged": "Merged",
       "open": "Open",
-      "mergePr": "Merge PR"
+      "mergePr": "Merge PR",
+      "chooseApproach": "Choose approach"
     },
     "structure": {
       "title": "Structure",
@@ -977,6 +978,20 @@
       "involvedServicesEmpty": "No connected services. Connect services on the service frame to select them here.",
       "involvedServiceStale": "No longer connected to this task's service; it is dropped on the next change."
     },
+    "aprioriBranches": {
+      "title": "Existing branches",
+      "mode": {
+        "reference": "Reference",
+        "working": "Working"
+      },
+      "remove": "Remove {branch}",
+      "searchPlaceholder": "Add an existing branch…",
+      "connectFirst": "Connect GitHub to add existing branches.",
+      "protectedWarning": "{branch} is a protected branch. Pushes from the run may be rejected.",
+      "multiRepoHint": "Working mode is unavailable while this task involves more than one service.",
+      "frozenHint": "The working branch is locked because a pull request already exists for this task.",
+      "hint": "Hand this task pre-existing branches of its repository. A reference branch is read-only context the agents may inspect; the single working branch is where the run keeps building instead of a new branch."
+    },
     "referenceRepos": {
       "title": "Reference repositories",
       "remove": "Remove {repo}",
@@ -1539,7 +1554,8 @@
         "human_review": "Mark read",
         "followup_pending": "Mark read",
         "initiative": "Mark read",
-        "markRead": "Mark read"
+        "markRead": "Mark read",
+        "fork_decision_pending": "Mark read"
       }
     },
     "aiProvidersBanner": {
@@ -2213,6 +2229,18 @@
         "createFailed": "Could not create policy",
         "defaultFailed": "Could not set default",
         "deleteFailed": "Could not delete policy"
+      },
+      "forkDecision": {
+        "label": "Implementation-fork decision",
+        "hint": "In auto mode, propose materially different approaches (and pause for a choice) when the task estimate meets a threshold.",
+        "minComplexity": "Min complexity",
+        "minRisk": "Min risk",
+        "minImpact": "Min impact",
+        "onMissingLabel": "No estimate",
+        "onMissing": {
+          "run": "Propose anyway",
+          "skip": "Skip"
+        }
       }
     },
     "observabilityConnection": {
@@ -3291,7 +3319,11 @@
       "subtasksInProgress": "· {count} in progress",
       "clickToRead": "Click to read this agent's output",
       "reviewApprove": "Review & approve {agent}'s proposal",
-      "resolve": "Resolve: {question}"
+      "resolve": "Resolve: {question}",
+      "forkDecision": {
+        "proposing": "Proposing approaches…",
+        "choose": "Choose an approach"
+      }
     },
     "health": {
       "title": "Pipeline health",
@@ -4668,5 +4700,34 @@
       "hint": "Optionally provision this environment now to test the recipe.",
       "run": "Trial provision"
     }
+  },
+  "forkDecision": {
+    "title": "Choose an implementation approach",
+    "titleWithBlock": "Choose an approach for {title}",
+    "subtitle": "Materially different ways to implement this task, before any code is written.",
+    "seam": "Where it lands:",
+    "recommended": "Recommended",
+    "riskNotes": "Risk:",
+    "noteLabel": "Steering note (optional)",
+    "notePlaceholder": "Anything the implementer should keep in mind…",
+    "choose": "Use this approach",
+    "proposing": {
+      "title": "Surfacing approaches…",
+      "hint": "Reading the code to find the materially different ways to build this."
+    },
+    "singlePath": {
+      "title": "One clear approach"
+    },
+    "chosen": {
+      "title": "Approach chosen",
+      "note": "Note: {note}"
+    },
+    "custom": {
+      "title": "Enter your own approach",
+      "placeholder": "Describe how you want this implemented…"
+    },
+    "empty": {
+      "title": "Nothing to decide"
+    }
   }
 }