@cat-factory/app 0.291.1 → 0.292.0

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

@@ -7,6 +7,7 @@ import InitiativeCard from './InitiativeCard.vue'
 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 { useBlockDrag } from '~/composables/useBlockDrag'
 import { useFrameStacking } from '~/composables/useFrameStacking'
 import { useViewport } from '~/composables/useViewport'
@@ -207,6 +208,10 @@ const bootstrapping = computed(
   () => run.value?.kind === 'bootstrap' && run.value.status === 'running',
 )
 const runFailed = computed(() => run.value?.status === 'failed')
+// A monorepo bootstrap parked on its adoption review: the run is waiting on THIS person, so the
+// card says so and offers the review rather than showing a generic "working…" it is not doing.
+const awaitingReview = computed(() => agentRuns.awaitingReview(props.id))
+const reviewOpen = ref(false)
 const bootstrapSubtasks = computed(() =>
   bootstrapping.value ? (run.value?.subtasks ?? null) : null,
 )
@@ -345,6 +350,21 @@ const ITEM_ICON: Record<string, string> = {
           <AgentStopButton :run-id="run.runId" :kind="run.kind" size="xs" variant="ghost" />
         </div>
       </div>
+      <!-- parked on a human adoption review: the run is waiting on the viewer, not working -->
+      <div
+        v-else-if="awaitingReview"
+        class="m-3 space-y-2 rounded-md border border-amber-500/40 bg-amber-500/5 p-3"
+      >
+        <div class="flex items-start gap-2">
+          <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>
+        <div class="flex justify-end">
+          <UButton size="xs" color="warning" variant="subtle" @click.stop="reviewOpen = true">
+            {{ t('bootstrap.adoption.cardAction') }}
+          </UButton>
+        </div>
+      </div>
       <!-- failed run: shared failure banner + retry -->
       <div v-else-if="runFailed && run" class="p-3">
         <AgentFailureCard :run="run" variant="expanded" />
@@ -546,5 +566,12 @@ const ITEM_ICON: Record<string, string> = {
            opposite border from the one the drag actually moves. -->
       <ResizeGrips :block="block" tone="frame" />
     </div>
+    <!-- Teleported by UModal, so it renders outside the canvas transform; kept inside the node's
+         single root element so the board node stays a one-root component. -->
+    <AdoptionReviewModal
+      v-if="reviewOpen && awaitingReview"
+      :job="awaitingReview"
+      @close="reviewOpen = false"
+    />
   </div>
 </template>

package/app/components/bootstrap/AdoptionReviewModal.vue

@@ -0,0 +1,301 @@
+<script setup lang="ts">
+// The human review a monorepo bootstrap parks on: for each convention area the platform
+// surveyed, the reviewer decides whether the new service follows the surrounding monorepo or
+// keeps what the reference template ships.
+//
+// The whole point of this surface is that a suggestion is CHECKABLE, so it renders the evidence
+// (the files each recommendation was read from) beside every line, and never shows a decision
+// as answered until the reviewer has actually answered it. It also renders the case where there
+// is no suggestion at all as its own state, because "the two repositories agreed on everything"
+// and "the analysis never ran" would otherwise look identical and lead to opposite conclusions.
+import type { AdoptionSource, BootstrapJob } from '~/types/domain'
+
+const props = defineProps<{ job: BootstrapJob }>()
+const emit = defineEmits<{ close: [] }>()
+
+const agentRuns = useAgentRunsStore()
+const toast = useToast()
+const { present } = usePipelineErrorToast()
+const { t } = useI18n()
+
+const open = ref(true)
+const submitting = ref(false)
+
+const plan = computed(() => props.job.adoptionPlan)
+const decisions = computed(() => plan.value?.decisions ?? [])
+const unavailable = computed(() => plan.value?.status !== 'ready')
+
+/** The reviewer's answers, keyed by decision id; seeded from the recommendations. */
+const choices = ref<Record<string, AdoptionSource>>({})
+const notes = ref<Record<string, string>>({})
+const overallNotes = ref('')
+
+// Seeding from the recommendation is a starting POINT, not an answer: `touched` is what tracks
+// whether a human has looked at each line, and the submit button waits for all of them. Without
+// it, pre-selecting the suggestion would make "approve" mean nothing.
+const touched = ref<Set<string>>(new Set())
+
+/**
+ * What the reviewer is answering, as an identity rather than as an object.
+ *
+ * The watcher below RESETS every answer, so what it keys on decides when a reviewer's work is
+ * thrown away. `decisions` is a computed array, so it is a fresh reference every time the store
+ * upserts a re-parsed job for this block, which any live `bootstrap` event or debounced board
+ * refresh does, including ones about other runs. Keying on it wiped a half-finished 10-decision
+ * review, silently reverting every override, while leaving the per-decision notes attached to
+ * re-seeded recommendations they were never written for.
+ */
+const planIdentity = computed(() => `${props.job.id}:${plan.value?.generatedAt ?? 0}`)
+
+watch(
+  planIdentity,
+  () => {
+    const seeded: Record<string, AdoptionSource> = {}
+    for (const decision of decisions.value) seeded[decision.id] = decision.recommended
+    choices.value = seeded
+    // Reset WITH the choices, never after them: a note left beside a re-seeded recommendation
+    // reads as an instruction the reviewer gave for a decision they no longer made.
+    notes.value = {}
+    touched.value = new Set()
+  },
+  { immediate: true },
+)
+
+const sourceItems = computed(() =>
+  (['monorepo', 'template', 'both', 'neither'] as const).map((value) => ({
+    label: t(`bootstrap.adoption.source.${value}`),
+    value,
+  })),
+)
+
+function choose(id: string, value: AdoptionSource) {
+  choices.value[id] = value
+  touched.value = new Set([...touched.value, id])
+}
+
+/** Accept every recommendation at once, which is still an explicit act by the reviewer. */
+function acceptAll() {
+  touched.value = new Set(decisions.value.map((d) => d.id))
+}
+
+const remaining = computed(() => decisions.value.filter((d) => !touched.value.has(d.id)).length)
+// An unavailable plan carries no decisions, so there is nothing to answer and nothing to wait
+// for: submitting it is the reviewer saying "go ahead, I am deciding this unaided", which is the
+// only exit from the park. Disabling it here left a deployment with no adoption model unable to
+// finish a monorepo bootstrap at all.
+const canSubmit = computed(() => remaining.value === 0)
+
+/** The monorepo this service is landing in, for the header line. */
+const target = computed(() => {
+  const monorepo = props.job.monorepo
+  return monorepo ? `${monorepo.repoOwner}/${monorepo.repoName}` : ''
+})
+
+async function submit() {
+  if (!canSubmit.value) return
+  submitting.value = true
+  try {
+    // Derived from the PLAN's decisions, so an unavailable plan sends an empty set: the server
+    // refuses answers naming decisions the plan does not carry, which is what makes a review
+    // submitted against a re-surveyed plan fail loudly instead of applying half of it.
+    await agentRuns.submitAdoptionReview(props.job.id, {
+      choices: decisions.value.map((decision) => ({
+        id: decision.id,
+        choice: choices.value[decision.id] ?? decision.recommended,
+        ...(notes.value[decision.id]?.trim() ? { note: notes.value[decision.id]!.trim() } : {}),
+      })),
+      ...(overallNotes.value.trim() ? { notes: overallNotes.value.trim() } : {}),
+    })
+    toast.add({
+      title: t('bootstrap.adoption.toast.approved'),
+      description: t('bootstrap.adoption.toast.approvedDesc', {
+        directory: props.job.monorepo?.directory ?? '',
+      }),
+      icon: 'i-lucide-check',
+      color: 'success',
+    })
+    open.value = false
+    emit('close')
+  } catch (e) {
+    present(e, 'bootstrap.adoption.toast.failed')
+  } finally {
+    submitting.value = false
+  }
+}
+
+watch(open, (isOpen) => {
+  if (!isOpen) emit('close')
+})
+</script>
+
+<template>
+  <UModal
+    v-model:open="open"
+    :title="t('bootstrap.adoption.title')"
+    :description="
+      t('bootstrap.adoption.subtitle', { target, directory: job.monorepo?.directory ?? '' })
+    "
+    :ui="{ content: 'max-w-3xl' }"
+  >
+    <template #body>
+      <div class="space-y-5">
+        <!-- No suggestion: state WHY, and let the reviewer proceed unaided rather than
+             presenting an empty list, which would read as "there was nothing to decide". -->
+        <div
+          v-if="unavailable"
+          class="space-y-2 rounded-md border border-amber-500/30 bg-amber-500/5 p-3"
+        >
+          <div class="flex items-start gap-2">
+            <UIcon name="i-lucide-triangle-alert" class="mt-0.5 h-4 w-4 shrink-0 text-amber-400" />
+            <p class="text-sm text-amber-200/90">
+              {{
+                t(
+                  `bootstrap.adoption.unavailable.${plan?.unavailableReason ?? 'analysis_unusable'}`,
+                )
+              }}
+            </p>
+          </div>
+          <p v-if="plan?.unavailableDetail" class="pl-6 text-xs text-slate-400">
+            {{ plan.unavailableDetail }}
+          </p>
+        </div>
+
+        <!-- The reviewer's own instructions, on BOTH paths. With no suggestion to answer this is
+             the only thing they can say, and it reaches the agent's brief verbatim. -->
+        <UFormField
+          v-if="unavailable"
+          :label="t('bootstrap.adoption.notes.label')"
+          :description="t('bootstrap.adoption.notes.unavailableDescription')"
+        >
+          <UTextarea v-model="overallNotes" :rows="3" class="w-full" />
+        </UFormField>
+
+        <template v-else>
+          <div class="flex items-center justify-between gap-3">
+            <p class="text-sm text-slate-400">{{ t('bootstrap.adoption.intro') }}</p>
+            <UButton
+              color="neutral"
+              variant="subtle"
+              size="xs"
+              icon="i-lucide-check-check"
+              @click="acceptAll"
+            >
+              {{ t('bootstrap.adoption.acceptAll') }}
+            </UButton>
+          </div>
+
+          <ul class="space-y-3">
+            <li
+              v-for="decision in decisions"
+              :key="decision.id"
+              class="space-y-3 rounded-md border p-3"
+              :class="
+                touched.has(decision.id)
+                  ? 'border-slate-700 bg-slate-900/40'
+                  : 'border-amber-500/40 bg-amber-500/5'
+              "
+            >
+              <div class="flex items-start justify-between gap-3">
+                <div>
+                  <p class="text-sm font-medium text-slate-100">{{ decision.title }}</p>
+                  <p class="text-[11px] uppercase tracking-wide text-slate-500">
+                    {{ t(`bootstrap.adoption.area.${decision.area}`) }}
+                  </p>
+                </div>
+                <UBadge v-if="!touched.has(decision.id)" color="warning" variant="subtle" size="sm">
+                  {{ t('bootstrap.adoption.needsYou') }}
+                </UBadge>
+              </div>
+
+              <div class="grid gap-2 text-xs sm:grid-cols-2">
+                <div class="rounded bg-slate-900/60 p-2">
+                  <p class="mb-1 font-semibold text-slate-300">
+                    {{ t('bootstrap.adoption.side.monorepo') }}
+                  </p>
+                  <p class="text-slate-400">
+                    {{ decision.monorepoPractice ?? t('bootstrap.adoption.side.nothing') }}
+                  </p>
+                </div>
+                <div class="rounded bg-slate-900/60 p-2">
+                  <p class="mb-1 font-semibold text-slate-300">
+                    {{ t('bootstrap.adoption.side.template') }}
+                  </p>
+                  <p class="text-slate-400">
+                    {{ decision.templatePractice ?? t('bootstrap.adoption.side.nothing') }}
+                  </p>
+                </div>
+              </div>
+
+              <p class="text-xs text-slate-400">{{ decision.rationale }}</p>
+
+              <!-- The evidence is what makes the suggestion checkable rather than an assertion,
+                   so it is shown, not tucked away. -->
+              <p v-if="decision.evidence.length" class="text-[11px] text-slate-500">
+                {{ t('bootstrap.adoption.evidence') }}
+                <span class="font-mono">{{ decision.evidence.join(', ') }}</span>
+              </p>
+
+              <div class="flex flex-wrap items-center gap-2">
+                <UButton
+                  v-for="item in sourceItems"
+                  :key="item.value"
+                  size="xs"
+                  :color="choices[decision.id] === item.value ? 'primary' : 'neutral'"
+                  :variant="choices[decision.id] === item.value ? 'solid' : 'subtle'"
+                  @click="choose(decision.id, item.value)"
+                >
+                  {{ item.label }}
+                </UButton>
+                <UBadge
+                  v-if="choices[decision.id] !== decision.recommended"
+                  color="info"
+                  variant="subtle"
+                  size="sm"
+                >
+                  {{ t('bootstrap.adoption.overridden') }}
+                </UBadge>
+              </div>
+
+              <UInput
+                v-model="notes[decision.id]"
+                size="sm"
+                :placeholder="t('bootstrap.adoption.notePlaceholder')"
+                class="w-full"
+              />
+            </li>
+          </ul>
+
+          <UFormField
+            :label="t('bootstrap.adoption.notes.label')"
+            :description="t('bootstrap.adoption.notes.description')"
+          >
+            <UTextarea v-model="overallNotes" :rows="3" class="w-full" />
+          </UFormField>
+        </template>
+      </div>
+    </template>
+
+    <template #footer>
+      <div class="flex w-full items-center justify-between gap-3">
+        <p v-if="!unavailable && remaining > 0" class="text-xs text-amber-300/90">
+          {{ t('bootstrap.adoption.remaining', { count: remaining }) }}
+        </p>
+        <span v-else />
+        <div class="flex items-center gap-2">
+          <UButton color="neutral" variant="ghost" @click="open = false">
+            {{ t('common.cancel') }}
+          </UButton>
+          <UButton
+            color="primary"
+            icon="i-lucide-play"
+            :loading="submitting"
+            :disabled="!canSubmit"
+            @click="submit"
+          >
+            {{ t('bootstrap.adoption.approve') }}
+          </UButton>
+        </div>
+      </div>
+    </template>
+  </UModal>
+</template>

package/app/components/bootstrap/BootstrapModal.vue

@@ -79,6 +79,56 @@ const typeItems = useFrameRepoTypeItems()
 
 const usingReference = computed(() => mode.value === 'reference')
 
+// ---- where the service LANDS ----------------------------------------------
+// A second, independent axis from `mode` (which says where the CONTENT comes from): a run
+// either creates a repository of its own, or writes the service into a subdirectory of an
+// existing monorepo and opens a pull request against it. The monorepo path adds the human
+// adoption review between the survey and the write, which is why the two are not one control.
+type Target = 'new-repo' | 'monorepo'
+const target = ref<Target>('new-repo')
+const targetItems = computed(() => [
+  {
+    label: t('bootstrap.target.newRepo.label'),
+    value: 'new-repo' as const,
+    description: t('bootstrap.target.newRepo.description'),
+  },
+  {
+    label: t('bootstrap.target.monorepo.label'),
+    value: 'monorepo' as const,
+    description: t('bootstrap.target.monorepo.description'),
+  },
+])
+const intoMonorepo = computed(() => target.value === 'monorepo')
+
+/** The projected repo the new service lands in, by numeric id. */
+const monorepoRepoId = ref<number | undefined>(undefined)
+const monorepoDirectory = ref('')
+
+const monorepoRepoItems = computed(() =>
+  github.repos.map((r) => ({ label: `${r.owner}/${r.name}`, value: r.githubId })),
+)
+
+// Mirrors the backend's `normalizeServiceDirectory`: the path becomes an agent's working
+// directory, so a value that could escape the checkout is refused here rather than at the API.
+const directoryError = computed<string | undefined>(() => {
+  const value = monorepoDirectory.value.trim()
+  if (!value) return undefined
+  const segments = value
+    .replace(/\\/g, '/')
+    .split('/')
+    .filter((s) => s && s !== '.')
+  if (!segments.length) return t('bootstrap.monorepo.directory.error.empty')
+  if (segments.some((s) => s === '..')) return t('bootstrap.monorepo.directory.error.escapes')
+  return undefined
+})
+
+// Landing in a monorepo needs no NEW repository, so the repo name is the SERVICE's name (and
+// seeds the directory's leaf); the create-repo affordances below are for the other target.
+watch([intoMonorepo, repoName], ([into, name]) => {
+  if (!into || !name.trim() || monorepoDirectory.value.trim()) return
+  monorepoDirectory.value = `services/${name.trim()}`
+})
+
 // UX-18: prompt before discarding a half-filled launch form on Escape / backdrop / the X.
 // The modal keeps its fields across opens (no reset watcher), so the baseline is whatever
 // the form held when it opened — a close only prompts once the user has typed something
@@ -227,6 +277,10 @@ function openManageInstall() {
 const canLaunch = computed(() => {
   if (needsConnection.value) return false
   if (!repoName.value.trim() || repoNameError.value) return false
+  if (intoMonorepo.value) {
+    if (!monorepoRepoId.value) return false
+    if (!monorepoDirectory.value.trim() || directoryError.value) return false
+  }
   return usingReference.value ? !!selectedArchId.value : instructions.value.trim().length > 0
 })
 
@@ -241,6 +295,14 @@ async function launch() {
       private: isPrivate.value,
       instructions: instructions.value.trim(),
       type: selectedType.value,
+      ...(intoMonorepo.value && monorepoRepoId.value
+        ? {
+            monorepo: {
+              repoGithubId: monorepoRepoId.value,
+              directory: monorepoDirectory.value.trim(),
+            },
+          }
+        : {}),
     })
     if (job.status === 'failed') {
       // The container couldn't even start (pre-flight failure, e.g. the target
@@ -257,13 +319,19 @@ async function launch() {
       // background and becomes a real, droppable service when it finishes.
       toast.add({
         title: t('bootstrap.toast.started'),
-        description: t('bootstrap.toast.startedDesc', { repo: job.repoName }),
+        // A monorepo run does not run straight through: it surveys, then waits for the
+        // reviewer. Saying "bootstrapping…" there would set the wrong expectation about who
+        // the next move belongs to.
+        description: job.monorepo
+          ? t('bootstrap.toast.startedMonorepoDesc', { directory: job.monorepo.directory })
+          : t('bootstrap.toast.startedDesc', { repo: job.repoName }),
         icon: 'i-lucide-loader-circle',
         color: 'info',
       })
       repoName.value = ''
       description.value = ''
       instructions.value = ''
+      monorepoDirectory.value = ''
       // Reset the repo role too, so a later bootstrap doesn't silently inherit this one's type.
       selectedType.value = 'service'
       // The provisional frame arrived (bootstrap() refreshed the board). Re-home it to
@@ -390,9 +458,12 @@ async function removeArch(a: ReferenceArchitecture) {
   }
 }
 
-const statusColor: Record<BootstrapStatus, 'neutral' | 'info' | 'success' | 'error'> = {
+const statusColor: Record<BootstrapStatus, 'neutral' | 'info' | 'success' | 'error' | 'warning'> = {
   pending: 'neutral',
   running: 'info',
+  // A parked run is not "in progress": it is waiting on a person, which is what `warning`
+  // says on every other surface where the platform is blocked on its user.
+  awaiting_review: 'warning',
   succeeded: 'success',
   failed: 'error',
 }
@@ -401,6 +472,7 @@ const statusColor: Record<BootstrapStatus, 'neutral' | 'info' | 'success' | 'err
 const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
   pending: t('bootstrap.status.pending'),
   running: t('bootstrap.status.running'),
+  awaiting_review: t('bootstrap.status.awaitingReview'),
   succeeded: t('bootstrap.status.succeeded'),
   failed: t('bootstrap.status.failed'),
 }))
@@ -417,11 +489,13 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
              (the button is absent for exactly the same reason). -->
         <p class="text-sm text-slate-400">
           {{
-            github.canCreateRepos
-              ? t('vcs.bootstrap.introCanCreate', { provider: providerLabel })
-              : createRepoUrl
-                ? t('vcs.bootstrap.introManual', { provider: providerLabel })
-                : t('vcs.bootstrap.introManualAny')
+            intoMonorepo
+              ? t('bootstrap.monorepo.intro')
+              : github.canCreateRepos
+                ? t('vcs.bootstrap.introCanCreate', { provider: providerLabel })
+                : createRepoUrl
+                  ? t('vcs.bootstrap.introManual', { provider: providerLabel })
+                  : t('vcs.bootstrap.introManualAny')
           }}
         </p>
 
@@ -446,6 +520,44 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
             {{ t('bootstrap.section.newRepo') }}
           </h3>
 
+          <UFormField :label="t('bootstrap.target.label')" required>
+            <URadioGroup v-model="target" :items="targetItems" />
+          </UFormField>
+
+          <!-- Landing in an existing monorepo: pick the repository and the subdirectory. The
+               run surveys the monorepo's conventions against the template's and PARKS for a
+               human adoption review before it writes anything. -->
+          <template v-if="intoMonorepo">
+            <UFormField
+              :label="t('bootstrap.monorepo.repo.label')"
+              :description="t('bootstrap.monorepo.repo.description')"
+              required
+            >
+              <div v-if="!monorepoRepoItems.length" class="text-sm text-slate-400">
+                {{ t('bootstrap.monorepo.repo.empty') }}
+              </div>
+              <USelect
+                v-else
+                v-model="monorepoRepoId"
+                :items="monorepoRepoItems"
+                :placeholder="t('bootstrap.monorepo.repo.placeholder')"
+                class="w-full"
+              />
+            </UFormField>
+            <UFormField
+              :label="t('bootstrap.monorepo.directory.label')"
+              :description="t('bootstrap.monorepo.directory.description')"
+              required
+              :error="directoryError"
+            >
+              <UInput
+                v-model="monorepoDirectory"
+                :placeholder="t('bootstrap.monorepo.directory.placeholder')"
+                class="w-full"
+              />
+            </UFormField>
+          </template>
+
           <UFormField :label="t('bootstrap.mode.label')" required>
             <URadioGroup v-model="mode" :items="modeItems" />
           </UFormField>
@@ -470,11 +582,15 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
           </template>
 
           <UFormField
-            :label="t('bootstrap.targetRepo.label')"
+            :label="
+              intoMonorepo ? t('bootstrap.serviceName.label') : t('bootstrap.targetRepo.label')
+            "
             :description="
-              repoOwner
-                ? t('bootstrap.targetRepo.descWithOwner', { owner: repoOwner })
-                : t('bootstrap.targetRepo.descNoOwner')
+              intoMonorepo
+                ? t('bootstrap.serviceName.description')
+                : repoOwner
+                  ? t('bootstrap.targetRepo.descWithOwner', { owner: repoOwner })
+                  : t('bootstrap.targetRepo.descNoOwner')
             "
             required
             :error="repoNameError"
@@ -490,7 +606,7 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
                      host's own form needs one, so that variant waits until a host is
                      resolved rather than guessing which page to open. -->
                 <UButton
-                  v-if="github.canCreateRepos || createRepoUrl"
+                  v-if="!intoMonorepo && (github.canCreateRepos || createRepoUrl)"
                   color="neutral"
                   variant="subtle"
                   :icon="github.canCreateRepos ? 'i-lucide-plus' : 'i-lucide-external-link'"
@@ -511,7 +627,7 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
                 </UButton>
               </div>
               <UButton
-                v-if="manageInstallUrl && !github.canCreateRepos"
+                v-if="!intoMonorepo && manageInstallUrl && !github.canCreateRepos"
                 color="neutral"
                 variant="ghost"
                 size="sm"

package/app/composables/api/bootstrap.ts

@@ -5,9 +5,11 @@ import {
   retryAgentRunContract,
   startBootstrapJobContract,
   stopAgentRunContract,
+  submitAdoptionReviewContract,
   updateReferenceArchitectureContract,
 } from '@cat-factory/contracts'
 import type {
+  AdoptionReviewInput,
   BootstrapRepoInput,
   CreateReferenceArchitectureInput,
   UpdateReferenceArchitectureInput,
@@ -47,6 +49,14 @@ export function bootstrapApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
     bootstrapRepo: (workspaceId: string, body: BootstrapRepoInput) =>
       send(startBootstrapJobContract, { pathPrefix: ws(workspaceId), body }),
 
+    // Settle a parked monorepo bootstrap's adoption plan and let the run write the service.
+    submitAdoptionReview: (workspaceId: string, jobId: string, body: AdoptionReviewInput) =>
+      send(submitAdoptionReviewContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { id: jobId },
+        body,
+      }),
+
     // ---- agent runs (unified failure + retry) -----------------------------
     // Retry any failed run (bootstrap or execution); the backend resolves the
     // kind from the unified `agent_runs` table and re-drives the right flow.

package/app/composables/usePipelineErrorToast.ts

@@ -83,6 +83,21 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
     titleKey: 'errors.conflict.title.dependencies_unmet',
     descriptionKey: 'errors.conflict.description.dependencies_unmet',
   },
