@cat-factory/app 0.294.0 → 0.296.0

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/stores/agentRuns.spec.ts

@@ -20,6 +20,7 @@ function job(id: string, over: Partial<BootstrapJob> = {}): BootstrapJob {
     failure: null,
     monorepo: null,
     phase: null,
+    delivery: 'direct_push',
     adoptionPlan: null,
     adoptionReview: null,
     prUrl: null,

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/types/bootstrap.ts

@@ -18,6 +18,7 @@ export type {
   BootstrapFailure,
   BootstrapJob,
   BootstrapPhase,
+  BootstrapDelivery,
   BootstrapRepoInput,
   MonorepoBootstrapTarget,
   MonorepoBootstrapRef,

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": {
@@ -5086,7 +5090,8 @@
       "title": "Letzte Läufe",
       "fromArch": "aus {name}",
       "fromScratch": "von Grund auf",
-      "open": "Öffnen"
+      "open": "Öffnen",
+      "openPr": "Pull Request"
     },
     "status": {
       "pending": "ausstehend",
@@ -5134,11 +5139,24 @@
       "label": "Wo der Service entsteht",
       "newRepo": {
         "label": "Ein neues Repository",
-        "description": "Ein eigenes Repository anlegen und den Service als ersten Commit pushen."
+        "description": "Ein eigenes Repository anlegen und den Service hineinschreiben."
       },
       "monorepo": {
         "label": "Ein Verzeichnis in einem bestehenden Monorepo",
-        "description": "Den Service einem vorhandenen Repository hinzufügen und einen Pull Request öffnen."
+        "description": "Den Service einem Repository hinzufügen, das du bereits hast."
+      }
+    },
+    "delivery": {
+      "label": "Wie die Arbeit ankommt",
+      "pullRequest": {
+        "label": "Pull Request öffnen",
+        "descNewRepo": "Einen Branch pushen und einen Pull Request gegen den ersten Commit des Repositories öffnen, damit jemand das Gerüst prüft, bevor es zum Default-Branch wird. Das Repository muss bereits einen Commit haben.",
+        "descMonorepo": "Einen Branch pushen und einen Pull Request öffnen. Es wird nichts für dich gemergt."
+      },
+      "directPush": {
+        "label": "Direkt pushen",
+        "descNewRepo": "Den Service direkt als ersten Commit auf den Default-Branch schreiben.",
+        "descMonorepo": "Während der Agent arbeitet, direkt auf den Default-Branch committen. Bei einem Fehlschlag bleibt liegen, was bereits geschrieben wurde."
       }
     },
     "serviceName": {
@@ -5146,7 +5164,7 @@
       "description": "Benennt den Service auf dem Board und schlägt sein Verzeichnis vor."
     },
     "monorepo": {
-      "intro": "Der Service wird in ein Verzeichnis eines bestehenden Repositories geschrieben und als Pull Request geliefert. Es wird nichts für dich gemergt und nichts außerhalb des neuen Verzeichnisses geändert.",
+      "intro": "Der Service wird in ein Verzeichnis eines bestehenden Repositories geschrieben; außerhalb dieses Verzeichnisses wird nichts geändert.",
       "repo": {
         "label": "Monorepo",
         "description": "Das Repository, in dem der neue Service liegt. Es muss bereits mit diesem Workspace verknüpft sein.",
@@ -5236,7 +5254,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": {

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": {
@@ -1872,7 +1876,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 +1892,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 +2001,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": {
@@ -7276,7 +7283,8 @@
       "title": "Recent runs",
       "fromArch": "from {name}",
       "fromScratch": "from scratch",
-      "open": "Open"
+      "open": "Open",
+      "openPr": "Pull request"
     },
     "status": {
       "pending": "pending",
@@ -7324,11 +7332,24 @@
       "label": "Where the service goes",
       "newRepo": {
         "label": "A new repository",
-        "description": "Create a repository of its own and push the service as its first commit."
+        "description": "Create a repository of its own and write the service into it."
       },
       "monorepo": {
         "label": "A directory in an existing monorepo",
-        "description": "Add the service to a repository you already have, and open a pull request."
+        "description": "Add the service to a repository you already have."
+      }
+    },
+    "delivery": {
+      "label": "How the work lands",
+      "pullRequest": {
+        "label": "Open a pull request",
+        "descNewRepo": "Push a branch and open a pull request against the repository's first commit, so someone reviews the scaffold before it becomes the default branch. The repository must already have a commit.",
+        "descMonorepo": "Push a branch and open a pull request. Nothing is merged for you."
+      },
+      "directPush": {
+        "label": "Push directly",
+        "descNewRepo": "Write the service straight onto the default branch as the repository's first commit.",
+        "descMonorepo": "Commit onto the default branch as the agent works. A run that fails leaves what it had already written behind."
       }
     },
     "serviceName": {
@@ -7336,7 +7357,7 @@
       "description": "Names the service on the board and seeds its directory."
     },
     "monorepo": {
-      "intro": "The service is written into a directory of an existing repository and delivered as a pull request. Nothing is merged for you, and nothing outside the new directory is changed.",
+      "intro": "The service is written into a directory of an existing repository, and nothing outside that directory is changed.",
       "repo": {
         "label": "Monorepo",
         "description": "The repository the new service lives in. It must already be linked to this workspace.",
@@ -7426,6 +7447,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": {

package/i18n/locales/es.json

@@ -413,7 +413,8 @@
       "retrying": "Reintentando…",
       "history": {
         "previousErrors": "{count} error anterior | {count} errores anteriores"
-      }
+      },
+      "resumeBootstrap": "Reanudar desde: {step}"
     },
     "stop": {
       "label": "Detener",
@@ -1768,7 +1769,8 @@
       "cacheRead": "{tokens} leídos de caché",
       "cacheReadHint": "Tokens de entrada servidos desde la caché del proveedor (unas 0,1 veces el precio de la entrada fresca)",
       "cacheWrite": "{tokens} escritos en caché",
-      "cacheWriteHint": "Tokens de entrada escritos en la caché del proveedor (de 1,25 a 2 veces el precio de la entrada fresca)"
+      "cacheWriteHint": "Tokens de entrada escritos en la caché del proveedor (de 1,25 a 2 veces el precio de la entrada fresca)",
+      "costNoRollup": "Sin valorar: la estimación se calcula a partir del resumen por paso, y esta ejecución no tiene ninguno. Abajo se indica lo que consumieron sus llamadas."
     },
     "phase": {
       "title": "Adónde fueron los tokens",
@@ -1783,7 +1785,8 @@
       "costHint": "Coste estimado de los tokens de esta fase a precios de lista. Un guion indica que esta instalación no tiene tarifa para el modelo que se ejecutó.",
       "carryCostHint": "Cuánto cargó cada fase sobre los turnos posteriores: su contexto contado una vez por cada turno que tuvo que reenviarlo. Compara entre sí las fases de una ejecución; por sí sola la cifra no significa nada. Una fase que se ejecuta al final arrastra poco por mucho que haya gastado, así que lee esta columna junto a los tokens de al lado.",
       "unattributed": "Sin atribuir",
-      "unattributedHint": "registrado por un canal que no informa de la fase"
+      "unattributedHint": "registrado por un canal que no informa de la fase",
+      "noRollup": "Esta ejecución no tiene pasos de pipeline, así que no hay un resumen por fase: sus llamadas al modelo están registradas abajo, pero nada las agrupa ni las valora."
     },
     "metricsBar": {
       "calls": "{count} llamada | {count} llamadas",
@@ -1891,7 +1894,8 @@
       "result": "Resultado",
       "dropped": "{chars} caracteres descartados al capturar",
       "truncated": "Se muestran las primeras {shown} llamadas de esta ejecución. Los recuentos de arriba corresponden a la ejecución completa; filtra por los fallos para verlos todos.",
-      "failuresTruncated": "Se muestran las primeras {shown} llamadas fallidas. El recuento de arriba corresponde a la ejecución completa."
+      "failuresTruncated": "Se muestran las primeras {shown} llamadas fallidas. El recuento de arriba corresponde a la ejecución completa.",
+      "surveyReadsElsewhere": "Las lecturas del estudio no están aquí: explora mediante el lector acotado de la plataforma y cada lectura queda registrada en la transcripción de adopción de la ejecución. Abajo están las llamadas a herramientas del contenedor que escribió el servicio."
     }
   },
   "platformObservability": {
@@ -6952,7 +6956,8 @@
       "title": "Ejecuciones recientes",
       "fromArch": "desde {name}",
       "fromScratch": "desde cero",
-      "open": "Abrir"
+      "open": "Abrir",
+      "openPr": "Pull request"
     },
     "status": {
       "pending": "pendiente",
@@ -7004,11 +7009,24 @@
       "label": "Dónde va el servicio",
       "newRepo": {
         "label": "Un repositorio nuevo",
-        "description": "Crear un repositorio propio y subir el servicio como su primer commit."
+        "description": "Crear un repositorio propio y escribir el servicio en él."
       },
       "monorepo": {
         "label": "Un directorio de un monorepo existente",
-        "description": "Añadir el servicio a un repositorio que ya tienes y abrir un pull request."
+        "description": "Añadir el servicio a un repositorio que ya tienes."
+      }
+    },
+    "delivery": {
+      "label": "Cómo se entrega el trabajo",
+      "pullRequest": {
+        "label": "Abrir un pull request",
+        "descNewRepo": "Subir una rama y abrir un pull request contra el primer commit del repositorio, para que alguien revise el andamiaje antes de que sea la rama principal. El repositorio ya debe tener un commit.",
+        "descMonorepo": "Subir una rama y abrir un pull request. No se fusiona nada por ti."
+      },
+      "directPush": {
+        "label": "Subir directamente",
+        "descNewRepo": "Escribir el servicio directamente en la rama principal como primer commit del repositorio.",
+        "descMonorepo": "Hacer commits en la rama principal mientras el agente trabaja. Si la ejecución falla, queda lo que ya se había escrito."
       }
     },
     "serviceName": {
@@ -7016,7 +7034,7 @@
       "description": "Nombra el servicio en el tablero y propone su directorio."
     },
     "monorepo": {
-      "intro": "El servicio se escribe en un directorio de un repositorio existente y se entrega como pull request. No se fusiona nada por ti ni se cambia nada fuera del nuevo directorio.",
+      "intro": "El servicio se escribe en un directorio de un repositorio existente, y no se cambia nada fuera de ese directorio.",
       "repo": {
         "label": "Monorepo",
         "description": "El repositorio donde vivirá el nuevo servicio. Ya debe estar vinculado a este espacio de trabajo.",
@@ -7106,7 +7124,26 @@
         "approvedDesc": "El agente está escribiendo {directory} y abrirá un pull request.",
         "failed": "No se pudo enviar la revisión"
       }
-    }
+    },
+    "steps": {
+      "title": "Pasos del bootstrap",
+      "name": {
+        "scaffold": "Crear la estructura del repositorio",
+        "survey": "Analizar el monorepo y la plantilla",
+        "review": "Tus decisiones de adopción",
+        "apply": "Escribir el servicio y abrir la pull request"
+      },
+      "state": {
+        "pending": "Sin empezar",
+        "running": "En curso",
+        "awaiting_review": "Esperándote",
+        "done": "Hecho",
+        "failed": "Con error",
+        "stopped": "Detenido",
+        "unknown": "Estado ilegible"
+      }
+    },
+    "runKind": "Arranque de repositorio"
   },
   "riskPolicy": {
     "health": {