@cat-factory/app 0.111.2 → 0.112.0

package/app/stores/execution.spec.ts

@@ -134,3 +134,55 @@ describe('execution store snapshot/event reconcile', () => {
     expect(store.getInstance('e1')?.status).toBe('done')
   })
 })
+
+/** A run whose steps carry an (optional) per-step metrics rollup. */
+function runWithMetrics(
+  id: string,
+  rev: number,
+  steps: Array<{ agentKind: string; metrics?: { calls: number } | null }>,
+): ExecutionInstance {
+  return { id, blockId: `blk_${id}`, steps, status: 'running', rev } as unknown as ExecutionInstance
+}
+
+describe('execution store metrics preservation (live-only rollup)', () => {
+  let store: ReturnType<typeof useExecutionStore>
+  beforeEach(() => {
+    store = useExecutionStore()
+  })
+
+  it('a metric-less running-fold event does not blank the last-known step metrics', () => {
+    // A step-boundary emit carried the rollup...
+    store.upsert(runWithMetrics('e1', 1, [{ agentKind: 'coder', metrics: { calls: 3 } }]))
+    // ...a later progress-only fold (higher rev) omits it — the backend skips the rollup there.
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'coder' }]))
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics?.calls).toBe(3)
+    expect(store.getInstance('e1')?.rev).toBe(2) // the fold still won (progress/subtasks applied)
+  })
+
+  it('a fresh rollup overrides the preserved value', () => {
+    store.upsert(runWithMetrics('e1', 1, [{ agentKind: 'coder', metrics: { calls: 3 } }]))
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'coder' }])) // fold: preserved
+    store.upsert(runWithMetrics('e1', 3, [{ agentKind: 'coder', metrics: { calls: 7 } }]))
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics?.calls).toBe(7)
+  })
+
+  it('does not carry metrics across a reshaped step (agentKind mismatch at the index)', () => {
+    store.upsert(runWithMetrics('e1', 1, [{ agentKind: 'coder', metrics: { calls: 3 } }]))
+    // A different kind at index 0 must not inherit the coder's rollup.
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'reviewer' }]))
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics).toBeUndefined()
+  })
+
+  it('preserves metrics through a lagging full refresh that omits them (hydrate)', () => {
+    // Establish the workspace first (a fresh-workspace hydrate replaces outright by design).
+    store.hydrate([runWithMetrics('e1', 1, [{ agentKind: 'coder' }])], 'ws1')
+    store.upsert(runWithMetrics('e1', 2, [{ agentKind: 'coder', metrics: { calls: 5 } }]))
+    // A snapshot never carries metrics (never persisted); a same-rev refresh must not blank it.
+    store.hydrate([runWithMetrics('e1', 2, [{ agentKind: 'coder' }])], 'ws1')
+    const step = store.getInstance('e1')!.steps[0] as unknown as { metrics?: { calls: number } }
+    expect(step.metrics?.calls).toBe(5)
+  })
+})

package/app/stores/execution.ts

