@cat-factory/app 0.295.0 → 0.296.1

package/app/composables/useBootstrapRunSteps.spec.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import type { BootstrapJob } from '~/types/domain'
+import { useAgentRunsStore } from '~/stores/agentRuns'
+import { useBootstrapRunSteps } from '~/composables/useBootstrapRunSteps'
+
+// What this composable owns beyond the shared derivation (tested in `@cat-factory/contracts`):
+// the SPA-only question of whether a run has more than one step, which is what decides whether
+// the board renders a step list at all and whether the retry control offers to RESUME.
+
+const MONOREPO: BootstrapJob['monorepo'] = {
+  repoGithubId: 7,
+  directory: 'services/payments',
+  repoOwner: 'acme',
+  repoName: 'platform',
+  branch: null,
+}
+
+function job(id: string, over: Partial<BootstrapJob> = {}): BootstrapJob {
+  return {
+    id,
+    workspaceId: 'ws_test',
+    referenceArchitectureId: null,
+    referenceArchitectureName: null,
+    repoName: id,
+    repoOwner: null,
+    repoUrl: null,
+    instructions: '',
+    status: 'running',
+    blockId: `blk_${id}`,
+    subtasks: null,
+    error: null,
+    failure: null,
+    monorepo: null,
+    phase: null,
+    // The base fixture is a new-repo run, so it takes that target's default delivery. The step
+    // rule never reads the field, which is why no case below overrides it: how a run's work
+    // lands says nothing about how many moves it takes to get there.
+    delivery: 'direct_push',
+    adoptionPlan: null,
+    adoptionReview: null,
+    prUrl: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  }
+}
+
+/** A recorded plan; only its own status is read by the rule. */
+function plan(status: 'ready' | 'unavailable'): BootstrapJob['adoptionPlan'] {
+  return { status } as unknown as BootstrapJob['adoptionPlan']
+}
+
+describe('useBootstrapRunSteps', () => {
+  let store: ReturnType<typeof useAgentRunsStore>
+  beforeEach(() => {
+    store = useAgentRunsStore()
+  })
+
+  it('offers nothing for a new-repo run, which has one move and so nothing to resume', () => {
+    store.upsertBootstrap(job('b1', { status: 'failed' }))
+    const { multiStep, resumeStep } = useBootstrapRunSteps('b1')
+    expect(multiStep.value).toBe(false)
+    // Null rather than 'scaffold': there is progress to keep on a monorepo run and none here,
+    // so the card must keep saying "retry" instead of promising a resume it cannot make.
+    expect(resumeStep.value).toBeNull()
+  })
+
+  it('marks the survey done and the review as the step a broken monorepo run is holding', () => {
+    store.upsertBootstrap(
+      job('b2', {
+        monorepo: MONOREPO,
+        phase: 'survey',
+        status: 'failed',
+        failure: { kind: 'agent' } as unknown as BootstrapJob['failure'],
+        adoptionPlan: plan('ready'),
+      }),
+    )
+    const { steps, multiStep, resumeStep } = useBootstrapRunSteps('b2')
+    expect(multiStep.value).toBe(true)
+    expect(steps.value).toEqual([
+      { id: 'survey', state: 'done' },
+      { id: 'review', state: 'failed' },
+      { id: 'apply', state: 'pending' },
+    ])
+    expect(resumeStep.value).toBe('review')
+  })
+
+  it('renders a run the reviewer STOPPED as stopped, not as a broken review step', () => {
+    // A stop is stored as a `failed` status with a `cancelled` kind, and this is the shape the
+    // card actually renders: stopping a parked run must not report the reviewer's own decision
+    // step back to them as a fault. The resume it offers is unchanged.
+    store.upsertBootstrap(
+      job('b2s', {
+        monorepo: MONOREPO,
+        phase: 'survey',
+        status: 'failed',
+        failure: { kind: 'cancelled' } as unknown as BootstrapJob['failure'],
+        adoptionPlan: plan('ready'),
+      }),
+    )
+    const { steps, resumeStep } = useBootstrapRunSteps('b2s')
+    expect(steps.value.map((step) => step.state)).toEqual(['done', 'stopped', 'pending'])
+    expect(resumeStep.value).toBe('review')
+  })
+
+  it('follows the run as live events advance it, rather than pinning the first read', () => {
+    // The card is open while the run moves: the review is settled and the apply dispatches, and
+    // the step list has to follow the store rather than the value it was mounted with.
+    store.upsertBootstrap(job('b3', { monorepo: MONOREPO, phase: 'survey', updatedAt: 1 }))
+    const { steps, resumeStep } = useBootstrapRunSteps('b3')
+    expect(steps.value.map((s) => s.state)).toEqual(['running', 'pending', 'pending'])
+    store.upsertBootstrap(
+      job('b3', {
+        monorepo: MONOREPO,
+        phase: 'apply',
+        adoptionPlan: plan('ready'),
+        adoptionReview: { choices: [] } as unknown as BootstrapJob['adoptionReview'],
+        updatedAt: 2,
+      }),
+    )
+    expect(steps.value.map((s) => s.state)).toEqual(['done', 'done', 'running'])
+    expect(resumeStep.value).toBe('apply')
+  })
+
+  it('answers empty for a run the store does not hold', () => {
+    const { steps, multiStep, resumeStep } = useBootstrapRunSteps('nope')
+    expect(steps.value).toEqual([])
+    expect(multiStep.value).toBe(false)
+    expect(resumeStep.value).toBeNull()
+  })
+})

