@cat-factory/app 0.296.2 → 0.296.4

package/README.md

@@ -203,9 +203,10 @@ reaches the wire. **Every string a descriptor carries is deployment-authored Eng
 verbatim**, labels, help, option captions and the `section` grouping captions alike: only the
 platform's own chrome around them (the path-invalid message) is i18n, so no descriptor string enters
 a locale catalog. And **the value-bag rules live in `utils/descriptorFields.ts`, not in the SFC**
-(`defaultDescriptorValues` for the initial values, `setDescriptorValue` / `setDescriptorCheckbox` /
-`toggleDescriptorGroupValue` for one edit): what an edit freezes on an entity is what a unit test
-must be able to reach, and a rule inside a component is only reachable by mounting one.
+(`setDescriptorValue` / `setDescriptorCheckbox` / `toggleDescriptorGroupValue` for one edit; the
+initial values come straight from contracts' `descriptorFieldDefaults`, the same helper the server
+folds in at the creation door): what an edit freezes on an entity is what a unit test must be able
+to reach, and a rule inside a component is only reachable by mounting one.
 
 Mirroring the server's check leaves one refusal still reachable, deliberately: the deployment can
 re-register the descriptor while the dialog sits open, so a create can come back `422` with

package/app/components/board/AddTaskModal.vue

@@ -22,7 +22,11 @@ import type {
   TaskTypeFields,
 } from '~/types/domain'
 import { DOC_KINDS, DOC_KIND_FIELDS } from '~/types/domain'
