@cat-factory/app 0.181.0 → 0.182.1

package/app/utils/interviewGate.spec.ts

@@ -1,5 +1,11 @@
 import { describe, it, expect } from 'vitest'
-import { interviewGatePhase } from './interviewGate'
+import {
+  DOC_INTERVIEWER_KIND,
+  INITIATIVE_INTERVIEWER_KIND,
+  interviewGatePhase,
+  interviewStepReached,
+} from './interviewGate'
+import type { ExecutionInstance } from '~/types/domain'
 
 // `interviewGatePhase` is what stops continue/proceed reading as no-ops in BOTH interview windows
 // (initiative planning, document interview): the resume is asynchronous — the HTTP call only wakes
@@ -7,45 +13,114 @@ import { interviewGatePhase } from './interviewGate'
 // what distinguishes "parked, waiting on you" from "a pass is running", a distinction the entity
 // alone cannot make.
 
+/** The interview step has been reached — the default for every case not about the split below. */
+const REACHED = true
+
 describe('interviewGatePhase', () => {
   it('is awaiting while the run is parked on the human', () => {
-    expect(interviewGatePhase('awaiting', 'blocked')).toBe('awaiting')
+    expect(interviewGatePhase('awaiting', 'blocked', REACHED)).toBe('awaiting')
   })
 
   it('is working once the resumed run is running again, even though the entity still says awaiting', () => {
     // The exact regression: continue/proceed leave the entity's status untouched until the pass
     // finishes, so an entity-only reading renders the same questions and looks like a dead button.
-    expect(interviewGatePhase('awaiting', 'running')).toBe('working')
+    expect(interviewGatePhase('awaiting', 'running', REACHED)).toBe('working')
   })
 
   it('is working for the FIRST pass, before any question exists', () => {
-    expect(interviewGatePhase(undefined, 'running')).toBe('working')
+    expect(interviewGatePhase(undefined, 'running', REACHED)).toBe('working')
   })
 
   it('is failed when the run stopped before the interview settled', () => {
     // Must not stay `working`: a pass that dies would otherwise spin forever.
-    expect(interviewGatePhase('awaiting', 'failed')).toBe('failed')
-    expect(interviewGatePhase(undefined, 'failed')).toBe('failed')
+    expect(interviewGatePhase('awaiting', 'failed', REACHED)).toBe('failed')
+    expect(interviewGatePhase(undefined, 'failed', REACHED)).toBe('failed')
   })
 
   it('is converged once the interview settled, whatever the run went on to do', () => {
     // `converged` outranks `failed`: a later step's failure belongs to that step, not the
     // interview, and the block's own failure surface reports it.
-    expect(interviewGatePhase('done', 'running')).toBe('converged')
-    expect(interviewGatePhase('done', 'failed')).toBe('converged')
-    expect(interviewGatePhase('done', undefined)).toBe('converged')
+    expect(interviewGatePhase('done', 'running', REACHED)).toBe('converged')
+    expect(interviewGatePhase('done', 'failed', REACHED)).toBe('converged')
+    expect(interviewGatePhase('done', undefined, REACHED)).toBe('converged')
   })
 
   it('is idle when the interview never ran', () => {
-    expect(interviewGatePhase(undefined, undefined)).toBe('idle')
+    expect(interviewGatePhase(undefined, undefined, REACHED)).toBe('idle')
   })
 
   it('degrades to the entity-only reading when the run is not cached', () => {
     // A window opened before the execution snapshot lands must show the questions, never a spinner.
-    expect(interviewGatePhase('awaiting', undefined)).toBe('awaiting')
+    expect(interviewGatePhase('awaiting', undefined, REACHED)).toBe('awaiting')
   })
 
   it('keeps a paused run answerable', () => {
-    expect(interviewGatePhase('awaiting', 'paused')).toBe('awaiting')
+    expect(interviewGatePhase('awaiting', 'paused', REACHED)).toBe('awaiting')
+  })
+})
+
+// Neither interview leads its pipeline — initiative planning explores the codebase first, the
+// document pipeline researches and outlines first — and that lead-in is minutes of container work.
+// Reported as `working` it claims an interviewer is chewing on answers the human was never asked
+// for; these pin the split.
+describe('interviewGatePhase — before the interview step is reached', () => {
+  it('is preparing while an EARLIER step is running', () => {
+    expect(interviewGatePhase(undefined, 'running', false)).toBe('preparing')
+  })
+
+  it('does not offer a stale previous round to answer during the lead-in', () => {
+    // On a re-plan the entity still carries the last run's questions until the gate's
+    // `resetForFreshRun` fires, which is now AFTER the lead-in. Reading those as `awaiting` would
+    // invite the human to answer a round about to be discarded.
+    expect(interviewGatePhase('awaiting', 'running', false)).toBe('preparing')
+  })
+
+  it('still reports a settled or failed run over the lead-in', () => {
+    expect(interviewGatePhase('done', 'running', false)).toBe('converged')
+    expect(interviewGatePhase(undefined, 'failed', false)).toBe('failed')
+  })
+
+  it('is unchanged when the run is not running at all', () => {
+    expect(interviewGatePhase('awaiting', 'blocked', false)).toBe('awaiting')
+    expect(interviewGatePhase(undefined, undefined, false)).toBe('idle')
+  })
+})
+
+const run = (kinds: string[], currentStep: number) =>
+  ({ steps: kinds.map((agentKind) => ({ agentKind })), currentStep }) as Pick<
+    ExecutionInstance,
+    'steps' | 'currentStep'
+  >
+
+describe('interviewStepReached', () => {
+  const PLANNING = ['initiative-analyst', INITIATIVE_INTERVIEWER_KIND, 'initiative-planner']
+
+  it('is false while an earlier step is current', () => {
+    expect(interviewStepReached(run(PLANNING, 0), INITIATIVE_INTERVIEWER_KIND)).toBe(false)
+  })
+
+  it('is true from the interview step onward', () => {
+    expect(interviewStepReached(run(PLANNING, 1), INITIATIVE_INTERVIEWER_KIND)).toBe(true)
+    expect(interviewStepReached(run(PLANNING, 2), INITIATIVE_INTERVIEWER_KIND)).toBe(true)
+  })
+
+  it('degrades to true when the run is not cached yet', () => {
+    // Over-reporting "still preparing" would leave a genuinely parked interview looking dormant,
+    // which is worse than generic copy — so an unknown run keeps the pre-existing reading.
+    // Both spellings of "no run": `useResultViewRunMeta` resolves to null, a store lookup to
+    // undefined, and the two windows use one each.
+    expect(interviewStepReached(undefined, INITIATIVE_INTERVIEWER_KIND)).toBe(true)
+    expect(interviewStepReached(null, INITIATIVE_INTERVIEWER_KIND)).toBe(true)
+  })
+
+  it('degrades to true for a chain carrying no such step', () => {
+    expect(
+      interviewStepReached(run(['doc-researcher', 'doc-writer'], 0), DOC_INTERVIEWER_KIND),
+    ).toBe(true)
+  })
+
+  it('locates the document interviewer behind its own lead-in', () => {
+    const authoring = run(['doc-researcher', 'doc-outliner', DOC_INTERVIEWER_KIND], 1)
+    expect(interviewStepReached(authoring, DOC_INTERVIEWER_KIND)).toBe(false)
   })
 })

