@cat-factory/app 0.280.1 → 0.280.2

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/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/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}",
@@ -6194,7 +6199,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 +8045,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

@@ -4768,7 +4768,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 +7350,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 +8334,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

@@ -4607,7 +4607,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 +7091,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 +8045,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

@@ -4607,7 +4607,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 +7091,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 +8045,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."
   }
 }

package/i18n/locales/he.json

@@ -4607,7 +4607,12 @@
     "status": {
       "awaiting": "ממתין לתשובות",
       "done": "הושלם"
-    }
+    },
+    "saveFailedCount": "לא ניתן היה לשמור {count} מהתשובות שלך",
+    "continueFailed": "לא ניתן היה לשלוח את התשובות שלך",
+    "proceedFailed": "לא ניתן היה להתחיל את הטיוטה",
+    "unanswerable": "לשאלה הזאת אין מזהה, ולכן לא ניתן לרשום עבורה תשובה.",
+    "saveFailed": "לא ניתן היה לשמור את התשובה שלך"
   },
   "documents": {
     "picker": {
@@ -7086,6 +7091,11 @@
       "preparingHint": "התכנון קורא תחילה את המאגר כדי שלא תישאל על מה שהקוד יכול לענות. השאלות יופיעו כאן בסיום.",
       "failed": "הרצת התכנון נעצרה",
       "failedHint": "היא הסתיימה לפני שהמתכנן הספיק להשיב. התשובות שלך נשמרו; הרץ תכנון מחדש מהיוזמה.",
+      "saveFailed": "לא ניתן היה לשמור את התשובה שלך",
+      "saveFailedCount": "לא ניתן היה לשמור {count} מהתשובות שלך",
+      "continueFailed": "לא ניתן היה לשלוח את התשובות שלך",
+      "proceedFailed": "לא ניתן היה להתחיל את התכנון",
+      "unanswerable": "לשאלה הזאת אין מזהה, ולכן לא ניתן לרשום עבורה תשובה.",
       "answerPlaceholder": "התשובה שלך",
       "hint": "שליחת תשובות מאפשרת למתכנן לשאול שאלות המשך; תכנן עכשיו מנסח את התוכנית עם התשובות עד כה.",
       "unanswered": "שאלות ללא מענה: {count}",
@@ -8035,6 +8045,14 @@
       "undeclared": "השלב מעולם לא הצהיר על מועמדים, ולכן לא היה מה להשוות. הריצה המשיכה.",
       "parseFailed": "לא ניתן היה לקרוא את הצהרת המועמדים של השלב, ולכן לא היה מה להשוות. הריצה המשיכה.",
       "noCandidates": "השלב לא הכין אף מועמד, ולכן לא היה מה להשוות. הריצה המשיכה."
-    }
+    },
+    "noRun": {
+      "title": "אין הרצה לקריאה",
+      "hint": "ההשוואה הזאת משויכת להרצה של הפייפליין. פתחו אותה מהכרטיס או מציר הזמן של השלב שיצר אותה, כדי שניתן יהיה לטעון את המועמדים."
+    },
+    "empty": {
+      "title": "אין מה להשוות"
+    },
+    "loadFailed": "לא ניתן היה לטעון את המועמדים שנוצרו."
   }
 }

package/i18n/locales/it.json

@@ -5689,6 +5689,11 @@
       "preparingHint": "La pianificazione legge prima il repository, cosi non ti viene chiesto cio che il codice puo rispondere. Le domande compariranno qui al termine.",
       "failed": "L'esecuzione della pianificazione si e interrotta",
       "failedHint": "Si e conclusa prima che il pianificatore potesse rispondere. Le tue risposte sono salvate; riesegui la pianificazione dall'iniziativa.",
+      "saveFailed": "Impossibile salvare la tua risposta",
+      "saveFailedCount": "Impossibile salvare {count} delle tue risposte",
+      "continueFailed": "Impossibile inviare le tue risposte",
+      "proceedFailed": "Impossibile avviare la pianificazione",
+      "unanswerable": "Questa domanda non ha un id, quindi non è possibile registrarvi una risposta.",
       "answerPlaceholder": "La tua risposta",
       "hint": "Invia risposte consente al pianificatore di porre domande di follow-up; Pianifica ora redige il piano con le risposte fornite finora.",
       "unanswered": "Domande senza risposta: {count}",