-import { BUG_FISHING_PHASES } from '@cat-factory/contracts'
+import {
+  BUG_FISHING_DEFAULT_PASS_BUDGET,
+  BUG_FISHING_MAX_PASS_BUDGET,
+  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'
@@ -39,7 +43,7 @@ import {
   sanitizeDescriptorFields,
   validateDescriptorFields,
 } from '@cat-factory/contracts'
-import { defaultDescriptorValues } from '~/utils/descriptorFields'
+import { descriptorFieldDefaults } from '@cat-factory/contracts'
 import { pipelineAllowedForManualStart } from '~/utils/pipeline'
 import { buildTaskTypePickerRows } from '~/utils/taskTypePicker'
 
@@ -138,6 +142,8 @@ const timeboxHours = ref<number | undefined>(undefined)
 // the deliberate act) plus an optional focus folded into every angle's prompt.
 const fishingPhaseIds = ref<string[]>([])
 const fishingFocus = ref('')
+/** Held as a string because the input is a text field; parsed at submit, blank ⇒ the default. */
+const fishingMaxPasses = ref('')
 // Spike research criteria — folded into the spike agent's prompt (see the backend `spike` kind).
 const spikeResearchQuestion = ref('')
 const spikeSuccessCriteria = ref('')
@@ -304,12 +310,37 @@ function buildCustomTypeFields(): TaskTypeFields | undefined {
  * 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.
  */
+/**
+ * The typed pass budget, or undefined when the field is blank.
+ *
+ * `null` is the third answer: something was typed that is not a budget. Kept distinct from blank
+ * so {@link fishingMaxPassesProblem} can refuse it HERE, where the person can see which field is
+ * wrong, rather than letting the create call come back as a generic 422 whose only detail is a
+ * valibot path.
+ */
+const fishingMaxPassesValue = computed<number | null | undefined>(() => {
+  const raw = fishingMaxPasses.value.trim()
+  if (!raw) return undefined
+  const parsed = Number(raw)
+  if (!Number.isInteger(parsed)) return null
+  return parsed >= 1 && parsed <= BUG_FISHING_MAX_PASS_BUDGET ? parsed : null
+})
+
+/** The message shown under the pass-budget field, or null when it is fine. */
+const fishingMaxPassesProblem = computed(() =>
+  fishingMaxPassesValue.value === null
+    ? t('board.addTask.bugFishingFields.maxPasses.problem', { max: BUG_FISHING_MAX_PASS_BUDGET })
+    : null,
+)
+
 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()
+  const maxPasses = fishingMaxPassesValue.value
+  if (typeof maxPasses === 'number') f.fishingMaxPasses = maxPasses
   return Object.keys(f).length ? f : undefined
 }
 
@@ -493,7 +524,7 @@ watch(taskType, (next) => {
   const custom = customTaskTypes.value.find((tt) => tt.taskType === next)
   // A custom type owns a fresh field bag on every switch (its descriptors differ per type), seeded
   // to whatever defaults the new type declares.
-  customFieldValues.value = defaultDescriptorValues(custom?.fields ?? [])
+  customFieldValues.value = descriptorFieldDefaults(custom?.fields ?? [])
   // An unresolvable preset leaves the current selection alone rather than blanking it: a type
   // switch is an edit to a form the user is already filling in, not a reset.
   const preset = defaultPipelineIdFor(next)
@@ -597,6 +628,7 @@ watch(open, (isOpen) => {
   timeboxHours.value = undefined
   fishingPhaseIds.value = []
   fishingFocus.value = ''
+  fishingMaxPasses.value = ''
   spikeResearchQuestion.value = ''
   spikeSuccessCriteria.value = ''
   spikeOptionsToCompare.value = ''
@@ -708,6 +740,10 @@ const canAdd = computed(() => {
     return false
   // A custom type's collected form must satisfy its descriptor (the same rule the server enforces).
   if (customFieldProblems.value.length > 0) return false
+  // The pass budget is bounded by `taskTypeFieldsSchema`, so a value outside it is refused at
+  // creation whatever this form does. Refusing it here is what turns that into a message beside
+  // the field rather than a generic failure toast.
+  if (taskType.value === 'bug-fishing' && fishingMaxPassesProblem.value) return false
   return true
 })
 
@@ -1105,6 +1141,30 @@ function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseC
                 class="w-full"
               />
             </UFormField>
+            <!-- An OVERRIDE, so it is hidden at the basic tier and what remains is exactly the
+                 shipped default it would have shown. It bites only on a codebase large enough to
+                 be split into territories, where the plan is territories x angles. -->
+            <UFormField
+              v-if="uiMode.isAdvanced"
+              :label="t('board.addTask.bugFishingFields.maxPasses.label')"
+              :hint="t('board.addTask.optional')"
+              :description="
+                t('board.addTask.bugFishingFields.maxPasses.hint', {
+                  count: BUG_FISHING_DEFAULT_PASS_BUDGET,
+                })
+              "
+              :error="fishingMaxPassesProblem ?? undefined"
+            >
+              <UInput
+                v-model="fishingMaxPasses"
+                type="number"
+                :min="1"
+                :max="BUG_FISHING_MAX_PASS_BUDGET"
+                :step="1"
+                :placeholder="String(BUG_FISHING_DEFAULT_PASS_BUDGET)"
+                data-testid="add-task-fishing-max-passes"
+              />
+            </UFormField>
           </div>
 
           <div v-else-if="taskType === 'spike'" class="space-y-3">

package/app/components/board/BoardCanvas.vue

@@ -5,7 +5,7 @@ import BlockNode from './nodes/BlockNode.vue'
 import EpicNode from './nodes/EpicNode.vue'
 import TaskDependencyEdges from './TaskDependencyEdges.vue'
 import DependencyConnectOverlay from './DependencyConnectOverlay.vue'
-import { readDndPayload, blockIdFromEvent } from '~/utils/dnd'
+import { blockIdFromEvent } from '~/utils/dnd'
 import { BOARD_FLOW_ID, BOARD_MIN_ZOOM, BOARD_MAX_ZOOM } from '~/composables/useBoardFlow'
 import { provideBoardActivity } from '~/composables/useBoardActivity'
 import { useTaskExpansion } from '~/composables/useTaskExpansion'
@@ -18,21 +18,17 @@ import { boardPanMode } from '~/utils/boardPanMode'
 import { createBoardNodeProjection } from './BoardCanvas.logic'
 
 const board = useBoardStore()
-const pipelines = usePipelinesStore()
-const execution = useExecutionStore()
 const ui = useUiStore()
 const github = useGitHubStore()
-const toast = useToast()
 // The drop resolves its target task at the moment of the drop, so the sandbox reading is a
 // function of that id rather than a computed over a bound block.
-const { forcedFor } = useDryRunPolicy()
 const access = useWorkspaceAccess()
 const { t } = useI18n()
 
-const { onNodeDragStop, onViewportChange, screenToFlowCoordinate } = useVueFlow(BOARD_FLOW_ID)
+const { onNodeDragStop, onViewportChange } = useVueFlow(BOARD_FLOW_ID)
 const { draggingId } = useBlockDrag()
 const { hoveredFrameId } = useFrameStacking()
-const { freeFramePosition, focusFrame } = useFramePlacement()
+const { focusFrame } = useFramePlacement()
 // The board's "no two top-level nodes overlap" invariant: whenever a frame comes to overlap a
 // neighbour (dragged onto it, grown into it by a border drag, or grown by its first task), the two
 // are bounced apart. Every client draws that correction; only the one whose own gesture caused the
@@ -127,94 +123,10 @@ function onNodeDoubleClick({ event, node }: NodeMouseEvent) {
 function onPaneClick() {
   ui.select(null)
 }
-
-// ---- palette drag & drop onto the canvas ----------------------------------
-function onDragOver(event: DragEvent) {
-  event.preventDefault()
-  if (event.dataTransfer) event.dataTransfer.dropEffect = 'copy'
-}
-
-async function onDrop(event: DragEvent) {
-  event.preventDefault()
-  const payload = readDndPayload(event)
-  if (!payload) return
-
-  if (payload.kind === 'block') {
-    // Drop where the cursor is, but nudge off any existing frame it lands on so a new
-    // frame never overlaps a neighbour; then centre the camera on it.
-    const dropped = screenToFlowCoordinate({ x: event.clientX, y: event.clientY })
-    const position = freeFramePosition({ near: dropped })
-    try {
-      const block = await board.addBlock(payload.blockType, position)
-      ui.select(block.id)
-      await focusFrame(block.id)
-    } catch {
-      toast.add({
-        title: t('board.canvas.addBlockFailedTitle'),
-        description: t('board.canvas.addBlockFailedBody'),
-        color: 'error',
-      })
-    }
-    return
-  }
-
-  if (payload.kind === 'pipeline') {
-    // Pipelines run against tasks, not frames. The nearest [data-block-id] under
-    // the cursor is the task card when dropped inside an expanded frame.
-    const blockId = blockIdFromEvent(event)
-    const target = blockId ? board.getBlock(blockId) : undefined
-    const pipeline = pipelines.getPipeline(payload.pipelineId)
-    // Unknown pipeline id is an internal glitch (nothing the user can act on); a drop
-    // onto blank canvas / a non-block, though, needs the same "aim at a task" nudge the
-    // wrong-level path gives — otherwise the drop just vanishes (UX-07).
-    if (!pipeline) return
-    if (!target) {
-      toast.add({
-        title: t('board.canvas.dropOntoTaskTitle'),
-        description: t('board.canvas.dropOntoTaskBody'),
-      })
-      return
-    }
-    if (target.level !== 'task') {
-      toast.add({
-        title: t('board.canvas.dropOntoTaskTitle'),
-        description: t('board.canvas.dropOntoTaskBody'),
-      })
-      return
-    }
-    if (!board.isRunnable(target.id)) {
-      toast.add({
-        title: t('board.canvas.taskBlockedTitle'),
-        description: t('board.canvas.taskBlockedBody'),
-      })
-      return
-    }
-    // A dropped pipeline starts live and has nothing to ask for, but a preset that sandboxes the
-    // dropper's role means this run merges nothing. Said HERE, because the drop is the only
-    // moment this surface has: the ordinary start stays silent (it is already visible on the
-    // card it landed on), and only the sandbox, which is not, earns a toast.
-    if (forcedFor(target.id)) {
-      toast.add({
-        title: t('board.dryRunToast.title'),
-        description: t('board.dryRunToast.body', { name: pipeline.name }),
-        color: 'warning',
-        icon: 'i-lucide-shield',
-      })
-    }
-    execution.start(target.id, pipeline)
-    ui.select(target.id)
-  }
-}
 </script>
 
 <template>
-  <div
-    ref="boardEl"
-    data-testid="board-canvas"
-    class="relative h-full w-full"
-    @drop="onDrop"
-    @dragover="onDragOver"
-  >
+  <div ref="boardEl" data-testid="board-canvas" class="relative h-full w-full">
     <VueFlow
       :id="BOARD_FLOW_ID"
       :nodes="nodes"

package/app/components/board/CreateInitiativeModal.vue

@@ -21,7 +21,7 @@ import {
   validateInitiativePresetInputs,
 } from '@cat-factory/contracts'
 import type { InitiativePresetInputs, InitiativePresetInputValue } from '~/types/domain'
-import { defaultDescriptorValues } from '~/utils/descriptorFields'
+import { descriptorFieldDefaults } from '@cat-factory/contracts'
 import { GENERIC_PRESET_ID } from '~/stores/initiative'
 import DescriptorFields from '~/components/common/DescriptorFields.vue'
 import ContextAttachmentFields from '~/components/context/ContextAttachmentFields.vue'
@@ -71,7 +71,7 @@ let probeSeq = 0
 /** Seed the form to the selected preset's descriptor defaults, then fire its detection probe. */
 function applyPreset(): void {
   const descriptor = selectedPreset.value
-  inputs.value = descriptor ? defaultDescriptorValues(descriptor.fields) : {}
+  inputs.value = descriptor ? descriptorFieldDefaults(descriptor.fields) : {}
   void runProbe()
 }
 

package/app/components/bugFishing/BugFishingWindow.vue

@@ -68,11 +68,44 @@ const severityRank = (s: BugFishingSeverity) => {
 }
 
 /**
- * Which phase's findings the reader is looking at. `null` is "everything caught so far", which
- * is the default because an expedition's value is the whole catch — the per-phase filter exists
+ * A pass is an ANGLE over a TERRITORY, so a phase id alone no longer identifies one: on a
+ * partitioned codebase the same angle runs once per territory. The rail selects, filters and
+ * counts by this pair, which is also why it is derived in one place rather than spelled at each
+ * site.
+ */
+function passKey(pass: { id: string; territoryId?: string | null }): string {
+  return `${pass.territoryId ?? ''}::${pass.id}`
+}
+
+/**
+ * Which pass's findings the reader is looking at. `null` is "everything caught so far", which
+ * is the default because an expedition's value is the whole catch — the per-pass filter exists
  * for someone working through one angle at a time, not as the primary reading.
  */
-const selectedPhaseId = ref<string | null>(null)
+const selectedPassKey = ref<string | null>(null)
+
+/**
+ * The passes grouped by the territory they fished, in plan order.
+ *
+ * One group with no territory is the pass-through: a codebase small enough to fish whole (or an
+ * expedition planned before territories existed) renders exactly the flat angle rail it always
+ * did, because its group has no header to show.
+ */
+const territoryGroups = computed(() => {
+  const groups: { id: string | null; label: string | null; passes: typeof phases.value }[] = []
+  for (const phase of phases.value) {
+    const id = phase.territoryId ?? null
+    const last = groups[groups.length - 1]
+    if (last && last.id === id) last.passes.push(phase)
+    else groups.push({ id, label: phase.territoryLabel ?? null, passes: [phase] })
+  }
+  return groups
+})
+
+/** The expedition's plan: the budget, what it cut, and what the survey could not see. */
+const plan = computed(() => state.value?.plan ?? null)
+/** The cells the pass budget cut, so the window can name the ground nobody looked at. */
+const unfished = computed(() => plan.value?.unfished ?? [])
 
 /** Whether findings whose decision has been made are shown. Off by default: what is left to
  *  decide is the working list, and a triaged finding that stays in it reads as untriaged. */
@@ -92,10 +125,12 @@ function isOpen(f: BugFishingFinding): boolean {
 }
 
 const visibleFindings = computed<BugFishingFinding[]>(() => {
-  const byPhase = selectedPhaseId.value
-    ? findings.value.filter((f) => f.phaseId === selectedPhaseId.value)
+  const byPass = selectedPassKey.value
+    ? findings.value.filter(
+        (f) => passKey({ id: f.phaseId, territoryId: f.territoryId }) === selectedPassKey.value,
+      )
     : findings.value
-  const triaged = showTriaged.value ? byPhase : byPhase.filter(isOpen)
+  const triaged = showTriaged.value ? byPass : byPass.filter(isOpen)
   return [...triaged].sort((a, b) => severityRank(a.severity) - severityRank(b.severity))
 })
 
@@ -106,19 +141,38 @@ const spawnedCount = computed(
   () => findings.value.filter((f) => f.spawn?.status === 'spawned').length,
 )
 
-/** The phase the rail has selected, when one is. */
+/** The pass the rail has selected, when one is. */
 const selectedPhase = computed(() =>
-  selectedPhaseId.value ? (phases.value.find((p) => p.id === selectedPhaseId.value) ?? null) : null,
+  selectedPassKey.value
+    ? (phases.value.find((p) => passKey(p) === selectedPassKey.value) ?? null)
+    : null,
 )
 
+/**
+ * What share of its territory's manifest a settled pass reported reading, as a percentage, or
+ * null when there is nothing honest to show.
+ *
+ * Null covers two different absences on purpose, and neither renders as 0%. A pass that reported
+ * no paths said nothing about what it read, and a whole-codebase pass had no manifest to be a
+ * share of; showing either as "0% covered" would accuse a pass that may have read everything.
+ */
+function coverageShare(pass: { coverage?: { filesRead: number; manifestFiles: number } | null }) {
+  const coverage = pass.coverage
+  if (!coverage || coverage.manifestFiles <= 0) return null
+  return Math.min(100, Math.round((coverage.filesRead / coverage.manifestFiles) * 100))
+}
+
 /** How many angles have settled (completed or failed) — what the still-fishing banner counts. */
 const settledPhaseCount = computed(
   () => phases.value.filter((p) => p.status === 'completed' || p.status === 'failed').length,
 )
 
-/** How many findings each phase contributed, for the rail's per-angle count. */
-function phaseFindingCount(phaseId: string): number {
-  return findings.value.filter((f) => f.phaseId === phaseId).length
+/** How many findings each pass contributed, for the rail's per-pass count. */
+function phaseFindingCount(pass: { id: string; territoryId?: string | null }): number {
+  const key = passKey(pass)
+  return findings.value.filter(
+    (f) => passKey({ id: f.phaseId, territoryId: f.territoryId }) === key,
+  ).length
 }
 
 /**
@@ -216,50 +270,80 @@ const PHASE_ICON: Record<string, string> = {
           type="button"
           class="mb-1 w-full rounded-md px-2 py-1.5 text-left text-[12px]"
           :class="
-            selectedPhaseId === null
+            selectedPassKey === null
               ? 'bg-slate-800 text-slate-100'
               : 'text-slate-400 hover:bg-slate-800/60'
           "
-          @click="selectedPhaseId = null"
+          @click="selectedPassKey = null"
         >
           {{ t('bugFishing.phases.all', { count: findings.length }) }}
         </button>
-        <ul class="space-y-0.5">
-          <li v-for="phase in phases" :key="phase.id">
-            <button
-              type="button"
-              class="flex w-full items-start gap-2 rounded-md px-2 py-1.5 text-left"
-              :class="
-                selectedPhaseId === phase.id
-                  ? 'bg-slate-800 text-slate-100'
-                  : 'text-slate-400 hover:bg-slate-800/60'
-              "
-              :data-testid="`bug-fishing-phase-${phase.id}`"
-              @click="selectedPhaseId = phase.id"
-            >
-              <UIcon
-                :name="PHASE_ICON[phase.status] ?? 'i-lucide-circle-dashed'"
-                class="mt-0.5 h-3.5 w-3.5 shrink-0"
-                :class="{
-                  'animate-spin text-sky-300': phase.status === 'fishing',
-                  'text-emerald-400': phase.status === 'completed',
-                  'text-amber-400': phase.status === 'failed',
-                  'text-slate-600': phase.status === 'pending',
-                }"
-              />
-              <span class="min-w-0 flex-1">
-                <span class="block truncate text-[12px]">{{ phase.title }}</span>
-                <span class="block text-[10px] text-slate-500">
-                  {{
-                    phase.status === 'completed' || phase.status === 'failed'
-                      ? t('bugFishing.phases.found', { count: phaseFindingCount(phase.id) })
-                      : t(`bugFishing.phases.status.${phase.status}`)
-                  }}
+        <!-- Grouped by TERRITORY on a partitioned codebase. A codebase small enough to fish
+             whole has one group with no label, which renders as the flat angle rail. -->
+        <div v-for="group in territoryGroups" :key="group.id ?? 'whole'" class="mb-2">
+          <p
+            v-if="group.label"
+            class="mb-1 mt-2 truncate px-1 text-[10px] font-semibold uppercase tracking-wide text-sky-400/80"
+            :title="group.label"
+          >
+            {{ group.label }}
+          </p>
+          <ul class="space-y-0.5">
+            <li v-for="phase in group.passes" :key="passKey(phase)">
+              <button
+                type="button"
+                class="flex w-full items-start gap-2 rounded-md px-2 py-1.5 text-left"
+                :class="
+                  selectedPassKey === passKey(phase)
+                    ? 'bg-slate-800 text-slate-100'
+                    : 'text-slate-400 hover:bg-slate-800/60'
+                "
+                :data-testid="`bug-fishing-phase-${phase.id}`"
+                @click="selectedPassKey = passKey(phase)"
+              >
+                <UIcon
+                  :name="PHASE_ICON[phase.status] ?? 'i-lucide-circle-dashed'"
+                  class="mt-0.5 h-3.5 w-3.5 shrink-0"
+                  :class="{
+                    'animate-spin text-sky-300': phase.status === 'fishing',
+                    'text-emerald-400': phase.status === 'completed',
+                    'text-amber-400': phase.status === 'failed',
+                    'text-slate-600': phase.status === 'pending',
+                  }"
+                />
+                <span class="min-w-0 flex-1">
+                  <span class="block truncate text-[12px]">{{ phase.title }}</span>
+                  <span class="block text-[10px] text-slate-500">
+                    {{
+                      phase.status === 'completed' || phase.status === 'failed'
+                        ? t('bugFishing.phases.found', { count: phaseFindingCount(phase) })
+                        : t(`bugFishing.phases.status.${phase.status}`)
+                    }}
+                  </span>
+                  <!-- The coverage rail. A LOW share is what tells a reader that "found nothing"
+                       here means "did not look"; absent (a pass that reported no reads, or one
+                       with no manifest to be a share of) shows nothing at all rather than 0%. -->
+                  <span
+                    v-if="coverageShare(phase) !== null"
+                    class="mt-1 block"
+                    :data-testid="`bug-fishing-coverage-${phase.id}`"
+                    :title="t('bugFishing.coverage.tooltip', { percent: coverageShare(phase) })"
+                  >
+                    <span class="block h-0.5 w-full rounded-full bg-slate-700">
+                      <span
+                        class="block h-0.5 rounded-full bg-sky-500/70"
+                        :style="{ width: `${coverageShare(phase)}%` }"
+                      />
+                    </span>
+                    <span class="mt-0.5 block text-[10px] text-slate-600">
+                      {{ t('bugFishing.coverage.share', { percent: coverageShare(phase) }) }}
+                    </span>
+                  </span>
                 </span>
-              </span>
-            </button>
-          </li>
-        </ul>
+              </button>
+            </li>
+          </ul>
+        </div>
       </aside>
 
       <div class="min-w-0 flex-1 overflow-y-auto px-5 py-4">
@@ -303,6 +387,44 @@ const PHASE_ICON: Record<string, string> = {
           </span>
         </div>
 
+        <!-- What this expedition did NOT cover. Three separate facts, each with its own fix, so
+             none of them is folded into the others: the pass budget cut cells nobody fished, the
+             provider truncated the tree the territories were computed from, or the codebase could
+             not be surveyed at all. A cap silent about its tail teaches the reader that the tail
+             was clean. -->
+        <div
+          v-if="plan && (unfished.length > 0 || plan.treeTruncated || plan.surveyUnavailableReason)"
+          data-testid="bug-fishing-plan"
+          class="mb-4 rounded-lg border border-amber-500/25 bg-amber-500/5 px-3 py-2 text-[12px] text-amber-200"
+        >
+          <p v-if="plan.surveyUnavailableReason" data-testid="bug-fishing-survey-unavailable">
+            {{ t('bugFishing.plan.surveyUnavailable', { reason: plan.surveyUnavailableReason }) }}
+          </p>
+          <p v-if="plan.treeTruncated" data-testid="bug-fishing-tree-truncated" class="mt-1">
+            {{ t('bugFishing.plan.treeTruncated') }}
+          </p>
+          <template v-if="unfished.length > 0">
+            <p class="mt-1" data-testid="bug-fishing-unfished">
+              {{
+                t('bugFishing.plan.unfished', {
+                  fished: phases.length,
+                  planned: plan.plannedCells,
+                })
+              }}
+            </p>
+            <ul class="mt-1 space-y-0.5 text-[11px] text-amber-200/80">
+              <li v-for="cell in unfished" :key="`${cell.territoryId}::${cell.phaseId}`">
+                {{
+                  t('bugFishing.plan.unfishedCell', {
+                    territory: cell.territoryLabel,
+                    angle: cell.phaseTitle,
+                  })
+                }}
+              </li>
+            </ul>
+          </template>
+        </div>
+
         <!-- What the marks will run. Stated before anything is created, because the pipeline is
              the shape of the work a mark causes. -->
         <div

package/app/components/common/DescriptorFields.vue

@@ -166,11 +166,18 @@ function selectItems(field: DescriptorField) {
           @update:model-value="(v: string) => set(field.key, v)"
         />
 
+        <!-- The declared bounds are INPUT HINTS only: `validateDescriptorFields` is what actually
+             refuses a value, here and at every other door, so a stepper that respects them is a
+             convenience rather than the check. `integer` steps by one; a field that admits
+             fractions leaves `step` unset so the browser does not round the value away. -->
         <UInput
           v-else-if="field.type === 'number'"
           :model-value="numberStr(field.key)"
           type="number"
           class="w-full font-mono"
+          :min="field.min"
+          :max="field.max"
+          :step="field.integer ? 1 : undefined"
           :placeholder="field.placeholder"
           @update:model-value="(v: string) => set(field.key, v === '' ? undefined : Number(v))"
         />

package/app/components/foundational/FoundationalServiceCatalogList.vue

@@ -14,7 +14,8 @@
 // A contract body is fetched only when a human expands one, through the SAME lazy read a consumer
 // dispatch makes — so what is inspected here is what an agent would be given, and merely opening
 // the catalog transfers no documents.
-import { computed, reactive, ref } from 'vue'
+import { computed, ref } from 'vue'
+import { useBusyRows } from '~/composables/useBusyRows'
 import type { ApiContractFormat, FoundationalServiceTier } from '~/types/domain'
 import { useFoundationalServicesStore } from '~/stores/foundationalServices'
 import FoundationalContractSummary from '~/components/foundational/FoundationalContractSummary.vue'
@@ -45,17 +46,7 @@ const tierColor = {
   workspace: 'primary',
 } as const satisfies Record<FoundationalServiceTier, string>
 
-const busyRows = reactive(new Set<string>())
-const rowBusy = (key: string) => busyRows.has(key)
-async function withRow(key: string, fn: () => Promise<void>) {
-  if (busyRows.has(key)) return
-  busyRows.add(key)
-  try {
-    await fn()
-  } finally {
-    busyRows.delete(key)
-  }
-}
+const { rowBusy, withRow } = useBusyRows()
 
 /** Service ids whose contract documents the user has expanded. */
 const expanded = ref<string[]>([])

package/app/components/foundational/FoundationalServiceSources.vue

@@ -14,6 +14,7 @@
 // Mirrors the skill library's sources UI: with the GitHub App connected the user searches a repo
 // and browses to a path; otherwise the manual owner/name fields are the fallback.
 import { computed, reactive, ref, watch } from 'vue'
+import { useBusyRows } from '~/composables/useBusyRows'
 import type {
   FolderScanCoverage,
   FoundationalServiceOwnerKind,
@@ -44,17 +45,7 @@ const { confirm } = useConfirm()
 const githubReady = computed(() => github.available === true && github.connected)
 
 // Per-row in-flight tracking so only the control that triggered an action spins.
-const busyRows = reactive(new Set<string>())
-const rowBusy = (key: string) => busyRows.has(key)
-async function withRow(key: string, fn: () => Promise<void>) {
-  if (busyRows.has(key)) return
-  busyRows.add(key)
-  try {
-    await fn()
-  } finally {
-    busyRows.delete(key)
-  }
-}
+const { rowBusy, withRow } = useBusyRows()
 
 // ---- link a repo source ----------------------------------------------------
 const mode = ref<FoundationalServiceSourceMode>('directory')