package/app/utils/interviewGate.ts

@@ -12,15 +12,57 @@ import type { ExecutionInstance } from '~/types/domain'
  * disagree about whether there is anything to answer.
  *
  *  - `idle` — the interview has not run yet (nothing to answer, nothing in flight).
+ *  - `preparing` — the run is working on an EARLIER step; the interview has not begun.
  *  - `working` — an interviewer pass is running; the human waits.
  *  - `awaiting` — the run is parked on the human's answers.
  *  - `converged` — the interview settled; the run moved on.
  *  - `failed` — the run stopped before the interview settled.
  */
-export type InterviewGatePhase = 'idle' | 'working' | 'awaiting' | 'converged' | 'failed'
+export type InterviewGatePhase =
+  | 'idle'
+  | 'preparing'
+  | 'working'
+  | 'awaiting'
+  | 'converged'
+  | 'failed'
 
 /**
- * Resolve the phase from the interview entity's status AND its run's status.
+ * The agent kind of each gate's own step, which is what {@link interviewStepReached} locates in the
+ * run's chain. Kept here beside the phase they feed rather than inline at each window, so the two
+ * surfaces can't drift onto different spellings of the same step.
+ */
+export const INITIATIVE_INTERVIEWER_KIND = 'initiative-interviewer'
+export const DOC_INTERVIEWER_KIND = 'doc-interviewer'
+
+/**
+ * Whether the run has REACHED the interview gate's own step — i.e. whether a running run is
+ * running the interviewer, or something ahead of it.
+ *
+ * Neither gate leads its pipeline: `pl_initiative` explores the codebase first, and the document
+ * pipeline researches and outlines first. Without this the whole of that lead-in reads as
+ * `working`, so the window claims an interviewer pass is chewing on answers the human has not
+ * given yet — for however long a container step takes.
+ *
+ * Degrades to `true` (today's reading, no `preparing` claim) when the run is not cached yet or the
+ * chain carries no such step: a phase that over-reports "we are still preparing" would leave a
+ * genuinely-parked interview looking dormant, which is worse than the copy being generic.
+ *
+ * Takes `null` as well as `undefined` because the two window seams spell "no run" differently —
+ * `useResultViewRunMeta` resolves to `null`, a store lookup to `undefined` — and both mean the same
+ * thing here.
+ */
+export function interviewStepReached(
+  run: Pick<ExecutionInstance, 'steps' | 'currentStep'> | null | undefined,
+  agentKind: string,
+): boolean {
+  if (!run) return true
+  const index = run.steps.findIndex((step) => step.agentKind === agentKind)
+  return index < 0 || index <= run.currentStep
+}
+
+/**
+ * Resolve the phase from the interview entity's status, its run's status, and whether the run has
+ * reached the interview step ({@link interviewStepReached}).
  *
  * The RUN status is load-bearing, not redundant. Continue/proceed are ASYNC by design: the HTTP
  * call only records the intent on the parked step and wakes the durable driver, which then runs
@@ -35,17 +77,27 @@ export type InterviewGatePhase = 'idle' | 'working' | 'awaiting' | 'converged' |
  * says so instead of spinning forever. An unknown run (no instance cached yet) degrades to the
  * entity-only reading, never to a spinner.
  *
+ * `stepReached` splits that running window in two, because "a pass is in flight" and "your turn is
+ * still coming" are different things to be told and the difference is minutes long. It is a
+ * REQUIRED argument rather than an optional one: a caller that omitted it would silently get the
+ * misleading half, which is the bug this exists to fix.
+ *
  * `converged` wins over `failed` on purpose: once the interview settled, a later failure belongs
- * to the step that failed (the analyst/planner, the writer), and the block's own failure surface
- * reports it — the interview window claiming the interview broke would be wrong.
+ * to the step that failed (the planner, the writer), and the block's own failure surface reports
+ * it — the interview window claiming the interview broke would be wrong.
  */
 export function interviewGatePhase(
   status: 'awaiting' | 'done' | undefined,
   runStatus: ExecutionInstance['status'] | undefined,
+  stepReached: boolean,
 ): InterviewGatePhase {
   if (status === 'done') return 'converged'
   if (runStatus === 'failed') return 'failed'
-  if (runStatus === 'running') return 'working'
+  // Before `status === 'awaiting'`: on a re-plan the entity still carries the PREVIOUS run's
+  // questions until the gate's `resetForFreshRun` fires, which now happens after the lead-in
+  // steps. Reading those as "awaiting your answers" would invite a human to answer a round that
+  // is about to be discarded.
+  if (runStatus === 'running') return stepReached ? 'working' : 'preparing'
   if (status === 'awaiting') return 'awaiting'
   return 'idle'
 }