+  // A monorepo bootstrap's review was submitted for a run that has since moved on: the fix is
+  // to look at where the run actually is, not to retry.
+  bootstrap_not_awaiting_review: {
+    titleKey: 'errors.conflict.title.bootstrap_not_awaiting_review',
+    descriptionKey: 'errors.conflict.description.bootstrap_not_awaiting_review',
+  },
+  adoption_plan_unavailable: {
+    titleKey: 'errors.conflict.title.adoption_plan_unavailable',
+    descriptionKey: 'errors.conflict.description.adoption_plan_unavailable',
+  },
+  // The remedy is a different DIRECTORY, not a different repository or a retry.
+  monorepo_directory_taken: {
+    titleKey: 'errors.conflict.title.monorepo_directory_taken',
+    descriptionKey: 'errors.conflict.description.monorepo_directory_taken',
+  },
   input_gate_not_parked: {
     titleKey: 'errors.conflict.title.input_gate_not_parked',
     descriptionKey: 'errors.conflict.description.input_gate_not_parked',

package/app/stores/agentRuns.spec.ts

@@ -18,6 +18,11 @@ function job(id: string, over: Partial<BootstrapJob> = {}): BootstrapJob {
     subtasks: null,
     error: null,
     failure: null,
+    monorepo: null,
+    phase: null,
+    adoptionPlan: null,
+    adoptionReview: null,
+    prUrl: null,
     createdAt: 1,
     updatedAt: 1,
     ...over,