package/app/composables/useBootstrapRunSteps.ts

@@ -0,0 +1,37 @@
+import { computed, type ComputedRef, type MaybeRefOrGetter, toValue } from 'vue'
+import {
+  bootstrapResumeStep,
+  bootstrapRunSteps,
+  type BootstrapRunStep,
+  type BootstrapStepId,
+} from '@cat-factory/contracts'
+import { useAgentRunsStore } from '~/stores/agentRuns'
+
+/**
+ * A bootstrap run projected onto its steps, for the surfaces that render them and for the
+ * button that resumes one.
+ *
+ * The projection itself lives in `@cat-factory/contracts` and is shared with the backend, which
+ * BRANCHES on the same rule (`bootstrapResume`) in `BootstrapService.retry`; this side needs only
+ * the step it answers with, never the state it carries. What this composable adds is the
+ * one SPA-side question the backend never asks: whether the run has more than one step at all.
+ * A new-repo bootstrap is a single move, so for it a step list restates the banner it sits under
+ * and "resume from…" is a promise about progress there is none of: it simply starts again.
+ */
+export function useBootstrapRunSteps(runId: MaybeRefOrGetter<string | null | undefined>): {
+  /** The run's steps in order, with the reached one carrying the run's state. Empty if unknown. */
+  steps: ComputedRef<BootstrapRunStep[]>
+  /** Whether the run is a multi-step (monorepo) one: the gate every caller here needs. */
+  multiStep: ComputedRef<boolean>
+  /** The step a retry re-enters at, or null when the run is single-step or unknown. */
+  resumeStep: ComputedRef<BootstrapStepId | null>
+} {
+  const agentRuns = useAgentRunsStore()
+  const job = computed(() => agentRuns.bootstrapById(toValue(runId)))
+  const steps = computed<BootstrapRunStep[]>(() => (job.value ? bootstrapRunSteps(job.value) : []))
+  const multiStep = computed(() => steps.value.length > 1)
+  const resumeStep = computed<BootstrapStepId | null>(() =>
+    job.value && multiStep.value ? bootstrapResumeStep(job.value) : null,
+  )
+  return { steps, multiStep, resumeStep }
+}

package/app/composables/usePipelineErrorToast.spec.ts

@@ -5,6 +5,7 @@ import {
   describeGenericFailure,
 } from '~/composables/usePipelineErrorToast'
 import { ApiError } from '~/composables/api/errors'
