@cat-factory/app 0.179.0 → 0.181.0

package/app/components/tasks/BugHuntModal.vue

@@ -10,6 +10,13 @@
 // unavailable or failed still shows its candidates (flagged as unassessed, since the scan is
 // useful on its own), and a scan that hit its cap says so — a silently shortened list reads
 // exactly like an exhaustive one.
+//
+// The tracker selector doubles as the "add a tracker" affordance (the same two-tier menu
+// `<ContextIssuePicker>` renders, off the shared `buildSourceChoices`): a hunt is a common
+// place to find out the tracker holding the bugs isn't connected here yet, and the answer
+// has to be a route to that tracker's own connect screen rather than "go find the
+// Integrations hub". The connect modal opens OVER the hunt, so nothing typed here is lost.
+import type { DropdownMenuItem } from '@nuxt/ui'
 import type { TaskSourceReadReason } from '@cat-factory/contracts'
 import type {
   BugHuntAnalysisStatus,
@@ -17,6 +24,7 @@ import type {
   BugHuntConfidence,
   TaskSourceKind,
 } from '~/types/domain'
+import { type SourceChoice, buildSourceChoices, reconcileSource } from '~/utils/taskSources'
 import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
 
 const { t, d, n } = useI18n()
@@ -54,8 +62,64 @@ const containerItems = computed(() =>
     })),
 )
 
