@cat-factory/app 0.280.1 → 0.281.0

package/app/composables/useInterviewDrafts.ts

@@ -0,0 +1,184 @@
+import { computed, reactive, watch } from 'vue'
+
+/**
+ * Per-question answer drafts for an INTERVIEW gate window (the initiative planner's interviewer and
+ * the doc-authoring interviewer), plus the two ways they leave the browser: one answer on blur, and
+ * every dirty answer on the way out.
+ *
+ * Both windows hold the same shape of draft for the same reason, and recording one is a PLAIN SAVE:
+ * it writes the reply without resolving the interview, which is what the window's own two commands
+ * do. That is what makes the FLUSH disposition correct here rather than a discard prompt (see
+ * `ResultWindowDrafts.logic.spec.ts` for the rule and the per-window table).
+ *
+ * It is ONE seam because the two windows held byte-identical copies of this logic and only ever got
+ * fixed one at a time: the doc interview grew a close-time flush while the planner kept dropping
+ * answers on close, and neither reported a failed write. Three properties are easy to lose when this
+ * is hand-rolled per window, and each one was:
+ *
+ *  - The flush CAPTURES what it needs synchronously. `blockId` and everything derived from it go
+ *    null the instant the view tears down, so an awaited loop that re-reads them writes nowhere.
+ *  - Each answer settles INDEPENDENTLY. A loop that awaited straight through dropped every answer
+ *    after the first rejection, with the window already gone.
+ *  - Every path REPORTS its own failure. Both backing stores rethrow and Vue discards a handler's
+ *    returned promise, so an unreported write is an unhandled rejection and, to the user, a no-op.
+ */
+
+/** The minimum an exchange has to carry for a draft answer to be held against it. */
+export interface InterviewDraftQuestion {
+  /**
+   * The id the answer write addresses. Optional because the wire shape leaves it optional (a
+   * hand-authored or fixture exchange parses without one); see {@link useInterviewDrafts}'s
+   * `addressable`.
+   */
+  id?: string
+  /** Stable key for the list and the draft map: the question id, or its index as a fallback. */
+  key: string
+  /** What is already recorded. Seeds the draft, and decides whether the draft is dirty. */
+  answer?: string
+}
+
+export function useInterviewDrafts<Q extends InterviewDraftQuestion>(opts: {
+  /** The block the answers are written against, or null while no view is open. */
+  blockId: () => string | null
+  /** Every exchange the session holds, settled rounds included. */
+  questions: () => Q[]
+  /** The subset still owing an answer, which is what the submit button waits on. */
+  pending: () => Q[]
+  /** Record ONE answer against the block. */
+  write: (blockId: string, questionId: string, answer: string) => Promise<unknown>
+  /**
+   * Whether this question's draft may be written at all. A question set aside as not-relevant had
+   * its recorded answer cleared, so writing a stale local draft back would silently re-answer it.
+   */
+  writable?: (question: Q) => boolean
+  /** Toast titles for a failed write: one answer lost, and several (which takes a `{ count }`). */
+  failureTitleKeys: { one: string; many: string }
+}) {
+  const { present } = usePipelineErrorToast()
+
+  const drafts = reactive<Record<string, string>>({})
+  // Seeded from the entity and refreshed as new rounds arrive, without clobbering an answer the
+  // human is mid-edit on.
+  watch(
+    opts.questions,
+    (list) => {
+      for (const question of list) {
+        if (!(question.key in drafts)) drafts[question.key] = question.answer ?? ''
+      }
+    },
+    { immediate: true },
+  )
+
+  /**
+   * Whether an answer to this exchange can be RECORDED at all: the write addresses a question BY
+   * ID, so one without an id has nowhere for an answer to go.
+   *
+   * Callers disable that question's input and say why. Accepting text into it instead would take an
+   * answer the flush could only drop, which is the silent loss this seam exists to end.
+   */
+  function addressable(question: Q): boolean {
+    return typeof question.id === 'string' && question.id.length > 0
+  }
+
+  /**
+   * Questions still missing a drafted answer, which is what a submit button gates on (and renders,
+   * because a disabled button with no stated reason is itself a "nothing happened").
+   *
+   * Unaddressable questions are excluded: nothing the human can type clears one, so counting it
+   * would disable the submit for good.
+   */
+  const unanswered = computed(
+    () => opts.pending().filter((q) => addressable(q) && !drafts[q.key]?.trim()).length,
+  )
+
+  /**
+   * Persist one answer when its draft differs from what is recorded. The block id is threaded in
+   * rather than read off `opts.blockId()`, so a flush that started as the window closed still writes
+   * to the right board.
+   */
+  async function persist(blockId: string, question: Q): Promise<void> {
+    const id = question.id
+    if (!id || opts.writable?.(question) === false) return
+    const next = (drafts[question.key] ?? '').trim()
+    if (!next || next === (question.answer ?? '').trim()) return
+    await opts.write(blockId, id, next)
+  }
+
+  /** Report a failed write, naming how many answers did not make it. */
+  function report(failed: number, cause: unknown): void {
+    present(cause, failed === 1 ? opts.failureTitleKeys.one : opts.failureTitleKeys.many, {
+      count: failed,
+    })
+  }
+
+  /**
+   * Persist every dirty draft, each on its OWN: one rejection may not cost the answers after it.
+   * Returns how many could not be written plus the first cause, which is what the caller reports.
+   *
+   * Sequential rather than concurrent because each write is a read-modify-write of the session's one
+   * question-and-answer array, so two in flight would race to overwrite each other's answer.
+   */
+  async function flushAll(blockId: string, list: Q[]): Promise<{ failed: number; cause: unknown }> {
+    let failed = 0
+    let cause: unknown
+    for (const question of list) {
+      try {
+        await persist(blockId, question)
+      } catch (error) {
+        failed += 1
+        if (failed === 1) cause = error
+      }
+    }
+    return { failed, cause }
+  }
+
+  /**
+   * Save this ONE answer against the block that is open right now: the blur handler, and the same
+   * call an adopted recommendation makes. Detached, because Vue discards a handler's returned
+   * promise, so the failure is reported here or nowhere.
+   */
+  function saveAnswer(question: Q): void {
+    const blockId = opts.blockId()
+    if (!blockId) return
+    void persist(blockId, question).catch((error) => report(1, error))
+  }
+
+  /**
+   * Persist every dirty draft on the way out, detached so it can be called from the synchronous
+   * close hook. A close-time flush is the one path with no button left on screen to have reported a
+   * failure, so it reports the loss itself.
+   */
+  function flushDrafts(): void {
+    const blockId = opts.blockId()
+    if (!blockId) return
+    const list = [...opts.questions()]
+    void (async () => {
+      const { failed, cause } = await flushAll(blockId, list)
+      if (failed > 0) report(failed, cause)
+    })()
+  }
+
+  /**
+   * Flush every dirty draft, then run a window action, but ONLY if every draft was written: an
+   * answer that failed to save may not be submitted as if it were there. On a failure the report is
+   * the whole outcome, and the window is left as it is, with the same button on screen and the text
+   * still in its box.
+   */
+  async function flushThen(
+    action: (blockId: string) => Promise<unknown>,
+    failureTitleKey: string,
+  ): Promise<void> {
+    const blockId = opts.blockId()
+    if (!blockId) return
+    const { failed, cause } = await flushAll(blockId, [...opts.questions()])
+    if (failed > 0) {
+      report(failed, cause)
+      return
+    }
+    // The action rejects too (both backing stores rethrow) and it is reached from a click handler
+    // whose promise Vue discards, so its failure is reported here or nowhere.
+    await action(blockId).catch((error) => present(error, failureTitleKey))
+  }
+
+  return { drafts, addressable, unanswered, saveAnswer, flushDrafts, flushThen }
+}