+import { BOOTSTRAP_REFERENCE_REASONS, UNAVAILABLE_REASONS } from '@cat-factory/contracts'
 import en from '../../i18n/locales/en.json'
 
 /**
@@ -304,6 +305,23 @@ describe('describeGenericFailure', () => {
     ).toBe('errors.generic.description.unexpected')
   })
 
+  it('gives every reason with its own copy a key that ships, and lets it beat the status class', () => {
+    // Derived from the vocabularies the code reads rather than pinned to a count: a new reason is
+    // supposed to be an ordinary addition, and an expectation that fails on every one of them
+    // trains the next person to re-pin it unread. What is worth asserting is the property the
+    // exhaustive `Record` alone cannot make, that the key it maps to actually EXISTS in the
+    // catalog, and that a reason wins over the status class it is attached to. Both refusals here
+    // reach a person who can act on them, and the generic 503 wording ("this deployment has not
+    // configured the capability") would send them to configure something that is already wired.
+    for (const reason of [...UNAVAILABLE_REASONS, ...BOOTSTRAP_REFERENCE_REASONS]) {
+      const failure = describeGenericFailure(
+        new ApiError(503, { error: { code: 'unavailable', details: { reason } } }),
+      )
+      expect(failure.descriptionKey).not.toBe('errors.generic.description.unavailable')
+      expect(hasKey(failure.descriptionKey), `${reason} has no copy`).toBe(true)
+    }
+  })
+
   it('never presents a conflict (parseConflict owns those) but still classifies safely', () => {
     // `conflict` is deliberately absent from the map, so it reads as an unrecognised code rather
     // than throwing — the conflict path intercepts it long before this function is reached.

package/app/composables/usePipelineErrorToast.ts

@@ -28,7 +28,12 @@ import { createBespokeConflictToasts } from '~/composables/pipelineErrorToast/be
 // Imported by path rather than left to Nuxt's auto-import: this module is also loaded directly by
 // unit tests (and from store setup), where the auto-import globals are not installed.
 import { useCopyToClipboard } from '~/composables/useCopyToClipboard'
-import type { ApiErrorCode, ConflictReason, UnavailableReason } from '@cat-factory/contracts'
+import type {
+  ApiErrorCode,
+  BootstrapReferenceReason,
+  ConflictReason,
+  UnavailableReason,
+} from '@cat-factory/contracts'
 import { apiErrorEnvelope, apiErrorReason, apiErrorStatus } from './api/errors'
 
 /** The parsed shape of a backend conflict (`{ error: { code: 'conflict', details } }`). */
@@ -386,8 +391,16 @@ const GENERIC_DESCRIPTION_KEYS: Record<Exclude<ApiErrorCode, 'conflict'>, string
  * the reasons in {@link UNAVAILABLE_REASONS} carry their own copy, and the exhaustive `Record`
  * over that union is the drift guard: a new user-reachable 503 reason fails this typecheck until
  * it has wording.
+ *
+ * `BootstrapReferenceReason` joins it because the same argument reaches one 422: a bootstrap
+ * refused for its reference architecture is not "the request was malformed", it names a specific
+ * entry a specific person can go and fix. The launch dialog handles that one itself, since it can
+ * open the entry. This is what every OTHER caller of the funnel is told instead of the status
+ * class's generic wording, above all a retry driven from the run card.
  */
