@cat-factory/app 0.181.0 → 0.182.0

package/README.md

@@ -131,7 +131,10 @@ example ships in [`deploy/frontend`](../../deploy/frontend) (the `acme:security`
 
 - **Board canvas** (`components/board`) — `BoardCanvas` + `nodes/` (`BlockNode`,
   `ModuleFrame`, `TaskCard`), dependency edges, the per-block `AgentFailureCard` /
-  `AgentStopButton`, and a deep-zoom `focus/BlockFocusView`.
+  `AgentStopButton`, and a deep-zoom `focus/BlockFocusView`. A running task card expands
+  its build pipeline (`TaskPipelineMini`) on hover at any zoom level, and across every
+  on-screen card past the `steps` zoom band — the two grants are combined in the
+  `taskExpansion` store and driven by `useTaskExpansion`.
 - **Sidebar & chrome** (`components/layout`) — board/account switchers, palettes
   entry points, the language + [interface-mode](#interface-modes-basic--advanced)
   switchers, the `SpendWarningBanner`, and the toolbar (zoom, LOD, decision queue).

package/app/components/board/nodes/DraggableTask.vue

@@ -10,8 +10,9 @@ const task = computed(() => board.getBlock(props.taskId))
 const { draggingId, startDrag } = useBlockDrag()
 
 // An expanded pipeline grows downward over its neighbours, so it must stack above the
-// other (compact) task cards — never let a neighbour render on top of the pipeline.
-const expanded = computed(() => expansion.allowed.has(props.taskId))
+// other (compact) task cards — never let a neighbour render on top of the pipeline. Reads
+// the same predicate the pipeline itself renders on, so the two can't disagree.
+const expanded = computed(() => expansion.isExpanded(props.taskId))
 
 // Once a task is merged it stops being a unit of work and becomes part of the
 // architecture: it no longer renders as a draggable card (arrows fall back to its

package/app/components/board/nodes/TaskPipelineMini.vue

@@ -12,11 +12,11 @@ import { lodAtLeast } from '~/composables/useSemanticZoom'
 import { prReviewPhase } from '~/utils/prReviewProgress'
 import PrReviewPhaseBadge from '~/components/prReview/PrReviewPhaseBadge.vue'
 
-// Spatial drill-down inside a task card: at the `steps` zoom band the task's
-// build-pipeline steps appear, and one band deeper (`subtasks`) each step's live
-// todo breakdown expands — done / in-progress / pending — exactly the way a
-// zoomed-in bootstrap card reads. Renders nothing until the task has a run and
-// the user has zoomed in far enough, so it's safe to mount on every task card.
+// Drill-down inside a task card: the task's build-pipeline steps appear on hover (at any
+// zoom level) or once the `steps` zoom band is reached, and one band deeper (`subtasks`)
+// each step's live todo breakdown expands — done / in-progress / pending — exactly the way
+// a zoomed-in bootstrap card reads. Renders nothing until the task has a run and the card
+// is expanded, so it's safe to mount on every task card.
 const props = defineProps<{ taskId: string }>()
 
 const execution = useExecutionStore()
@@ -40,13 +40,10 @@ const runFailed = computed(() => instance.value?.status === 'failed')
 // (spinning "Running") rather than a frozen subtask list.
 const companionByStep = computed(() => steps.value.map((s) => gateCompanionFor(s, runFailed.value)))
 
-// Expand the pipeline list only when zoomed in far enough AND the board driver
-// permits this card — on-screen, and the centre-most of any cards that would
-// otherwise overlap (see useTaskExpansion) — so deep-zoom expansions don't pile up.
-const showSteps = computed(
-  () =>
-    lodAtLeast(lod.value, 'steps') && steps.value.length > 0 && expansion.canExpand(props.taskId),
-)
+// Expand the pipeline list when the board driver says so: this card is hovered (at any
+// zoom level), or the deep zoom bands granted it — on-screen, and the centre-most of any
+// cards that would otherwise overlap. See stores/taskExpansion.ts.
+const showSteps = computed(() => steps.value.length > 0 && expansion.isExpanded(props.taskId))
 const showItems = computed(() => lodAtLeast(lod.value, 'subtasks'))
 
 // Clicking a step opens the full agent step-detail overlay — execution metadata

package/app/components/docs/DocInterviewWindow.vue

@@ -19,7 +19,11 @@
 import { computed, reactive, watch } from 'vue'
 import InterviewGateNotice from '~/components/common/InterviewGateNotice.vue'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
-import { interviewGatePhase } from '~/utils/interviewGate'
+import {
+  DOC_INTERVIEWER_KIND,
+  interviewGatePhase,
+  interviewStepReached,
+} from '~/utils/interviewGate'
 
 const board = useBoardStore()
 const docInterview = useDocInterviewStore()
@@ -63,7 +67,13 @@ const resuming = computed(() => docInterview.resuming)
  * actually says, so the questions come back rather than the window sticking on a spinner.
  */
 const phase = computed(() =>
-  resuming.value ? 'working' : interviewGatePhase(session.value?.status, run.value?.status),
+  resuming.value
+    ? 'working'
+    : interviewGatePhase(
+        session.value?.status,
+        run.value?.status,
+        interviewStepReached(run.value, DOC_INTERVIEWER_KIND),
+      ),
 )
 /** The interview converged: the synthesized authoring brief is what the window shows. */
 const converged = computed(() => phase.value === 'converged')
@@ -133,10 +143,21 @@ const onProceed = () => flushThen((id) => docInterview.proceedInterview(id))
           {{ t('docInterview.intro') }}
         </p>
 
+        <!-- The run is still ahead of the interview (the researcher + outliner steps). Same
+             chrome, different claim: nothing has been asked yet, so the "working on your answers"
+             copy below would describe answers that do not exist. -->
+        <InterviewGateNotice
+          v-if="phase === 'preparing'"
+          variant="working"
+          :title="t('docInterview.preparing')"
+          :hint="t('docInterview.preparingHint')"
+          testid="doc-interview-preparing"
+        />
+
         <!-- A pass is running: the human is waiting on the interviewer. Without this the window is
              byte-identical to the parked state and the submit reads as a no-op. -->
         <InterviewGateNotice
-          v-if="phase === 'working'"
+          v-else-if="phase === 'working'"
           variant="working"
           :title="t('docInterview.working')"
           :hint="t('docInterview.workingHint')"

package/app/components/initiative/InitiativePlanningWindow.vue

@@ -4,8 +4,9 @@
 // (pending `qa` entries with an empty answer) are shown here; the human answers them, then either
 // SUBMITS them (the `continue` action: the interviewer re-runs and may ask follow-ups) or plans
 // now (the `proceed` action: skip the remaining questions — the interviewer converges and the run
-// advances to the analyst/planner). The labels say submit/plan-now rather than continue/proceed
-// because the latter pair both read as "go forward" and were indistinguishable in use.
+// advances to the planner; the analyst already ran, ahead of this gate). The labels say
+// submit/plan-now rather than continue/proceed because the latter pair both read as "go forward"
+// and were indistinguishable in use.
 // Opened via the universal result-view host: from the inspector / card
 // (`ui.openInitiativePlanning`) or as the interviewer step's result view. Live `initiative`
 // stream events patch the store, so an open window follows the interview as it progresses.
@@ -29,7 +30,11 @@ import {
   isPendingQuestion,
   orderInterviewQuestions,
 } from '~/utils/initiative'
-import { interviewGatePhase } from '~/utils/interviewGate'
+import {
+  INITIATIVE_INTERVIEWER_KIND,
+  interviewGatePhase,
+  interviewStepReached,
+} from '~/utils/interviewGate'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 import StepRunMeta from '~/components/panels/StepRunMeta.vue'
 
@@ -117,7 +122,11 @@ const resuming = computed(() => initiatives.resuming)
 const phase = computed(() =>
   resuming.value
     ? 'working'
-    : interviewGatePhase(initiative.value?.interview?.status, run.value?.status),
+    : interviewGatePhase(
+        initiative.value?.interview?.status,
+        run.value?.status,
+        interviewStepReached(run.value, INITIATIVE_INTERVIEWER_KIND),
+      ),
 )
 
 /**
@@ -229,10 +238,21 @@ async function onDiscard() {
             {{ t('initiative.planning.intro') }}
           </p>
 
+          <!-- The run is still ahead of the interview — the codebase analysis that grounds it. It
+               wears the working chrome but says something different on purpose: nothing has been
+               asked yet, so "working on your answers" would describe answers that do not exist. -->
+          <InterviewGateNotice
+            v-if="phase === 'preparing'"
+            variant="working"
+            :title="t('initiative.planning.preparing')"
+            :hint="t('initiative.planning.preparingHint')"
+            testid="initiative-planning-preparing"
+          />
+
           <!-- A pass is running: the human is waiting on the planner. Without this the window is
                byte-identical to the parked state and the submit reads as a no-op. -->
           <InterviewGateNotice
-            v-if="phase === 'working'"
+            v-else-if="phase === 'working'"
             variant="working"
             :title="t('initiative.planning.working')"
             :hint="t('initiative.planning.workingHint')"
@@ -316,8 +336,8 @@ async function onDiscard() {
     <!-- Action rail. The submit/plan-now pair shows only while the run is actually parked on the
          human: mid-pass they would re-submit a question set already in flight, and the resume is a
          no-op once it isn't. Discard is the opposite — it is offered for as long as a run owns the
-         block, because the phases where those two are hidden (working, failed) are exactly the ones
-         a wedged run sits in. -->
+         block, because the phases where those two are hidden (preparing, working, failed) are
+         exactly the ones a wedged run sits in. -->
     <footer
       v-if="initiative && (canDiscard || (phase === 'awaiting' && questions.length > 0))"
       class="flex items-center justify-between gap-3 border-t border-slate-800 px-5 py-3"

package/app/composables/useInitiativePlanning.ts

@@ -4,7 +4,11 @@ import { useExecutionStore } from '~/stores/execution'
 import { useInitiativesStore } from '~/stores/initiative'
 import { usePipelinesStore } from '~/stores/pipelines'
 import { useUiStore } from '~/stores/ui'
-import { interviewGatePhase } from '~/utils/interviewGate'
+import {
+  INITIATIVE_INTERVIEWER_KIND,
+  interviewGatePhase,
+  interviewStepReached,
+} from '~/utils/interviewGate'
 
 /**
  * Shared planning affordances for an `initiative`-level block, used by BOTH the board card
@@ -41,12 +45,14 @@ export function useInitiativePlanning(blockId: MaybeRefOrGetter<string>) {
    * The live interview phase, derived from the entity AND the planning run (see
    * {@link interviewGatePhase} for why the run status is load-bearing).
    */
-  const interviewPhase = computed(() =>
-    interviewGatePhase(
+  const interviewPhase = computed(() => {
+    const run = execution.getByBlock(toValue(blockId))
+    return interviewGatePhase(
       initiative.value?.interview?.status,
-      execution.getByBlock(toValue(blockId))?.status,
-    ),
-  )
+      run?.status,
+      interviewStepReached(run, INITIATIVE_INTERVIEWER_KIND),
+    )
+  })
 
   /**
    * The interviewer has PARKED the planning run for the human. NOT keyed on whether individual
@@ -62,8 +68,20 @@ export function useInitiativePlanning(blockId: MaybeRefOrGetter<string>) {
    */
   const awaitingAnswers = computed(() => interviewPhase.value === 'awaiting')
 
-  /** An interviewer pass is running — the human is waiting on the planner, not the reverse. */
-  const interviewing = computed(() => interviewPhase.value === 'working')
+  /**
+   * The planning run is mid-flight with nothing for the human to answer — either an interviewer
+   * pass is running (`working`) or the run has not reached the interview yet (`preparing`, the
+   * codebase analysis that now leads). BOTH phases, deliberately: this drives the card's and
+   * inspector's "Planning in progress" button, which is the only route into the planning window
+   * while a run owns the block. Narrowing it to `working` would drop that route for the whole of
+   * the analysis and fall through to a "Run planning" button for a run already running.
+   *
+   * The two phases are distinguished INSIDE the window, where there is room to say which is which;
+   * the affordance is the same either way.
+   */
+  const interviewing = computed(
+    () => interviewPhase.value === 'working' || interviewPhase.value === 'preparing',
+  )
 
   /**
    * Optimistic start flag: flip true the instant "Run planning" is clicked, before the stream

package/app/composables/useTaskExpansion.ts

@@ -15,22 +15,24 @@ function sameSet(a: Set<string>, b: Set<string>) {
 }
 
 /**
- * Board-level driver deciding which task cards may expand their full pipeline list
- * once zoomed in (the deep `steps`/`subtasks` bands). Two gates, recomputed every
- * frame against live DOM rects so they follow pan / zoom / drag / resize:
+ * Board-level driver deciding which task cards expand their full pipeline list.
+ * Recomputed every frame against live DOM rects so it follows pan / zoom / drag / resize,
+ * and writes two independent grants into the `taskExpansion` store (which combines them —
+ * see the store for how they resolve):
  *
- *  - visibility: a task expands only while its card overlaps the board viewport.
- *  - overlap: walking the visible candidates nearest-header-to-screen-centre first, a
- *    task expands only if its footprint doesn't collide with one already granted, so the
- *    card you're looking at wins an overlap and the rest stay compact.
- *  - hover: the task directly under the pointer is granted first, so hovering any card
- *    expands its pipeline regardless of its position on screen. "Under the pointer" is
- *    the TOPMOST card at the cursor (document.elementFromPoint), so hovering a region
+ *  - hover: the task directly under the pointer, at ANY zoom level. "Under the pointer"
+ *    is the TOPMOST card at the cursor (document.elementFromPoint), so hovering a region
  *    already covered by another open pipeline keeps that pipeline, not the card beneath.
+ *  - zoom: at the deep `steps`/`subtasks` bands, every on-screen card, minus overlaps —
+ *    two sub-gates:
+ *      - visibility: a task expands only while its card overlaps the board viewport.
+ *      - overlap: walking the visible candidates nearest-header-to-screen-centre first, a
+ *        task expands only if its footprint doesn't collide with one already granted, so
+ *        the card you're looking at wins an overlap and the rest stay compact. The hovered
+ *        card is granted first, so it wins every overlap it's part of.
  *
- * Writes the permitted id set into the `taskExpansion` store; `TaskPipelineMini` reads it.
- * Only tasks with a running pipeline (steps to show) are candidates — a task that
- * wouldn't expand never blocks a neighbour.
+ * Only tasks with a running pipeline (steps to show) are candidates for either grant — a
+ * task that wouldn't expand never blocks a neighbour and never lifts an empty card.
  */
 export function useTaskExpansion(container: Ref<HTMLElement | null>) {
   const board = useBoardStore()
@@ -65,14 +67,27 @@ export function useTaskExpansion(container: Ref<HTMLElement | null>) {
   // The task whose card is topmost at the pointer, or null. Using elementFromPoint (not a
   // rect test) means an open pipeline stacked above a neighbour wins the hit, so hovering
   // a region obscured by another pipeline doesn't switch to the card hidden beneath it.
+  //
+  // Blocks with no pipeline to show are filtered out here rather than left to the card:
+  // a frame, a module, or a task with no run expands to nothing, and granting it would
+  // still lift an empty card over its neighbours (see DraggableTask's z-index).
   function hoveredTaskId(): string | null {
     if (!pointer) return null
     const hit = document.elementFromPoint(pointer.x, pointer.y)
-    return hit?.closest('[data-block-id]')?.getAttribute('data-block-id') ?? null
+    const id = hit?.closest('[data-block-id]')?.getAttribute('data-block-id') ?? null
+    if (!id || !execution.getByBlock(id)?.steps.length) return null
+    return id
   }
 
   function recompute() {
-    // Task cards only expand at the deep zoom bands; clear everything otherwise.
+    // Hover expands a card at ANY zoom band, so the pointer hit is resolved BEFORE the
+    // zoom gate below — resolving it after would collapse the hovered card the moment the
+    // user zoomed back out past the `steps` band.
+    const hovered = hoveredTaskId()
+    if (store.hoveredId !== hovered) store.setHovered(hovered)
+
+    // The zoom-driven expansion (every on-screen card, overlap-resolved) is deep-band
+    // only; clear its grants otherwise. The hover grant above stands on its own.
     if (!lodAtLeast(ui.lod, 'steps')) {
       if (store.allowed.size) store.setAllowed(new Set())
       return
@@ -117,7 +132,6 @@ export function useTaskExpansion(container: Ref<HTMLElement | null>) {
     // clears every footprint already granted, so the centre-most card wins any overlap.
     // The hovered card is granted FIRST, so hovering a card expands it regardless of its
     // distance from the centre (and a centre-most neighbour it overlaps yields to it).
-    const hovered = hoveredTaskId()
     const claimed: Rect[] = []
     const next = new Set<string>()
     const hoveredCard = hovered ? candidates.find((c) => c.id === hovered) : undefined

package/app/modular/panels/inspector.logic.ts

@@ -76,7 +76,7 @@ const isTask = (b: Block) => b.level === 'task'
 const isFrame = (b: Block) => b.level === 'frame'
 /**
  * A block whose inspector carries a pipeline RUN. An initiative's planning pipeline is an
- * ordinary run of ordinary agent steps (interviewer → analyst → planner → committer), so it
+ * ordinary run of ordinary agent steps (analyst → interviewer → planner → committer), so it
  * gets the same execution panel a task does — step list, live phases, step-detail drill-down,
  * and the Stop / Discard-run controls that are the only way to unwedge a stalled planning run.
  * Before this it had no run surface at all, which is why a stuck plan was a dead end.

package/app/stores/taskExpansion.spec.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest'
+import { useTaskExpansionStore } from '~/stores/taskExpansion'
+import { useUiStore } from '~/stores/ui'
+
+/**
+ * The expansion gate combines two independent grants (hover at any zoom, the deep zoom
+ * bands otherwise). Both `TaskPipelineMini` (what renders) and `DraggableTask` (what
+ * stacks on top) read `isExpanded`, so these cases pin the rule they share.
+ *
+ * Zoom is set through the ui store's raw `zoom`, the same value the board canvas writes;
+ * `lod` derives from it (< 1.8 is shallower than the `steps` band).
+ */
+function setup(zoom: number) {
+  const ui = useUiStore()
+  ui.zoom = zoom
+  const store = useTaskExpansionStore()
+  store.setDriverActive(true)
+  return store
+}
+
+describe('taskExpansion — hover expands at any zoom level', () => {
+  it('expands the hovered card while zoomed out past the steps band', () => {
+    const store = setup(0.5) // `far`
+    store.setHovered('task-a')
+    expect(store.isExpanded('task-a')).toBe(true)
+    // Hover is a grant of ONE card: its neighbours stay compact at this zoom.
+    expect(store.isExpanded('task-b')).toBe(false)
+  })
+
+  it('expands the hovered card at every band, not just the shallow ones', () => {
+    const store = setup(1) // `mid`
+    store.setHovered('task-a')
+    expect(store.isExpanded('task-a')).toBe(true)
+    useUiStore().zoom = 1.5 // `close`
+    expect(store.isExpanded('task-a')).toBe(true)
+    useUiStore().zoom = 3 // `subtasks`
+    expect(store.isExpanded('task-a')).toBe(true)
+  })
+
+  it('collapses again once the pointer leaves the card', () => {
+    const store = setup(0.5)
+    store.setHovered('task-a')
+    store.setHovered(null)
+    expect(store.isExpanded('task-a')).toBe(false)
+  })
+
+  it('expands a hovered card the zoom gate denied for overlapping a neighbour', () => {
+    const store = setup(2) // `steps`
+    store.setAllowed(new Set(['task-b']))
+    store.setHovered('task-a')
+    expect(store.isExpanded('task-a')).toBe(true)
+    expect(store.isExpanded('task-b')).toBe(true)
+  })
+})
+
+describe('taskExpansion — the zoom grant is unchanged', () => {
+  it('honours the driver grant only from the steps band up', () => {
+    const store = setup(1.5) // `close` — one band shallower than `steps`
+    store.setAllowed(new Set(['task-a']))
+    expect(store.isExpanded('task-a')).toBe(false)
+    useUiStore().zoom = 2 // `steps`
+    expect(store.isExpanded('task-a')).toBe(true)
+  })
+
+  it('denies a card the driver left out of the permitted set', () => {
+    const store = setup(2)
+    store.setAllowed(new Set(['task-b']))
+    expect(store.isExpanded('task-a')).toBe(false)
+  })
+
+  it('falls back to allowed with no driver mounted, still only at the deep bands', () => {
+    const ui = useUiStore()
+    ui.zoom = 2
+    const store = useTaskExpansionStore() // driverActive stays false
+    expect(store.isExpanded('task-a')).toBe(true)
+    ui.zoom = 1
+    expect(store.isExpanded('task-a')).toBe(false)
+  })
+
+  it('drops both grants when the driver unmounts', () => {
+    const store = setup(2)
+    store.setAllowed(new Set(['task-a']))
+    store.setHovered('task-b')
+    store.setDriverActive(false)
+    expect(store.allowed.size).toBe(0)
+    expect(store.hoveredId).toBeNull()
+  })
+})

package/app/stores/taskExpansion.ts

@@ -1,37 +1,57 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
+import { lodAtLeast } from '~/composables/useSemanticZoom'
+import { useUiStore } from '~/stores/ui'
 
 /**
- * Which task cards may expand their full build-pipeline list once zoomed in.
+ * Which task cards render their full build-pipeline list.
  *
- * Deep-zoom (`steps`/`subtasks`) grows a task card downward, and cards are
- * absolutely positioned in their frame, so several expanded cards stacked
- * vertically pile on top of each other. The board driver (`useTaskExpansion`)
- * recomputes a permitted set every frame — only on-screen cards, the one closest to
- * the screen centre when two would overlap, plus whichever card the pointer is hovering
- * (hover expands a card regardless of position) — and writes it here.
- * `TaskPipelineMini` reads `canExpand` to decide whether to expand or stay compact.
+ * Two independent grants, both written every frame by the board driver
+ * (`useTaskExpansion`) and combined HERE so the render (`TaskPipelineMini`) and the
+ * stacking (`DraggableTask`) can never disagree about which cards are expanded:
  *
- * `driverActive` lets the gate degrade gracefully: with no board driver mounted
- * (e.g. a card rendered in isolation) `canExpand` falls back to "allowed", so the
- * plain zoom behaviour is unchanged.
+ *  - HOVER — the card under the pointer expands at ANY zoom level. Pointing at a task
+ *    is asking what it is doing right now, and that answer used to be reachable only
+ *    by first zooming past the `steps` band.
+ *  - ZOOM — past the `steps` band, every on-screen card expands. Deep-zoom grows a card
+ *    downward and cards are absolutely positioned in their frame, so several expanded
+ *    cards stacked vertically pile on top of each other; the driver denies whichever
+ *    would collide with a card nearer the screen centre and writes the survivors here.
+ *
+ * `driverActive` lets the zoom grant degrade gracefully: with no board driver mounted
+ * (e.g. a card rendered in isolation) it falls back to "allowed", so the plain zoom
+ * behaviour is unchanged. The hover grant needs no fallback — without the driver
+ * nothing is hovered.
  */
 export const useTaskExpansionStore = defineStore('taskExpansion', () => {
+  const ui = useUiStore()
   const allowed = ref<Set<string>>(new Set())
+  const hoveredId = ref<string | null>(null)
   const driverActive = ref(false)
 
   function setAllowed(ids: Set<string>) {
     allowed.value = ids
   }
 
+  function setHovered(id: string | null) {
+    hoveredId.value = id
+  }
+
   function setDriverActive(active: boolean) {
     driverActive.value = active
-    if (!active) allowed.value = new Set()
+    if (!active) {
+      allowed.value = new Set()
+      hoveredId.value = null
+    }
   }
 
-  function canExpand(id: string) {
+  /** Whether this task card should render its pipeline: hovered at any zoom, else
+   *  granted by the deep-zoom bands. */
+  function isExpanded(id: string) {
+    if (hoveredId.value === id) return true
+    if (!lodAtLeast(ui.lod, 'steps')) return false
     return driverActive.value ? allowed.value.has(id) : true
   }
 
-  return { allowed, driverActive, setAllowed, setDriverActive, canExpand }
+  return { allowed, hoveredId, driverActive, setAllowed, setHovered, setDriverActive, isExpanded }
 })

package/app/utils/catalog.ts

@@ -439,16 +439,17 @@ export const SYSTEM_AGENT_META: Record<string, AgentArchetype> = {
     description:
       'Provisions the ephemeral environment the tester and human-test gate run against (kubernetes / custom services); a no-op for docker-compose / infraless.',
   },
-  // The Initiative Planning pipeline's two steps. Only runnable on an initiative
+  // The Initiative Planning pipeline's steps. Only runnable on an initiative
   // block (pl_initiative — enforced by the engine), so they are display-metadata
-  // system kinds, never palette archetypes.
+  // system kinds, never palette archetypes. The analyst runs FIRST, ahead of the
+  // interviewer, so the interview covers only what the code cannot answer.
   'initiative-interviewer': {
     kind: 'initiative-interviewer',
     label: 'Initiative Interviewer',
     icon: 'i-lucide-messages-square',
     color: '#818cf8',
     description:
-      'Interviews you on the goals, scope and constraints of the initiative, then synthesizes the agreed brief the analyst and planner build on.',
+      'Interviews you on the goals, scope and constraints the codebase cannot answer, then synthesizes the agreed brief the planner builds on.',
     // Opens the dedicated planning Q&A window (answer / continue / proceed) while parked.
     resultView: 'initiative-planning',
   },
@@ -458,7 +459,7 @@ export const SYSTEM_AGENT_META: Record<string, AgentArchetype> = {
     icon: 'i-lucide-microscope',
     color: '#818cf8',
     description:
-      'Explores the codebase and writes an analysis (architecture, touch points, risks) that grounds the plan. Makes no changes.',
+      'Explores the codebase first and writes an analysis (architecture, touch points, risks) that grounds both the interview and the plan. Makes no changes.',
     resultView: 'initiative-tracker',
   },
   'initiative-planner': {

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

@@ -4294,9 +4294,11 @@
       "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 +4649,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",
@@ -5469,9 +5471,11 @@
       "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",
@@ -5304,9 +5306,11 @@
       "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",
@@ -5304,9 +5306,11 @@
       "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": "התשובה שלך",
@@ -5315,9 +5317,11 @@
       "intro": "המתכנן ממקד את היוזמה. ענה על שאלותיו כדי לעצב את המטרה והאילוצים, ואז שלח את התשובות. אפשר גם לבקש ממנו לתכנן עכשיו עם מה שכבר יש לו.",
       "empty": "לא נמצאה יוזמה עבור בלוק זה.",
       "converged": "אין שאלות ממתינות. למתכנן יש את מה שנדרש והוא מנסח את התוכנית.",
-      "idle": "התכנון עדיין לא התחיל. הרץ תכנון מהיוזמה כדי להתחיל את הראיון.",
+      "idle": "התכנון עדיין לא התחיל. הרץ תכנון מהיוזמה: תחילה הוא מנתח את בסיס הקוד ולאחר מכן מראיין אותך.",
       "working": "המתכנן מעבד את התשובות שלך",
       "workingHint": "זה לוקח רגע. שאלות המשך יופיעו כאן בסיום, או שהוא יתחיל לנסח את התוכנית אם יש לו מספיק מידע.",
+      "preparing": "בסיס הקוד נסרק לפני הראיון",
+      "preparingHint": "התכנון קורא תחילה את המאגר כדי שלא תישאל על מה שהקוד יכול לענות. השאלות יופיעו כאן בסיום.",
       "failed": "הרצת התכנון נעצרה",
       "failedHint": "היא הסתיימה לפני שהמתכנן הספיק להשיב. התשובות שלך נשמרו; הרץ תכנון מחדש מהיוזמה.",
       "answerPlaceholder": "התשובה שלך",

package/i18n/locales/it.json

@@ -4294,9 +4294,11 @@
       "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 +4649,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": "回答",
@@ -5316,9 +5318,11 @@
       "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ź",
@@ -5304,9 +5306,11 @@
       "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",

package/i18n/locales/tr.json

@@ -3582,6 +3582,8 @@
     "converged": "Bekleyen soru yok. Görüşmecinin ihtiyacı olan bilgi var ve belge taslağı hazırlanıyor.",
     "working": "Görüşmeci yanıtlarınızı işliyor",
     "workingHint": "Bu biraz sürer. Bittiğinde ek sorular burada görünür, yeterli bilgi varsa taslak hazırlanmaya başlar.",
+    "preparing": "Görüşmeden önce belge araştırılıyor",
+    "preparingHint": "Çalışma önce arka plan bilgisi toplar ve bir taslak plan çıkarır. Sorular bittiğinde burada görünür.",
     "failed": "Belge çalışması durdu",
     "failedHint": "Görüşmeci yanıt veremeden sona erdi. Yanıtlarınız kaydedildi; belge görevini yeniden çalıştırın.",
     "answerPlaceholder": "Yanıtınız",
@@ -5316,9 +5318,11 @@
       "intro": "Planlayici bu girisimi kapsamlandiriyor. Hedefi ve kisitlari sekillendirmek icin sorularini yanitlayin, ardindan yanitlari gonderin. Elindekiyle hemen planlamasini da isteyebilirsiniz.",
       "empty": "Bu blok icin girisim bulunamadi.",
       "converged": "Bekleyen soru yok. Planlayici ihtiyaci olani aldi ve plani hazirliyor.",
-      "idle": "Planlama henuz baslamadi. Gorusmeyi baslatmak icin girisimden planlamayi calistirin.",
+      "idle": "Planlama henuz baslamadi. Girisimden planlamayi calistirin: once kod tabanini analiz eder, sonra sizinle gorusur.",
       "working": "Planlayici yanitlarinizi isliyor",
       "workingHint": "Bu biraz surer. Bittiginde ek sorular burada gorunur, yeterli bilgi varsa plani hazirlamaya baslar.",
+      "preparing": "Gorusmeden once kod tabani inceleniyor",
+      "preparingHint": "Planlama once depoyu okur, boylece kodun yanitlayabilecegi seyler size sorulmaz. Sorular bittiginde burada gorunur.",
       "failed": "Planlama calismasi durdu",
       "failedHint": "Planlayici yanit veremeden sona erdi. Yanitlariniz kaydedildi; planlamayi girisimden yeniden calistirin.",
       "answerPlaceholder": "Yanitiniz",

package/i18n/locales/uk.json

@@ -3570,6 +3570,8 @@
     "converged": "Немає запитань, що очікують. Інтерв'юер має все необхідне, і документ у процесі написання.",
     "working": "Інтерв'юер опрацьовує ваші відповіді",
     "workingHint": "Це займе трохи часу. Додаткові запитання з'являться тут після завершення, або почнеться написання чернетки, якщо йому достатньо даних.",
+    "preparing": "Дослідження документа перед інтерв'ю",
+    "preparingHint": "Запуск спершу збирає матеріали та готує план. Запитання з'являться тут після завершення.",
     "failed": "Запуск документа зупинено",
     "failedHint": "Він завершився, перш ніж інтерв'юер встиг відповісти. Ваші відповіді збережено; запустіть завдання документа ще раз.",
     "answerPlaceholder": "Ваша відповідь",
@@ -5304,9 +5306,11 @@
       "intro": "Планувальник окреслює цю ініціативу. Дайте відповіді на його питання, щоб сформувати мету й обмеження, а потім надішліть їх. Також можна попросити його спланувати зараз із тим, що вже є.",
       "empty": "Для цього блоку ініціативу не знайдено.",
       "converged": "Немає питань, що очікують. Планувальник має все необхідне й готує план.",
-      "idle": "Планування ще не розпочато. Запустіть планування з ініціативи, щоб почати інтерв'ю.",
+      "idle": "Планування ще не розпочато. Запустіть планування з ініціативи: спершу воно аналізує кодову базу, а потім проводить інтерв'ю.",
       "working": "Планувальник опрацьовує ваші відповіді",
       "workingHint": "Це займе трохи часу. Додаткові питання з'являться тут після завершення, або планувальник почне готувати план, якщо йому достатньо даних.",
+      "preparing": "Аналіз кодової бази перед інтерв'ю",
+      "preparingHint": "Планування спершу читає репозиторій, щоб не питати вас про те, що може відповісти код. Питання з'являться тут після завершення.",
       "failed": "Запуск планування зупинено",
       "failedHint": "Він завершився, перш ніж планувальник встиг відповісти. Ваші відповіді збережено; запустіть планування з ініціативи ще раз.",
       "answerPlaceholder": "Ваша відповідь",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.181.0",
+  "version": "0.182.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",