package/app/composables/usePipelineErrorToast.ts

@@ -102,6 +102,14 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
     titleKey: 'errors.conflict.title.risk_policy_not_inherited',
     descriptionKey: 'errors.conflict.description.risk_policy_not_inherited',
   },
+  // Raised only by the public `/api/v1/kaizen/entries/:id/acknowledge` route today, so no SPA
+  // action reaches it. Mapped all the same, because the map is exhaustive over the wire
+  // vocabulary rather than over the subset this app happens to trigger: the day a Kaizen screen
+  // grows an acknowledge button, the copy is already here rather than an untranslated fallback.
+  kaizen_entry_not_settled: {
+    titleKey: 'errors.conflict.title.kaizen_entry_not_settled',
+    descriptionKey: 'errors.conflict.description.kaizen_entry_not_settled',
+  },
   task_limit_reached: {
     titleKey: 'errors.conflict.title.task_limit_reached',
     descriptionKey: 'errors.conflict.description.task_limit_reached',

package/app/stores/binaryCandidates.ts

@@ -21,6 +21,12 @@ export const useBinaryCandidatesStore = defineStore('binaryCandidates', () => {
 
   /** True while a keep call is in flight (drives the button spinner / disabled state). */
   const keeping = ref(false)
+  /**
+   * True while the warm-up read is in flight. The window renders no state until it settles, and
+   * "still fetching" must not render as the "nothing to choose between" empty state: on this
+   * surface that empty state is a claim the run generated nothing to compare.
+   */
+  const loading = ref(false)
   /** The last error message from an action, surfaced inline; cleared on the next action. */
   const error = ref<string | null>(null)
 
@@ -48,9 +54,24 @@ export const useBinaryCandidatesStore = defineStore('binaryCandidates', () => {
     if (step) step.binaryCandidates = state
   }
 
-  /** Warm the live state from the GET (the stream also keeps it fresh). Best-effort. */
+  /**
+   * The most recent {@link load} attempt. Only the latest one may write `loading` or `error`: two
+   * reads do overlap (a Retry beside a window switching run, an open triggered while one is in
+   * flight), and a superseded attempt settling afterwards used to clear the spinner and stamp its
+   * own verdict over the newer read's. A slow failure landing after a fast success is the bad case,
+   * because it reports a load failure across candidates that are on screen.
+   */
+  let attempt = 0
+
+  /**
+   * Warm the live state from the GET (the stream also keeps it fresh). The failure is RECORDED
+   * rather than swallowed: with no state on the step, a failed read and a run that produced no
+   * candidates are the same `null` and opposite facts, and only one of them is worth a Retry.
+   */
   async function load(executionId: string): Promise<void> {
+    const mine = ++attempt
     error.value = null
+    loading.value = true
     try {
       await execution.echoAfter(
         executionId,
@@ -60,7 +81,9 @@ export const useBinaryCandidatesStore = defineStore('binaryCandidates', () => {
         },
       )
     } catch (e) {
-      error.value = e instanceof Error ? e.message : 'Failed to load'
+      if (mine === attempt) error.value = e instanceof Error ? e.message : 'Failed to load'
+    } finally {
+      if (mine === attempt) loading.value = false
     }
   }
 
@@ -85,5 +108,5 @@ export const useBinaryCandidatesStore = defineStore('binaryCandidates', () => {
     }
   }
 
-  return { keeping, error, load, keep }
+  return { keeping, loading, error, load, keep }
 })

package/app/stores/kaizen.spec.ts

@@ -20,6 +20,9 @@ function grading(over: Partial<KaizenGrading> = {}): KaizenGrading {
     recommendations: [],
     graderModel: null,
     error: null,
+    acknowledgedAt: null,
+    acknowledgedBy: null,
+    acknowledgementNote: null,
     createdAt: 1,
     updatedAt: 1,
     ...over,

package/app/stores/ui/modals.ts

@@ -74,6 +74,17 @@ export interface ReviewFrictionModalContext {
   debt: ReviewDebtRow[]
   /** Retry the create with `acknowledgeReviewDebt` — present only for the soft `warn` tier. */
   onConfirm: (() => void) | null
+  /**
+   * Whether the opener's create is in flight right now, so "Create anyway" can show its spinner and
+   * refuse a second click (UX-78). A GETTER over the opener's own `saving` ref rather than a copied
+   * boolean: the dialog's context object is captured once at open, so a snapshot would be frozen at
+   * `false` for the whole retry. Reading it inside a `computed` keeps the reactivity.
+   *
+   * Load-bearing, not cosmetic: the retry's first await resolves the staged context attachments
+   * (a network round-trip per item), so a second click during that window filed a SECOND task and
+   * started a second pipeline run against the same request.
+   */
+  pending?: () => boolean
 }
 
 /** Clears both hub came-from markers; injected into the slices whose `open*` handlers reset them. */

package/app/utils/binaryCandidates.spec.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from 'vitest'
 import type { PipelineStep } from '~/types/execution'
-import { binaryCandidateHasWarnings, binaryCandidateView } from './binaryCandidates'
+import {
+  binaryCandidateAbsence,
+  binaryCandidateHasWarnings,
+  binaryCandidateView,
+} from './binaryCandidates'
 
 function step(overrides: Record<string, unknown> = {}): PipelineStep {
   // The candidate override MERGES into the base state rather than replacing it, so a case that
@@ -108,3 +112,43 @@ describe('binaryCandidateHasWarnings', () => {
     }
   })
 })
+
+describe('binaryCandidateAbsence', () => {
+  const RUN = 'exec_1'
+
+  // The window used to render a titled shell with a blank body for all four of these (UX-80).
+  // They are different facts, and only one of them is a claim about the RUN.
+  it('separates no run, a read in flight, a failed read, and a run that compared nothing', () => {
+    expect(binaryCandidateAbsence(false, null, null)).toBe('no_run')
+    expect(binaryCandidateAbsence(true, null, RUN)).toBe('loading')
+    expect(binaryCandidateAbsence(false, 'network down', RUN)).toBe('load_failed')
+    expect(binaryCandidateAbsence(false, null, RUN)).toBe('nothing_compared')
+  })
+
+  // A Retry re-enters `loading` while the PREVIOUS attempt's message is still recorded. Reporting
+  // the stale failure over the live attempt would make the button look like it did nothing.
+  it('lets a fresh attempt outrank the error it is clearing', () => {
+    expect(binaryCandidateAbsence(true, 'network down', RUN)).toBe('loading')
+  })
+
+  // 'nothing_compared' renders "nothing to compare", which is a statement about what the run
+  // produced. A request that never landed knows nothing about that, so it must never reach here.
+  it('never claims emptiness on the strength of a request that failed', () => {
+    for (const error of ['boom', 'Failed to load']) {
+      expect(binaryCandidateAbsence(false, error, RUN)).not.toBe('nothing_compared')
+    }
+  })
+
+  // With no run the warm-up read is never started, so the store's flags belong to some OTHER
+  // window's read. Reporting them here would describe a run nobody asked about, and falling through
+  // to emptiness would claim this run compared nothing without ever having looked.
+  it('never reports a state it did not read, nor emptiness, when there is no run', () => {
+    for (const loading of [true, false]) {
+      for (const error of [null, 'network down']) {
+        for (const run of [null, undefined, '']) {
+          expect(binaryCandidateAbsence(loading, error, run)).toBe('no_run')
+        }
+      }
+    }
+  })
+})

package/app/utils/binaryCandidates.ts

@@ -127,6 +127,39 @@ export function binaryCandidateHasWarnings(view: BinaryCandidateView): boolean {
   return invalidEntries > 0 || omitted > 0 || unusablePreviews > 0
 }
 
+/**
+ * Why the window has no comparison to render. Four different facts that a single blank body
+ * conflated (UX-80), each needing a different reaction from the reader: nothing to read from, wait,
+ * retry, or accept that the run compared nothing. `nothing_compared` is a CLAIM about the run, so
+ * it is only ever the answer once a read of that run has settled and not failed.
+ */
+export type BinaryCandidateAbsence = 'no_run' | 'loading' | 'load_failed' | 'nothing_compared'
+
+/**
+ * The absence to render when {@link binaryCandidateView} produced nothing.
+ *
+ * Precedence is the point, and it is stated here rather than in the template's branch order:
+ *
+ *  - No RUN outranks everything. The window is keyed to an execution and the warm-up read is
+ *    skipped without one, so `loading`/`error` can only be describing some other window's read;
+ *    reporting either would attribute a state to a run nobody asked about, and reporting emptiness
+ *    would claim this run compared nothing on the strength of never having looked.
+ *  - An in-flight read outranks a stale error from the previous attempt, so a Retry does not keep
+ *    showing the failure it is busy clearing.
+ *  - A recorded error outranks emptiness, so a request that never landed cannot render as "this run
+ *    generated nothing to compare".
+ */
+export function binaryCandidateAbsence(
+  loading: boolean,
+  error: string | null | undefined,
+  executionId: string | null | undefined,
+): BinaryCandidateAbsence {
+  if (!executionId) return 'no_run'
+  if (loading) return 'loading'
+  if (error) return 'load_failed'
+  return 'nothing_compared'
+}
+
 /**
  * State → the i18n key for the line explaining why no choice was offered.
  *

package/i18n/locales/de.json

@@ -5689,6 +5689,11 @@
       "preparingHint": "Die Planung liest zuerst das Repository, damit Sie nicht nach dem gefragt werden, was der Code beantworten kann. Fragen erscheinen hier, sobald das erledigt ist.",
       "failed": "Der Planungslauf wurde abgebrochen",
       "failedHint": "Er endete, bevor der Planer antworten konnte. Ihre Antworten sind gespeichert; führen Sie die Planung von der Initiative aus erneut aus.",
+      "saveFailed": "Antwort konnte nicht gespeichert werden",
+      "saveFailedCount": "{count} Ihrer Antworten konnten nicht gespeichert werden",
+      "continueFailed": "Antworten konnten nicht gesendet werden",
+      "proceedFailed": "Die Planung konnte nicht gestartet werden",
+      "unanswerable": "Diese Frage hat keine ID, daher kann keine Antwort dazu gespeichert werden.",
       "answerPlaceholder": "Ihre Antwort",
       "hint": "Antworten senden lässt den Planer Rückfragen stellen; Jetzt planen entwirft den Plan mit den bisherigen Antworten.",
       "unanswered": "Unbeantwortete Fragen: {count}",
@@ -5966,7 +5971,8 @@
         "submission_not_allowed": "Zusammenführen für diesen Lauf nicht erlaubt",
         "webhook_limit_reached": "Webhook-Limit erreicht",
         "risk_policy_inherited": "Diese Richtlinie gehört zum Konto",
-        "risk_policy_not_inherited": "Diese Richtlinie gehört zu diesem Board"
+        "risk_policy_not_inherited": "Diese Richtlinie gehört zu diesem Board",
+        "kaizen_entry_not_settled": "Der Kaizen-Eintrag wurde noch nicht bewertet"
       },
       "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.",
@@ -6007,7 +6013,8 @@
         "submission_not_allowed": "Die Merge-Richtlinie dieser Aufgabe erlaubt der Rolle, die diesen Lauf gestartet hat, diese Änderungsart nicht zusammenzuführen. Jemand mit einer passenden Rolle kann es tun, oder ein Admin erweitert die Richtlinie in der Merge-Vorlage.",
         "webhook_limit_reached": "Für diesen Workspace ist bereits die maximale Anzahl ausgehender Webhooks registriert. Entfernen Sie einen nicht mehr benötigten und registrieren Sie diesen erneut.",
         "risk_policy_inherited": "Sie gilt für alle Boards des Kontos und kann daher nicht von hier geändert werden. Klone sie in dieses Board und bearbeite die Kopie.",
-        "risk_policy_not_inherited": "Sie ist bereits die eigene Richtlinie dieses Boards: bearbeite sie direkt oder lösche sie, wenn sie nicht mehr angeboten werden soll."
+        "risk_policy_not_inherited": "Sie ist bereits die eigene Richtlinie dieses Boards: bearbeite sie direkt oder lösche sie, wenn sie nicht mehr angeboten werden soll.",
+        "kaizen_entry_not_settled": "Die Bewertung steht noch aus oder läuft gerade, es gibt also keine Empfehlungen zum Bestätigen. Versuchen Sie es erneut, sobald sie abgeschlossen ist."
       },
       "action": {
         "connectGitHub": "GitHub verbinden",
@@ -6194,7 +6201,12 @@
     "status": {
       "awaiting": "Warten auf Antworten",
       "done": "Fertig"
-    }
+    },
+    "saveFailedCount": "{count} Ihrer Antworten konnten nicht gespeichert werden",
+    "continueFailed": "Antworten konnten nicht gesendet werden",
+    "proceedFailed": "Der Entwurf konnte nicht gestartet werden",
+    "unanswerable": "Diese Frage hat keine ID, daher kann keine Antwort dazu gespeichert werden.",
+    "saveFailed": "Antwort konnte nicht gespeichert werden"
   },
   "gates": {
     "subtitle": {
@@ -8035,6 +8047,14 @@
       "undeclared": "Der Schritt hat seine Kandidaten nie deklariert, es gab also nichts zu vergleichen. Der Lauf ging weiter.",
       "parseFailed": "Die Kandidaten-Deklaration des Schritts war nicht lesbar, es gab also nichts zu vergleichen. Der Lauf ging weiter.",
       "noCandidates": "Der Schritt hat keine Kandidaten bereitgestellt, es gab also nichts zu vergleichen. Der Lauf ging weiter."
-    }
+    },
+    "noRun": {
+      "title": "Kein Lauf zum Auslesen",
+      "hint": "Dieser Vergleich ist an einen Pipeline-Lauf gebunden. Öffnen Sie ihn über die Karte oder die Zeitleiste des erzeugenden Schritts, damit die Kandidaten geladen werden können."
+    },
+    "empty": {
+      "title": "Nichts zu vergleichen"
+    },
+    "loadFailed": "Die erzeugten Kandidaten konnten nicht geladen werden."
   }
 }

package/i18n/locales/en.json

@@ -757,7 +757,8 @@
         "submission_not_allowed": "Merge not allowed for this run",
         "webhook_limit_reached": "Webhook limit reached",
         "risk_policy_inherited": "This policy belongs to the account",
-        "risk_policy_not_inherited": "This policy belongs to this board"
+        "risk_policy_not_inherited": "This policy belongs to this board",
+        "kaizen_entry_not_settled": "The Kaizen entry has not been graded yet"
       },
       "description": {
         "dependencies_unmet": "This task depends on others that aren't finished yet. Complete or unblock them, then start it again.",
@@ -801,7 +802,8 @@
         "submission_not_allowed": "This task's merge policy doesn't let the role that started this run merge this kind of change. Somebody whose role may merge it can do so, or an admin can widen the policy in the merge preset.",
         "webhook_limit_reached": "This workspace already has the maximum number of outbound webhooks registered. Remove one you no longer need, then register this again.",
         "risk_policy_inherited": "It is shared with every board in the account, so it cannot be changed from here. Clone it to this board and edit the copy.",
-        "risk_policy_not_inherited": "It is already this board's own policy: edit it directly, or delete it if you no longer want it offered."
+        "risk_policy_not_inherited": "It is already this board's own policy: edit it directly, or delete it if you no longer want it offered.",
+        "kaizen_entry_not_settled": "Its grading is still queued or running, so there are no recommendations to acknowledge. Try again once it finishes."
       },
       "action": {
         "connectGitHub": "Connect GitHub",
@@ -4768,7 +4770,12 @@
     "status": {
       "awaiting": "Awaiting answers",
       "done": "Done"
-    }
+    },
+    "saveFailedCount": "Could not save {count} of your answers",
+    "continueFailed": "Could not submit your answers",
+    "proceedFailed": "Could not start the draft",
+    "unanswerable": "This question carries no id, so an answer cannot be recorded against it.",
+    "saveFailed": "Could not save your answer"
   },
   "documents": {
     "picker": {
@@ -7345,6 +7352,11 @@
       "preparingHint": "Planning reads the repository first, so you are not asked what the code can answer. Questions appear here once that is done.",
       "failed": "The planning run stopped",
       "failedHint": "It ended before the planner could answer. Your answers are saved; re-run planning from the initiative to try again.",
+      "saveFailed": "Could not save your answer",
+      "saveFailedCount": "Could not save {count} of your answers",
+      "continueFailed": "Could not submit your answers",
+      "proceedFailed": "Could not start planning",
+      "unanswerable": "This question carries no id, so an answer cannot be recorded against it.",
       "answerPlaceholder": "Your answer",
       "hint": "Submit answers lets the planner ask follow-ups; Plan now drafts the plan with the answers so far.",
       "unanswered": "Unanswered questions: {count}",
@@ -8324,6 +8336,14 @@
       "undeclared": "The step never declared its candidates, so there was nothing to compare. The run continued.",
       "parseFailed": "The step’s candidate declaration could not be read, so there was nothing to compare. The run continued.",
       "noCandidates": "The step staged no candidates, so there was nothing to compare. The run continued."
-    }
+    },
+    "noRun": {
+      "title": "No run to read",
+      "hint": "This comparison is keyed to a pipeline run. Open it from the generating step's card or timeline so its candidates can be loaded."
+    },
+    "empty": {
+      "title": "Nothing to compare"
+    },
+    "loadFailed": "Could not load the generated candidates."
   }
 }

package/i18n/locales/es.json

@@ -682,7 +682,8 @@
         "submission_not_allowed": "Fusión no permitida para esta ejecución",
         "webhook_limit_reached": "Límite de webhooks alcanzado",
         "risk_policy_inherited": "Esta política pertenece a la cuenta",
-        "risk_policy_not_inherited": "Esta política pertenece a este tablero"
+        "risk_policy_not_inherited": "Esta política pertenece a este tablero",
+        "kaizen_entry_not_settled": "La entrada de Kaizen aún no se ha evaluado"
       },
       "description": {
         "dependencies_unmet": "Esta tarea depende de otras que aún no están terminadas. Complétalas o desbloquéalas y vuelve a iniciarla.",
@@ -723,7 +724,8 @@
         "submission_not_allowed": "La política de fusión de esta tarea no permite que el rol que inició la ejecución fusione este tipo de cambio. Alguien cuyo rol sí lo permita puede hacerlo, o un administrador puede ampliar la política en el preajuste de fusión.",
         "webhook_limit_reached": "Este espacio de trabajo ya tiene registrado el número máximo de webhooks salientes. Elimina uno que ya no necesites y vuelve a registrar este.",
         "risk_policy_inherited": "Se comparte con todos los tableros de la cuenta, así que no puede cambiarse desde aquí. Clónala en este tablero y edita la copia.",
-        "risk_policy_not_inherited": "Ya es la política propia de este tablero: edítala directamente o elimínala si no quieres que se ofrezca."
+        "risk_policy_not_inherited": "Ya es la política propia de este tablero: edítala directamente o elimínala si no quieres que se ofrezca.",
+        "kaizen_entry_not_settled": "Su evaluación sigue en cola o en curso, así que no hay recomendaciones que confirmar. Inténtalo de nuevo cuando termine."
       },
       "action": {
         "connectGitHub": "Conectar GitHub",
@@ -4607,7 +4609,12 @@
     "status": {
       "awaiting": "Esperando respuestas",
       "done": "Hecho"
-    }
+    },
+    "saveFailedCount": "No se pudieron guardar {count} de tus respuestas",
+    "continueFailed": "No se pudieron enviar tus respuestas",
+    "proceedFailed": "No se pudo iniciar el borrador",
+    "unanswerable": "Esta pregunta no tiene id, así que no se puede registrar ninguna respuesta para ella.",
+    "saveFailed": "No se pudo guardar tu respuesta"
   },
   "documents": {
     "picker": {
@@ -7086,6 +7093,11 @@
       "preparingHint": "La planificacion lee primero el repositorio para no preguntarte lo que el codigo ya responde. Las preguntas apareceran aqui cuando termine.",
       "failed": "La ejecucion de planificacion se detuvo",
       "failedHint": "Termino antes de que el planificador pudiera responder. Tus respuestas estan guardadas; vuelve a ejecutar la planificacion desde la iniciativa.",
+      "saveFailed": "No se pudo guardar tu respuesta",
+      "saveFailedCount": "No se pudieron guardar {count} de tus respuestas",
+      "continueFailed": "No se pudieron enviar tus respuestas",
+      "proceedFailed": "No se pudo iniciar la planificación",
+      "unanswerable": "Esta pregunta no tiene id, así que no se puede registrar ninguna respuesta para ella.",
       "answerPlaceholder": "Tu respuesta",
       "hint": "Enviar respuestas permite al planificador hacer mas preguntas; Planificar ahora redacta el plan con las respuestas actuales.",
       "unanswered": "Preguntas sin responder: {count}",
@@ -8035,6 +8047,14 @@
       "undeclared": "El paso nunca declaró sus candidatos, así que no había nada que comparar. La ejecución continuó.",
       "parseFailed": "No se pudo leer la declaración de candidatos del paso, así que no había nada que comparar. La ejecución continuó.",
       "noCandidates": "El paso no preparó ningún candidato, así que no había nada que comparar. La ejecución continuó."
-    }
+    },
+    "noRun": {
+      "title": "No hay ninguna ejecución que leer",
+      "hint": "Esta comparación está vinculada a una ejecución de la canalización. Ábrela desde la tarjeta o la cronología del paso que la generó para que se puedan cargar sus candidatos."
+    },
+    "empty": {
+      "title": "Nada que comparar"
+    },
+    "loadFailed": "No se pudieron cargar los candidatos generados."
   }
 }

package/i18n/locales/fr.json

@@ -682,7 +682,8 @@
         "submission_not_allowed": "Fusion non autorisée pour cette exécution",
         "webhook_limit_reached": "Limite de webhooks atteinte",
         "risk_policy_inherited": "Cette politique appartient au compte",
-        "risk_policy_not_inherited": "Cette politique appartient à ce tableau"
+        "risk_policy_not_inherited": "Cette politique appartient à ce tableau",
+        "kaizen_entry_not_settled": "L'entrée Kaizen n'a pas encore été évaluée"
       },
       "description": {
         "dependencies_unmet": "Cette tâche dépend d'autres qui ne sont pas encore terminées. Terminez-les ou débloquez-les, puis relancez-la.",
@@ -723,7 +724,8 @@
         "submission_not_allowed": "La politique de fusion de cette tâche n'autorise pas le rôle qui a lancé cette exécution à fusionner ce type de changement. Un coéquipier dont le rôle le permet peut le faire, ou un admin peut élargir la politique dans le préréglage de fusion.",
         "webhook_limit_reached": "Cet espace de travail a déjà enregistré le nombre maximal de webhooks sortants. Supprimez-en un dont vous n’avez plus besoin, puis enregistrez celui-ci à nouveau.",
         "risk_policy_inherited": "Elle est partagée par tous les tableaux du compte et ne peut donc pas être modifiée ici. Clonez-la vers ce tableau et modifiez la copie.",
-        "risk_policy_not_inherited": "C'est déjà la politique propre à ce tableau : modifiez-la directement, ou supprimez-la si vous ne voulez plus qu'elle soit proposée."
+        "risk_policy_not_inherited": "C'est déjà la politique propre à ce tableau : modifiez-la directement, ou supprimez-la si vous ne voulez plus qu'elle soit proposée.",
+        "kaizen_entry_not_settled": "Son évaluation est encore en attente ou en cours, il n'y a donc aucune recommandation à accuser réception. Réessayez une fois qu'elle sera terminée."
       },
       "action": {
         "connectGitHub": "Connecter GitHub",
@@ -4607,7 +4609,12 @@
     "status": {
       "awaiting": "En attente de réponses",
       "done": "Terminé"
-    }
+    },
+    "saveFailedCount": "Impossible d’enregistrer {count} de vos réponses",
+    "continueFailed": "Impossible d’envoyer vos réponses",
+    "proceedFailed": "Impossible de lancer la rédaction",
+    "unanswerable": "Cette question n’a pas d’identifiant : aucune réponse ne peut y être enregistrée.",
+    "saveFailed": "Impossible d’enregistrer votre réponse"
   },
   "documents": {
     "picker": {
@@ -7086,6 +7093,11 @@
       "preparingHint": "La planification lit d'abord le depot afin de ne pas vous demander ce que le code peut repondre. Les questions apparaitront ici une fois termine.",
       "failed": "L'execution de planification s'est arretee",
       "failedHint": "Elle s'est terminee avant que le planificateur puisse repondre. Vos reponses sont enregistrees ; relancez la planification depuis l'initiative.",
+      "saveFailed": "Impossible d’enregistrer votre réponse",
+      "saveFailedCount": "Impossible d’enregistrer {count} de vos réponses",
+      "continueFailed": "Impossible d’envoyer vos réponses",
+      "proceedFailed": "Impossible de lancer la planification",
+      "unanswerable": "Cette question n’a pas d’identifiant : aucune réponse ne peut y être enregistrée.",
       "answerPlaceholder": "Votre reponse",
       "hint": "Envoyer les reponses permet au planificateur de poser des questions complementaires ; Planifier maintenant redige le plan avec les reponses actuelles.",
       "unanswered": "Questions sans reponse : {count}",
@@ -8035,6 +8047,14 @@
       "undeclared": "L’étape n’a jamais déclaré ses candidats, il n’y avait donc rien à comparer. L’exécution a continué.",
       "parseFailed": "La déclaration de candidats de l’étape était illisible, il n’y avait donc rien à comparer. L’exécution a continué.",
       "noCandidates": "L’étape n’a préparé aucun candidat, il n’y avait donc rien à comparer. L’exécution a continué."
-    }
+    },
+    "noRun": {
+      "title": "Aucune exécution à lire",
+      "hint": "Cette comparaison est liée à une exécution de pipeline. Ouvrez-la depuis la carte ou la chronologie de l’étape qui l’a produite pour que ses candidats puissent être chargés."
+    },
+    "empty": {
+      "title": "Rien à comparer"
+    },
+    "loadFailed": "Impossible de charger les candidats générés."
   }
 }