@cat-factory/app 0.111.2 → 0.112.0

package/app/components/forkDecision/ForkDecisionWindow.vue

@@ -0,0 +1,300 @@
+<script setup lang="ts">
+// Implementation-fork decision window — the dedicated surface for the read-only proposer's
+// materially different implementation approaches, opened via the universal result-view host
+// (`ui.openForkDecision`). It reads the live fork state straight off the run's Coder step
+// (`step.forkDecision`, kept fresh by the execution stream) and lets a human pick a proposed
+// fork OR enter their own free-text approach. Once chosen, the Coder re-runs with the chosen
+// approach folded in. Chat is added in a later slice.
+import { computed, ref, watch } from 'vue'
+import { useResultView } from '~/composables/useResultView'
+import { useExecutionStore } from '~/stores/execution'
+import { useBoardStore } from '~/stores/board'
+import { useForkDecisionStore } from '~/stores/forkDecision'
+import type { ForkDecisionStepState, ForkOption } from '~/types/execution'
+import { FORK_DECISION_META } from '~/utils/catalog'
+
+const execution = useExecutionStore()
+const board = useBoardStore()
+const forkDecision = useForkDecisionStore()
+
+const { t } = useI18n()
+
+// Hybrid: state rides the coder step (like follow-ups), but warm it from the GET on open too.
+const { open, blockId, instanceId, stepIndex, close } = useResultView('fork-decision', {
+  onOpen: (id) => void forkDecision.load(id),
+})
+
+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 state = computed<ForkDecisionStepState | null>(() => step.value?.forkDecision ?? null)
+const status = computed(() => state.value?.status ?? null)
+const forks = computed<ForkOption[]>(() => state.value?.forks ?? [])
+const awaiting = computed(() => status.value === 'awaiting_choice')
+
+// The human's selection: a proposed fork id, or the sentinel 'custom' for the free-text path.
+const selected = ref<string | null>(null)
+const customText = ref('')
+const note = ref('')
+
+// Default the selection to the recommended fork whenever the fork set changes.
+watch(
+  forks,
+  (list) => {
+    if (
+      selected.value &&
+      (selected.value === 'custom' || list.some((f) => f.id === selected.value))
+    )
+      return
+    selected.value = list.find((f) => f.recommended)?.id ?? list[0]?.id ?? null
+  },
+  { immediate: true },
+)
+
+const canChoose = computed(() => {
+  if (!awaiting.value || forkDecision.choosing) return false
+  if (selected.value === 'custom') return customText.value.trim().length > 0
+  return selected.value != null
+})
+
+async function onChoose() {
+  const id = instanceId.value
+  if (!id || !canChoose.value) return
+  const noteText = note.value.trim() || undefined
+  const choice =
+    selected.value === 'custom'
+      ? { custom: customText.value.trim(), note: noteText }
+      : { forkId: selected.value!, note: noteText }
+  await forkDecision.choose(id, choice).catch(() => {})
+}
+</script>
+
+<template>
+  <Teleport to="body">
+    <div
+      v-if="open"
+      data-testid="fork-decision-window"
+      class="fixed inset-0 z-50 flex max-h-[100dvh] items-stretch justify-center bg-slate-950/70 backdrop-blur-sm"
+      @click.self="close"
+    >
+      <div
+        class="m-4 flex w-full max-w-3xl flex-col overflow-hidden rounded-2xl border border-slate-800 bg-slate-900 shadow-2xl"
+        role="dialog"
+        aria-modal="true"
+      >
+        <!-- Header -->
+        <header class="flex items-center gap-3 border-b border-slate-800 px-5 py-3">
+          <span
+            class="flex h-8 w-8 items-center justify-center rounded-lg bg-violet-500/15 text-violet-300"
+          >
+            <UIcon :name="FORK_DECISION_META.icon" class="h-4 w-4" />
+          </span>
+          <div class="min-w-0 flex-1">
+            <h2 class="truncate text-sm font-semibold text-slate-100">
+              {{
+                block
+                  ? t('forkDecision.titleWithBlock', { title: block.title })
+                  : t('forkDecision.title')
+              }}
+            </h2>
+            <p class="truncate text-[11px] text-slate-400">{{ t('forkDecision.subtitle') }}</p>
+          </div>
+          <button
+            class="rounded-md p-1.5 text-slate-400 hover:bg-slate-800 hover:text-slate-200"
+            @click="close"
+          >
+            <UIcon name="i-lucide-x" class="h-4 w-4" />
+          </button>
+        </header>
+
+        <div class="min-h-0 flex-1 overflow-y-auto px-5 py-4">
+          <!-- Proposing: the read-only proposer is still working. -->
+          <div
+            v-if="status === 'proposing'"
+            class="flex h-full flex-col items-center justify-center gap-2 py-10 text-center text-slate-400"
+          >
+            <UIcon name="i-lucide-loader-circle" class="h-8 w-8 animate-spin opacity-60" />
+            <p class="text-sm">{{ t('forkDecision.proposing.title') }}</p>
+            <p class="max-w-sm text-[11px] text-slate-500">
+              {{ t('forkDecision.proposing.hint') }}
+            </p>
+          </div>
+
+          <!-- A single path (no materially different alternatives): a read-only record. -->
+          <div
+            v-else-if="status === 'single_path'"
+            class="rounded-xl border border-slate-800 bg-slate-900/60 px-4 py-3 text-slate-300"
+          >
+            <p class="text-[13px] font-medium text-slate-100">
+              {{ t('forkDecision.singlePath.title') }}
+            </p>
+            <p v-if="state?.singlePathReason" class="mt-1 text-[12px]">
+              {{ state.singlePathReason }}
+            </p>
+          </div>
+
+          <!-- Chosen: a read-only record of what was decided. -->
+          <div
+            v-else-if="status === 'chosen'"
+            class="rounded-xl border border-violet-500/40 bg-slate-900/60 px-4 py-3 text-slate-300"
+          >
+            <p class="text-[13px] font-medium text-violet-200">
+              {{ t('forkDecision.chosen.title') }}
+            </p>
+            <p v-if="state?.chosen?.custom" class="mt-1 whitespace-pre-wrap text-[12px]">
+              {{ state.chosen.custom }}
+            </p>
+            <p v-else-if="state?.chosen?.forkId" class="mt-1 text-[12px]">
+              {{ forks.find((f) => f.id === state?.chosen?.forkId)?.title }}
+            </p>
+            <p v-if="state?.chosen?.note" class="mt-1 text-[11px] text-slate-400">
+              {{ t('forkDecision.chosen.note', { note: state.chosen.note }) }}
+            </p>
+          </div>
+
+          <!-- Awaiting the human's choice. -->
+          <div v-else-if="awaiting" class="space-y-3">
+            <p
+              v-if="forkDecision.error"
+              class="rounded-md bg-rose-500/10 px-3 py-2 text-[12px] text-rose-300"
+            >
+              {{ forkDecision.error }}
+            </p>
+
+            <p
+              v-if="state?.seamSummary"
+              class="rounded-md bg-slate-800/50 px-3 py-2 text-[12px] text-slate-300"
+            >
+              <span class="text-slate-500">{{ t('forkDecision.seam') }}</span>
+              {{ state.seamSummary }}
+            </p>
+
+            <!-- Proposed fork cards -->
+            <article
+              v-for="fork in forks"
+              :key="fork.id"
+              data-testid="fork-option-card"
+              class="cursor-pointer rounded-xl border px-4 py-3 transition"
+              :class="
+                selected === fork.id
+                  ? 'border-violet-500/70 bg-violet-500/5'
+                  : 'border-slate-800 bg-slate-900/60 hover:border-slate-700'
+              "
+              @click="selected = fork.id"
+            >
+              <div class="flex items-start gap-2">
+                <input
+                  type="radio"
+                  class="mt-1 accent-violet-500"
+                  :checked="selected === fork.id"
+                  @change="selected = fork.id"
+                />
+                <div class="min-w-0 flex-1">
+                  <div class="flex items-center gap-2">
+                    <h3 class="min-w-0 flex-1 text-[13px] font-medium text-slate-100">
+                      {{ fork.title }}
+                    </h3>
+                    <UBadge v-if="fork.recommended" color="primary" variant="subtle" size="sm">
+                      {{ t('forkDecision.recommended') }}
+                    </UBadge>
+                  </div>
+                  <p v-if="fork.summary" class="mt-0.5 text-[12px] text-slate-400">
+                    {{ fork.summary }}
+                  </p>
+                  <p class="mt-1.5 whitespace-pre-wrap text-[12px] text-slate-300">
+                    {{ fork.approach }}
+                  </p>
+                  <ul v-if="fork.tradeoffs.length" class="mt-1.5 space-y-0.5">
+                    <li
+                      v-for="(tr, i) in fork.tradeoffs"
+                      :key="i"
+                      class="flex gap-1.5 text-[11px] text-slate-400"
+                    >
+                      <span class="text-slate-600">•</span>{{ tr }}
+                    </li>
+                  </ul>
+                  <p v-if="fork.riskNotes" class="mt-1.5 text-[11px] text-amber-300/90">
+                    <span class="text-amber-500/70">{{ t('forkDecision.riskNotes') }}</span>
+                    {{ fork.riskNotes }}
+                  </p>
+                </div>
+              </div>
+            </article>
+
+            <!-- Custom approach -->
+            <article
+              class="rounded-xl border px-4 py-3 transition"
+              :class="
+                selected === 'custom'
+                  ? 'border-violet-500/70 bg-violet-500/5'
+                  : 'border-slate-800 bg-slate-900/60'
+              "
+            >
+              <label class="flex cursor-pointer items-center gap-2" @click="selected = 'custom'">
+                <input type="radio" class="accent-violet-500" :checked="selected === 'custom'" />
+                <span class="text-[13px] font-medium text-slate-100">{{
+                  t('forkDecision.custom.title')
+                }}</span>
+              </label>
+              <textarea
+                v-model="customText"
+                data-testid="fork-custom-input"
+                rows="3"
+                :placeholder="t('forkDecision.custom.placeholder')"
+                class="mt-2 w-full resize-y rounded-md border border-slate-700 bg-slate-950/60 px-2.5 py-1.5 text-[12px] text-slate-100 placeholder:text-slate-600 focus:border-violet-500 focus:outline-none focus-visible:ring-2 focus-visible:ring-violet-500/60"
+                @focus="selected = 'custom'"
+              />
+            </article>
+
+            <!-- Optional steering note -->
+            <div>
+              <label class="mb-1 block text-[11px] text-slate-400">{{
+                t('forkDecision.noteLabel')
+              }}</label>
+              <input
+                v-model="note"
+                type="text"
+                :placeholder="t('forkDecision.notePlaceholder')"
+                class="w-full rounded-md border border-slate-700 bg-slate-950/60 px-2.5 py-1.5 text-[12px] text-slate-100 placeholder:text-slate-600 focus:border-violet-500 focus:outline-none"
+              />
+            </div>
+          </div>
+
+          <!-- Skipped / no state: nothing to decide. -->
+          <div
+            v-else
+            class="flex h-full flex-col items-center justify-center gap-2 py-10 text-center text-slate-400"
+          >
+            <UIcon :name="FORK_DECISION_META.icon" class="h-8 w-8 opacity-40" />
+            <p class="text-sm">{{ t('forkDecision.empty.title') }}</p>
+          </div>
+        </div>
+
+        <footer
+          v-if="awaiting"
+          class="flex items-center justify-end gap-2 border-t border-slate-800 px-5 py-3"
+        >
+          <UButton color="neutral" variant="ghost" size="sm" @click="close">
+            {{ t('common.cancel') }}
+          </UButton>
+          <UButton
+            data-testid="fork-option-choose"
+            color="primary"
+            size="sm"
+            icon="i-lucide-check"
+            :loading="forkDecision.choosing"
+            :disabled="!canChoose"
+            @click="onChoose"
+          >
+            {{ t('forkDecision.choose') }}
+          </UButton>
+        </footer>
+      </div>
+    </div>
+  </Teleport>
+</template>