-const UNAVAILABLE_DESCRIPTION_KEYS: Record<UnavailableReason, string> = {
+const REASON_DESCRIPTION_KEYS: Record<UnavailableReason | BootstrapReferenceReason, string> = {
+  reference_repo_not_found: 'errors.reason.description.reference_repo_not_found',
+  reference_repo_unreadable: 'errors.reason.description.reference_repo_unreadable',
   binary_generators_unreachable: 'errors.unavailable.description.binary_generators_unreachable',
   foundational_builtins_unreachable:
     'errors.unavailable.description.foundational_builtins_unreachable',
@@ -445,7 +458,7 @@ export function describeGenericFailure(error: unknown): GenericFailure {
   // A REASON that has its own copy wins over the status class's, through the same widened-alias
   // read and for the same reason: a `reason` this build doesn't know must resolve to `undefined`
   // and fall through, never narrow the wire string to the union by casting.
-  const byReason: Readonly<Record<string, string | undefined>> = UNAVAILABLE_DESCRIPTION_KEYS
+  const byReason: Readonly<Record<string, string | undefined>> = REASON_DESCRIPTION_KEYS
   const reason = apiErrorReason(error)
   const mapped =
     (reason ? byReason[reason] : undefined) ?? (envelope?.code ? byCode[envelope.code] : undefined)

package/app/stores/agentRuns.ts

@@ -158,6 +158,18 @@ export const useAgentRunsStore = defineStore('agentRuns', () => {
     return map
   })
 
+  /**
+   * One bootstrap run by its RUN id.
+   *
+   * The counterpart to `execution.getInstance`, and it exists for the same surfaces: anything
+   * that holds a run id and needs the run WHOLE rather than the coarse {@link byBlock} summary:
+   * the observability panel's header, and the step list a card renders. A retry mints a NEW id,
+   * so unlike the block-keyed reads below this one needs nothing of the list's ordering.
+   */
+  function bootstrapById(runId: string | null | undefined): BootstrapJob | undefined {
+    return runId ? bootstrapJobs.value.find((job) => job.id === runId) : undefined
+  }
+
   /**
    * The parked monorepo bootstrap for a block, when it is waiting on an adoption review.
    *
@@ -221,6 +233,7 @@ export const useAgentRunsStore = defineStore('agentRuns', () => {
 
   return {
     bootstrapJobs,
+    bootstrapById,
     awaitingReview,
     submitAdoptionReview,
     hydrate,

package/app/utils/bootstrapSteps.ts

@@ -0,0 +1,60 @@
+import type { BootstrapStepState } from '@cat-factory/contracts'
+
+// Display metadata for a bootstrap run's step states, the `catalog.ts` idea at the scale of one
+// vocabulary: the icon and the two tones that render a state, in ONE record rather than three
+// parallel ones keyed alike. Three had to be kept in step by hand, which is a silent way to give
+// a newly added state (`stopped`, say) a red icon and calm text.
+//
+// Module scope rather than a component's `<script setup>`, where a top-level const is rebuilt for
+// every instance: the step list renders on every in-progress, parked and failed bootstrap card on
+// the board, plus the inspector and the failure card.
+
+/** How one step state renders: its icon, the icon's tone, and the label's. */
+export interface BootstrapStepStyle {
+  icon: string
+  iconClass: string
+  labelClass: string
+}
+
+/**
+ * The style per state. `stopped` is deliberately NOT the failure red: a run someone stopped is
+ * stored as a failure without being one, and the step they stopped in is usually the review,
+ * whose only actor is the reviewer themselves.
+ */
+export const BOOTSTRAP_STEP_STYLE: Record<BootstrapStepState, BootstrapStepStyle> = {
+  pending: {
+    icon: 'i-lucide-circle',
+    iconClass: 'text-slate-500',
+    labelClass: 'text-slate-500',
+  },
+  running: {
+    icon: 'i-lucide-loader-circle',
+    iconClass: 'animate-spin text-amber-400',
+    labelClass: 'text-amber-100',
+  },
+  awaiting_review: {
+    icon: 'i-lucide-user-check',
+    iconClass: 'text-amber-400',
+    labelClass: 'text-amber-100',
+  },
+  done: {
+    icon: 'i-lucide-check-circle-2',
+    iconClass: 'text-emerald-400',
+    labelClass: 'text-slate-400',
+  },
+  failed: {
+    icon: 'i-lucide-alert-triangle',
+    iconClass: 'text-rose-400',
+    labelClass: 'text-rose-200',
+  },
+  stopped: {
+    icon: 'i-lucide-circle-stop',
+    iconClass: 'text-slate-400',
+    labelClass: 'text-slate-300',
+  },
+  unknown: {
+    icon: 'i-lucide-help-circle',
+    iconClass: 'text-slate-400',
+    labelClass: 'text-slate-400',
+  },
+}

package/app/utils/catalog.spec.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect } from 'vitest'
-import { PIPELINE_PURPOSES, purposeAllowsAgentCategory } from '@cat-factory/contracts'
+import {
+  MONOREPO_ADOPTION_AGENT_KIND,
+  PIPELINE_PURPOSES,
+  purposeAllowsAgentCategory,
+  REPO_BOOTSTRAP_AGENT_KIND,
+} from '@cat-factory/contracts'
 import type { AgentKind, BlockStatus, BlockType } from '~/types/domain'
 import { narrowAgentPalette } from '~/utils/agentPalette'
 import {
@@ -78,6 +83,17 @@ describe('catalog', () => {
     }
   })
 
+  it('names the kinds a bootstrap run files its telemetry under', () => {
+    // The backend stamps these two on a bootstrap run's metric, snapshot and tool-call rows, and
+    // the observability panel groups by kind. Unnamed here they roll up under the generic "Agent"
+    // fallback: the survey's model calls and the apply container's under one unlabelled heading,
+    // on the one panel whose job is telling them apart. Asserted through the same constants the
+    // backend imports, so this cannot pass against a stale spelling.
+    for (const kind of [REPO_BOOTSTRAP_AGENT_KIND, MONOREPO_ADOPTION_AGENT_KIND]) {
+      expect(agentKindMeta(kind).label, `${kind} falls back to the unnamed agent`).not.toBe('Agent')
+    }
+  })
+
   it('classifies every built-in kind into a tier', () => {
     // The palette / model-preset surfaces open on `basic`, so a built-in that forgot its tier
     // would silently fall to the DEFAULT (intermediate) and vanish from the default view for

package/app/utils/catalog.ts

@@ -8,7 +8,11 @@ import type {
   TaskTypeMeta,
 } from '~/types/domain'
 import type { BadgeColor } from '~/utils/badge'
-import { isBuiltinGatableKind } from '@cat-factory/contracts'
+import {
+  isBuiltinGatableKind,
+  MONOREPO_ADOPTION_AGENT_KIND,
+  REPO_BOOTSTRAP_AGENT_KIND,
+} from '@cat-factory/contracts'
 
 /** Simple unique id helper (fine for a client-only prototype). */
 export function uid(prefix = 'id'): string {
@@ -636,6 +640,33 @@ export const SYSTEM_AGENT_META: Record<string, AgentArchetype> = {
       'Re-examines a single challenged PR-review finding against the full source, then upholds ' +
       '(strengthening it) or retracts it with a justification. Configurable separately from the reviewer.',
   },
+  // The two agent kinds a REPO BOOTSTRAP run files its telemetry under. Neither is placeable
+  // and neither is a model-routing key (the bootstrapper runs on the `architect` routing, the
+  // advisor on the workspace default): they are here so the observability panel a bootstrap run
+  // opens names what actually ran. Without them both roll up as the generic "Agent" fallback,
+  // which puts the survey's model calls and the apply container's under one unnamed heading on
+  // the one panel whose job is telling them apart.
+  //
+  // Keyed off the contracts constants the BACKEND stamps on those rows, never a second spelling:
+  // a rename that missed one side would fall back to the unnamed heading with nothing failing.
+  [REPO_BOOTSTRAP_AGENT_KIND]: {
+    kind: REPO_BOOTSTRAP_AGENT_KIND,
+    tier: 'advanced',
+    label: 'Repo Bootstrapper',
+    icon: 'i-lucide-package-plus',
+    color: '#f59e0b',
+    description:
+      'Scaffolds a new repository from a reference architecture, or writes a new service into a monorepo and opens the pull request.',
+  },
+  [MONOREPO_ADOPTION_AGENT_KIND]: {
+    kind: MONOREPO_ADOPTION_AGENT_KIND,
+    tier: 'advanced',
+    label: 'Adoption Advisor',
+    icon: 'i-lucide-scale',
+    color: '#f59e0b',
+    description:
+      'Reads a monorepo and the reference template and proposes what a new service should adopt from each. Its suggestion is the one a human settles before anything is written.',
+  },
   // 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. The analyst runs FIRST, ahead of the

package/i18n/locales/de.json

@@ -3195,7 +3195,8 @@
       "retrying": "Wird wiederholt…",
       "history": {
         "previousErrors": "{count} vorheriger Fehler | {count} vorherige Fehler"
-      }
+      },
+      "resumeBootstrap": "Fortsetzen ab: {step}"
     },
     "stop": {
       "label": "Stoppen",
@@ -3814,7 +3815,8 @@
       "cacheRead": "{tokens} aus dem Cache gelesen",
       "cacheReadHint": "Eingabe-Tokens, die aus dem Cache des Providers bedient wurden (etwa 0,1x der Preis frischer Eingabe-Tokens)",
       "cacheWrite": "{tokens} in den Cache geschrieben",
-      "cacheWriteHint": "Eingabe-Tokens, die in den Cache des Providers geschrieben wurden (1,25x bis 2x der Preis frischer Eingabe-Tokens)"
+      "cacheWriteHint": "Eingabe-Tokens, die in den Cache des Providers geschrieben wurden (1,25x bis 2x der Preis frischer Eingabe-Tokens)",
+      "costNoRollup": "Nicht bepreist: Die Schätzung wird aus der Aufstellung pro Schritt gebildet, und dieser Lauf hat keine. Was seine Aufrufe verbraucht haben, steht unten."
     },
     "phase": {
       "title": "Wohin die Tokens geflossen sind",
@@ -3829,7 +3831,8 @@
       "costHint": "Geschätzte Kosten der Token dieser Phase zu Listenpreisen. Ein Strich bedeutet, dass diese Installation keinen Satz für das ausgeführte Modell kennt.",
       "carryCostHint": "Wie stark jede Phase die nachfolgenden Runden belastet hat: ihr Kontext einmal für jede spätere Runde gezählt, die ihn erneut senden musste. Vergleichen Sie die Phasen eines Laufs miteinander; für sich allein sagt die Zahl nichts aus. Eine spät laufende Phase schleppt wenig mit, wie viel sie auch verbraucht hat; lesen Sie diese Spalte daher zusammen mit den Tokens daneben.",
       "unattributed": "Nicht zugeordnet",
-      "unattributedHint": "von einem Kanal erfasst, der keine Phase meldet"
+      "unattributedHint": "von einem Kanal erfasst, der keine Phase meldet",
+      "noRollup": "Dieser Lauf hat keine Pipeline-Schritte, daher gibt es keine Aufstellung nach Phasen: Seine Modellaufrufe sind unten erfasst, aber nichts gruppiert oder bepreist sie."
     },
     "metricsBar": {
       "calls": "{count} Aufruf | {count} Aufrufe",
@@ -3937,7 +3940,8 @@
       "result": "Ergebnis",
       "dropped": "{chars} Zeichen bei der Erfassung verworfen",
       "truncated": "Es werden die ersten {shown} Aufrufe dieses Laufs angezeigt. Die Zahlen oben gelten für den gesamten Lauf; filtere auf die Fehlschläge, um alle zu sehen.",
-      "failuresTruncated": "Es werden die ersten {shown} fehlgeschlagenen Aufrufe angezeigt. Die Zahl oben gilt für den gesamten Lauf."
+      "failuresTruncated": "Es werden die ersten {shown} fehlgeschlagenen Aufrufe angezeigt. Die Zahl oben gilt für den gesamten Lauf.",
+      "surveyReadsElsewhere": "Die Lesevorgänge der Erhebung stehen nicht hier: Sie erkundet über den begrenzten Leser der Plattform, und jeder Lesevorgang ist im Übernahmeprotokoll des Laufs erfasst. Unten stehen die Tool-Aufrufe des Containers, der den Service geschrieben hat."
     }
   },
   "platformObservability": {
@@ -5046,7 +5050,14 @@
       "label": "Referenzarchitektur",
       "description": "Das verwaltete Basis-Repo zum Klonen und Anpassen.",
       "empty": "Noch keine Referenzarchitekturen. Fügen Sie unten eine hinzu oder wechseln Sie zu 'Von Grund auf'.",
-      "placeholder": "Referenzarchitektur wählen"
+      "placeholder": "Referenzarchitektur wählen",
+      "refusal": {
+        "title": "Diese Referenzarchitektur konnte nicht verwendet werden",
+        "notFound": "{repo} ist über die Quellcodeverwaltungs-Verbindung dieses Workspace nicht sichtbar. Entweder nennt dieser Eintrag das falsche Repository, oder die Verbindung hat keinen Zugriff darauf. Es wurde nichts angelegt: Korrigieren Sie den Eintrag und starten Sie erneut, alles andere in diesem Formular bleibt erhalten.",
+        "unreadable": "{repo} konnte gerade nicht gelesen werden, deshalb wurde nichts angelegt. Es ist nichts falsch konfiguriert: Starten Sie erneut, sobald die Verbindung wieder steht, alles andere in diesem Formular bleibt erhalten.",
+        "unnamedRepo": "Das Repository der Referenzarchitektur",
+        "edit": "Diese Referenzarchitektur bearbeiten"
+      }
     },
     "targetRepo": {
       "label": "Name des Ziel-Repositorys",
@@ -5250,7 +5261,26 @@
         "approvedDesc": "Der Agent schreibt jetzt {directory} und öffnet einen Pull Request.",
         "failed": "Prüfung konnte nicht abgeschickt werden"
       }
-    }
+    },
+    "steps": {
+      "title": "Bootstrap-Schritte",
+      "name": {
+        "scaffold": "Repository aufsetzen",
+        "survey": "Monorepo und Vorlage untersuchen",
+        "review": "Deine Übernahme-Entscheidungen",
+        "apply": "Service schreiben und Pull Request öffnen"
+      },
+      "state": {
+        "pending": "Nicht begonnen",
+        "running": "Läuft",
+        "awaiting_review": "Wartet auf dich",
+        "done": "Fertig",
+        "failed": "Fehlgeschlagen",
+        "stopped": "Gestoppt",
+        "unknown": "Status nicht lesbar"
+      }
+    },
+    "runKind": "Repository-Bootstrap"
   },
   "fragments": {
     "panel": {
@@ -6082,6 +6112,12 @@
         "service_catalog_response_too_large": "Das Entwicklerportal hat mit mehr Daten geantwortet, als diese Plattform in einer Antwort aufnimmt. Öffne die Servicekatalog-Einstellungen und senke das Service-Limit oder deaktiviere den Import von Schnittstellendefinitionen, und importiere dann erneut."
       }
     },