@@ -6194,7 +6199,12 @@
     "status": {
       "awaiting": "In attesa di risposte",
       "done": "Fatto"
-    }
+    },
+    "saveFailedCount": "Impossibile salvare {count} delle tue risposte",
+    "continueFailed": "Impossibile inviare le tue risposte",
+    "proceedFailed": "Impossibile avviare la bozza",
+    "unanswerable": "Questa domanda non ha un id, quindi non è possibile registrarvi una risposta.",
+    "saveFailed": "Impossibile salvare la tua risposta"
   },
   "gates": {
     "subtitle": {
@@ -8035,6 +8045,14 @@
       "undeclared": "Il passo non ha mai dichiarato i suoi candidati, quindi non c’era nulla da confrontare. L’esecuzione è proseguita.",
       "parseFailed": "La dichiarazione dei candidati del passo non era leggibile, quindi non c’era nulla da confrontare. L’esecuzione è proseguita.",
       "noCandidates": "Il passo non ha preparato alcun candidato, quindi non c’era nulla da confrontare. L’esecuzione è proseguita."
-    }
+    },
+    "noRun": {
+      "title": "Nessuna esecuzione da leggere",
+      "hint": "Questo confronto è legato a un’esecuzione della pipeline. Aprilo dalla scheda o dalla cronologia del passo che l’ha generato, così i suoi candidati possono essere caricati."
+    },
+    "empty": {
+      "title": "Nulla da confrontare"
+    },
+    "loadFailed": "Impossibile caricare i candidati generati."
   }
 }

package/i18n/locales/ja.json

@@ -4607,7 +4607,12 @@
     "status": {
       "awaiting": "回答待ち",
       "done": "完了"
-    }
+    },
+    "saveFailedCount": "回答のうち {count} 件を保存できませんでした",
+    "continueFailed": "回答を送信できませんでした",
+    "proceedFailed": "下書きを開始できませんでした",
+    "unanswerable": "この質問には ID がないため、回答を記録できません。",
+    "saveFailed": "回答を保存できませんでした"
   },
   "documents": {
     "picker": {
@@ -7086,6 +7091,11 @@
       "preparingHint": "計画はまずリポジトリを読み取るため、コードから分かることは質問されません。完了すると質問がここに表示されます。",
       "failed": "計画の実行が停止しました",
       "failedHint": "プランナーが応答する前に終了しました。回答は保存されています。イニシアチブから計画を再実行してください。",
+      "saveFailed": "回答を保存できませんでした",
+      "saveFailedCount": "回答のうち {count} 件を保存できませんでした",
+      "continueFailed": "回答を送信できませんでした",
+      "proceedFailed": "プランニングを開始できませんでした",
+      "unanswerable": "この質問には ID がないため、回答を記録できません。",
       "answerPlaceholder": "回答",
       "hint": "「回答を送信」ではプランナーが追加の質問をします。「今すぐ計画」ではこれまでの回答をもとに計画を作成します。",
       "unanswered": "未回答の質問: {count}",
@@ -8035,6 +8045,14 @@
       "undeclared": "このステップは候補を申告しなかったため、比較するものがありませんでした。実行は続行されました。",
       "parseFailed": "このステップの候補の申告を読み取れなかったため、比較するものがありませんでした。実行は続行されました。",
       "noCandidates": "このステップは候補を用意しなかったため、比較するものがありませんでした。実行は続行されました。"
-    }
+    },
+    "noRun": {
+      "title": "読み取る実行がありません",
+      "hint": "この比較はパイプラインの実行に紐づいています。候補を読み込めるように、生成したステップのカードまたはタイムラインから開いてください。"
+    },
+    "empty": {
+      "title": "比較する候補はありません"
+    },
+    "loadFailed": "生成された候補を読み込めませんでした。"
   }
 }