package/app/components/layout/NotificationsInbox.vue

@@ -60,6 +60,10 @@ const META: Record<Notification['type'], { icon: string; color: Accent }> = {
   // Clicking the title opens the Follow-up companion window for the run (see `reveal`); "act"
   // just marks it read (items are decided in that window — file / send back / answer — not here).
   followup_pending: { icon: 'i-lucide-compass', color: 'warning' },
+  // The fork-decision phase surfaced materially different implementation approaches. Clicking
+  // 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' },
   // The initiative loop needs attention (a blocked task, or completion). Clicking the title
   // opens the initiative tracker window; "act" just marks it read.
   initiative: { icon: 'i-lucide-milestone', color: 'primary' },
@@ -81,6 +85,7 @@ const ACTION_KEYS: Record<Notification['type'], string> = {
   visual_confirmation_ready: 'layout.notifications.action.visual_confirmation_ready',
   human_review: 'layout.notifications.action.human_review',
   followup_pending: 'layout.notifications.action.followup_pending',
+  fork_decision_pending: 'layout.notifications.action.fork_decision_pending',
   initiative: 'layout.notifications.action.initiative',
 }
 
@@ -151,6 +156,7 @@ function reveal(n: Notification) {
   else if (n.type === 'visual_confirmation_ready') revealVisualConfirm(n)
   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 === 'initiative') ui.openInitiativeTracker(n.blockId)
   else ui.select(n.blockId)
 }