+    "reason": {
+      "description": {
+        "reference_repo_not_found": "Das Repository hinter der Referenzarchitektur dieses Laufs ist über die Quellcodeverwaltungs-Verbindung dieses Workspace nicht sichtbar. Entweder nennt der Eintrag das falsche Repository, oder die Verbindung hat keinen Zugriff darauf: Korrigieren Sie die Referenzarchitektur oder erteilen Sie den Zugriff, und versuchen Sie es erneut.",
+        "reference_repo_unreadable": "Das Repository hinter der Referenzarchitektur dieses Laufs konnte gerade nicht gelesen werden, deshalb wurde der Lauf nicht gegen eine Vorlage gestartet, die er möglicherweise nicht klonen kann. Es ist nichts falsch konfiguriert und keine Änderung nötig: versuchen Sie es erneut, sobald die Verbindung wieder steht."
+      }
+    },
     "action": {
       "retryFailed": "Wiederholung fehlgeschlagen",
       "startFailed": "Start fehlgeschlagen",

package/i18n/locales/en.json

@@ -464,6 +464,10 @@
         "@previousErrors": {
           "description": "Count-based tally of a run's earlier failed attempts, rendered as e.g. '3 previous errors' (count is always >= 1). Provide ALL plural forms your language needs (English has 2; Polish/Ukrainian need 3 - one/few/many - via the custom pluralRules in i18n.config.ts)."
         }
+      },
+      "resumeBootstrap": "Resume from: {step}",
+      "@resumeBootstrap": {
+        "description": "Retry label for a multi-step (monorepo) bootstrap, which resumes at the step the run reached rather than starting over. {step} is one of the bootstrap.steps.name values."
       }
     },
     "stop": {
@@ -705,6 +709,12 @@
         "service_catalog_response_too_large": "The developer portal answered with more data than this platform will hold in one response. Open the service-catalog settings and lower the service cap, or turn off importing interface definitions, then import again."
       }
     },
