@cat-factory/app 0.295.0 → 0.296.1

package/app/components/board/AgentFailureCard.vue

@@ -7,6 +7,7 @@
 import type { ConflictReason, EnvironmentFailureReason } from '@cat-factory/contracts'
 import type { AgentRunSummary } from '~/stores/agentRuns'
 import FailureDetail from '~/components/board/FailureDetail.vue'
+import BootstrapRunSteps from '~/components/bootstrap/BootstrapRunSteps.vue'
 
 const props = withDefaults(
   defineProps<{ run: AgentRunSummary; variant?: 'compact' | 'expanded' }>(),
@@ -92,9 +93,29 @@ const title = computed(() => {
     ? t('board.failure.bootstrapFailed')
     : t('board.failure.runFailed')
 })
-const retryLabel = computed(() =>
-  props.run.kind === 'bootstrap' ? t('board.failure.retryBootstrap') : t('board.failure.retryRun'),
+// A MULTI-STEP bootstrap (the monorepo flow) is not retried from the top: the service resumes
+// from the step the run reached, keeping the survey's paid-for reads and, past the review, the
+// decisions a human already gave. So the button says which step it re-enters at, from the SAME
+// rule the service branches on, rather than "retry", which invites the reviewer to expect to be
+// asked for their decisions again. A single-step run has nothing to resume and keeps "retry".
+const { resumeStep } = useBootstrapRunSteps(() =>
+  props.run.kind === 'bootstrap' ? props.run.runId : null,
 )
+const retryLabel = computed(() => {
+  if (props.run.kind !== 'bootstrap') return t('board.failure.retryRun')
+  const step = resumeStep.value
+  return step
+    ? t('board.failure.resumeBootstrap', { step: t(`bootstrap.steps.name.${step}`) })
+    : t('board.failure.retryBootstrap')
+})
+
+// The run's own observability panel. Offered here because a failed BOOTSTRAP has no step surface
+// to reach it from (a task run's steps each carry their own "Model activity" control), and what
+// a bootstrap failed on is exactly the question its model calls, provided context and tool-call
+// trajectory answer.
+function inspectRun() {
+  ui.openObservability(props.run.runId)
+}
 
 const retrying = ref(false)
 async function retry() {
@@ -159,6 +180,14 @@ async function retry() {
       }}
     </p>
 
+    <!-- Which of the run's steps it got to. Renders for a multi-step (monorepo) bootstrap only;
+         see BootstrapRunSteps. -->
+    <BootstrapRunSteps
+      v-if="!compact && run.kind === 'bootstrap'"
+      :run-id="run.runId"
+      class="mt-2"
+    />
+
     <FailureDetail
       v-if="!compact && failure"
       :detail="failure.detail"
@@ -184,6 +213,18 @@ async function retry() {
         {{ retrying ? t('board.failure.retrying') : compact ? t('common.retry') : retryLabel }}
       </button>
 
+      <button
+        v-if="run.kind === 'bootstrap'"
+        type="button"
+        class="nodrag flex items-center gap-1 rounded-md bg-rose-900/20 text-rose-300 hover:bg-rose-900/50"
+        :class="compact ? 'px-2 py-0.5 text-[10px]' : 'px-2 py-1 text-[11px]'"
+        data-testid="agent-failure-inspect"
+        @click.stop="inspectRun"
+      >
+        <UIcon name="i-lucide-activity" :class="compact ? 'h-3 w-3' : 'h-3.5 w-3.5'" />
+        {{ t('observability.modelActivity') }}
+      </button>
+
       <!-- Environment provisioning failures are almost always a deploy-backend / provider-config
            issue, so link straight to where it's set up rather than leaving the user to hunt. The
            destination + label follow the cause: a `deploy_runner_unwired` failure needs the runner

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

@@ -8,6 +8,7 @@ import ResizeGrips from './ResizeGrips.vue'
 import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentStopButton from '~/components/board/AgentStopButton.vue'
 import AdoptionReviewModal from '~/components/bootstrap/AdoptionReviewModal.vue'
+import BootstrapRunSteps from '~/components/bootstrap/BootstrapRunSteps.vue'
 import { useBlockDrag } from '~/composables/useBlockDrag'
 import { useFrameStacking } from '~/composables/useFrameStacking'
 import { useViewport } from '~/composables/useViewport'
@@ -346,7 +347,21 @@ const ITEM_ICON: Record<string, string> = {
             <span>{{ item.label }}</span>
           </li>
         </ul>
-        <div v-if="run" class="mt-2 flex justify-end">
+        <!-- Which of the run's own steps it is on. A monorepo bootstrap is three moves around a
+             human decision, and the bar above reports only the current container's todo list, so
+             without this the card cannot say whether the survey, the review or the write is what
+             is happening. Renders nothing for a one-step new-repo run. -->
+        <BootstrapRunSteps v-if="run" :run-id="run.runId" class="mt-2" />
+        <div v-if="run" class="mt-2 flex items-center justify-end gap-1.5">
+          <UButton
+            size="xs"
+            color="neutral"
+            variant="ghost"
+            icon="i-lucide-activity"
+            @click.stop="ui.openObservability(run.runId)"
+          >
+            {{ t('observability.modelActivity') }}
+          </UButton>
           <AgentStopButton :run-id="run.runId" :kind="run.kind" size="xs" variant="ghost" />
         </div>
       </div>
@@ -359,6 +374,7 @@ const ITEM_ICON: Record<string, string> = {
           <UIcon name="i-lucide-user-check" class="mt-0.5 h-4 w-4 shrink-0 text-amber-400" />
           <p class="text-xs text-amber-200/90">{{ t('bootstrap.adoption.cardPrompt') }}</p>
         </div>
+        <BootstrapRunSteps :run-id="awaitingReview.id" />
         <div class="flex justify-end">
           <UButton size="xs" color="warning" variant="subtle" @click.stop="reviewOpen = true">
             {{ t('bootstrap.adoption.cardAction') }}

package/app/components/bootstrap/BootstrapModal.logic.spec.ts

@@ -1,11 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import {
   defaultBootstrapDelivery,
+  referenceRefusalOf,
+  referenceRefusalSurvivesSave,
   serviceDirectoryLeaf,
   serviceDirectoryParent,
 } from '~/components/bootstrap/BootstrapModal.logic'
 
-// The rule these two pin is what makes the field browsable AND typable at once: the tree hands
+// The rule the first two pin is what makes the field browsable AND typable at once: the tree hands
 // back the folder it was standing in plus the leaf, so a name someone typed has to survive a
 // trip through the tree. Reading the leaf off the service name instead would silently discard it.
 
@@ -43,6 +45,79 @@ describe('serviceDirectoryParent', () => {
   })
 })
 
+// The refusal a launch can come back with. Both halves are read off ONE wire envelope and the
+// stakes are the same in either direction: a banner that is dropped while it is still true takes
+// away the only pointer to the broken entry, and one kept after it is fixed reads as a live error.
+describe('referenceRefusalOf', () => {
+  /** The envelope shape the contract client throws, as `apiErrorEnvelope` reads it. */
+  const failure = (details: Record<string, unknown>) => ({ body: { error: { details } } })
+
+  it('reads the reason and the two fields that name the offending entry', () => {
+    expect(
+      referenceRefusalOf(
+        failure({
+          reason: 'reference_repo_not_found',
+          referenceArchitectureId: 'ref_1',
+          repo: 'acme/service-template',
+        }),
+      ),
+    ).toEqual({
+      reason: 'reference_repo_not_found',
+      architectureId: 'ref_1',
+      repo: 'acme/service-template',
+    })
+  })
+
+  it('keeps the two reasons apart, since only one of them means the entry is wrong', () => {
+    expect(referenceRefusalOf(failure({ reason: 'reference_repo_unreadable' }))?.reason).toBe(
+      'reference_repo_unreadable',
+    )
+  })
+
+  it('is null for every other failure, so an unrelated error never shows this banner', () => {
+    expect(referenceRefusalOf(failure({ reason: 'github_not_connected' }))).toBeNull()
+    expect(referenceRefusalOf(failure({}))).toBeNull()
+    expect(referenceRefusalOf(new Error('network down'))).toBeNull()
+    expect(referenceRefusalOf(undefined)).toBeNull()
+  })
+
+  it('answers null for the ids rather than trusting whatever the field held', () => {
+    // The refusal drives a jump to one entry, so a non-string id must not reach the lookup as one.
+    expect(
+      referenceRefusalOf(
+        failure({ reason: 'reference_repo_not_found', referenceArchitectureId: 7, repo: null }),
+      ),
+    ).toEqual({ reason: 'reference_repo_not_found', architectureId: null, repo: null })
+  })
+})
+
+describe('referenceRefusalSurvivesSave', () => {
+  const refusal = {
+    reason: 'reference_repo_not_found',
+    architectureId: 'ref_1',
+    repo: 'acme/service-template',
+  } as const
+
+  it('is cleared by saving the entry it named: that entry no longer reads the way it did', () => {
+    expect(referenceRefusalSurvivesSave('ref_1', refusal)).toBe(false)
+  })
+
+  it('survives an edit to a DIFFERENT entry, which changed nothing about this claim', () => {
+    expect(referenceRefusalSurvivesSave('ref_2', refusal)).toBe(true)
+  })
+
+  it('survives CREATING an entry beside the refused one', () => {
+    // The case that lost the banner: adding an architecture while the refused one is still
+    // selected and still unreachable, so the next launch fails again with nothing pointing at it.
+    expect(referenceRefusalSurvivesSave(null, refusal)).toBe(true)
+    expect(referenceRefusalSurvivesSave(undefined, refusal)).toBe(true)
+  })
+
+  it('has nothing to survive when no refusal stands', () => {
+    expect(referenceRefusalSurvivesSave('ref_1', null)).toBe(false)
+  })
+})
+
 describe('defaultBootstrapDelivery', () => {
   it('reviews a monorepo and pushes a repository being created', () => {
     // The form has to SHOW the default it is about to send, and the two targets want opposite

package/app/components/bootstrap/BootstrapModal.logic.ts

@@ -1,12 +1,14 @@
+import type { BootstrapReferenceReason } from '@cat-factory/contracts'
+import { apiErrorEnvelope, apiErrorReason } from '~/composables/api/errors'
 import type { BootstrapDelivery } from '~/types/domain'
 import { repoPathSegments } from '~/utils/repoPath'
 
-// The pure half of the bootstrap launch form's monorepo service-directory field. That field
-// holds one string but carries two decisions: what the new directory is CALLED and WHERE in the
-// repo it sits. Browsing the repo tree answers only the second, so it rewrites the parent and
-// keeps the leaf, which means both halves have to be readable off the typed value on their own.
-// Extracted for the reason every `*.logic.ts` here is: a decision worth a test should not need a
-// mounted component to reach.
+// The pure half of the bootstrap launch form: the monorepo service-directory field, the delivery
+// default, and the refusal a launch can come back with. The directory field holds one string but
+// carries two decisions: what the new directory is CALLED and WHERE in the repo it sits. Browsing
+// the repo tree answers only the second, so it rewrites the parent and keeps the leaf, which means
+// both halves have to be readable off the typed value on their own. Extracted for the reason every
+// `*.logic.ts` here is: a decision worth a test should not need a mounted component to reach.
 
 /**
  * What the new directory is called: the last segment of the typed path.
@@ -42,3 +44,50 @@ export function serviceDirectoryParent(directory: string): string {
 export function defaultBootstrapDelivery(intoMonorepo: boolean): BootstrapDelivery {
   return intoMonorepo ? 'pull_request' : 'direct_push'
 }
+
+/** A launch the backend refused because of the reference architecture it named. */
+export interface ReferenceRefusal {
+  reason: BootstrapReferenceReason
+  /** The entry that named the repository, so the fix opens the right one of several. */
+  architectureId: string | null
+  /** `owner/name` as the entry spells it. */
+  repo: string | null
+}
+
+/**
+ * The refusal a failed launch carries, or null when it failed for anything else.
+ *
+ * The reason comes from the shared `apiErrorReason`, never a second hand-rolled read of the same
+ * wire field: that helper is what keeps a renamed code a typecheck failure here instead of a
+ * silent fall-through to the generic toast. The envelope is read directly only for the two extra
+ * fields this refusal carries, which no shared accessor knows about.
+ */
+export function referenceRefusalOf(error: unknown): ReferenceRefusal | null {
+  const reason = apiErrorReason(error)
+  if (reason !== 'reference_repo_not_found' && reason !== 'reference_repo_unreadable') return null
+  const details = (apiErrorEnvelope(error)?.details ?? {}) as Record<string, unknown>
+  return {
+    reason,
+    architectureId:
+      typeof details.referenceArchitectureId === 'string' ? details.referenceArchitectureId : null,
+    repo: typeof details.repo === 'string' ? details.repo : null,
+  }
+}
+
+/**
+ * Whether saving a reference architecture makes a standing refusal stale.
+ *
+ * Only the entry the refusal NAMED: that one has been rewritten, so the refusal no longer
+ * describes it, and whether the new value is reachable is the next launch's question. Every other
+ * save leaves it alone. Clearing on any save is the bug this answers: adding a second
+ * architecture, or editing an unrelated one, dropped the banner while the refused entry was still
+ * selected and still unreachable, taking away the one affordance pointing at the problem.
+ */
+export function referenceRefusalSurvivesSave(
+  /** The entry that was saved, or null/undefined when the save CREATED a new one. */
+  savedArchitectureId: string | null | undefined,
+  refusal: ReferenceRefusal | null,
+): boolean {
+  if (!refusal) return false
+  return !savedArchitectureId || savedArchitectureId !== refusal.architectureId
+}

package/app/components/bootstrap/BootstrapModal.vue

@@ -12,6 +12,9 @@ import type {
 } from '~/types/domain'
 import {
   defaultBootstrapDelivery,
+  type ReferenceRefusal,
+  referenceRefusalOf,
+  referenceRefusalSurvivesSave,
   serviceDirectoryLeaf,
   serviceDirectoryParent,
 } from '~/components/bootstrap/BootstrapModal.logic'
@@ -243,6 +246,49 @@ const selectedArch = computed(() =>
   bootstrap.architectures.find((a) => a.id === selectedArchId.value),
 )
 
+// ---- a launch refused for its reference architecture -----------------------
+// The backend pre-flights the template against the workspace's source-control connection BEFORE
+// it records anything, so this refusal costs the user nothing except a correction: the run does
+// not exist, the board has no card, and every other field of this form is still filled in. That
+// is what the alert is for. A toast would say the same words and then disappear, leaving the
+// person to work out which of the two repositories in this dialog was the problem. Reading it off
+// the wire, and deciding when a save makes it stale, are in `BootstrapModal.logic.ts`.
+const referenceRefusal = ref<ReferenceRefusal | null>(null)
+
+const referenceRefusalMessage = computed(() => {
+  const refusal = referenceRefusal.value
+  if (!refusal) return ''
+  const repo = refusal.repo ?? t('bootstrap.reference.refusal.unnamedRepo')
+  return refusal.reason === 'reference_repo_not_found'
+    ? t('bootstrap.reference.refusal.notFound', { repo })
+    : t('bootstrap.reference.refusal.unreadable', { repo })
+})
+
+/**
+ * Whether correcting the ENTRY is the fix. Only for `not_found`: an unreadable probe says nothing
+ * about the entry, so offering to edit it there would send someone to change a value that is
+ * very likely already right.
+ */
+const referenceRefusalIsFixable = computed(
+  () => referenceRefusal.value?.reason === 'reference_repo_not_found',
+)
+
+/** Open the refused entry's edit form, prefilled, leaving the launch form untouched. */
+function editRefusedArchitecture() {
+  const id = referenceRefusal.value?.architectureId
+  const arch = bootstrap.architectures.find((a) => a.id === id)
+  if (arch) startEdit(arch)
+}
+
+// A refusal is about ONE entry as it was, so picking a different reference architecture makes it
+// stale, and a stale error banner reads as a live one. Reopening the dialog clears it for the same
+// reason: the form deliberately keeps its fields across opens, but a refusal is not a field, it is
+// a claim about a check that has not been made again. Saving the refused entry clears it too
+// (`saveArch`), and saving any other one deliberately does not.
+watch([open, selectedArchId], () => {
+  referenceRefusal.value = null
+})
+
 const archOptions = computed(() =>
   bootstrap.architectures.map((a) => ({
     label: `${a.name} · ${a.repoOwner}/${a.repoName}`,
@@ -433,6 +479,10 @@ async function launch() {
       ui.closeBootstrap()
     }
   } catch (e) {
+    // A reference-architecture refusal is kept on the form as well as toasted: the run was never
+    // recorded, so what the user needs is the one field to change and everything else left alone,
+    // which a toast cannot hold still long enough to give them.
+    referenceRefusal.value = referenceRefusalOf(e)
     present(e, 'bootstrap.toast.bootstrapFailed')
   } finally {
     launching.value = false
@@ -513,8 +563,12 @@ async function saveArch() {
       description: archForm.value.description.trim(),
       defaultInstructions: archForm.value.defaultInstructions.trim(),
     }
-    if (archForm.value.id) await bootstrap.updateArchitecture(archForm.value.id, body)
+    const editedId = archForm.value.id
+    if (editedId) await bootstrap.updateArchitecture(editedId, body)
     else await bootstrap.createArchitecture(body)
+    if (!referenceRefusalSurvivesSave(editedId, referenceRefusal.value)) {
+      referenceRefusal.value = null
+    }
     showArchForm.value = false
     archForm.value = blankForm()
     archRepoSlug.value = undefined
@@ -706,6 +760,31 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
                 class="w-full"
               />
             </UFormField>
+
+            <!-- The launch was refused for the template, before anything was recorded. The
+                 remedy lives in this same dialog, so the alert carries the jump to it rather
+                 than describing where to go. -->
+            <UAlert
+              v-if="referenceRefusal"
+              color="error"
+              variant="subtle"
+              icon="i-lucide-triangle-alert"
+              :title="t('bootstrap.reference.refusal.title')"
+              :description="referenceRefusalMessage"
+              data-testid="bootstrap-reference-refusal"
+            >
+              <template v-if="referenceRefusalIsFixable" #actions>
+                <UButton
+                  color="error"
+                  variant="soft"
+                  size="xs"
+                  icon="i-lucide-pencil"
+                  @click="editRefusedArchitecture"
+                >
+                  {{ t('bootstrap.reference.refusal.edit') }}
+                </UButton>
+              </template>
+            </UAlert>
           </template>
 
           <UFormField

package/app/components/bootstrap/BootstrapRunSteps.vue

@@ -0,0 +1,50 @@
+<script setup lang="ts">
+// The steps a bootstrap run is made of, with the one it reached marked.
+//
+// A monorepo bootstrap is three moves around a human decision (survey → your adoption
+// decisions → write the service and open the PR), and it was rendered as a single
+// "bootstrapping…" bar. That bar cannot say which move a stopped run got to, so "retry" read
+// as "start the whole thing again" when what the platform actually does is resume from the
+// step reached, the survey's paid-for reads and the reviewer's settled decisions included.
+//
+// The steps and their states come from `@cat-factory/contracts`, which is also what
+// `BootstrapService.retry` branches on: the label on the button and the behaviour behind it
+// are one rule, not two. How a state RENDERS is `BOOTSTRAP_STEP_STYLE`, beside the vocabulary
+// it is keyed by.
+import type { BootstrapStepId, BootstrapStepState } from '@cat-factory/contracts'
+
+const props = defineProps<{ runId: string }>()
+
+const { t } = useI18n()
+// A ONE-step run renders nothing: a new-repo bootstrap is a single move, which the banner around
+// this already names, and a one-row checklist restating it is noise rather than information.
+const { steps: allSteps, multiStep } = useBootstrapRunSteps(() => props.runId)
+const steps = computed(() => (multiStep.value ? allSteps.value : []))
+
+function stepLabel(id: BootstrapStepId): string {
+  return t(`bootstrap.steps.name.${id}`)
+}
+function stateLabel(state: BootstrapStepState): string {
+  return t(`bootstrap.steps.state.${state}`)
+}
+</script>
+
+<template>
+  <ol v-if="steps.length" class="space-y-1" data-testid="bootstrap-run-steps">
+    <li
+      v-for="step in steps"
+      :key="step.id"
+      class="flex items-start gap-1.5 text-[11px]"
+      :data-step="step.id"
+      :data-state="step.state"
+    >
+      <UIcon
+        :name="BOOTSTRAP_STEP_STYLE[step.state].icon"
+        class="mt-px h-3 w-3 shrink-0"
+        :class="BOOTSTRAP_STEP_STYLE[step.state].iconClass"
+      />
+      <span :class="BOOTSTRAP_STEP_STYLE[step.state].labelClass">{{ stepLabel(step.id) }}</span>
+      <span class="ms-auto shrink-0 text-slate-500">{{ stateLabel(step.state) }}</span>
+    </li>
+  </ol>
+</template>

package/app/components/panels/InspectorPanel.vue

@@ -7,6 +7,7 @@ import { inspectorPanels } from '~/modular/panels/inspector.logic'
 import IconButton from '~/components/common/IconButton.vue'
 import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentStopButton from '~/components/board/AgentStopButton.vue'
+import BootstrapRunSteps from '~/components/bootstrap/BootstrapRunSteps.vue'
 import { BLUEPRINT_AGENT_KIND } from '@cat-factory/contracts'
 import { VCS_PROVIDER_ICONS } from '~/utils/vcs'
 
@@ -489,16 +490,33 @@ const showOriginalDescription = ref(false)
       <!-- failed run (bootstrap or execution): shared failure banner + retry -->
       <AgentFailureCard v-if="failedRun" :run="failedRun" />
 
-      <!-- running bootstrap: let the user stop it (kills the container) -->
+      <!-- running bootstrap: show the steps, let the user inspect it, let them stop it -->
       <div
         v-else-if="runningRun"
-        class="flex items-center justify-between gap-2 rounded-lg border border-amber-900/60 bg-amber-950/30 px-3 py-2"
+        class="space-y-2 rounded-lg border border-amber-900/60 bg-amber-950/30 px-3 py-2"
       >
-        <span class="flex items-center gap-1.5 text-xs text-amber-300">
-          <UIcon name="i-lucide-loader-circle" class="h-3.5 w-3.5 animate-spin" />
-          {{ t('panels.inspector.bootstrapping') }}
-        </span>
-        <AgentStopButton :run-id="runningRun.runId" :kind="runningRun.kind" size="xs" />
+        <div class="flex items-center justify-between gap-2">
+          <span class="flex items-center gap-1.5 text-xs text-amber-300">
+            <UIcon name="i-lucide-loader-circle" class="h-3.5 w-3.5 animate-spin" />
+            {{ t('panels.inspector.bootstrapping') }}
+          </span>
+          <div class="flex items-center gap-1.5">
+            <!-- A bootstrap has no step surface of its own, so this is where its run details are
+                 reached from: the same panel every task run opens, over the same four sinks. -->
+            <UButton
+              v-if="runningRun.kind === 'bootstrap'"
+              size="xs"
+              color="neutral"
+              variant="ghost"
+              icon="i-lucide-activity"
+              @click="ui.openObservability(runningRun.runId)"
+            >
+              {{ t('observability.modelActivity') }}
+            </UButton>
+            <AgentStopButton :run-id="runningRun.runId" :kind="runningRun.kind" size="xs" />
+          </div>
+        </div>
+        <BootstrapRunSteps v-if="runningRun.kind === 'bootstrap'" :run-id="runningRun.runId" />
       </div>
 
       <!-- external links -->

package/app/components/panels/ObservabilityPanel.vue

@@ -50,13 +50,30 @@ const EMPTY_TRAJECTORY: RunToolCallTrajectory = Object.freeze({
 const ui = useUiStore()
 const execution = useExecutionStore()
 const board = useBoardStore()
+const agentRuns = useAgentRunsStore()
 const observability = useObservabilityStore()
 const { t, d } = useI18n()
 
 const executionId = computed(() => ui.observabilityInstanceId)
 const open = computed(() => !!executionId.value)
 const instance = computed(() => execution.getInstance(executionId.value ?? undefined))
-const block = computed(() => (instance.value ? board.getBlock(instance.value.blockId) : undefined))
+// The panel is opened over an AGENT RUN, and a repo bootstrap is one: it has no execution row,
+// so everything below that reads `instance` answers nothing for it. Its own run supplies the two
+// things the panel states about a run rather than about its calls: whose work this was, and what
+// it failed on. The four telemetry reads need none of it: they are keyed by the run id alone.
+const bootstrap = computed(() => agentRuns.bootstrapById(executionId.value))
+const blockId = computed(() => instance.value?.blockId ?? bootstrap.value?.blockId ?? null)
+const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))
+/**
+ * The line under the title. An execution names its pipeline; a bootstrap names itself, because
+ * "which pipeline" has no answer for it and an empty subtitle on a panel opened from a service
+ * card reads as a panel that failed to load rather than as a run of a different kind.
+ */
+const runSubtitle = computed(() =>
+  instance.value ? instance.value.pipelineName : bootstrap.value ? t('bootstrap.runKind') : '',
+)
+/** The structured failure the pinned summary speaks from, whichever kind of run this is. */
+const runFailure = computed(() => instance.value?.failure ?? bootstrap.value?.failure ?? null)
 
 const calls = computed<LlmCallMetric[]>(() =>
   executionId.value ? observability.callsFor(executionId.value) : [],
@@ -201,7 +218,7 @@ const visibleCalls = computed(() => filterCallsByOutcome(calls.value, callFilter
  */
 const failureEvidence = computed(() =>
   deriveRunFailureEvidence({
-    failure: instance.value?.failure ?? null,
+    failure: runFailure.value,
     calls: calls.value,
     callsAnswer: sinkAnswer({
       loading: loading.value,
@@ -357,7 +374,19 @@ function sum(items: LlmCallMetric[], pick: (m: LlmCallMetric) => number): number
 
 // Where the run's tokens went, by PHASE. Unlike the totals above (derived from the capped call
 // list), this reads the engine's SQL rollup off the steps, so it stays honest on a long run.
-const phaseRows = computed(() => foldRunPhaseMetrics(instance.value?.steps ?? []))
+//
+// A run with NO execution row (a repo bootstrap) has no steps to fold one from, which is a
+// different fact from a run whose phases each spent nothing, and the difference matters here
+// more than anywhere: this rollup is also what prices the run, so left as an empty list it hides
+// both the table and the cost tile, and a bootstrap that made N model calls reads as one that
+// cost nothing. Stated as its own answer, and rendered as a note.
+const phaseRollup = computed<{ available: boolean; rows: ReturnType<typeof foldRunPhaseMetrics> }>(
+  () =>
+    instance.value
+      ? { available: true, rows: foldRunPhaseMetrics(instance.value.steps ?? []) }
+      : { available: false, rows: [] },
+)
+const phaseRows = computed(() => phaseRollup.value.rows)
 const phaseCarryTotal = computed(() =>
   phaseRows.value.reduce((acc, p) => acc + p.carryCostTokens, 0),
 )
@@ -391,6 +420,18 @@ const showCost = computed(
 const runCost = computed(() =>
   formatCost(sumCosts(phaseRows.value.map((p) => p.costEstimate)), costCurrency.value),
 )
+/**
+ * What the cost tile SAYS when it shows no figure. An unpriced phase and a run kind with no
+ * rollup to price from are different facts, and the tile is rendered for the second one rather
+ * than dropped: a missing tile is indistinguishable from a run that cost nothing.
+ */
+const costNoteKey = computed(() =>
+  !phaseRollup.value.available
+    ? 'observability.summary.costNoRollup'
+    : runCost.value
+      ? 'observability.summary.costHint'
+      : 'observability.summary.costIncomplete',
+)
 /** Share of the run's carry cost a phase accounts for (0..100), or null when nothing carried. */
 function carryShare(carryCostTokens: number): number | null {
   return phaseCarryTotal.value > 0 ? pct(carryCostTokens / phaseCarryTotal.value) : null
@@ -473,7 +514,7 @@ function exportJson() {
               {{ t('observability.modelActivity') }}
             </h1>
             <p v-if="block" class="truncate text-xs text-slate-500">
-              {{ block.title }} · {{ instance?.pipelineName }}
+              {{ block.title }} · {{ runSubtitle }}
             </p>
           </div>
           <div class="ms-auto flex items-center gap-1.5">
@@ -569,18 +610,14 @@ function exportJson() {
                   </dt>
                   <dd class="mt-0.5 tabular-nums text-slate-200">{{ totals.calls }}</dd>
                 </div>
-                <div v-if="showCost">
+                <div v-if="showCost || !phaseRollup.available">
                   <dt class="text-[11px] uppercase tracking-wide text-slate-500">
                     {{ t('observability.summary.cost') }}
                   </dt>
                   <dd class="mt-0.5 tabular-nums text-slate-200">
                     {{ runCost ?? '—' }}
                     <span class="mt-0.5 block text-[11px] text-slate-500">
-                      {{
-                        runCost
-                          ? t('observability.summary.costHint')
-                          : t('observability.summary.costIncomplete')
-                      }}
+                      {{ t(costNoteKey) }}
                     </span>
                   </dd>
                 </div>
@@ -683,18 +720,23 @@ function exportJson() {
             <!-- where the run's tokens went, by phase (the engine's SQL rollup, not the
                  capped call list) -->
             <section
-              v-if="phaseRows.length"
+              v-if="phaseRows.length || !phaseRollup.available"
               class="rounded-xl border border-slate-800 bg-slate-900/50 p-4"
             >
               <div class="flex items-baseline gap-2">
                 <h2 class="text-[11px] uppercase tracking-wide text-slate-500">
                   {{ t('observability.phase.title') }}
                 </h2>
-                <span class="text-[11px] text-slate-600">
+                <span v-if="phaseRollup.available" class="text-[11px] text-slate-600">
                   {{ t('observability.phase.subtitle') }}
                 </span>
               </div>
-              <div class="mt-3 overflow-x-auto">
+              <!-- No rollup to fold: said in words, because an absent table and a run that spent
+                   nothing look identical, and the calls listed above prove it spent something. -->
+              <p v-if="!phaseRollup.available" class="mt-2 text-[12px] text-slate-400">
+                {{ t('observability.phase.noRollup') }}
+              </p>
+              <div v-else class="mt-3 overflow-x-auto">
                 <table class="w-full min-w-[32rem] text-[12px]">
                   <thead>
                     <tr class="text-[11px] uppercase tracking-wide text-slate-500">
@@ -998,6 +1040,17 @@ function exportJson() {
               @show-failing-tools="revealFailingToolCalls"
               @retry="retryFailureEvidence"
             />
+            <!-- A monorepo bootstrap's SURVEY explores through the platform's own bounded reader,
+                 whose every read lands on the run's adoption transcript rather than here (that is
+                 the record a reviewer checks a recommendation against, and it outlives this
+                 window). Said out loud because the apply container's calls below are not empty,
+                 so the survey's absence would otherwise read as a phase that used no tools. -->
+            <p
+              v-if="bootstrap?.monorepo"
+              class="rounded-lg border border-dashed border-slate-800 px-3 py-2 text-[12px] text-slate-400"
+            >
+              {{ t('observability.toolCalls.surveyReadsElsewhere') }}
+            </p>
             <ToolCallList
               v-model:filter="toolFilter"
               :trajectory="trajectory"