@@ -176,6 +182,15 @@ function revealFollowUps(n: Notification) {
   else if (n.blockId) ui.select(n.blockId)
 }
 
+/**
+ * Open the implementation-fork decision window for a run parked awaiting a fork choice.
+ * Falls back to focusing the block when the run isn't loaded.
+ */
+function revealForkDecision(n: Notification) {
+  if (n.executionId && execution.getInstance(n.executionId)) ui.openForkDecision(n.executionId)
+  else if (n.blockId) ui.select(n.blockId)
+}
+
 /**
  * Open the human-testing window for a parked `human-test` gate: find the run's parked
  * human-test step and open it through the universal step dispatch (its archetype declares

package/app/components/panels/StepResultViewHost.vue

@@ -22,6 +22,7 @@ import ConsensusSessionWindow from '~/components/consensus/ConsensusSessionWindo
 import GenericStructuredResultView from '~/components/panels/GenericStructuredResultView.vue'
 import ServiceSpecWindow from '~/components/spec/ServiceSpecWindow.vue'
 import FollowUpWindow from '~/components/followUp/FollowUpWindow.vue'
+import ForkDecisionWindow from '~/components/forkDecision/ForkDecisionWindow.vue'
 import MergerResultView from '~/components/panels/MergerResultView.vue'
 import InitiativeTrackerWindow from '~/components/initiative/InitiativeTrackerWindow.vue'
 import InitiativePlanningWindow from '~/components/initiative/InitiativePlanningWindow.vue'
@@ -52,6 +53,10 @@ const STEP_RESULT_VIEWS: Record<string, Component> = {
   // The future-looking Follow-up companion: the Coder's surfaced loose ends / questions.
   // Opened directly via `ui.openFollowUps` (the blinking chip + the `followup_pending` card).
   'follow-ups': FollowUpWindow,
+  // The implementation-fork decision: the proposer's materially different approaches + the
+  // human's pick / custom approach. Opened directly via `ui.openForkDecision` (the pipeline
+  // chip, the inspector button, and the `fork_decision_pending` card).
+  'fork-decision': ForkDecisionWindow,
   // The merger's verdict: the PR's complexity/risk/impact scores + the engine's auto-merge
   // or awaiting-review decision (and why), instead of the agent's raw JSON.
   merger: MergerResultView,

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

@@ -136,6 +136,11 @@ function openStep(i: number) {
   if (instance.value) ui.openStepDetail(instance.value.id, i)
 }
 
+// Open the implementation-fork decision window for a coder step parked awaiting a choice.
+function openForkFor(i: number) {
+  if (instance.value) ui.openForkDecision(instance.value.id, i)
+}
+
 // Stop the run WITHOUT deleting it: halts the container + driver and records a
 // `cancelled` failure, leaving the run readable + retryable (the block goes
 // `blocked`). The destructive reset (delete the run, return the task to `planned`)
@@ -335,6 +340,22 @@ async function mergePr() {
             >
               {{ t('inspector.execution.decide') }}
             </UButton>
+            <!-- A coder step parked on the implementation-fork decision: pick an approach
+                 (or enter a custom one) in the dedicated window, not a plain approval. -->
+            <UButton
+              v-else-if="
+                s.approval &&
+                s.approval.status === 'pending' &&
+                s.forkDecision?.status === 'awaiting_choice'
+              "
+              color="primary"
+              variant="soft"
+              size="xs"
+              icon="i-lucide-git-fork"
+              @click="openForkFor(i)"
+            >
+              {{ t('inspector.execution.chooseApproach') }}
+            </UButton>
             <UButton
               v-else-if="s.approval && s.approval.status === 'pending'"
               color="warning"

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),