@cat-factory/app 0.293.1 → 0.295.0

package/app/components/board/AddTaskModal.vue

@@ -22,6 +22,7 @@ import type {
   TaskTypeFields,
 } from '~/types/domain'
 import { DOC_KINDS, DOC_KIND_FIELDS } from '~/types/domain'
+import { BUG_FISHING_PHASES } from '@cat-factory/contracts'
 import { resolveComponentRegistry } from '@modular-vue/core'
 import { useReactiveSlots } from '@modular-vue/runtime'
 import type { AppSlots, ResultViewContribution } from '~/modular/slots'
@@ -97,6 +98,11 @@ const TASK_TYPES = computed<{ value: TaskTypeChoice; label: string; icon: string
   const all: { value: TaskTypeChoice; label: string; icon: string }[] = [
     { value: 'feature', label: t('board.addTask.types.feature'), icon: 'i-lucide-sparkles' },
     { value: 'bug', label: t('board.addTask.types.bug'), icon: 'i-lucide-bug' },
+    {
+      value: 'bug-fishing',
+      label: t('board.addTask.types.bugFishing'),
+      icon: 'i-lucide-fish',
+    },
     { value: 'document', label: t('board.addTask.types.document'), icon: 'i-lucide-file-text' },
     { value: 'spike', label: t('board.addTask.types.spike'), icon: 'i-lucide-flask-conical' },
     {
@@ -127,6 +133,11 @@ const isRecurring = computed(() => taskType.value === 'recurring')
 const severity = ref<'low' | 'medium' | 'high' | 'critical' | ''>('')
 const stepsToReproduce = ref('')
 const timeboxHours = ref<number | undefined>(undefined)
+// Bug-fishing expedition: which ANGLES to fish (empty ⇒ every shipped angle, the intended
+// default — an expedition exists to cover ground nobody thought to look at, so narrowing it is
+// the deliberate act) plus an optional focus folded into every angle's prompt.
+const fishingPhaseIds = ref<string[]>([])
+const fishingFocus = ref('')
 // Spike research criteria — folded into the spike agent's prompt (see the backend `spike` kind).
 const spikeResearchQuestion = ref('')
 const spikeSuccessCriteria = ref('')
@@ -284,6 +295,24 @@ function buildCustomTypeFields(): TaskTypeFields | undefined {
   return Object.keys(bag).length ? { custom: bag } : undefined
 }
 
+/**
+ * The bug-fishing expedition's creation fields. Both NARROW a hunt that otherwise covers every
+ * angle, so both are omitted when they narrow nothing: an empty selection and "every angle" are
+ * the same run, and storing the full catalog would freeze today's angle list onto a task that
+ * runs next quarter.
+ *
+ * Its own function rather than another arm of {@link buildTypeFields}, whose per-type chain is at
+ * its complexity ceiling — a budget is a split trigger, not a number to raise.
+ */
+function buildBugFishingFields(): TaskTypeFields | undefined {
+  const f: TaskTypeFields = {}
+  if (fishingPhaseIds.value.length && fishingPhaseIds.value.length < BUG_FISHING_PHASES.length) {
+    f.fishingPhaseIds = [...fishingPhaseIds.value]
+  }
+  if (fishingFocus.value.trim()) f.fishingFocus = fishingFocus.value.trim()
+  return Object.keys(f).length ? f : undefined
+}
+
 function buildTypeFields(): TaskTypeFields | undefined {
   if (taskType.value === 'bug') {
     const f: TaskTypeFields = {}
@@ -291,6 +320,7 @@ function buildTypeFields(): TaskTypeFields | undefined {
     if (stepsToReproduce.value.trim()) f.stepsToReproduce = stepsToReproduce.value.trim()
     return Object.keys(f).length ? f : undefined
   }
+  if (taskType.value === 'bug-fishing') return buildBugFishingFields()
   if (taskType.value === 'spike') {
     const f: TaskTypeFields = {}
     // `v-model.number` on a cleared number input yields '' (not undefined), which would
@@ -420,6 +450,7 @@ const DEFAULT_PIPELINE_FOR_TYPE: Partial<Record<TaskTypeChoice, string>> = {
   document: 'pl_document',
   review: 'pl_review',
   media: 'pl_media',
+  'bug-fishing': 'pl_bug_fishing',
 }
 /**
  * The pipeline a task type opens with: a custom type's registered `defaultPipelineId`, else the
@@ -564,6 +595,8 @@ watch(open, (isOpen) => {
   severity.value = ''
   stepsToReproduce.value = ''
   timeboxHours.value = undefined
+  fishingPhaseIds.value = []
+  fishingFocus.value = ''
   spikeResearchQuestion.value = ''
   spikeSuccessCriteria.value = ''
   spikeOptionsToCompare.value = ''
@@ -1027,6 +1060,53 @@ function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseC
             </UFormField>
           </div>
 
+          <!-- Bug-fishing expedition. Both fields NARROW a hunt that otherwise covers every
+               angle, which is why neither is required and why the angle list is rendered as
+               opt-OUT checkboxes rather than an empty multi-select: leaving it alone has to
+               mean "fish everything", not "fish nothing". -->
+          <div v-else-if="taskType === 'bug-fishing'" class="space-y-3">
+            <UFormField
+              :label="t('board.addTask.bugFishingFields.angles.label')"
+              :hint="t('board.addTask.optional')"
+              :description="t('board.addTask.bugFishingFields.angles.hint')"
+            >
+              <div class="grid gap-1.5 sm:grid-cols-2">
+                <label
+                  v-for="phase in BUG_FISHING_PHASES"
+                  :key="phase.id"
+                  class="flex items-start gap-2 rounded-md px-1.5 py-1 text-[12px] hover:bg-slate-800/40"
+                >
+                  <input
+                    v-model="fishingPhaseIds"
+                    type="checkbox"
+                    :value="phase.id"
+                    class="mt-0.5 accent-sky-500"
+                    :data-testid="`add-task-fishing-angle-${phase.id}`"
+                  />
+                  <span class="min-w-0">
+                    <span class="block text-slate-200">{{ phase.title }}</span>
+                    <span class="block text-[11px] text-slate-500">{{ phase.goal }}</span>
+                  </span>
+                </label>
+              </div>
+              <p v-if="fishingPhaseIds.length === 0" class="mt-1.5 text-[11px] text-slate-500">
+                {{ t('board.addTask.bugFishingFields.angles.allSelected') }}
+              </p>
+            </UFormField>
+            <UFormField
+              :label="t('board.addTask.bugFishingFields.focus.label')"
+              :hint="t('board.addTask.optional')"
+            >
+              <UTextarea
+                v-model="fishingFocus"
+                :rows="2"
+                autoresize
+                :placeholder="t('board.addTask.bugFishingFields.focus.placeholder')"
+                class="w-full"
+              />
+            </UFormField>
+          </div>
+
           <div v-else-if="taskType === 'spike'" class="space-y-3">
             <UFormField :label="t('board.addTask.timebox')">
               <UInput

package/app/components/board/RecurringPipelineModal.vue

@@ -139,17 +139,43 @@ const selectablePipelines = computed(() =>
 )
 const selectedPipeline = computed(() => pipelines.getPipeline(pipelineId.value))
 
+/**
+ * Whether a pipeline RUNS a step of this kind: present in its `agentKinds` AND not disabled.
+ *
+ * The three questions this modal asks about the picked pipeline (does it fish, does it file a
+ * ticket, does it pull from the tracker) are the same question about three kinds, and each of
+ * them has to honour the disabled half: a step somebody turned off imposes nothing, so demanding
+ * its configuration would block a schedule on a step that will not run.
+ */
+function hasEnabledStep(
+  pipeline: { agentKinds: string[]; enabled?: boolean[] } | null | undefined,
+  kind: string,
+): boolean {
+  if (!pipeline) return false
+  return pipeline.agentKinds.some((k, i) => k === kind && pipeline.enabled?.[i] !== false)
+}
+
 // Infer the template from the picked pipeline so the backend seeds the right block
 // description (and so we know to show the tracker config).
 //
 // Only the pipelines whose SHAPE is specific to one kind of recurring work can be inferred this
-// way, and `bug-triage` is now the only one: `dep-update` and `tech-debt` were both retired from
-// the catalog (the first was the ordinary build tail under a recurring name, the second that tail
-// behind an audit head), so those schedules now run an ordinary build rung — which is also what
-// every generic schedule runs, so inferring a template from it would mislabel all of them. Both
-// templates survive for an explicit API caller; see `scheduleTemplateSchema`.
+// way. `dep-update` and `tech-debt` were both retired from the catalog (the first was the
+// ordinary build tail under a recurring name, the second that tail behind an audit head), so
+// those schedules now run an ordinary build rung — which is also what every generic schedule
+// runs, so inferring a template from it would mislabel all of them. Both templates survive for an
+// explicit API caller; see `scheduleTemplateSchema`.
+//
+// The expedition is read off its own step KIND rather than off `pl_bug_fishing`'s id, for the
+// reason `filesTicket` below states: an id keys on the one preset that ships today and misses
+// every pipeline a workspace composes around the same step, and the whole seed description is
+// about what a `bug-fisher` pass does.
+const isBugFishing = computed(() => hasEnabledStep(selectedPipeline.value, 'bug-fisher'))
 const template = computed<ScheduleTemplate>(() =>
-  pipelineId.value === 'pl_bug_triage' ? 'bug-triage' : 'custom',
+  isBugFishing.value
+    ? 'bug-fishing'
+    : pipelineId.value === 'pl_bug_triage'
+      ? 'bug-triage'
+      : 'custom',
 )
 /**
  * Whether the picked pipeline FILES a ticket (an enabled `tracker` step), so the schedule's first
@@ -159,24 +185,12 @@ const template = computed<ScheduleTemplate>(() =>
  * `analysis` + `tracker` head. Keying on the id would have offered the tracker config to exactly
  * the one pipeline that no longer exists, and to none of the pipelines that now do this work.
  */
-const filesTicket = computed(() => {
-  const pipeline = selectedPipeline.value
-  if (!pipeline) return false
-  return pipeline.agentKinds.some(
-    (kind, i) => kind === 'tracker' && pipeline.enabled?.[i] !== false,
-  )
-})
+const filesTicket = computed(() => hasEnabledStep(selectedPipeline.value, 'tracker'))
 
 // A pipeline whose ENABLED steps include `bug-intake` pulls its work from the tracker board, so
 // the intake config is surfaced + required. Mirrors the backend `pipelineHasEnabledBugIntake`
 // (a disabled step imposes nothing), so the modal doesn't demand config for a step that won't run.
-const isBugIntake = computed(() => {
-  const pipeline = selectedPipeline.value
-  if (!pipeline) return false
-  return pipeline.agentKinds.some(
-    (kind, i) => kind === 'bug-intake' && pipeline.enabled?.[i] !== false,
-  )
-})
+const isBugIntake = computed(() => hasEnabledStep(selectedPipeline.value, 'bug-intake'))
 /**
  * Whether the intake section is shown, and in which DISPATCH mode — both DERIVED from the picked
  * pipeline rather than chosen, because the two modes are not interchangeable:

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

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest'
+import {
+  defaultBootstrapDelivery,
+  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
+// 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.
+
+describe('serviceDirectoryLeaf', () => {
+  it('is the typed path’s own last segment, not the service name', () => {
+    expect(serviceDirectoryLeaf('services/billing', 'payments')).toBe('billing')
+  })
+
+  it('treats a bare name as the leaf (a directory at the repo root)', () => {
+    expect(serviceDirectoryLeaf('billing', 'payments')).toBe('billing')
+  })
+
+  it('survives a trailing slash rather than reading as an empty leaf', () => {
+    expect(serviceDirectoryLeaf('services/billing/', 'payments')).toBe('billing')
+  })
+
+  it('falls back to the service name while the field is still blank', () => {
+    expect(serviceDirectoryLeaf('', 'payments')).toBe('payments')
+    expect(serviceDirectoryLeaf('   ', '  payments  ')).toBe('payments')
+  })
+
+  it('is empty when neither is known, so the tree can say it has nothing to place', () => {
+    expect(serviceDirectoryLeaf('', '')).toBe('')
+  })
+})
+
+describe('serviceDirectoryParent', () => {
+  it('is the folder the typed path sits in', () => {
+    expect(serviceDirectoryParent('packages/services/billing')).toBe('packages/services')
+  })
+
+  it('is the repo root for a bare name', () => {
+    expect(serviceDirectoryParent('billing')).toBe('')
+    expect(serviceDirectoryParent('')).toBe('')
+  })
+})
+
+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
+    // ones, so a constant would render the wrong answer for one of them and ask the person to
+    // correct a choice they never made. Same rule the backend applies to a request naming none.
+    expect(defaultBootstrapDelivery(true)).toBe('pull_request')
+    expect(defaultBootstrapDelivery(false)).toBe('direct_push')
+  })
+})

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

@@ -0,0 +1,44 @@
+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.
+
+/**
+ * What the new directory is called: the last segment of the typed path.
+ *
+ * Falls back to the service name, which is what the field's own seeding watcher would have put
+ * there anyway, so opening the tree before typing a path still has a name to place. Empty only
+ * when NEITHER is known, and that answer is load-bearing: with nothing to place, the tree can
+ * decide nothing and says so rather than offering picks that compose a bare folder path.
+ */
+export function serviceDirectoryLeaf(directory: string, serviceName: string): string {
+  return repoPathSegments(directory).at(-1) ?? serviceName.trim()
+}
+
+/**
+ * The folder the typed path sits in, and so where the tree should OPEN: empty for a bare name,
+ * because a name with no parent is a directory at the repo root.
+ */
+export function serviceDirectoryParent(directory: string): string {
+  return repoPathSegments(directory).slice(0, -1).join('/')
+}
+
+/**
+ * The delivery a target takes when nobody has answered the question.
+ *
+ * The backend applies the same rule for a request that names none, and it is stated on both
+ * sides deliberately: the form has to SHOW the default it is about to send, and a control
+ * rendering the wrong one asks the person to correct something they never chose. The two targets
+ * want opposite answers, which is why it is a function of the target rather than a constant.
+ *
+ * Also what the form RESETS to after a launch: an explicit choice binds the run it was made for,
+ * never every later one, so the reset restores the default for whatever target is still selected.
+ */
+export function defaultBootstrapDelivery(intoMonorepo: boolean): BootstrapDelivery {
+  return intoMonorepo ? 'pull_request' : 'direct_push'
+}

package/app/components/bootstrap/BootstrapModal.vue

@@ -4,7 +4,18 @@
 // adapt it (in a sandbox container) — either by cloning a chosen reference
 // architecture, or from scratch following a freeform prompt. The modal pairs the
 // launch form with the managed base list.
-import type { BootstrapStatus, FrameRepoType, ReferenceArchitecture } from '~/types/domain'
+import type {
+  BootstrapDelivery,
+  BootstrapStatus,
+  FrameRepoType,
+  ReferenceArchitecture,
+} from '~/types/domain'
+import {
+  defaultBootstrapDelivery,
+  serviceDirectoryLeaf,
+  serviceDirectoryParent,
+} from '~/components/bootstrap/BootstrapModal.logic'
+import RepoTreeBrowser from '~/components/github/RepoTreeBrowser.vue'
 import VcsConnectSurfaces from '~/components/vcs/VcsConnectSurfaces.vue'
 import { appInstallationManageUrl, newRepoUrl, VCS_PROVIDER_LABELS } from '~/utils/vcs'
 
@@ -100,6 +111,42 @@ const targetItems = computed(() => [
 ])
 const intoMonorepo = computed(() => target.value === 'monorepo')
 
+// ---- how the work LANDS ----------------------------------------------------
+// A third axis, orthogonal to both of the above: the same service, written the same way, either
+// arrives as a pull request somebody reviews or straight on the default branch. The two targets
+// want opposite defaults (a repository being created has nobody to review its first commit; a
+// monorepo's default branch is the branch every other service builds from), which is exactly why
+// this is a control and not a constant.
+const delivery = ref<BootstrapDelivery>(defaultBootstrapDelivery(false))
+// Whether the person has answered this question themselves. Until they have, switching target
+// re-defaults; once they have, their answer stands, because re-defaulting over an explicit
+// choice is how a run they asked to review lands unreviewed. Cleared after a launch, so the
+// answer binds the run it was given for rather than every later one (see `launch`).
+const deliveryTouched = ref(false)
+watch(intoMonorepo, (into) => {
+  if (!deliveryTouched.value) delivery.value = defaultBootstrapDelivery(into)
+})
+function chooseDelivery(value: BootstrapDelivery) {
+  deliveryTouched.value = true
+  delivery.value = value
+}
+const deliveryItems = computed(() => [
+  {
+    label: t('bootstrap.delivery.pullRequest.label'),
+    value: 'pull_request' as const,
+    description: intoMonorepo.value
+      ? t('bootstrap.delivery.pullRequest.descMonorepo')
+      : t('bootstrap.delivery.pullRequest.descNewRepo'),
+  },
+  {
+    label: t('bootstrap.delivery.directPush.label'),
+    value: 'direct_push' as const,
+    description: intoMonorepo.value
+      ? t('bootstrap.delivery.directPush.descMonorepo')
+      : t('bootstrap.delivery.directPush.descNewRepo'),
+  },
+])
+
 /** The projected repo the new service lands in, by numeric id. */
 const monorepoRepoId = ref<number | undefined>(undefined)
 const monorepoDirectory = ref('')
@@ -108,20 +155,43 @@ 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.
+// `repoPathSegments` is the backend's `normalizeServiceDirectory` reduction: 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 directorySegments = computed(() => repoPathSegments(monorepoDirectory.value))
 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')
+  if (!monorepoDirectory.value.trim()) return undefined
+  if (!directorySegments.value.length) return t('bootstrap.monorepo.directory.error.empty')
+  if (directorySegments.value.some((seg) => seg === '..')) {
+    return t('bootstrap.monorepo.directory.error.escapes')
+  }
   return undefined
 })
 
+// ---- exploring the monorepo for the directory's home -----------------------
+// The target must NOT exist, so nothing in the tree can BE it: the tree picks the enclosing
+// folder and hands back that folder plus the leaf (see `BootstrapModal.logic`, which owns the
+// two readings of the typed value).
+const directoryLeaf = computed(() => serviceDirectoryLeaf(monorepoDirectory.value, repoName.value))
+const browsingDirectory = ref(false)
+// The folder the tree opens at, captured when the browser is OPENED rather than read live off
+// the field: as a computed it would re-navigate the listing on every keystroke in the input.
+const directoryBrowseStart = ref('')
+
+function toggleDirectoryBrowse() {
+  if (!browsingDirectory.value) {
+    directoryBrowseStart.value = serviceDirectoryParent(monorepoDirectory.value)
+  }
+  browsingDirectory.value = !browsingDirectory.value
+}
+
+/** The tree emits the composed path: the folder it was standing in plus the leaf it was given. */
+function placeDirectory(path: string | undefined) {
+  if (!path) return
+  monorepoDirectory.value = path
+  browsingDirectory.value = false
+}
+
 // 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]) => {
@@ -295,6 +365,7 @@ async function launch() {
       private: isPrivate.value,
       instructions: instructions.value.trim(),
       type: selectedType.value,
+      delivery: delivery.value,
       ...(intoMonorepo.value && monorepoRepoId.value
         ? {
             monorepo: {
@@ -332,8 +403,15 @@ async function launch() {
       description.value = ''
       instructions.value = ''
       monorepoDirectory.value = ''
+      browsingDirectory.value = false
       // Reset the repo role too, so a later bootstrap doesn't silently inherit this one's type.
       selectedType.value = 'service'
+      // And the delivery, which has to reset the ANSWERED flag with it: leaving that set disarms
+      // the per-target default for good, so a "push directly" picked deliberately for one
+      // monorepo would go on governing the next bootstrap, into a different repository, without
+      // the person having been asked about that one. Back to the current target's own default.
+      deliveryTouched.value = false
+      delivery.value = defaultBootstrapDelivery(intoMonorepo.value)
       // The provisional frame arrived (bootstrap() refreshed the board). Re-home it to
       // free space so it never overlaps an existing service — the backend places it on a
       // fixed diagonal stagger that can land on top of a large neighbour — then centre the
@@ -524,6 +602,17 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
             <URadioGroup v-model="target" :items="targetItems" />
           </UFormField>
 
+          <!-- Where the service goes and how it gets there are two questions, and the second
+               has no answer that is right for both targets. Its descriptions therefore change
+               with the target rather than the control being duplicated per target. -->
+          <UFormField :label="t('bootstrap.delivery.label')" required>
+            <URadioGroup
+              :model-value="delivery"
+              :items="deliveryItems"
+              @update:model-value="chooseDelivery($event as BootstrapDelivery)"
+            />
+          </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. -->
@@ -550,11 +639,49 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
               required
               :error="directoryError"
             >
-              <UInput
-                v-model="monorepoDirectory"
-                :placeholder="t('bootstrap.monorepo.directory.placeholder')"
-                class="w-full"
-              />
+              <div class="space-y-2">
+                <div class="flex items-center gap-2">
+                  <UInput
+                    v-model="monorepoDirectory"
+                    :placeholder="t('bootstrap.monorepo.directory.placeholder')"
+                    class="flex-1"
+                  />
+                  <UButton
+                    v-if="monorepoRepoId !== undefined"
+                    variant="soft"
+                    color="neutral"
+                    icon="i-lucide-folder-search"
+                    :title="t('bootstrap.monorepo.directory.browse')"
+                    :aria-label="t('bootstrap.monorepo.directory.browse')"
+                    data-testid="bootstrap-directory-browse"
+                    @click="toggleDirectoryBrowse()"
+                  />
+                </div>
+
+                <!-- The tree answers WHERE, never WHAT: with no name to place yet it could
+                     decide nothing, so say that instead of listing a repo for nothing. -->
+                <div
+                  v-if="browsingDirectory && monorepoRepoId !== undefined"
+                  class="rounded-md border border-slate-800 bg-slate-900/40 p-2"
+                >
+                  <p class="mb-2 text-xs text-slate-400">
+                    {{
+                      directoryLeaf
+                        ? t('bootstrap.monorepo.directory.browseHint')
+                        : t('bootstrap.monorepo.directory.browseNeedsName')
+                    }}
+                  </p>
+                  <RepoTreeBrowser
+                    v-if="directoryLeaf"
+                    :repo-github-id="monorepoRepoId"
+                    mode="dir"
+                    :new-dir-name="directoryLeaf"
+                    :model-value="monorepoDirectory"
+                    :start-path="directoryBrowseStart"
+                    @update:model-value="placeDirectory"
+                  />
+                </div>
+              </div>
             </UFormField>
           </template>
 
@@ -733,6 +860,18 @@ const statusLabel = computed<Record<BootstrapStatus, string>>(() => ({
               >
                 {{ t('bootstrap.recent.open') }}
               </ULink>
+              <!-- The deliverable of a `pull_request` run, and the only thing it produced that
+                   the user still has to act on. A monorepo run has no `repoUrl` at all, so
+                   without this the run's whole output is unreachable from the list that
+                   offered the choice. -->
+              <ULink
+                v-if="job.prUrl"
+                :to="job.prUrl"
+                target="_blank"
+                class="text-[11px] text-indigo-400 hover:underline"
+              >
+                {{ t('bootstrap.recent.openPr') }}
+              </ULink>
               <UBadge :color="statusColor[job.status]" variant="subtle" size="sm">
                 {{ statusLabel[job.status] }}
               </UBadge>