-const sourceItems = computed(() =>
-  tasks.offeredSources.map((s) => ({ label: s.label, value: s.source })),
+const descriptor = computed(() => (source.value ? tasks.descriptorFor(source.value) : undefined))
+
+// Two-tier tracker menu: pick one the workspace already offers, or add one it doesn't.
+const sourceChoices = computed(() => buildSourceChoices(tasks.sources, source.value))
+const sourceMenu = computed<DropdownMenuItem[][]>(() =>
+  sourceChoices.value.map((group) =>
+    group.map((choice) =>
+      choice.action === 'select'
+        ? {
+            label: choice.label,
+            icon: choice.icon,
+            trailingIcon: choice.active ? 'i-lucide-check' : undefined,
+            onSelect: () => {
+              source.value = choice.source
+            },
+          }
+        : {
+            label: addLabel(choice),
+            icon: 'i-lucide-plug',
+            onSelect: () => addSource(choice.source),
+          },
+    ),
+  ),
+)
+
+/** The trackers that can be added — the empty state's buttons, where none is offered yet. */
+const addableSources = computed(() =>
+  sourceChoices.value.flat().filter((c) => c.action !== 'select'),
+)
+
+/**
+ * Wording for an addable tracker: `enable` is connected but toggled off for this workspace,
+ * so the user is never told to "connect" something they already connected.
+ */
+function addLabel(choice: SourceChoice): string {
+  return choice.action === 'enable'
+    ? t('bugHunt.enableSource', { label: choice.label })
+    : t('bugHunt.connectSource', { label: choice.label })
+}
+
+/**
+ * The tracker the user left to add, so it becomes the selection the moment it turns up
+ * offered (the connect modal re-probes on success and this hunt stays open underneath it).
+ * Also the reconcile trigger for a source that STOPS being offered — disconnected, or
+ * toggled off in settings while the hunt sat open.
+ */
+const awaitingConnect = ref<TaskSourceKind | null>(null)
+function addSource(s: TaskSourceKind) {
+  awaitingConnect.value = s
+  ui.openTaskConnect(s)
+}
+watch(
+  () => tasks.offeredSources.map((s) => s.source),
+  (offered) => {
+    const next = reconcileSource(offered, source.value, awaitingConnect.value)
+    if (next && next === awaitingConnect.value) awaitingConnect.value = null
+    if (next !== source.value) source.value = next
+  },
 )
 
 const boardItems = computed(() =>
@@ -100,6 +164,7 @@ watch(open, (isOpen) => {
   boardId.value = ''
   issueType.value = ''
   labels.value = ''
+  awaitingConnect.value = null
   source.value = ui.bugHunt?.source ?? tasks.offeredSources[0]?.source ?? undefined
   containerId.value = ui.bugHunt?.containerId ?? containerItems.value[0]?.value
   if (source.value) hunt.loadBoards(source.value)
@@ -193,16 +258,16 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
       <div v-if="!tasks.anyOffered" class="space-y-3 text-center">
         <UIcon name="i-lucide-plug" class="mx-auto h-8 w-8 text-slate-500" />
         <p class="text-sm text-slate-400">{{ t('bugHunt.connectFirst') }}</p>
-        <div class="flex justify-center gap-2">
+        <div class="flex flex-wrap justify-center gap-2">
           <UButton
-            v-for="s in tasks.sources"
-            :key="s.source"
+            v-for="choice in addableSources"
+            :key="choice.source"
             color="primary"
             variant="soft"
-            :icon="s.icon"
-            @click="ui.openTaskConnect(s.source)"
+            :icon="choice.icon"
+            @click="addSource(choice.source)"
           >
-            {{ t('bugHunt.connectSource', { label: s.label }) }}
+            {{ addLabel(choice) }}
           </UButton>
         </div>
       </div>
@@ -217,7 +282,24 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
 
         <div class="grid gap-3 sm:grid-cols-2">
           <UFormField :label="t('bugHunt.tracker')">
-            <USelect v-model="source" :items="sourceItems" class="w-full" />
+            <!-- The selector is also the way to ADD a tracker: each entry in the second group
+                 opens that tracker's own connect screen over this modal, so the hunt (and
+                 anything typed into it) is still here when the user comes back. -->
+            <UDropdownMenu
+              :items="sourceMenu"
+              :content="{ side: 'bottom', align: 'start' }"
+              class="w-full"
+            >
+              <UButton
+                color="neutral"
+                variant="soft"
+                :icon="descriptor?.icon"
+                trailing-icon="i-lucide-chevron-down"
+                class="w-full justify-between"
+              >
+                <span class="truncate">{{ descriptor?.label ?? t('bugHunt.pickTracker') }}</span>
+              </UButton>
+            </UDropdownMenu>
           </UFormField>
 
           <UFormField :label="t('bugHunt.board')">

package/app/components/tasks/ContextIssuePicker.vue

@@ -21,7 +21,7 @@ import type { TaskSourceReadReason } from '@cat-factory/contracts'
 import type { SourceTask, TaskSearchResult, TaskSourceKind } from '~/types/domain'
 import { apiErrorReason } from '~/composables/api/errors'
 import EmptyState from '~/components/common/EmptyState.vue'
-import { buildSourceChoices, reconcileSource } from '~/components/tasks/ContextIssuePicker.logic'
+import { buildSourceChoices, reconcileSource } from '~/utils/taskSources'
 
 const props = defineProps<{
   /** contextKeys already staged by the caller, so they're filtered out / not re-offered. */

package/app/components/tasks/TaskContextIssues.vue

@@ -1,6 +1,10 @@
 <script setup lang="ts">
-// Inspector section for a task block: the tracker issues (Jira, GitHub Issues, …)
-// attached to it as agent context. Attaching uses the SAME inline picker as task
+// Inspector section for a task OR initiative block: the tracker issues (Jira,
+// GitHub Issues, …) attached to it as agent context. An initiative takes the same
+// attachments (the create-initiative modal stages them exactly as the add-task one
+// does) and its whole planning pipeline reads them, so it gets the same section —
+// only the prose differs, which is why the hint/empty copy is level-keyed below.
+// Attaching uses the SAME inline picker as task
 // creation (source selector + in-repo search + paste-by-reference —
 // ContextIssuePicker), NOT the old dropdown that opened a second, page-level
 // "Import an issue…" modal on top of the inspector (stacked page-level modals
@@ -28,6 +32,20 @@ onMounted(() => {
 })
 
 const linked = computed(() => tasks.tasksForBlock(props.block.id))
+
+// Two STATIC literal keys per string, picked by level — the copy names what reads the issue
+// (the agents implementing a task vs the pipeline that plans an initiative), which is the
+// whole point of the hint. Assembling one key from `block.level` would defeat the typed
+// message-key check for a two-member choice that gains nothing from being dynamic.
+const isInitiative = computed(() => props.block.level === 'initiative')
+const hint = computed(() =>
+  isInitiative.value ? t('tasks.contextIssues.hintInitiative') : t('tasks.contextIssues.hint'),
+)
+const emptyHint = computed(() =>
+  isInitiative.value
+    ? t('tasks.contextIssues.emptyHintInitiative')
+    : t('tasks.contextIssues.emptyHint'),
+)
 // Already-linked issues, so the inline picker filters them out / never re-offers them.
 const chosenKeys = computed(() =>
   linked.value.map((issue) =>
@@ -71,7 +89,7 @@ async function attach(item: PendingContext) {
   <InspectorSection
     v-if="tasks.available"
     :title="t('tasks.contextIssues.title')"
-    :hint="t('tasks.contextIssues.hint')"
+    :hint="hint"
     :count="linked.length"
   >
     <template #actions>
@@ -133,7 +151,7 @@ async function attach(item: PendingContext) {
       </a>
     </div>
     <p v-else class="text-[11px] text-slate-500">
-      {{ t('tasks.contextIssues.emptyHint') }}
+      {{ emptyHint }}
     </p>
   </InspectorSection>
 </template>

package/app/composables/useResultViewRunMeta.spec.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+import type { PipelineStep } from '~/types/execution'
+import { resultViewStepIndex } from '~/composables/useResultViewRunMeta'
+
+// The off-path fallback: which step a result window reports run metadata for when it was opened
+// from a board card / the inspector rather than from the run's timeline. The precedence exists
+// because a window's kind set can mix model-running steps with bookkeeping ones — the initiative
+// tracker is registered for the analyst, the planner AND `initiative-committer`, which runs no
+// model — so "the most recent one" alone would anchor on the step with no telemetry.
+
+function step(agentKind: string, overrides: Partial<PipelineStep> = {}): PipelineStep {
+  return { agentKind, state: 'pending', ...overrides } as PipelineStep
+}
+
+/** A step that recorded model calls (the shape `attachStepMetrics` folds onto the run). */
+function metered(agentKind: string, calls: number, startedAt = 1_000): PipelineStep {
+  return step(agentKind, { startedAt, metrics: { calls } as PipelineStep['metrics'] })
+}
+
+describe('resultViewStepIndex', () => {
+  it('is null when no step declares the view', () => {
+    const steps = [step('coder'), step('tester')]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBeNull()
+  })
+
+  it('falls back to the first declaring step before the run reaches any of them', () => {
+    const steps = [
+      step('initiative-interviewer'),
+      step('initiative-analyst'),
+      step('initiative-planner'),
+    ]
+    // Index 1 — the analyst; the interviewer declares the PLANNING window, not the tracker.
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(1)
+  })
+
+  it('prefers the last started step while the run is mid-flight with no telemetry yet', () => {
+    const steps = [
+      step('initiative-interviewer', { startedAt: 10 }),
+      step('initiative-analyst', { startedAt: 20 }),
+      step('initiative-planner'),
+    ]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(1)
+  })
+
+  it('prefers the last step that actually ran a model over a later bookkeeping step', () => {
+    const steps = [
+      metered('initiative-interviewer', 4),
+      metered('initiative-analyst', 12),
+      metered('initiative-planner', 31),
+      // Runs no model, so it records no calls — and must not shadow the planner's telemetry.
+      step('initiative-committer', { startedAt: 2_000 }),
+    ]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(2)
+  })
+
+  it('ignores a metered step belonging to another window', () => {
+    const steps = [metered('initiative-interviewer', 9), step('initiative-analyst')]
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(1)
+    expect(resultViewStepIndex(steps, 'initiative-planning')).toBe(0)
+  })
+
+  it('treats a zero-call rollup as unmetered', () => {
+    const steps = [
+      metered('initiative-analyst', 5),
+      step('initiative-planner', {
+        startedAt: 3_000,
+        metrics: { calls: 0 } as PipelineStep['metrics'],
+      }),
+    ]
+    // The analyst keeps the tier-1 match: a rollup that recorded nothing is not telemetry, so
+    // the later step doesn't shadow it just for having a `metrics` object.
+    expect(resultViewStepIndex(steps, 'initiative-tracker')).toBe(0)
+  })
+})

package/app/composables/useResultViewRunMeta.ts

@@ -0,0 +1,98 @@
+import { computed } from 'vue'
+import type { ExecutionInstance, PipelineStep } from '~/types/execution'
+import { agentKindMeta } from '~/utils/catalog'
+
+/**
+ * Resolves the `StepRunMeta` prop bundle for a dedicated result window, for BOTH of the ways
+ * such a window opens (see `stores/ui/resultViews.ts`):
+ *
+ * - the PIPELINE path (`dispatchStepView`), which carries `instanceId` + `stepIndex` — the step
+ *   is exactly the one that was clicked, as every step-backed window already assumes; and
+ * - an OFF-PATH open (`ui.openInitiativeTracker`, `ui.openInitiativePlanning`, …), which carries
+ *   only a block id, because the human entered from the board card or the inspector rather than
+ *   from the run's timeline.
+ *
+ * Windows that are reachable BOTH ways used to fall back to no metadata at all on the second
+ * route, which is how the initiative windows ended up with no run details, no model and no token
+ * telemetry — on the entry point people actually use. The fallback resolves the block's live run
+ * and picks the step this window represents, so the two routes report the same facts.
+ */
+export function useResultViewRunMeta(
+  viewId: string,
+  source: {
+    blockId: () => string | null
+    instanceId: () => string | null
+    stepIndex: () => number | null
+  },
+) {
+  const execution = useExecutionStore()
+
+  /**
+   * The run the metadata describes: the dispatched one on the pipeline path, else the block's
+   * live run. Read reactively rather than resolved once at open time, so a window left open
+   * across a run start/advance follows it instead of freezing on whatever existed at mount.
+   */
+  const instance = computed<ExecutionInstance | null>(() => {
+    const id = source.instanceId()
+    if (id !== null) return execution.getInstance(id) ?? null
+    const blockId = source.blockId()
+    return blockId ? (execution.getByBlock(blockId) ?? null) : null
+  })
+
+  const stepNumber = computed<number | null>(() => {
+    const index = source.stepIndex()
+    if (index !== null) return index
+    return instance.value ? resultViewStepIndex(instance.value.steps, viewId) : null
+  })
+
+  const step = computed<PipelineStep | null>(() => {
+    const index = stepNumber.value
+    if (index === null) return null
+    return instance.value?.steps[index] ?? null
+  })
+
+  return {
+    instance,
+    step,
+    /** The run id, for the copyable field + the "View all calls" observability link. */
+    instanceId: computed(() => instance.value?.id),
+    /** 1-based position, as `StepRunMeta` renders it ("N of M"). */
+    position: computed(() => (stepNumber.value === null ? undefined : stepNumber.value + 1)),
+    totalSteps: computed(() => instance.value?.steps.length),
+    runFailed: computed(() => instance.value?.status === 'failed'),
+    failureAt: computed(() => instance.value?.failure?.occurredAt),
+  }
+}
+
+/**
+ * The step an off-path open should report, among the run's steps whose agent kind declares
+ * `viewId` as its dedicated result view (the same `resultView` seam `dispatchStepView` routes
+ * on, so the mapping can never drift from the window registry).
+ *
+ * Precedence, most to least specific:
+ *
+ * 1. the last step that has actually RUN A MODEL. A window's kind set can span both model-running
+ *    steps and bookkeeping ones — the initiative tracker is registered for the analyst and the
+ *    planner but also for `initiative-committer`, which runs no model — and anchoring on the last
+ *    STARTED step alone would hand a human who opened the window for its telemetry the one step
+ *    guaranteed to have none.
+ * 2. the last started step, so a run mid-flight (or one whose telemetry sink isn't wired) still
+ *    reports timing, model and run id rather than nothing.
+ * 3. the first declaring step, so a run that hasn't reached any of them yet still names which
+ *    step is coming and how far into the pipeline it sits.
+ *
+ * Null when the run declares none — the caller hides the sidebar rather than rendering an empty one.
+ */
+export function resultViewStepIndex(steps: readonly PipelineStep[], viewId: string): number | null {
+  let first: number | null = null
+  let lastStarted: number | null = null
+  let lastMetered: number | null = null
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i]
+    if (!step || agentKindMeta(step.agentKind).resultView !== viewId) continue
+    if (first === null) first = i
+    if (step.startedAt != null) lastStarted = i
+    if ((step.metrics?.calls ?? 0) > 0) lastMetered = i
+  }
+  return lastMetered ?? lastStarted ?? first
+}

package/app/docs/consumer-extensions.md

@@ -170,16 +170,17 @@ re-deriving the "which run is this / how did the model do" facts. **Composables*
 **components** must be named through the `#components` virtual module (see the boxed note
 below). Compose these:
 
-| Building block         | Reference it as                           | What it gives you                                                                                                                                                                                                                                                                                             |
-| ---------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ResultWindowShell`    | `#components` → `PanelsResultWindowShell` | The shared modal chrome for a result window — backdrop, header (icon/title/subtitle), a `#header-extras` slot, close button, and the modal _behaviour_ (focus-trap + return, body-scroll lock, shared-stack Escape via `useModalBehavior`). Pass `stepRef` to surface the shared "restart from here" control. |
-| `StepRunMeta`          | `#components` → `PanelsStepRunMeta`       | **The shared run-details metadata block** every agent window reuses: step position, live duration, model, run id, and the LLM model-activity rollup. Drop it into your window's sidebar — never reinvent run metadata.                                                                                        |
-| `MarkdownProse`        | `#components` → `CommonMarkdownProse`     | Render an agent's prose output as markdown.                                                                                                                                                                                                                                                                   |
-| `CopyButton`           | `#components` → `CommonCopyButton`        | The shared copy-to-clipboard affordance.                                                                                                                                                                                                                                                                      |
-| `InspectorSection`     | `#components` → `PanelsInspectorSection`  | The collapsible inspector-section shell (chevron header, count, hint) so a consumer panel reads like a built-in one.                                                                                                                                                                                          |
-| `useResultView(id)`    | auto-imported                             | The window seam contract: `{ open, blockId, instanceId, stepIndex, close }` (+ an `onOpen` loader for windows that fetch, and an `onClose` flush). Escape is owned by the shell, not here.                                                                                                                    |
-| `usePanelSubject<T>()` | `@modular-vue/core`                       | Read the block injected into an inspector panel by `<PanelsOutlet>`.                                                                                                                                                                                                                                          |
-| `useAppOverlays()`     | auto-imported                             | Open / close your own top-level overlays: `{ open(id, subject?), close(), active }`. The store-free seam a nav `run` closure uses to open an `appOverlays`-slot component (see "Top-level overlays").                                                                                                         |
+| Building block                | Reference it as                           | What it gives you                                                                                                                                                                                                                                                                                                                                                                                                |
+| ----------------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ResultWindowShell`           | `#components` → `PanelsResultWindowShell` | The shared modal chrome for a result window — backdrop, header (icon/title/subtitle), a `#header-extras` slot, close button, and the modal _behaviour_ (focus-trap + return, body-scroll lock, shared-stack Escape via `useModalBehavior`). Pass `stepRef` to surface the shared "restart from here" control.                                                                                                    |
+| `StepRunMeta`                 | `#components` → `PanelsStepRunMeta`       | **The shared run-details metadata block** every agent window reuses: step position, live duration, model, run id, and the LLM model-activity rollup. Drop it into your window's sidebar — never reinvent run metadata.                                                                                                                                                                                           |
+| `MarkdownProse`               | `#components` → `CommonMarkdownProse`     | Render an agent's prose output as markdown.                                                                                                                                                                                                                                                                                                                                                                      |
+| `CopyButton`                  | `#components` → `CommonCopyButton`        | The shared copy-to-clipboard affordance.                                                                                                                                                                                                                                                                                                                                                                         |
+| `InspectorSection`            | `#components` → `PanelsInspectorSection`  | The collapsible inspector-section shell (chevron header, count, hint) so a consumer panel reads like a built-in one.                                                                                                                                                                                                                                                                                             |
+| `useResultView(id)`           | auto-imported                             | The window seam contract: `{ open, blockId, instanceId, stepIndex, close }` (+ an `onOpen` loader for windows that fetch, and an `onClose` flush). Escape is owned by the shell, not here.                                                                                                                                                                                                                       |
+| `useResultViewRunMeta(id, …)` | auto-imported                             | The `StepRunMeta` prop bundle (`{ step, instanceId, position, totalSteps, runFailed, failureAt }`), resolved for BOTH ways a window opens. A window reachable off-path — from a board card or the inspector — carries no `stepIndex`, so wiring `StepRunMeta` straight off `useResultView` leaves it blank on exactly that route; this resolves the block's live run and the step your view id declares instead. |
+| `usePanelSubject<T>()`        | `@modular-vue/core`                       | Read the block injected into an inspector panel by `<PanelsOutlet>`.                                                                                                                                                                                                                                                                                                                                             |
+| `useAppOverlays()`            | auto-imported                             | Open / close your own top-level overlays: `{ open(id, subject?), close(), active }`. The store-free seam a nav `run` closure uses to open an `appOverlays`-slot component (see "Top-level overlays").                                                                                                                                                                                                            |
 
 > **Reference layer components through `#components`, not bare tags.** Nuxt auto-registers a
 > layer's components under a **path-derived** name (`components/panels/ResultWindowShell.vue`

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

@@ -98,11 +98,18 @@ describe('inspector panel group', () => {
     expect(visibleIds(block('epic'))).toEqual(['epic-children'])
   })
 
-  // An initiative's planning pipeline is an ordinary run, so it shares the task body's execution
-  // panel — its own inspector leading, the run detail under it. Pinned because the panel is the
-  // only surface carrying the Stop / Discard-run controls that unwedge a stalled planning run.
-  it('an initiative shows its inspector, then the shared execution panel', () => {
-    expect(visibleIds(block('initiative'))).toEqual(['initiative-inspector', 'task-execution'])
+  // An initiative shares two of the task body's panels: the CONTEXT sections (the
+  // create-initiative modal attaches the same documents/issues, and the planning pipeline reads
+  // them, so the inspector must surface them) and the execution panel (planning is an ordinary
+  // run — and that panel carries the only Stop / Discard-run controls that unwedge a stalled
+  // one). Order is pinned too: identity + controls, the context it was given, then the run.
+  it('an initiative shows its inspector, then the shared context + execution panels', () => {
+    expect(visibleIds(block('initiative'))).toEqual([
+      'initiative-inspector',
+      'task-context-docs',
+      'task-context-issues',
+      'task-execution',
+    ])
   })
 
   it('no subject selected resolves to no panels', () => {

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

@@ -82,6 +82,14 @@ const isFrame = (b: Block) => b.level === 'frame'
  * Before this it had no run surface at all, which is why a stuck plan was a dead end.
  */
 const hasRuns = (b: Block) => isTask(b) || b.level === 'initiative'
+/**
+ * A block that carries attached CONTEXT (imported documents + tracker issues). The
+ * create-initiative modal stages the same attachments the add-task modal does and links them
+ * to the initiative block, and the whole planning pipeline reads them — so an initiative
+ * whose inspector never showed them left the user with no evidence the attachment landed and
+ * no way to reach the source. Same panels, same store reads (both are keyed by block id only).
+ */
+const takesContext = (b: Block) => isTask(b) || b.level === 'initiative'
 /** frame OR module — the "container" panels. */
 const isContainer = (b: Block) => b.level === 'frame' || b.level === 'module'
 /**
@@ -111,8 +119,9 @@ const isDeployableFrame = (b: Block) => isFrame(b) && b.type !== 'document'
  * extensibility value.
  */
 export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
-  { id: 'task-context-docs', order: 10, when: isTask },
-  { id: 'task-context-issues', order: 20, when: isTask },
+  // Shared with the initiative body — an initiative takes the same attachments a task does.
+  { id: 'task-context-docs', order: 10, when: takesContext },
+  { id: 'task-context-issues', order: 20, when: takesContext },
   { id: 'recurring-schedule', order: 30, when: isTask },
   // Shared with the initiative body — the panel renders a RUN, and an initiative has one.
   { id: 'task-execution', order: 40, when: hasRuns },
@@ -133,8 +142,8 @@ export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
   // test-infra and release-health panels above it.
   { id: 'service-validation-checks', order: 180, when: isDeployableFrame },
   { id: 'epic-children', order: 200, when: (b) => b.level === 'epic' },
-  // Ordered BEFORE the shared execution panel (40) so an initiative reads the way a task does:
-  // its own identity + controls first, the run detail under them. Levels never overlap, so this
+  // Ordered FIRST so an initiative reads the way a task does: its own identity + controls, then
+  // the context it was given (10/20), then the run detail (40). Levels never overlap, so this
   // number only ever competes with the task ids the initiative body doesn't render.
-  { id: 'initiative-inspector', order: 35, when: (b) => b.level === 'initiative' },
+  { id: 'initiative-inspector', order: 5, when: (b) => b.level === 'initiative' },
 ]

package/app/utils/initiative.spec.ts

@@ -1,7 +1,7 @@
 import { INITIATIVE_ITEM_TERMINAL_STATUSES } from '@cat-factory/contracts'
 import { describe, it, expect } from 'vitest'
-import type { InitiativeItem, InitiativePhase } from '~/types/domain'
-import { pendingCheckpointPhase } from './initiative'
+import type { InitiativeItem, InitiativePhase, InitiativeQa } from '~/types/domain'
+import { isPendingQuestion, orderInterviewQuestions, pendingCheckpointPhase } from './initiative'
 
 // `pendingCheckpointPhase` mirrors the backend `pendingCheckpoint` (orchestration
 // `initiative.logic.ts`); these pin the same ordering/edge cases the loop pauses on, so the
@@ -71,3 +71,82 @@ describe('pendingCheckpointPhase', () => {
     expect(pendingCheckpointPhase(phases, [item('a', 'p1', status)])?.id).toBe('p1')
   })
 })
+
+// `isPendingQuestion` mirrors the backend rule of the same name (orchestration
+// `initiative.logic.ts`); `orderInterviewQuestions` is what the planning window renders by, so a
+// multi-round interview puts what the human still owes an answer above what they already settled.
+
+const qa = (over: Partial<InitiativeQa> & { id: string }): InitiativeQa => ({
+  question: over.id,
+  answer: '',
+  status: 'open',
+  ...over,
+})
+
+describe('isPendingQuestion', () => {
+  it('is pending while unanswered and not dismissed', () => {
+    expect(isPendingQuestion(qa({ id: 'a' }))).toBe(true)
+  })
+
+  it('is settled once answered', () => {
+    expect(isPendingQuestion(qa({ id: 'a', answer: 'yes' }))).toBe(false)
+  })
+
+  it('treats a whitespace-only answer as unanswered', () => {
+    expect(isPendingQuestion(qa({ id: 'a', answer: '   \n' }))).toBe(true)
+  })
+
+  it('is settled once dismissed, answered or not', () => {
+    expect(isPendingQuestion(qa({ id: 'a', status: 'dismissed' }))).toBe(false)
+  })
+
+  it('treats an absent answer/status (a hand-authored exchange) as pending', () => {
+    expect(isPendingQuestion({})).toBe(true)
+  })
+})
+
+describe('orderInterviewQuestions', () => {
+  const ids = (list: InitiativeQa[]) => orderInterviewQuestions(list).map((q) => q.id)
+
+  it('floats a later round of unanswered questions above the settled digest', () => {
+    // The shape the backend's `[...retainedQa, ...pending]` append produces on round two.
+    const list = [
+      qa({ id: 'r1-answered', answer: 'yes' }),
+      qa({ id: 'r1-dismissed', status: 'dismissed' }),
+      qa({ id: 'r2-a' }),
+      qa({ id: 'r2-b' }),
+    ]
+    expect(ids(list)).toEqual(['r2-a', 'r2-b', 'r1-answered', 'r1-dismissed'])
+  })
+
+  it('keeps chronological order within each group', () => {
+    const list = [
+      qa({ id: 'p1' }),
+      qa({ id: 's1', answer: 'yes' }),
+      qa({ id: 'p2' }),
+      qa({ id: 's2', status: 'dismissed' }),
+      qa({ id: 'p3' }),
+    ]
+    expect(ids(list)).toEqual(['p1', 'p2', 'p3', 's1', 's2'])
+  })
+
+  it('leaves a first round (all pending) exactly as the interviewer asked it', () => {
+    const list = [qa({ id: 'a' }), qa({ id: 'b' }), qa({ id: 'c' })]
+    expect(ids(list)).toEqual(['a', 'b', 'c'])
+  })
+
+  it('leaves a fully settled interview in its digest order', () => {
+    const list = [qa({ id: 'a', answer: 'x' }), qa({ id: 'b', status: 'dismissed' })]
+    expect(ids(list)).toEqual(['a', 'b'])
+  })
+
+  it('does not mutate the stored order (the interviewer prompt + tracker digest read it)', () => {
+    const list = [qa({ id: 'answered', answer: 'x' }), qa({ id: 'pending' })]
+    orderInterviewQuestions(list)
+    expect(list.map((q) => q.id)).toEqual(['answered', 'pending'])
+  })
+
+  it('handles an empty interview', () => {
+    expect(orderInterviewQuestions([])).toEqual([])
+  })
+})

package/app/utils/initiative.ts

@@ -6,6 +6,7 @@ import type {
   InitiativePhase,
   InitiativePresetDescriptor,
   InitiativePresetInputs,
+  InitiativeQa,
   InitiativeStatus,
 } from '~/types/domain'
 
@@ -111,6 +112,37 @@ export function initiativeProgress(
   }
 }
 
+/**
+ * Whether a planning-interview question still needs a human answer: not dismissed, and no answer
+ * yet. Mirrors the backend `isPendingQuestion` (orchestration `initiative.logic.ts`) — the rule the
+ * interviewer, the retained-across-rounds digest and the continue gate all key off — so the window's
+ * pending list, its unanswered counter and its render order can never disagree with the engine
+ * about what is still open.
+ */
+export function isPendingQuestion(q: Partial<Pick<InitiativeQa, 'answer' | 'status'>>): boolean {
+  return q.status !== 'dismissed' && (q.answer ?? '').trim().length === 0
+}
+
+/**
+ * Interview questions in the order the planning window renders them: everything still pending
+ * first, everything already settled (answered, or dismissed as not relevant) after, each group
+ * keeping the interviewer's own chronological order.
+ *
+ * Each round APPENDS its new questions after the digest retained from the previous ones (backend
+ * `applyInterviewQuestions`: `[...retainedQa, ...pending]`), so from round two onwards the only
+ * questions the human still has to act on sit below a growing wall of ones they already settled —
+ * on a long interview, below the fold entirely. This reorders the RENDER only; the stored `qa`
+ * order, which the interviewer prompt and the in-repo tracker digest read, is untouched.
+ */
+export function orderInterviewQuestions<T extends Partial<Pick<InitiativeQa, 'answer' | 'status'>>>(
+  qa: readonly T[],
+): T[] {
+  const pending: T[] = []
+  const settled: T[] = []
+  for (const q of qa) (isPendingQuestion(q) ? pending : settled).push(q)
+  return [...pending, ...settled]
+}
+
 /**
  * The phase whose completed checkpoint (D2) is awaiting a human, or null. Mirrors the backend
  * `pendingCheckpoint` (orchestration `initiative.logic.ts`) so the SPA recomputes the pending