package/i18n/locales/de.json

@@ -4282,21 +4282,33 @@
     "inspector": {
       "runPlanning": "Planung ausführen",
       "answerPlanning": "Planungsfragen beantworten",
+      "reviewPlan": "Plan prüfen",
+      "resolveDecision": "Auflösen",
       "planningInProgress": "Planung läuft",
       "pause": "Pausieren",
       "resume": "Fortsetzen",
       "cancel": "Initiative abbrechen",
       "hint": "Die Planning-Pipeline erkundet die Codebasis, entwirft den mehrphasigen Plan zur Freigabe und committet dann das Tracker-Dokument ins Repository."
     },
+    "planReview": {
+      "title": "Dieser Plan wartet auf dich",
+      "body": "Der Planner hat die Phasen und Aufgaben unten entworfen. Gib sie frei, um den Plan zu committen und die Arbeit zu starten, oder schicke den Plan mit deinen Änderungswünschen zurück.",
+      "approve": "Plan freigeben",
+      "requestChanges": "Änderungen anfordern",
+      "feedbackPlaceholder": "Was soll der Planner ändern? Umfang, Reihenfolge der Phasen, fehlende Arbeit, eine Aufgabe, die woanders hingehört …",
+      "sendBack": "An den Planner zurückschicken"
+    },
     "planning": {
       "title": "Die Initiative planen",
       "subtitle": "Beantworten Sie die Fragen des Planers, damit er die Initiative eingrenzen kann",
       "intro": "Der Planer grenzt diese Initiative ein. Beantworten Sie seine Fragen, um Ziel und Einschränkungen zu formen, und senden Sie sie dann ab. Sie können ihn auch mit dem, was er bereits hat, jetzt planen lassen.",
       "empty": "Keine Initiative für diesen Block gefunden.",
       "converged": "Keine Fragen ausstehend. Der Planer hat, was er braucht, und entwirft den Plan.",
-      "idle": "Die Planung wurde noch nicht gestartet. Führen Sie die Planung von der Initiative aus, um das Interview zu beginnen.",
+      "idle": "Die Planung wurde noch nicht gestartet. Führen Sie die Planung von der Initiative aus: Zuerst wird die Codebasis analysiert, danach werden Sie befragt.",
       "working": "Der Planer verarbeitet Ihre Antworten",
       "workingHint": "Das dauert einen Moment. Rückfragen erscheinen hier, sobald er fertig ist, oder er beginnt mit dem Entwurf des Plans, wenn ihm die Angaben genügen.",
+      "preparing": "Die Codebasis wird vor dem Interview analysiert",
+      "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.",
       "answerPlaceholder": "Ihre Antwort",
@@ -4647,6 +4659,8 @@
     "converged": "Es stehen keine Fragen aus. Der Interviewer hat, was er braucht, und das Dokument wird entworfen.",
     "working": "Der Interviewer verarbeitet deine Antworten",
     "workingHint": "Das dauert einen Moment. Nachfragen erscheinen hier, sobald er fertig ist, oder der Entwurf beginnt, wenn ihm die Angaben genügen.",
+    "preparing": "Das Dokument wird vor dem Interview recherchiert",
+    "preparingHint": "Der Lauf sammelt zuerst Hintergrundwissen und entwirft eine Gliederung. Fragen erscheinen hier, sobald das erledigt ist.",
     "failed": "Der Dokumentenlauf wurde abgebrochen",
     "failedHint": "Er endete, bevor der Interviewer antworten konnte. Deine Antworten sind gespeichert; führe die Dokumentaufgabe erneut aus.",
     "answerPlaceholder": "Deine Antwort",

package/i18n/locales/en.json

@@ -3678,6 +3678,8 @@
     "converged": "No questions are pending. The interviewer has what it needs and the document is being drafted.",
     "working": "The interviewer is working on your answers",
     "workingHint": "This takes a moment. Follow-up questions appear here when it is done, or drafting starts if it has enough.",
+    "preparing": "Researching the document before the interview",
+    "preparingHint": "The run gathers background and drafts an outline first. Questions appear here once that is done.",
     "failed": "The document run stopped",
     "failedHint": "It ended before the interviewer could answer. Your answers are saved; re-run the document task to try again.",
     "answerPlaceholder": "Your answer",
@@ -5457,21 +5459,33 @@
     "inspector": {
       "runPlanning": "Run planning",
       "answerPlanning": "Answer planning questions",
+      "reviewPlan": "Review plan",
+      "resolveDecision": "Resolve",
       "planningInProgress": "Planning in progress",
       "pause": "Pause",
       "resume": "Resume",
       "cancel": "Cancel initiative",
       "hint": "The planning pipeline explores the codebase, drafts the multi-phase plan for approval, then commits the tracker document to the repository."
     },
+    "planReview": {
+      "title": "This plan is waiting for you",
+      "body": "The planner drafted the phases and items below. Approve them to commit the plan and start the work, or send the plan back with what to change.",
+      "approve": "Approve plan",
+      "requestChanges": "Request changes",
+      "feedbackPlaceholder": "What should the planner change? Scope, phase order, missing work, an item that belongs elsewhere…",
+      "sendBack": "Send back to the planner"
+    },
     "planning": {
       "title": "Plan the initiative",
       "subtitle": "Answer the planner's questions so it can scope the initiative",
       "intro": "The planner is scoping this initiative. Answer its questions to shape the goal and constraints, then submit them. You can also have it plan now with what it already has.",
       "empty": "No initiative found for this block.",
       "converged": "No questions are pending. The planner has what it needs and is drafting the plan.",
-      "idle": "Planning has not started yet. Run planning from the initiative to begin the interview.",
+      "idle": "Planning has not started yet. Run planning from the initiative: it analyzes the codebase first, then interviews you.",
       "working": "The planner is working on your answers",
       "workingHint": "This takes a moment. Follow-up questions appear here when it is done, or it starts drafting the plan if it has enough.",
+      "preparing": "Exploring the codebase before the interview",
+      "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.",
       "answerPlaceholder": "Your answer",

package/i18n/locales/es.json

@@ -3570,6 +3570,8 @@
     "converged": "No hay preguntas pendientes. El entrevistador tiene lo que necesita y el documento se está redactando.",
     "working": "El entrevistador está procesando tus respuestas",
     "workingHint": "Esto tarda un momento. Las preguntas de seguimiento aparecerán aquí cuando termine, o empezará la redacción si ya tiene suficiente.",
+    "preparing": "Investigando el documento antes de la entrevista",
+    "preparingHint": "La ejecución primero reúne el contexto y esboza un esquema. Las preguntas aparecerán aquí cuando termine.",
     "failed": "La ejecución del documento se detuvo",
     "failedHint": "Terminó antes de que el entrevistador pudiera responder. Tus respuestas están guardadas; vuelve a ejecutar la tarea del documento.",
     "answerPlaceholder": "Tu respuesta",
@@ -5292,21 +5294,33 @@
     "inspector": {
       "runPlanning": "Ejecutar planificacion",
       "answerPlanning": "Responder preguntas de planificacion",
+      "reviewPlan": "Revisar plan",
+      "resolveDecision": "Resolver",
       "planningInProgress": "Planificacion en curso",
       "pause": "Pausar",
       "resume": "Reanudar",
       "cancel": "Cancelar iniciativa",
       "hint": "El pipeline de planificacion explora el codigo, redacta el plan multifase para su aprobacion y luego confirma el documento de seguimiento en el repositorio."
     },
+    "planReview": {
+      "title": "Este plan te está esperando",
+      "body": "El planificador redactó las fases y los elementos de abajo. Apruébalos para confirmar el plan y empezar el trabajo, o devuelve el plan indicando qué cambiar.",
+      "approve": "Aprobar plan",
+      "requestChanges": "Solicitar cambios",
+      "feedbackPlaceholder": "¿Qué debería cambiar el planificador? Alcance, orden de las fases, trabajo que falta, un elemento que va en otro sitio…",
+      "sendBack": "Devolver al planificador"
+    },
     "planning": {
       "title": "Planificar la iniciativa",
       "subtitle": "Responde las preguntas del planificador para acotar la iniciativa",
       "intro": "El planificador esta acotando esta iniciativa. Responde sus preguntas para definir el objetivo y las restricciones, y luego envialas. Tambien puedes pedirle que planifique ahora con lo que ya tiene.",
       "empty": "No se encontro ninguna iniciativa para este bloque.",
       "converged": "No hay preguntas pendientes. El planificador tiene lo que necesita y esta redactando el plan.",
-      "idle": "La planificacion aun no ha comenzado. Ejecuta la planificacion desde la iniciativa para iniciar la entrevista.",
+      "idle": "La planificacion aun no ha comenzado. Ejecuta la planificacion desde la iniciativa: primero analiza el codigo y despues te entrevista.",
       "working": "El planificador esta procesando tus respuestas",
       "workingHint": "Esto tarda un momento. Las preguntas de seguimiento apareceran aqui cuando termine, o empezara a redactar el plan si ya tiene suficiente.",
+      "preparing": "Explorando el codigo antes de la entrevista",
+      "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.",
       "answerPlaceholder": "Tu respuesta",

package/i18n/locales/fr.json

@@ -3570,6 +3570,8 @@
     "converged": "Aucune question en attente. L'intervieweur a ce qu'il lui faut et le document est en cours de rédaction.",
     "working": "L'intervieweur traite vos réponses",
     "workingHint": "Cela prend un instant. Les questions complémentaires apparaîtront ici une fois terminé, ou la rédaction commencera s'il en a assez.",
+    "preparing": "Recherche sur le document avant l'entretien",
+    "preparingHint": "L'exécution rassemble d'abord le contexte et ébauche un plan. Les questions apparaîtront ici une fois terminé.",
     "failed": "L'exécution du document s'est arrêtée",
     "failedHint": "Elle s'est terminée avant que l'intervieweur puisse répondre. Vos réponses sont enregistrées ; relancez la tâche du document.",
     "answerPlaceholder": "Votre réponse",
@@ -5292,21 +5294,33 @@
     "inspector": {
       "runPlanning": "Lancer la planification",
       "answerPlanning": "Repondre aux questions de planification",
+      "reviewPlan": "Examiner le plan",
+      "resolveDecision": "Résoudre",
       "planningInProgress": "Planification en cours",
       "pause": "Mettre en pause",
       "resume": "Reprendre",
       "cancel": "Annuler l'initiative",
       "hint": "Le pipeline de planification explore le code, redige le plan multiphase pour approbation, puis valide le document de suivi dans le depot."
     },
+    "planReview": {
+      "title": "Ce plan vous attend",
+      "body": "Le planificateur a rédigé les phases et les éléments ci-dessous. Approuvez-les pour valider le plan et lancer le travail, ou renvoyez le plan en indiquant ce qu'il faut changer.",
+      "approve": "Approuver le plan",
+      "requestChanges": "Demander des modifications",
+      "feedbackPlaceholder": "Que doit changer le planificateur ? Périmètre, ordre des phases, travail manquant, un élément qui a sa place ailleurs…",
+      "sendBack": "Renvoyer au planificateur"
+    },
     "planning": {
       "title": "Planifier l'initiative",
       "subtitle": "Repondez aux questions du planificateur pour cadrer l'initiative",
       "intro": "Le planificateur cadre cette initiative. Repondez a ses questions pour definir l'objectif et les contraintes, puis envoyez-les. Vous pouvez aussi lui demander de planifier maintenant avec ce qu'il a deja.",
       "empty": "Aucune initiative trouvee pour ce bloc.",
       "converged": "Aucune question en attente. Le planificateur dispose de ce qu'il faut et redige le plan.",
-      "idle": "La planification n'a pas encore demarre. Lancez la planification depuis l'initiative pour commencer l'entretien.",
+      "idle": "La planification n'a pas encore demarre. Lancez la planification depuis l'initiative : elle analyse d'abord le code, puis vous interroge.",
       "working": "Le planificateur traite vos reponses",
       "workingHint": "Cela prend un instant. Les questions complementaires apparaitront ici une fois termine, ou il commencera a rediger le plan s'il en a assez.",
+      "preparing": "Exploration du code avant l'entretien",
+      "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.",
       "answerPlaceholder": "Votre reponse",

package/i18n/locales/he.json

@@ -3581,6 +3581,8 @@
     "converged": "אין שאלות ממתינות. למראיין יש את מה שהוא צריך והמסמך בכתיבה.",
     "working": "המראיין מעבד את התשובות שלך",
     "workingHint": "זה לוקח רגע. שאלות המשך יופיעו כאן בסיום, או שתתחיל כתיבת הטיוטה אם יש לו מספיק מידע.",
+    "preparing": "המסמך נחקר לפני הראיון",
+    "preparingHint": "ההרצה אוספת תחילה רקע ומכינה מתאר. שאלות יופיעו כאן בסיום.",
     "failed": "הרצת המסמך נעצרה",
     "failedHint": "היא הסתיימה לפני שהמראיין הספיק להשיב. התשובות שלך נשמרו; הריצו מחדש את משימת המסמך.",
     "answerPlaceholder": "התשובה שלך",
@@ -5303,21 +5305,33 @@
     "inspector": {
       "runPlanning": "הרצת תכנון",
       "answerPlanning": "מענה על שאלות התכנון",
+      "reviewPlan": "בדיקת התוכנית",
+      "resolveDecision": "פתור",
       "planningInProgress": "התכנון מתבצע",
       "pause": "השהה",
       "resume": "המשך",
       "cancel": "ביטול היוזמה",
       "hint": "צינור התכנון חוקר את הקוד, מנסח את התוכנית הרב-שלבית לאישור, ואז שומר את מסמך המעקב במאגר."
     },
+    "planReview": {
+      "title": "התוכנית הזו ממתינה לך",
+      "body": "המתכנן ניסח את השלבים והפריטים שלמטה. אשרו אותם כדי לשמור את התוכנית ולהתחיל בעבודה, או החזירו את התוכנית עם מה שצריך לשנות.",
+      "approve": "אישור התוכנית",
+      "requestChanges": "בקשת שינויים",
+      "feedbackPlaceholder": "מה המתכנן צריך לשנות? היקף, סדר השלבים, עבודה חסרה, פריט ששייך למקום אחר…",
+      "sendBack": "החזרה למתכנן"
+    },
     "planning": {
       "title": "תכנון היוזמה",
       "subtitle": "ענה על שאלות המתכנן כדי למקד את היוזמה",
       "intro": "המתכנן ממקד את היוזמה. ענה על שאלותיו כדי לעצב את המטרה והאילוצים, ואז שלח את התשובות. אפשר גם לבקש ממנו לתכנן עכשיו עם מה שכבר יש לו.",
       "empty": "לא נמצאה יוזמה עבור בלוק זה.",
       "converged": "אין שאלות ממתינות. למתכנן יש את מה שנדרש והוא מנסח את התוכנית.",
-      "idle": "התכנון עדיין לא התחיל. הרץ תכנון מהיוזמה כדי להתחיל את הראיון.",
+      "idle": "התכנון עדיין לא התחיל. הרץ תכנון מהיוזמה: תחילה הוא מנתח את בסיס הקוד ולאחר מכן מראיין אותך.",
       "working": "המתכנן מעבד את התשובות שלך",
       "workingHint": "זה לוקח רגע. שאלות המשך יופיעו כאן בסיום, או שהוא יתחיל לנסח את התוכנית אם יש לו מספיק מידע.",
+      "preparing": "בסיס הקוד נסרק לפני הראיון",
+      "preparingHint": "התכנון קורא תחילה את המאגר כדי שלא תישאל על מה שהקוד יכול לענות. השאלות יופיעו כאן בסיום.",
       "failed": "הרצת התכנון נעצרה",
       "failedHint": "היא הסתיימה לפני שהמתכנן הספיק להשיב. התשובות שלך נשמרו; הרץ תכנון מחדש מהיוזמה.",
       "answerPlaceholder": "התשובה שלך",

package/i18n/locales/it.json

@@ -4282,21 +4282,33 @@
     "inspector": {
       "runPlanning": "Esegui pianificazione",
       "answerPlanning": "Rispondi alle domande di pianificazione",
+      "reviewPlan": "Rivedi il piano",
+      "resolveDecision": "Risolvi",
       "planningInProgress": "Pianificazione in corso",
       "pause": "Pausa",
       "resume": "Riprendi",
       "cancel": "Annulla iniziativa",
       "hint": "La pipeline di pianificazione esplora il codebase, redige il piano multi-fase per l'approvazione, poi effettua il commit del documento del tracker nel repository."
     },
+    "planReview": {
+      "title": "Questo piano ti sta aspettando",
+      "body": "Il planner ha redatto le fasi e gli elementi qui sotto. Approvali per confermare il piano e avviare il lavoro, oppure rimanda indietro il piano indicando cosa cambiare.",
+      "approve": "Approva il piano",
+      "requestChanges": "Richiedi modifiche",
+      "feedbackPlaceholder": "Cosa deve cambiare il planner? Ambito, ordine delle fasi, lavoro mancante, un elemento che sta altrove…",
+      "sendBack": "Rimanda al planner"
+    },
     "planning": {
       "title": "Pianifica l'iniziativa",
       "subtitle": "Rispondi alle domande del pianificatore affinche possa definire l'ambito dell'iniziativa",
       "intro": "Il pianificatore sta definendo l'ambito di questa iniziativa. Rispondi alle sue domande per dare forma all'obiettivo e ai vincoli, poi invia le risposte. Puoi anche chiedergli di pianificare subito con quello che ha gia.",
       "empty": "Nessuna iniziativa trovata per questo blocco.",
       "converged": "Nessuna domanda in sospeso. Il pianificatore ha cio che gli serve e sta redigendo il piano.",
-      "idle": "La pianificazione non e ancora iniziata. Esegui la pianificazione dall'iniziativa per avviare l'intervista.",
+      "idle": "La pianificazione non e ancora iniziata. Esegui la pianificazione dall'iniziativa: prima analizza il codice, poi ti intervista.",
       "working": "Il pianificatore sta elaborando le tue risposte",
       "workingHint": "Richiede qualche istante. Le domande di follow-up compariranno qui al termine, oppure iniziera a redigere il piano se ha abbastanza informazioni.",
+      "preparing": "Esplorazione del codice prima dell'intervista",
+      "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.",
       "answerPlaceholder": "La tua risposta",
@@ -4647,6 +4659,8 @@
     "converged": "Nessuna domanda in sospeso. L'intervistatore ha ciò che gli serve e il documento è in fase di redazione.",
     "working": "L'intervistatore sta elaborando le tue risposte",
     "workingHint": "Richiede qualche istante. Le domande di follow-up compariranno qui al termine, oppure inizierà la stesura se ha abbastanza informazioni.",
+    "preparing": "Ricerca sul documento prima dell'intervista",
+    "preparingHint": "L'esecuzione raccoglie prima il contesto e abbozza una scaletta. Le domande compariranno qui al termine.",
     "failed": "L'esecuzione del documento si è interrotta",
     "failedHint": "Si è conclusa prima che l'intervistatore potesse rispondere. Le tue risposte sono salvate; riesegui l'attività del documento.",
     "answerPlaceholder": "La tua risposta",

package/i18n/locales/ja.json

@@ -3582,6 +3582,8 @@
     "converged": "保留中の質問はありません。インタビュアーは必要な情報を得ており、ドキュメントを下書き中です。",
     "working": "インタビュアーが回答を処理しています",
     "workingHint": "少し時間がかかります。完了すると追加の質問がここに表示されます。情報が十分な場合は下書きの作成を開始します。",
+    "preparing": "インタビューの前に資料を調査しています",
+    "preparingHint": "実行はまず背景情報を集めてアウトラインを作成します。完了すると質問がここに表示されます。",
     "failed": "ドキュメントの実行が停止しました",
     "failedHint": "インタビュアーが応答する前に終了しました。回答は保存されています。ドキュメントのタスクを再実行してください。",
     "answerPlaceholder": "回答",
@@ -5304,21 +5306,33 @@
     "inspector": {
       "runPlanning": "計画を実行",
       "answerPlanning": "計画の質問に回答",
+      "reviewPlan": "計画をレビュー",
+      "resolveDecision": "解決",
       "planningInProgress": "計画を実行中",
       "pause": "一時停止",
       "resume": "再開",
       "cancel": "イニシアチブをキャンセル",
       "hint": "計画パイプラインはコードベースを調査し、承認用の複数フェーズ計画を起草し、その後トラッカー文書をリポジトリにコミットします。"
     },
+    "planReview": {
+      "title": "この計画が承認を待っています",
+      "body": "プランナーが以下のフェーズと項目を起草しました。承認すると計画がコミットされ、作業が始まります。変更したい点がある場合は、その内容を添えて計画を差し戻してください。",
+      "approve": "計画を承認",
+      "requestChanges": "変更を依頼",
+      "feedbackPlaceholder": "プランナーに変更してほしい点は何ですか。範囲、フェーズの順序、不足している作業、別の場所に属する項目など…",
+      "sendBack": "プランナーに差し戻す"
+    },
     "planning": {
       "title": "イニシアチブを計画",
       "subtitle": "プランナーの質問に答えてイニシアチブの範囲を定めます",
       "intro": "プランナーがこのイニシアチブの範囲を検討しています。質問に答えて目標と制約を形にし、回答を送信してください。現状の情報のまま計画を作成させることもできます。",
       "empty": "このブロックのイニシアチブが見つかりません。",
       "converged": "保留中の質問はありません。プランナーは必要な情報を得て計画を作成しています。",
-      "idle": "計画はまだ開始されていません。イニシアチブから計画を実行するとインタビューが始まります。",
+      "idle": "計画はまだ開始されていません。イニシアチブから計画を実行すると、まずコードベースを分析し、その後にインタビューが行われます。",
       "working": "プランナーが回答を処理しています",
       "workingHint": "少し時間がかかります。完了すると追加の質問がここに表示されます。情報が十分な場合は計画の作成を開始します。",
+      "preparing": "インタビューの前にコードベースを分析しています",
+      "preparingHint": "計画はまずリポジトリを読み取るため、コードから分かることは質問されません。完了すると質問がここに表示されます。",
       "failed": "計画の実行が停止しました",
       "failedHint": "プランナーが応答する前に終了しました。回答は保存されています。イニシアチブから計画を再実行してください。",
       "answerPlaceholder": "回答",

package/i18n/locales/pl.json

@@ -3570,6 +3570,8 @@
     "converged": "Brak oczekujących pytań. Ankieter ma to, czego potrzebuje, a dokument jest redagowany.",
     "working": "Ankieter przetwarza Twoje odpowiedzi",
     "workingHint": "To chwilę potrwa. Pytania uzupełniające pojawią się tutaj po zakończeniu, a jeśli informacji wystarczy, rozpocznie się redagowanie.",
+    "preparing": "Badanie dokumentu przed wywiadem",
+    "preparingHint": "Uruchomienie najpierw zbiera materiały i szkicuje konspekt. Pytania pojawią się tutaj po zakończeniu.",
     "failed": "Uruchomienie dokumentu zostało przerwane",
     "failedHint": "Zakończyło się, zanim ankieter zdążył odpowiedzieć. Twoje odpowiedzi są zapisane; uruchom zadanie dokumentu ponownie.",
     "answerPlaceholder": "Twoja odpowiedź",
@@ -5292,21 +5294,33 @@
     "inspector": {
       "runPlanning": "Uruchom planowanie",
       "answerPlanning": "Odpowiedz na pytania planowania",
+      "reviewPlan": "Przejrzyj plan",
+      "resolveDecision": "Rozwiąż",
       "planningInProgress": "Planowanie w toku",
       "pause": "Wstrzymaj",
       "resume": "Wznow",
       "cancel": "Anuluj inicjatywe",
       "hint": "Pipeline planowania bada kod, przygotowuje wielofazowy plan do zatwierdzenia, a nastepnie zapisuje dokument trackera w repozytorium."
     },
+    "planReview": {
+      "title": "Ten plan czeka na Ciebie",
+      "body": "Planer przygotował poniższe fazy i elementy. Zatwierdź je, aby zapisać plan i rozpocząć pracę, albo odeślij plan z informacją, co zmienić.",
+      "approve": "Zatwierdź plan",
+      "requestChanges": "Poproś o zmiany",
+      "feedbackPlaceholder": "Co planer ma zmienić? Zakres, kolejność faz, brakująca praca, element, który pasuje gdzie indziej…",
+      "sendBack": "Odeślij do planera"
+    },
     "planning": {
       "title": "Zaplanuj inicjatywe",
       "subtitle": "Odpowiedz na pytania planisty, aby okreslic zakres inicjatywy",
       "intro": "Planista okresla zakres tej inicjatywy. Odpowiedz na pytania, aby uksztaltowac cel i ograniczenia, a nastepnie wyslij odpowiedzi. Mozesz tez poprosic go, aby zaplanowal teraz na podstawie tego, co juz ma.",
       "empty": "Nie znaleziono inicjatywy dla tego bloku.",
       "converged": "Brak oczekujacych pytan. Planista ma to, czego potrzebuje, i tworzy plan.",
-      "idle": "Planowanie jeszcze sie nie rozpoczelo. Uruchom planowanie z poziomu inicjatywy, aby rozpoczac wywiad.",
+      "idle": "Planowanie jeszcze sie nie rozpoczelo. Uruchom planowanie z poziomu inicjatywy: najpierw analizuje kod, a potem przeprowadza z toba wywiad.",
       "working": "Planista przetwarza Twoje odpowiedzi",
       "workingHint": "To chwile potrwa. Pytania uzupelniajace pojawia sie tutaj po zakonczeniu, a jesli informacji wystarczy, planista zacznie tworzyc plan.",
+      "preparing": "Analiza kodu przed wywiadem",
+      "preparingHint": "Planowanie najpierw czyta repozytorium, wiec nie zapyta Cie o to, co wynika z kodu. Pytania pojawia sie tutaj po zakonczeniu.",
       "failed": "Uruchomienie planowania zostalo przerwane",
       "failedHint": "Zakonczylo sie, zanim planista zdazyl odpowiedziec. Twoje odpowiedzi sa zapisane; uruchom planowanie ponownie z poziomu inicjatywy.",
       "answerPlaceholder": "Twoja odpowiedz",