+    "reason": {
+      "description": {
+        "reference_repo_not_found": "The repository behind this run's reference architecture cannot be seen through this workspace's source-control connection. Either the entry names the wrong repository, or the connection has not been granted access to it: correct the reference architecture, or grant it access, then try again.",
+        "reference_repo_unreadable": "The repository behind this run's reference architecture could not be read just now, so the run was not started against a template it might be unable to clone. Nothing here is misconfigured and no change is needed: try again once the source-control connection recovers."
+      }
+    },
     "action": {
       "retryFailed": "Retry failed",
       "startFailed": "Failed to start",
@@ -1872,7 +1882,8 @@
       "cacheRead": "{tokens} cache read",
       "cacheReadHint": "Input tokens served from the provider's cache (about 0.1x the price of fresh input)",
       "cacheWrite": "{tokens} cache write",
-      "cacheWriteHint": "Input tokens written into the provider's cache (1.25x to 2x the price of fresh input)"
+      "cacheWriteHint": "Input tokens written into the provider's cache (1.25x to 2x the price of fresh input)",
+      "costNoRollup": "Not priced: the estimate is folded from a run's per-step rollup, and this run has none. What its calls consumed is listed below."
     },
     "phase": {
       "title": "Where the tokens went",
@@ -1887,7 +1898,8 @@
       "costHint": "Estimated cost of this phase's tokens at list rates. A dash means this deployment has no rate for the model that ran.",
       "carryCostHint": "How much each phase burdened the turns that came after it: its context counted once for every later turn that had to re-send it. Compare a run's phases with each other; on its own the number means nothing. A phase that runs late carries little however much it spent, so read this column alongside the tokens beside it.",
       "unattributed": "Unattributed",
-      "unattributedHint": "recorded by a channel that reports no phase"
+      "unattributedHint": "recorded by a channel that reports no phase",
+      "noRollup": "This run has no pipeline steps, so there is no per-phase rollup to fold: its model calls are recorded below, but nothing groups or prices them."
     },
     "metricsBar": {
       "calls": "{count} call | {count} calls",
@@ -1995,7 +2007,8 @@
       "result": "Result",
       "dropped": "{chars} characters dropped at capture",
       "truncated": "Showing the first {shown} calls of this run. The counts above are for the whole run; narrow to the failures to see all of them.",
-      "failuresTruncated": "Showing the first {shown} failing calls. The count above is for the whole run."
+      "failuresTruncated": "Showing the first {shown} failing calls. The count above is for the whole run.",
+      "surveyReadsElsewhere": "The survey's own reads are not here: it explores through the platform's bounded reader, and every read it made is recorded on the run's adoption transcript. Below are the tool calls of the container that wrote the service."
     }
   },
   "platformObservability": {
@@ -7236,7 +7249,14 @@
       "label": "Reference architecture",
       "description": "The managed base repo to clone and adapt.",
       "empty": "No reference architectures yet. Add one below, or switch to 'From scratch'.",
-      "placeholder": "Choose a reference architecture"
+      "placeholder": "Choose a reference architecture",
+      "refusal": {
+        "title": "This reference architecture could not be used",
+        "notFound": "{repo} cannot be seen through this workspace's source-control connection. Either this entry names the wrong repository, or the connection has not been granted access to it. Nothing was created, so correct the entry and launch again: everything else on this form is kept.",
+        "unreadable": "{repo} could not be read just now, so nothing was created. Nothing here is misconfigured: launch again once the source-control connection recovers, and everything else on this form is kept.",
+        "unnamedRepo": "The reference architecture's repository",
+        "edit": "Edit this reference architecture"
+      }
     },
     "targetRepo": {
       "label": "Target repository name",
@@ -7440,6 +7460,31 @@
         "approvedDesc": "The agent is now writing {directory} and will open a pull request.",
         "failed": "Could not submit the review"
       }
+    },
+    "steps": {
+      "title": "Bootstrap steps",
+      "name": {
+        "scaffold": "Scaffold the repository",
+        "survey": "Survey the monorepo and the template",
+        "review": "Your adoption decisions",
+        "apply": "Write the service and open the pull request"
+      },
+      "state": {
+        "pending": "Not started",
+        "running": "Running",
+        "awaiting_review": "Waiting for you",
+        "done": "Done",
+        "failed": "Failed",
+        "stopped": "Stopped",
+        "unknown": "State unreadable"
+      }
+    },
+    "@steps": {
+      "description": "The moves a bootstrap run is made of. A new-repo bootstrap is only `scaffold`; a monorepo bootstrap is survey → your decisions → apply. `state.stopped` is a run a person stopped, which is stored as a failure without being one; `state.unknown` is for a stored run status this build no longer defines."
+    },
+    "runKind": "Repo bootstrap",
+    "@runKind": {
+      "description": "The kind of run the observability panel is showing, in the line under its title where a task run names its pipeline instead. Keep it short."
     }
   },
   "initiative": {