@@ -40,6 +40,33 @@ export const useExecutionStore = defineStore('execution', () => {
     return status === 'done' || status === 'failed'
   }
 
+  /**
+   * Carry forward each step's LLM-metrics rollup (`step.metrics`) when an incoming
+   * instance omits it. Metrics is DERIVED, LIVE-ONLY state: the backend attaches it only
+   * on step-boundary/terminal emits (not on the frequent progress-only running folds — a
+   * perf optimisation that skips the per-run metrics GROUP BY on every poll tick) and
+   * never persists it, so it rides neither the snapshot nor a running-fold event. A plain
+   * REPLACE would blank the per-step metrics bar on every progress tick; per the live-push
+   * coherence rules a REPLACE must not drop live-only state, so preserve the last-known
+   * rollup per step. Steps are positionally stable within a run (same id ⇒ same shape), so
+   * match by index; the agentKind guard is belt-and-suspenders against a reshaped list.
+   */
+  function withPreservedMetrics(
+    incoming: ExecutionInstance,
+    cached: ExecutionInstance | undefined,
+  ): ExecutionInstance {
+    if (!cached) return incoming
+    let changed = false
+    const steps = incoming.steps.map((step, i) => {
+      if (step.metrics != null) return step
+      const prior = cached.steps[i]
+      if (prior?.metrics == null || prior.agentKind !== step.agentKind) return step
+      changed = true
+      return { ...step, metrics: prior.metrics }
+    })
+    return changed ? { ...incoming, steps } : incoming
+  }
+
   /**
    * Reconcile the cached executions with a server snapshot for `workspaceId`. A snapshot
    * is authoritative EXCEPT where a live `execution` event already advanced (or ADDED) a
@@ -81,7 +108,8 @@ export const useExecutionStore = defineStore('execution', () => {
     const held = new Map(instances.value.map((e) => [e.id, e]))
     const reconciled = next.map((incoming) => {
       const current = held.get(incoming.id)
-      return current && revOf(current) > revOf(incoming) ? current : incoming
+      if (current && revOf(current) > revOf(incoming)) return current
+      return withPreservedMetrics(incoming, current)
     })
     // Preserve a cached-only run UNLESS it is the terminal predecessor a retry replaced: a
     // finished (`done`/`failed`) run whose block the snapshot now covers under a fresh id.
@@ -101,7 +129,8 @@ export const useExecutionStore = defineStore('execution', () => {
   function upsert(instance: ExecutionInstance) {
     const i = instances.value.findIndex((e) => e.id === instance.id)
     if (i >= 0) {
-      if (revOf(instance) >= revOf(instances.value[i]!)) instances.value[i] = instance
+      if (revOf(instance) >= revOf(instances.value[i]!))
+        instances.value[i] = withPreservedMetrics(instance, instances.value[i]!)
     } else instances.value.push(instance)
   }
 

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/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",
@@ -1649,7 +1662,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 +2993,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 +4569,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",
@@ -1539,7 +1540,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 +2215,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 +3305,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 +4686,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"
+    }
   }
 }

package/i18n/locales/es.json

@@ -857,7 +857,8 @@
       "empty": {
         "title": "Aún no hay ejecuciones",
         "body": "Inicia un pipeline para ver el historial de ejecución aquí."
-      }
+      },
+      "chooseApproach": "Elegir enfoque"
     },
     "structure": {
       "title": "Estructura",
@@ -1476,7 +1477,8 @@
         "human_review": "Marcar como leída",
         "followup_pending": "Marcar como leída",
         "initiative": "Marcar como leída",
-        "markRead": "Marcar como leída"
+        "markRead": "Marcar como leída",
+        "fork_decision_pending": "Marcar como leído"
       },
       "toast": {
         "acted": "Marcado como resuelto",
@@ -2031,6 +2033,18 @@
       "confirmDelete": {
         "title": "¿Eliminar esta política de riesgo?",
         "body": "Se eliminará \"{name}\". Las tareas que lo usan volverán al valor predeterminado del espacio de trabajo."
+      },
+      "forkDecision": {
+        "label": "Decisión de bifurcación de implementación",
+        "hint": "En modo automático, propone enfoques sustancialmente distintos (y se detiene para elegir) cuando la estimación de la tarea alcanza un umbral.",
+        "minComplexity": "Complejidad mín.",
+        "minRisk": "Riesgo mín.",
+        "minImpact": "Impacto mín.",
+        "onMissingLabel": "Sin estimación",
+        "onMissing": {
+          "run": "Proponer igualmente",
+          "skip": "Omitir"
+        }
       }
     },
     "observabilityConnection": {
@@ -3204,7 +3218,11 @@
       "subtasksInProgress": "· {count} en progreso",
       "clickToRead": "Haz clic para leer la salida de este agente",
       "reviewApprove": "Revisar y aprobar la propuesta de {agent}",
-      "resolve": "Resolver: {question}"
+      "resolve": "Resolver: {question}",
+      "forkDecision": {
+        "proposing": "Proponiendo enfoques…",
+        "choose": "Elegir un enfoque"
+      }
     },
     "health": {
       "title": "Estado de los pipelines",
@@ -4539,5 +4557,34 @@
       "hint": "Opcionalmente, aprovisiona este entorno ahora para probar la receta.",
       "run": "Aprovisionamiento de prueba"
     }
+  },
+  "forkDecision": {
+    "title": "Elige un enfoque de implementación",
+    "titleWithBlock": "Elige un enfoque para {title}",
+    "subtitle": "Formas sustancialmente distintas de implementar esta tarea, antes de escribir código.",
+    "seam": "Dónde impacta:",
+    "recommended": "Recomendado",
+    "riskNotes": "Riesgo:",
+    "noteLabel": "Nota de orientación (opcional)",
+    "notePlaceholder": "Algo que la implementación deba tener en cuenta…",
+    "choose": "Usar este enfoque",
+    "proposing": {
+      "title": "Buscando enfoques…",
+      "hint": "Leyendo el código para encontrar las formas sustancialmente distintas de construir esto."
+    },
+    "singlePath": {
+      "title": "Un único enfoque claro"
+    },
+    "chosen": {
+      "title": "Enfoque elegido",
+      "note": "Nota: {note}"
+    },
+    "custom": {
+      "title": "Introduce tu propio enfoque",
+      "placeholder": "Describe cómo quieres que se implemente…"
+    },
+    "empty": {
+      "title": "Nada que decidir"
+    }
   }
 }

package/i18n/locales/fr.json

@@ -857,7 +857,8 @@
       "empty": {
         "title": "Aucune exécution pour l'instant",
         "body": "Lancez un pipeline pour voir l'historique d'exécution ici."
-      }
+      },
+      "chooseApproach": "Choisir l'approche"
     },
     "structure": {
       "title": "Structure",
@@ -1476,7 +1477,8 @@
         "human_review": "Marquer comme lu",
         "followup_pending": "Marquer comme lu",
         "initiative": "Marquer comme lu",
-        "markRead": "Marquer comme lu"
+        "markRead": "Marquer comme lu",
+        "fork_decision_pending": "Marquer comme lu"
       },
       "toast": {
         "acted": "Marqué comme traité",
@@ -2031,6 +2033,18 @@
       "confirmDelete": {
         "title": "Supprimer cette politique de risque ?",
         "body": "\"{name}\" sera supprimé. Les tâches qui l'utilisent reviendront à la politique par défaut de l'espace de travail."
+      },
+      "forkDecision": {
+        "label": "Décision de bifurcation d'implémentation",
+        "hint": "En mode auto, proposer des approches foncièrement différentes (et faire une pause pour choisir) quand l'estimation de la tâche atteint un seuil.",
+        "minComplexity": "Complexité min.",
+        "minRisk": "Risque min.",
+        "minImpact": "Impact min.",
+        "onMissingLabel": "Aucune estimation",
+        "onMissing": {
+          "run": "Proposer quand même",
+          "skip": "Ignorer"
+        }
       }
     },
     "observabilityConnection": {
@@ -3204,7 +3218,11 @@
       "subtasksInProgress": "· {count} en cours",
       "clickToRead": "Cliquez pour lire la sortie de cet agent",
       "reviewApprove": "Revoir et approuver la proposition de {agent}",
-      "resolve": "Résoudre : {question}"
+      "resolve": "Résoudre : {question}",
+      "forkDecision": {
+        "proposing": "Proposition d'approches…",
+        "choose": "Choisir une approche"
+      }
     },
     "health": {
       "title": "État des pipelines",
@@ -4539,5 +4557,34 @@
       "hint": "Provisionnez éventuellement cet environnement maintenant pour tester la recette.",
       "run": "Provisionnement d'essai"
     }
+  },
+  "forkDecision": {
+    "title": "Choisir une approche d'implémentation",
+    "titleWithBlock": "Choisir une approche pour {title}",
+    "subtitle": "Des façons foncièrement différentes de réaliser cette tâche, avant d'écrire du code.",
+    "seam": "Où cela intervient :",
+    "recommended": "Recommandé",
+    "riskNotes": "Risque :",
+    "noteLabel": "Note d'orientation (facultatif)",
+    "notePlaceholder": "Ce que l'implémentation doit garder à l'esprit…",
+    "choose": "Utiliser cette approche",
+    "proposing": {
+      "title": "Recherche des approches…",
+      "hint": "Lecture du code pour trouver les façons foncièrement différentes de le construire."
+    },
+    "singlePath": {
+      "title": "Une approche évidente"
+    },
+    "chosen": {
+      "title": "Approche choisie",
+      "note": "Note : {note}"
+    },
+    "custom": {
+      "title": "Saisir votre propre approche",
+      "placeholder": "Décrivez comment vous voulez que ce soit implémenté…"
+    },
+    "empty": {
+      "title": "Rien à décider"
+    }
   }
 }