@cat-factory/app 0.293.1 → 0.295.0

package/app/components/layout/NotificationsInbox.vue

@@ -68,6 +68,10 @@ const META: Record<Notification['type'], { icon: string; color: Accent }> = {
   // The PR reviewer surfaced findings to triage. Clicking the title opens the PR-review window
   // (see `reveal`); "act" just marks it read (findings are selected in that window, not here).
   pr_review_ready: { icon: 'i-lucide-clipboard-check', color: 'primary' },
+  // A bug-fishing expedition finished every angle and is waiting for its catch to be triaged.
+  // Clicking the title opens the expedition window (see `reveal`); "act" just marks it read
+  // (findings are marked in that window, and each mark spawns its own fix task, not here).
+  bug_fishing_triage: { icon: 'i-lucide-fish', color: 'primary' },
   // The initiative loop needs attention (a blocked task, or completion). Clicking the title
   // opens the initiative tracker window; "act" just marks it read.
   initiative: { icon: 'i-lucide-milestone', color: 'primary' },
@@ -112,6 +116,7 @@ const ACTION_KEYS: Record<Notification['type'], string> = {
   fork_decision_pending: 'layout.notifications.action.fork_decision_pending',
   judge_review: 'layout.notifications.action.judge_review',
   pr_review_ready: 'layout.notifications.action.pr_review_ready',
+  bug_fishing_triage: 'layout.notifications.action.bug_fishing_triage',
   initiative: 'layout.notifications.action.initiative',
   platform_health: 'layout.notifications.action.platform_health',
   budget_paused: 'layout.notifications.action.budget_paused',
@@ -240,6 +245,7 @@ function reveal(n: Notification) {
   else if (n.type === 'fork_decision_pending') revealForkDecision(n)
   else if (n.type === 'judge_review') revealJudge(n)
   else if (n.type === 'pr_review_ready') revealPrReview(n)
+  else if (n.type === 'bug_fishing_triage') revealBugFishing(n)
   else if (n.type === 'initiative') ui.openInitiativeTracker(n.blockId)
   else ui.select(n.blockId)
 }
@@ -295,6 +301,15 @@ function revealPrReview(n: Notification) {
   else if (n.blockId) ui.select(n.blockId)
 }
 
+/**
+ * Open the bug-fishing expedition window for a run whose angles have all settled. Falls back to
+ * focusing the block when the run is not loaded, exactly like its PR-review sibling.
+ */
+function revealBugFishing(n: Notification) {
+  if (n.executionId && execution.getInstance(n.executionId)) ui.openBugFishing(n.executionId)
+  else if (n.blockId) ui.select(n.blockId)
+}
+
 /**
  * Open the human-testing window for a parked `human-test` gate: find the run's parked
  * human-test step and open it through the universal step dispatch (its archetype declares

package/app/components/panels/ResultWindowDrafts.logic.spec.ts

@@ -45,6 +45,10 @@ const WINDOWS: Record<string, { drafts: Disposition; why: string }> = {
     drafts: 'confirm',
     why: 'per-item replies + the redo comment; a reply resolves an item and the redo starts a pass',
   },
+  'bugFishing/BugFishingWindow.vue': {
+    drafts: 'none',
+    why: 'every mark and dismiss commits on click; the fix-pipeline picker and the show-triaged toggle only shape what the NEXT click does',
+  },
   'clarity/ClarityReviewWindow.vue': {
     drafts: 'flush',
     why: 'per-finding answers, each recorded on its own',
@@ -112,7 +116,16 @@ const WINDOWS: Record<string, { drafts: Disposition; why: string }> = {
  * planning window's `v-model:answer="drafts[q.key]"` sat unnoticed in a 'none' row precisely because
  * it looked enough like the lightbox pair to pass a shape test.
  */
-const VIEW_STATE_BINDINGS = ['v-model:open="lightboxOpen"', 'v-model:index="lightboxIndex"']
+const VIEW_STATE_BINDINGS = [
+  'v-model:open="lightboxOpen"',
+  'v-model:index="lightboxIndex"',
+  // The bug-fishing window's two controls. Neither holds unsubmitted work: marking and dismissing
+  // a finding each commit on click, so the picker only decides which pipeline the NEXT mark runs
+  // and the toggle only decides which rows are listed. Losing either on close loses a selection,
+  // not something the user wrote.
+  'v-model="pipelineOverride"',
+  'v-model="showTriaged"',
+]
 
 /** Every component that mounts the shell, keyed by its path relative to `app/components`. */
 function findConsumers(): Map<string, string> {
@@ -167,9 +180,18 @@ function stateBindings(source: string): string[] {
   return [...source.matchAll(pattern)].map((match) => match[0])
 }
 
-/** A native form control, which holds typed input whether or not it carries a `v-model`. */
+/**
+ * A native form control, which holds typed input whether or not it carries a `v-model`.
+ *
+ * Checkboxes and radios are deliberately excluded: they hold a CHOICE, not typed input, so one
+ * left unsubmitted is a control the user can re-make in a click rather than something they wrote
+ * and would lose. The exclusion costs nothing, because this predicate is only the fallback for a
+ * control carrying no `v-model` at all — a toggle anybody reads is bound, and a binding is
+ * unknown to {@link VIEW_STATE_BINDINGS} until someone classifies it.
+ */
 function hasNativeControl(source: string): boolean {
-  return /<(?:input|textarea|select)\b/.test(source)
+  const controls = source.match(/<(?:input|textarea|select)\b[^>]*>/g) ?? []
+  return controls.some((tag) => !/type="(?:checkbox|radio)"/.test(tag))
 }
 
 /** What makes this window suspect for a 'none' row, or `null` when nothing does. */

package/app/components/panels/ResultWindowShell.logic.spec.ts

@@ -35,6 +35,10 @@ const WINDOWS: Record<string, { width: ResultWindowWidth; why: string }> = {
     width: 'full',
     why: 'options column + the choose/dismiss action rail',
   },
+  'bugFishing/BugFishingWindow.vue': {
+    width: 'full',
+    why: 'the angle rail + the catch column, whose finding rows lay badges, path and the mark/dismiss actions out beside each other',
+  },
   'clarity/ClarityReviewWindow.vue': {
     width: 'full',
     why: 'findings column + the answer/dismiss action rail',

package/app/components/settings/WorkspaceSettingsPanel.vue

@@ -9,7 +9,7 @@
 //     by external-tool URL resolvers); present only where any are declared.
 // The latter three are body-only section components rendered in tabs here (no longer
 // standalone modals).
-import { reactive, ref, watch } from 'vue'
+import { computed, reactive, ref, watch } from 'vue'
 import { useReactiveSlots } from '@modular-vue/runtime'
 import type { InputGateMode, ReviewFrictionMode, TaskLimitMode } from '~/types/domain'
 import RiskPolicyPanel from '~/components/settings/RiskPolicyPanel.vue'
@@ -22,12 +22,15 @@ import WorkspaceMembersSettings from '~/components/layout/WorkspaceMembersSettin
 import WorkspaceMetadataSettings from '~/components/settings/WorkspaceMetadataSettings.vue'
 import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
 import type { AppSlots } from '~/modular/slots'
+import { usePipelinesStore } from '~/stores/pipelines'
+import { pipelineAllowedForTaskType } from '~/utils/pipeline'
 
 const { t, te } = useI18n()
 const ui = useUiStore()
 const store = useWorkspaceSettingsStore()
 const workspace = useWorkspaceStore()
 const access = useWorkspaceAccess()
+const pipelines = usePipelinesStore()
 const toast = useToast()
 const { present } = usePipelineErrorToast()
 const slots = useReactiveSlots<AppSlots>()
@@ -182,6 +185,22 @@ const REVIEW_FRICTION_MODES = computed<{ value: ReviewFrictionMode; label: strin
   { value: 'enforce', label: t('settings.workspaceSettings.reviewFriction.modes.enforce') },
 ])
 
+/**
+ * The pipelines a bug-fishing expedition's spawned fix task may run, plus the "use the built-in
+ * bug-fix preset" row that clears the pin.
+ *
+ * Narrowed by the same predicate the create form uses for a `bug` task, because a spawned fix IS
+ * one — a board that could pin a document-authoring preset here would spawn tasks that author a
+ * document instead of fixing the defect they were spawned for. The clearing row carries the empty
+ * string rather than being absent, so "no board default" is a value someone can choose back to.
+ */
+const fixPipelineOptions = computed<{ value: string; label: string }[]>(() => [
+  { value: '', label: t('settings.workspaceSettings.bugFishing.builtInDefault') },
+  ...pipelines.pipelines
+    .filter((p) => pipelineAllowedForTaskType(p, 'bug'))
+    .map((p) => ({ value: p.id, label: p.name })),
+])
+
 /** The localized "Max {type} tasks" label for a per-type running-task limit input. */
 function maxTaskTypeLabel(type: LimitTaskType): string {
   const key = TASK_TYPE_KEYS[type]
@@ -203,6 +222,8 @@ const draft = reactive({
   doneLaneRetentionDays: 14 as number,
   kaizenEnabled: true,
   allowInitiatorPat: true,
+  // '' means "no board default", which resolves to the built-in bug-fix preset at spawn time.
+  bugFishingFixPipelineId: '',
   inputGateMode: 'standard' as InputGateMode,
   reviewFrictionMode: 'off' as ReviewFrictionMode,
   reviewFrictionWarnCount: 3,
@@ -230,6 +251,7 @@ function hydrate() {
   draft.doneLaneRetentionDays = s.doneLaneRetentionDays ?? 14
   draft.kaizenEnabled = s.kaizenEnabled
   draft.allowInitiatorPat = s.allowInitiatorPat
+  draft.bugFishingFixPipelineId = s.bugFishingFixPipelineId ?? ''
   draft.inputGateMode = s.inputGateMode
   draft.reviewFrictionMode = s.reviewFrictionMode
   draft.reviewFrictionWarnCount = s.reviewFrictionWarnCount
@@ -290,6 +312,9 @@ async function save() {
       doneLaneRetentionDays: draft.doneLaneRetentionEnabled ? draft.doneLaneRetentionDays : null,
       kaizenEnabled: draft.kaizenEnabled,
       allowInitiatorPat: draft.allowInitiatorPat,
+      // The empty string clears the pin back to the built-in preset (the backend trims it to null),
+      // which is how every other pinned-pipeline field on the platform is cleared.
+      bugFishingFixPipelineId: draft.bugFishingFixPipelineId,
       inputGateMode: draft.inputGateMode,
       reviewFrictionMode: draft.reviewFrictionMode,
       reviewFrictionWarnCount: draft.reviewFrictionWarnCount,
@@ -630,6 +655,26 @@ async function save() {
               </p>
             </section>
 
+            <!-- Bug-fishing expedition: the pipeline a MARKED finding's spawned fix task runs.
+                 It is a property of how this team fixes bugs rather than of any one hunt, which
+                 is why it is a board setting and not a field on the expedition. -->
+            <section class="space-y-2">
+              <h3 class="text-sm font-semibold text-slate-200">
+                {{ t('settings.workspaceSettings.bugFishing.heading') }}
+              </h3>
+              <p class="text-[11px] text-slate-400">
+                {{ t('settings.workspaceSettings.bugFishing.body') }}
+              </p>
+              <USelectMenu
+                v-model="draft.bugFishingFixPipelineId"
+                :items="fixPipelineOptions"
+                value-key="value"
+                size="sm"
+                class="max-w-md"
+                data-testid="workspace-settings-bug-fishing-pipeline"
+              />
+            </section>
+
             <!-- Kaizen agent -->
             <section class="space-y-2">
               <h3 class="text-sm font-semibold text-slate-200">

package/app/components/slack/SlackPanel.vue

@@ -74,6 +74,7 @@ const routes = reactive<Record<NotificationType, SlackRoute>>({
   fork_decision_pending: { enabled: false, channel: '' },
   judge_review: { enabled: false, channel: '' },
   pr_review_ready: { enabled: false, channel: '' },
+  bug_fishing_triage: { enabled: false, channel: '' },
   initiative: { enabled: false, channel: '' },
   platform_health: { enabled: false, channel: '' },
   budget_paused: { enabled: false, channel: '' },

package/app/composables/api/bugFishing.ts

@@ -0,0 +1,52 @@
+import {
+  addressBugFishingFindingsContract,
+  dismissBugFishingFindingContract,
+  getBugFishingContract,
+  resolveBugFishingContract,
+} from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * The bug-fishing expedition: the read-only `bug-fisher` agent reads the service's codebase once
+ * per ANGLE and reports what each angle caught, and the run parks once every angle has settled.
+ * These endpoints read the live catch, MARK findings (each spawning its own bug-fix task), drop
+ * one from triage, and finish a parked expedition. The read returns null when no `bug-fisher`
+ * step carries expedition state.
+ */
+export function bugFishingApi({ send, ws }: ApiContext) {
+  return {
+    // The live expedition state for a run (null when no bug-fisher step carries one).
+    getBugFishing: (workspaceId: string, executionId: string) =>
+      send(getBugFishingContract, { pathPrefix: ws(workspaceId), pathParams: { executionId } }),
+
+    // Mark findings to be addressed: one bug-fix task per finding, linked to the expedition.
+    // Accepted while later angles are still fishing, which is the point of the phase loop.
+    // `pipelineId` overrides the board's default fix pipeline for this batch only.
+    addressBugFishingFindings: (
+      workspaceId: string,
+      executionId: string,
+      body: { findingIds: string[]; pipelineId?: string },
+    ) =>
+      send(addressBugFishingFindingsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+        body,
+      }),
+
+    // Dismiss a finding: it stays on the record, struck through, and can no longer be marked.
+    dismissBugFishingFinding: (workspaceId: string, executionId: string, findingId: string) =>
+      send(dismissBugFishingFindingContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId, findingId },
+        body: {},
+      }),
+
+    // Finish a parked expedition (triage is done); the run advances past the step.
+    resolveBugFishing: (workspaceId: string, executionId: string) =>
+      send(resolveBugFishingContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+        body: {},
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -18,6 +18,7 @@ import { forkDecisionApi } from './api/forkDecision'
 import { inputGateApi } from './api/inputGate'
 import { judgeApi } from './api/judge'
 import { prReviewApi } from './api/prReview'
+import { bugFishingApi } from './api/bugFishing'
 import { fragmentsApi } from './api/fragments'
 import { foundationalServicesApi } from './api/foundationalServices'
 import { skillsApi } from './api/skills'
@@ -138,6 +139,7 @@ export function useApi() {
     ...inputGateApi(ctx),
     ...judgeApi(ctx),
     ...prReviewApi(ctx),
+    ...bugFishingApi(ctx),
     ...humanTestApi(ctx),
     ...visualConfirmApi(ctx),
     ...humanReviewApi(ctx),

package/app/composables/usePipelineErrorToast.ts

@@ -125,6 +125,27 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
     titleKey: 'errors.conflict.title.kaizen_entry_not_settled',
     descriptionKey: 'errors.conflict.description.kaizen_entry_not_settled',
   },
+  // The four bug-fishing-expedition refusals. `no_expedition` / `not_awaiting_triage` are the
+  // "wrong run" / "already finished" pair (the window refreshes rather than re-offering the
+  // control); `already_addressed` names findings that already have a fix task, so a second
+  // request cannot double-spawn; `no_host_frame` is a board-shape problem the operator fixes by
+  // putting the expedition under a service.
+  no_expedition: {
+    titleKey: 'errors.conflict.title.no_expedition',
+    descriptionKey: 'errors.conflict.description.no_expedition',
+  },
+  not_awaiting_triage: {
+    titleKey: 'errors.conflict.title.not_awaiting_triage',
+    descriptionKey: 'errors.conflict.description.not_awaiting_triage',
+  },
+  already_addressed: {
+    titleKey: 'errors.conflict.title.already_addressed',
+    descriptionKey: 'errors.conflict.description.already_addressed',
+  },
+  no_host_frame: {
+    titleKey: 'errors.conflict.title.no_host_frame',
+    descriptionKey: 'errors.conflict.description.no_host_frame',
+  },
   task_limit_reached: {
     titleKey: 'errors.conflict.title.task_limit_reached',
     descriptionKey: 'errors.conflict.description.task_limit_reached',

package/app/modular/result-views.ts

@@ -48,6 +48,9 @@ const ForkDecisionWindow = defineAsyncView(
   () => import('~/components/forkDecision/ForkDecisionWindow.vue'),
 )
 const PrReviewWindow = defineAsyncView(() => import('~/components/prReview/PrReviewWindow.vue'))
+const BugFishingWindow = defineAsyncView(
+  () => import('~/components/bugFishing/BugFishingWindow.vue'),
+)
 const MergerResultView = defineAsyncView(() => import('~/components/panels/MergerResultView.vue'))
 const InitiativeTrackerWindow = defineAsyncView(
   () => import('~/components/initiative/InitiativeTrackerWindow.vue'),
@@ -120,6 +123,9 @@ const BUILT_IN_RESULT_VIEWS: Record<ResultViewId, Component> = {
   'binary-candidates': BinaryCandidatesWindow,
   // The PR deep-review: the reviewer's sliced, prioritized findings + the human's multi-select.
   'pr-review': PrReviewWindow,
+  // The bug-fishing expedition: the per-angle catch, and the human's per-finding triage (each
+  // marked finding spawns its own bug-fix task).
+  'bug-fishing': BugFishingWindow,
   // The merger's verdict: PR complexity/risk/impact scores + the engine's decision (and why).
   merger: MergerResultView,
   // The initiative tracker: phases, per-item status + PR links, decisions, deviations, caveats.

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/bugFishing.ts

@@ -0,0 +1,143 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { BugFishingStepState } from '~/types/execution'
+import { useApi } from '~/composables/useApi'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useExecutionStore } from '~/stores/execution'
+
+/**
+ * The bug-fishing expedition's action surface. The live state lives on the run's `bug-fisher`
+ * step (`step.bugFishing`) and is kept fresh by the execution stream, so the window reads it
+ * straight off the execution store — this store only wraps the actions, tracks what is in
+ * flight so the window can disable its controls, and reflects the returned state back onto the
+ * execution store so the UI updates before the stream echoes the change. Keyed by executionId,
+ * mirroring the PR-review store.
+ */
+export const useBugFishingStore = defineStore('bugFishing', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+  const execution = useExecutionStore()
+
+  /**
+   * The finding ids whose fix task is being spawned right now. A SET rather than one boolean
+   * because marking is available while the expedition is still fishing, so a person can mark a
+   * second finding while the first is still spawning — and a shared flag would grey out the row
+   * they just clicked along with every other one.
+   */
+  const spawning = ref<Set<string>>(new Set())
+  /** True while the finish call is in flight (drives the Finish button's spinner). */
+  const resolving = ref(false)
+  /** The last error message from an action, surfaced inline; cleared on the next action. */
+  const error = ref<string | null>(null)
+
+  /**
+   * Apply an authoritative expedition state to the run's `bug-fisher` step. A pipeline could
+   * carry more than one, so target the one this state is about: prefer the step still awaiting
+   * triage, then the current step, then the first step carrying expedition state.
+   *
+   * Only ever called through {@link ExecutionStore.echoAfter}, which drops the echo when the
+   * event stream already delivered a newer revision. That guard matters most here: marking a
+   * finding is accepted mid-expedition, so an unguarded echo could put a later phase's findings
+   * back to the set the mark request happened to see.
+   */
+  function assign(
+    instance: ReturnType<typeof execution.getInstance> & object,
+    state: BugFishingStepState,
+  ): void {
+    const isLive = (s: (typeof instance.steps)[number]) =>
+      s.agentKind === 'bug-fisher' && s.bugFishing?.status === 'awaiting_triage'
+    const current = instance.steps[instance.currentStep]
+    const step =
+      instance.steps.find(isLive) ??
+      (current?.agentKind === 'bug-fisher' && current.bugFishing ? current : undefined) ??
+      instance.steps.find((s) => s.bugFishing)
+    if (step) step.bugFishing = state
+  }
+
+  /** Warm the live state from the GET (the stream also keeps it fresh). Best-effort. */
+  async function load(executionId: string): Promise<void> {
+    error.value = null
+    try {
+      await execution.echoAfter(
+        executionId,
+        () => api.getBugFishing(workspace.requireId(), executionId),
+        (state, instance) => {
+          if (state) assign(instance, state as BugFishingStepState)
+        },
+      )
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to load'
+    }
+  }
+
+  /**
+   * Mark findings to be addressed: each spawns its own bug-fix task, linked to the expedition.
+   * `pipelineId` overrides the board's default fix pipeline for this batch only.
+   */
+  async function address(
+    executionId: string,
+    findingIds: string[],
+    pipelineId?: string,
+  ): Promise<void> {
+    error.value = null
+    spawning.value = new Set([...spawning.value, ...findingIds])
+    try {
+      await execution.echoAfter(
+        executionId,
+        () =>
+          api.addressBugFishingFindings(workspace.requireId(), executionId, {
+            findingIds,
+            ...(pipelineId ? { pipelineId } : {}),
+          }),
+        (state, instance) => assign(instance, state as BugFishingStepState),
+      )
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to create the fix task'
+      throw e
+    } finally {
+      const next = new Set(spawning.value)
+      for (const id of findingIds) next.delete(id)
+      spawning.value = next
+    }
+  }
+
+  /** Dismiss a finding: it stays on the record, struck through, and can no longer be marked. */
+  async function dismiss(executionId: string, findingId: string): Promise<void> {
+    error.value = null
+    spawning.value = new Set([...spawning.value, findingId])
+    try {
+      await execution.echoAfter(
+        executionId,
+        () => api.dismissBugFishingFinding(workspace.requireId(), executionId, findingId),
+        (state, instance) => assign(instance, state as BugFishingStepState),
+      )
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to dismiss the finding'
+      throw e
+    } finally {
+      const next = new Set(spawning.value)
+      next.delete(findingId)
+      spawning.value = next
+    }
+  }
+
+  /** Finish a parked expedition: triage is done and the run advances past the step. */
+  async function resolve(executionId: string): Promise<void> {
+    error.value = null
+    resolving.value = true
+    try {
+      await execution.echoAfter(
+        executionId,
+        () => api.resolveBugFishing(workspace.requireId(), executionId),
+        (state, instance) => assign(instance, state as BugFishingStepState),
+      )
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to finish the expedition'
+      throw e
+    } finally {
+      resolving.value = false
+    }
+  }
+
+  return { spawning, resolving, error, load, address, dismiss, resolve }
+})

package/app/stores/ui/resultViews.ts

@@ -164,13 +164,19 @@ export function createUiResultViews() {
   // The run-scoped openers (a caller that knows only the RUN, so the step index has to be
   // resolved) live in a sibling module: they share one shape and one hazard, and lifting them out
   // keeps this factory inside its per-function line budget. Their two seams are bound here.
-  const { openFollowUps, openForkDecision, openBinaryCandidates, openPrReview, openTestEvidence } =
-    createRunStepOpeners({
-      dispatchStepView: (instanceId, stepIndex) => dispatchStepView(instanceId, stepIndex),
-      setResultView: (view, instance, stepIndex) => {
-        resultView.value = { view, blockId: instance.blockId, instanceId: instance.id, stepIndex }
-      },
-    })
+  const {
+    openFollowUps,
+    openForkDecision,
+    openBinaryCandidates,
+    openPrReview,
+    openBugFishing,
+    openTestEvidence,
+  } = createRunStepOpeners({
+    dispatchStepView: (instanceId, stepIndex) => dispatchStepView(instanceId, stepIndex),
+    setResultView: (view, instance, stepIndex) => {
+      resultView.value = { view, blockId: instance.blockId, instanceId: instance.id, stepIndex }
+    },
+  })
 
   function closeResultView() {
     resultView.value = null
@@ -212,6 +218,7 @@ export function createUiResultViews() {
     openForkDecision,
     openBinaryCandidates,
     openPrReview,
+    openBugFishing,
     openTestEvidence,
     openOutcome,
     openRunOutcome,

package/app/stores/ui/runStepOpeners.ts

@@ -136,6 +136,27 @@ export function createRunStepOpeners(deps: RunStepOpenerDeps) {
     )
   }
 
+  // Open the BUG-FISHING expedition window for a run's `bug-fisher` step (from the
+  // `bug_fishing_triage` notification / the step). Resolves the step index from the run when not
+  // given, preferring the step parked awaiting triage.
+  function openBugFishing(instanceId: string, stepIndex: number | null = null) {
+    withStep(
+      instanceId,
+      stepIndex,
+      (instance) => {
+        const awaiting = indexOf(
+          instance,
+          (s) => s.agentKind === 'bug-fisher' && s.bugFishing?.status === 'awaiting_triage',
+        )
+        if (awaiting >= 0) return awaiting
+        const current = instance.steps[instance.currentStep]
+        if (current?.agentKind === 'bug-fisher' && current.bugFishing) return instance.currentStep
+        return indexOf(instance, (s) => s.agentKind === 'bug-fisher' && !!s.bugFishing)
+      },
+      (instance, idx) => deps.setResultView('bug-fishing', instance, idx),
+    )
+  }
+
   // Open the Tester's result window for a run, where the screenshots and per-area outcomes it
   // captured are rendered. The entry point is the `test-evidence` deep link the engine puts in
   // every PR verification report's environment-lifecycle section, so the caller only ever knows
@@ -161,5 +182,12 @@ export function createRunStepOpeners(deps: RunStepOpenerDeps) {
     )
   }
 
-  return { openFollowUps, openForkDecision, openBinaryCandidates, openPrReview, openTestEvidence }
+  return {
+    openFollowUps,
+    openForkDecision,
+    openBinaryCandidates,
+    openPrReview,
+    openBugFishing,
+    openTestEvidence,
+  }
 }

package/app/stores/workspaceSettings.ts

@@ -35,6 +35,7 @@ const DEFAULTS: WorkspaceSettings = {
   allowInitiatorPat: true,
   // The custom metadata bag: empty until someone fills a declared field in. Never null — an
   // external-tool resolver indexes it (`ctx.metadata.gameId`) with no guard.
+  bugFishingFixPipelineId: null,
   metadata: {},
 }
 

package/app/types/bootstrap.ts

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

package/app/types/execution.ts

@@ -83,6 +83,15 @@ export type {
   PrReviewResolution,
   PrReviewPostReport,
   PrReviewPostFailure,
+  BugFishingStepState,
+  BugFishingStatus,
+  BugFishingPhase,
+  BugFishingPhaseStatus,
+  BugFishingFinding,
+  BugFishingSeverity,
+  BugFishingFindingKind,
+  BugFishingConfidence,
+  BugFishingSpawn,
   AgentEffortReport,
   FragmentAdherence,
   FragmentAdherenceItem,

package/app/utils/catalog.spec.ts

@@ -22,6 +22,7 @@ const AGENT_KINDS: AgentKind[] = [
   'requirements-brainstorm',
   'architecture-brainstorm',
   'bug-investigator',
+  'bug-fisher',
   'pr-reviewer',
   'spike',
   'task-estimator',

package/app/utils/catalog.ts

@@ -80,6 +80,25 @@ export const AGENT_ARCHETYPES: AgentArchetype[] = [
       'Read-only, multi-repo codebase investigation that traces the bug to its root cause and decides whether the report is fixable as-is or needs the reporter to clarify (no code changes).',
     resultView: 'generic-structured',
   },
+  {
+    // The BUG-FISHING expedition's single step, dispatched once per ANGLE by the engine's phase
+    // loop. Registered on the backend so it also arrives via the workspace manifest, but modelled
+    // statically here for the reason `pr-reviewer` is: `agentKindMeta('bug-fisher').resultView`
+    // has to resolve to the expedition window on every surface, not only once the manifest is
+    // hydrated. Mirrors the backend `presentation` in `bug-fisher.ts`.
+    kind: 'bug-fisher',
+    tier: 'intermediate',
+    label: 'Bug Fisher',
+    icon: 'i-lucide-fish',
+    color: '#0ea5e9',
+    category: 'review',
+    // Hunts for defects nobody reported: it belongs with the bug work rather than the build
+    // ladder, and with review because its product is findings.
+    purposes: ['bugfix', 'review'],
+    description:
+      'Read-only, multi-angle hunt through an existing codebase for genuine logic gaps, latent bugs, footguns and unhandled edge cases — one pass per angle, nothing changed.',
+    resultView: 'bug-fishing',
+  },
   {
     // A read-only, token-bounded deep review of an EXISTING open pull request (the `pl_review`
     // pipeline's single step). Registered on the backend so it also arrives via the workspace
@@ -953,6 +972,12 @@ export const TASK_TYPE_META: Record<string, TaskTypeMeta> = {
     color: '#f87171',
     labelKey: 'board.addTask.types.bug',
   },
+  'bug-fishing': {
+    taskType: 'bug-fishing',
+    icon: 'i-lucide-fish',
+    color: '#0ea5e9',
+    labelKey: 'board.addTask.types.bugFishing',
+  },
   document: {
     taskType: 'document',
     icon: 'i-lucide-file-text',