@cat-factory/app 0.313.0 → 0.315.1

package/README.md

@@ -1492,6 +1492,13 @@ example ships in [`deploy/frontend`](https://github.com/kibertoad/cat-factory/tr
   switchers, the `SpendWarningBanner`, and the toolbar (zoom, LOD, decision queue).
 - **Palettes** (`components/palettes`): drag blocks, pipelines and agents onto
   the board.
+- **Describe new work** (`components/queue/DescribeWorkModal.vue`, `utils/describeWork.ts`): the
+  one-sentence intake, from Create, the palette and the queue header. It files a feature or a bug
+  from a sentence and a service, titled by the first sentence; the overrides sit behind one
+  disclosure, and the merge policy and model preset follow the full form's tier rule
+  (`showOverrideField`), so basic mode and the designer role see the pipeline only.
+  It rebuilds no other kind: "More kinds" and "Attach context" hand the text to `AddTaskModal`,
+  which stays the one home of those rules. Both share `utils/reviewFriction.ts` for the review-debt 409.
 - **Setup checklist** (`components/setup/SetupChecklistPanel.vue`, `utils/setupChecklist.ts`):
   every prerequisite for "a task can run and merge" in one list, for people who can change the
   setup. It adds no probe of its own: each row reads what its banner or startup dialog already

package/app/components/board/AddTaskModal.vue

@@ -36,6 +36,7 @@ import FragmentSelector from '~/components/fragments/FragmentSelector.vue'
 import ReviewSkillQueue from '~/components/skills/ReviewSkillQueue.vue'
 import RiskPolicyPicker from '~/components/riskPolicy/RiskPolicyPicker.vue'
 import { parseConflict } from '~/composables/usePipelineErrorToast'
+import { isReviewDebtConflict, reviewFrictionContext } from '~/utils/reviewFriction'
 import { apiErrorEnvelope } from '~/composables/api/errors'
 import type { ReviewTargetReason } from '@cat-factory/contracts'
 import {
@@ -526,6 +527,8 @@ function defaultPipelineIdFor(type: TaskTypeChoice): string {
   return offered ? preset : ''
 }
 
+// Set while a prefill's type is being seeded with a carried pipeline (see `onModalOpen` below).
+let seedingPrefill = false
 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
@@ -533,6 +536,10 @@ watch(taskType, (next) => {
   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.
+  if (seedingPrefill) {
+    seedingPrefill = false
+    return
+  }
   const preset = defaultPipelineIdFor(next)
   if (preset) pipelineId.value = preset
 })
@@ -667,13 +674,23 @@ onModalOpen(open, () => {
   agentConfigValues.value = {}
   pendingContext.value = []
   // Seed from a prefill when opened from another surface (e.g. "create task from
-  // issue" sets the title + stages the issue as linked context). Pipeline / preset
-  // are intentionally left at their defaults so the user confirms them here.
+  // issue" sets the title + stages the issue as linked context). Pipeline / preset stay at their
+  // defaults unless the opener carries a choice the person already made (the one-sentence
+  // intake's kind and overrides), which the hand-off must not reset.
   const prefill = ui.addTaskPrefill
   if (prefill) {
     if (prefill.title) title.value = prefill.title
     if (prefill.description) description.value = prefill.description
     if (prefill.context?.length) pendingContext.value = [...prefill.context]
+    if (prefill.taskType && prefill.taskType !== taskType.value) {
+      taskType.value = prefill.taskType
+      // The type watcher runs after this block and would replace a carried pipeline with the
+      // new type's default; a seeded type is not the edit that watcher is for.
+      seedingPrefill = !!prefill.pipelineId
+    }
+    if (prefill.pipelineId) pipelineId.value = prefill.pipelineId
+    if (prefill.riskPolicyId) riskPolicyId.value = prefill.riskPolicyId
+    if (prefill.modelPresetId) modelPresetId.value = prefill.modelPresetId
   }
   documents.loadDocuments().catch(() => {})
   tasks.loadTasks().catch(() => {})
@@ -831,8 +848,15 @@ async function submitCreate(acknowledgeReviewDebt: boolean) {
     ui.closeAddTask()
   } catch (e) {
     const conflict = parseConflict(e)
-    if (conflict?.reason === 'review_debt_warn' || conflict?.reason === 'review_debt_blocked') {
-      openReviewFrictionDialog(conflict)
+    if (isReviewDebtConflict(conflict)) {
+      ui.openReviewFriction(
+        reviewFrictionContext(
+          conflict,
+          () => void submitCreate(true),
+          () => saving.value,
+          () => ui.closeAddTask(),
+        ),
+      )
       return
     }
     const refusal = createRefusalMessage(e)
@@ -883,32 +907,6 @@ function createRefusalMessage(error: unknown): string | null {
   if (reason === 'task_type_fields_invalid') return t('board.addTask.customFieldsInvalid')
   return REVIEW_TARGET_MESSAGES[reason as ReviewTargetReason]?.(details) ?? null
 }
-
-/** Turn a parsed review-debt friction 409 into the dialog context (see ReviewFrictionDialog.vue). */
-function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseConflict>>) {
-  const details = conflict.details
-  const rawDebt = Array.isArray(details.debt) ? details.debt : []
-  const debt = rawDebt.map((d) => {
-    const row = (d ?? {}) as { blockId?: unknown; title?: unknown; waitingMinutes?: unknown }
-    return {
-      blockId: typeof row.blockId === 'string' ? row.blockId : '',
-      title: typeof row.title === 'string' ? row.title : null,
-      waitingMinutes: typeof row.waitingMinutes === 'number' ? row.waitingMinutes : 0,
-    }
-  })
-  const isWarn = conflict.reason === 'review_debt_warn'
-  ui.openReviewFriction({
-    kind: isWarn ? 'warn' : 'blocked',
-    reason:
-      details.friction === 'count' || details.friction === 'stuck' ? details.friction : undefined,
-    threshold: typeof details.threshold === 'number' ? details.threshold : null,
-    debt,
-    onConfirm: isWarn ? () => void submitCreate(true) : null,
-    // A getter, not a snapshot: the dialog reads it inside a computed so its button spins and
-    // locks for as long as the retry actually runs (UX-78).
-    pending: () => saving.value,
-  })
-}
 </script>
 
 <template>
@@ -954,6 +952,7 @@ function openReviewFrictionDialog(conflict: NonNullable<ReturnType<typeof parseC
                   :icon="ty.icon"
                   size="xs"
                   :title="ty.description"
+                  :aria-pressed="taskType === ty.value"
                   :data-testid="`task-type-${ty.value}`"
                   @click="
                     () => {

package/app/components/board/ReviewFrictionDialog.vue

@@ -53,17 +53,20 @@ const body = computed(() => {
 /** Deep-link to a waiting task's block and dismiss the whole friction flow. */
 function goToBlock(blockId: string) {
   if (blockId) ui.select(blockId)
+  leave()
+}
+
+/** Close the friction and the form that raised it. */
+function leave() {
+  const onLeave = ctx.value?.onLeave
   ui.closeReviewFriction()
-  ui.closeAddTask()
+  onLeave?.()
 }
 
 function goReview() {
   const first = ctx.value?.debt[0]
   if (first) goToBlock(first.blockId)
-  else {
-    ui.closeReviewFriction()
-    ui.closeAddTask()
-  }
+  else leave()
 }
 
 function createAnyway() {

package/app/components/layout/NotificationsInbox.vue

@@ -2,6 +2,11 @@
 import type { Notification } from '~/types/domain'
 import type { ReviewEffort } from '~/types/merge'
 import SectionLabel from '~/components/common/SectionLabel.vue'
+import {
+  notificationTarget,
+  notificationVerbKey,
+  type NotificationRouteDeps,
+} from '~/utils/notificationRoutes'
 
 // The board's notification inbox: a bell with an open-count badge that opens a
 // panel of human-actionable items (a PR awaiting a merge decision, a completed
@@ -133,6 +138,45 @@ function actionLabel(n: Notification): string {
   return te(key) ? t(key) : t('layout.notifications.action.markRead')
 }
 
+// The store reads and openers every route uses (`utils/notificationRoutes.ts`).
+const routeDeps: NotificationRouteDeps = {
+  getInstance: (id) => execution.getInstance(id),
+  select: (id) => ui.select(id),
+  openStepDetail: (id, index) => ui.openStepDetail(id, index),
+  openDecision: (id, decisionId) => ui.openDecision(id, decisionId),
+  openFollowUps: (id) => ui.openFollowUps(id),
+  openForkDecision: (id) => ui.openForkDecision(id),
+  openPrReview: (id) => ui.openPrReview(id),
+  openBugFishing: (id) => ui.openBugFishing(id),
+  openRequirementReview: (id) => ui.openRequirementReview(id),
+  openClarityReview: (id) => ui.openClarityReview(id),
+  openInitiativeTracker: (id) => ui.openInitiativeTracker(id),
+  openOperatorDashboard: () => ui.openOperatorDashboard(),
+}
+
+/**
+ * The primary verb for a card whose act button only marks it read, from the same resolution its
+ * click takes. `te()`-guarded like the act label: a locale missing the key gets no button rather
+ * than a raw key path.
+ */
+function goToLabel(n: Notification): string | null {
+  const key = notificationVerbKey(n, routeDeps)
+  return key && te(key) ? t(key) : null
+}
+
+/** Each open card's go-to label, computed once per change rather than once per binding. */
+const goToLabels = computed(
+  () => new Map(notifications.open.map((n) => [n.id, goToLabel(n)] as const)),
+)
+
+// The popover is closed when a card takes the person somewhere, so it does not stay open under
+// the window it opened and reappear when that window closes.
+const open = ref(false)
+function goTo(n: Notification) {
+  open.value = false
+  reveal(n)
+}
+
 /** A notification the escalation sweep has flagged as overdue (waited past the threshold). */
 function isUrgent(n: Notification): boolean {
   return n.severity === 'urgent'
@@ -217,120 +261,9 @@ async function dismiss(n: Notification) {
   }
 }
 
-/**
- * Clicking a notification's title takes the user where they can act on it. A
- * `requirement_review` / `clarity_review` summons them straight back into the matching review
- * window (the async incorporate/re-review raised new findings or hit the cap); every other
- * type just focuses the related block on the board.
- */
+/** Clicking a notification's title, or its verb, takes the user where they can act on it. */
 function reveal(n: Notification) {
-  // A `platform_health` card is deployment-scoped (no block) — send the operator to the
-  // dashboard where the live aggregate numbers behind the alert live.
-  if (n.type === 'platform_health') return ui.openOperatorDashboard()
-  if (!n.blockId) return
-  if (n.type === 'requirement_review') ui.openRequirementReview(n.blockId)
-  else if (n.type === 'clarity_review') ui.openClarityReview(n.blockId)
-  else if (n.type === 'decision_required') revealDecision(n)
-  else if (n.type === 'human_test_ready') revealHumanTest(n)
-  else if (n.type === 'visual_confirmation_ready') revealVisualConfirm(n)
-  else if (n.type === 'human_review') revealHumanReview(n)
-  else if (n.type === 'followup_pending') revealFollowUps(n)
-  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)
-}
-
-/**
- * Open the gate window for a parked `human-review` gate: find the run's human-review step and
- * open it through the universal step dispatch (its archetype declares the `gate` result view,
- * where the human can request a freeform fix). Falls back to focusing the block.
- */
-function revealHumanReview(n: Notification) {
-  const instance = n.executionId ? execution.getInstance(n.executionId) : undefined
-  const idx = instance?.steps.findIndex((s) => s.agentKind === 'human-review') ?? -1
-  if (instance && idx >= 0) ui.openStepDetail(instance.id, idx)
-  else if (n.blockId) ui.select(n.blockId)
-}
-
-/**
- * Open the Follow-up companion window for a run whose Coder parked on undecided items.
- * Falls back to focusing the block when the run isn't loaded.
- */
-function revealFollowUps(n: Notification) {
-  if (n.executionId && execution.getInstance(n.executionId)) ui.openFollowUps(n.executionId)
-  else if (n.blockId) ui.select(n.blockId)
-}
-
-/**
- * Open the implementation-fork decision window for a run parked awaiting a fork choice.
- * Falls back to focusing the block when the run isn't loaded.
- */
-function revealForkDecision(n: Notification) {
-  if (n.executionId && execution.getInstance(n.executionId)) ui.openForkDecision(n.executionId)
-  else if (n.blockId) ui.select(n.blockId)
-}
-
-/**
- * Open the judge window for a run parked on a rubric verdict: find the step carrying the parked
- * verdict and open it through the universal step dispatch (a registered judge declares the
- * `judge` result view). Falls back to focusing the block when the run isn't loaded.
- */
-function revealJudge(n: Notification) {
-  const instance = n.executionId ? execution.getInstance(n.executionId) : undefined
-  const idx = instance?.steps.findIndex((s) => s.judge?.status === 'awaiting_decision') ?? -1
-  if (instance && idx >= 0) ui.openStepDetail(instance.id, idx)
-  else if (n.blockId) ui.select(n.blockId)
-}
-
-/**
- * Open the PR deep-review window for a run parked awaiting a finding selection.
- * Falls back to focusing the block when the run isn't loaded.
- */
-function revealPrReview(n: Notification) {
-  if (n.executionId && execution.getInstance(n.executionId)) ui.openPrReview(n.executionId)
-  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
- * the `human-test` result view). Falls back to focusing the block.
- */
-function revealHumanTest(n: Notification) {
-  const instance = n.executionId ? execution.getInstance(n.executionId) : undefined
-  const idx =
-    instance?.steps.findIndex(
-      (s) => s.agentKind === 'human-test' && s.state === 'waiting_decision',
-    ) ?? -1
-  if (instance && idx >= 0) ui.openStepDetail(instance.id, idx)
-  else if (n.blockId) ui.select(n.blockId)
-}
-
-/**
- * Open the visual-confirmation window for a parked `visual-confirmation` gate: find the run's
- * parked step and open it through the universal step dispatch (its archetype declares the
- * `visual-confirm` result view). Falls back to focusing the block.
- */
-function revealVisualConfirm(n: Notification) {
-  const instance = n.executionId ? execution.getInstance(n.executionId) : undefined
-  const idx =
-    instance?.steps.findIndex(
-      (s) => s.agentKind === 'visual-confirmation' && s.state === 'waiting_decision',
-    ) ?? -1
-  if (instance && idx >= 0) ui.openStepDetail(instance.id, idx)
-  else if (n.blockId) ui.select(n.blockId)
+  notificationTarget(n, routeDeps)?.open()
 }
 
 /**
@@ -370,23 +303,10 @@ function revealFailingRun(run: { executionId: string; blockId: string | null })
   if (execution.getInstance(run.executionId)) ui.openObservability(run.executionId)
   else if (run.blockId) ui.select(run.blockId)
 }
-
-/**
- * Open the decision surface for a parked iteration-cap run: find the run's step that is
- * waiting on a human and open it through the universal step dispatch — which routes a
- * `requirements-review` step to the review window and a companion step to its detail
- * panel (where the iteration-cap prompt lives). Falls back to focusing the block.
- */
-function revealDecision(n: Notification) {
-  const instance = n.executionId ? execution.getInstance(n.executionId) : undefined
-  const idx = instance?.steps.findIndex((s) => s.state === 'waiting_decision') ?? -1
-  if (instance && idx >= 0) ui.openStepDetail(instance.id, idx)
-  else if (n.blockId) ui.select(n.blockId)
-}
 </script>
 
 <template>
-  <UPopover v-if="notifications.count" :content="{ align: 'end' }">
+  <UPopover v-if="notifications.count" v-model:open="open" :content="{ align: 'end' }">
     <UButton
       data-testid="notifications-bell"
       :color="hasUrgent ? 'error' : 'warning'"
@@ -426,7 +346,7 @@ function revealDecision(n: Notification) {
                   variant="link"
                   class="block min-w-0 flex-1 truncate p-0 text-start text-sm font-medium text-default hover:underline"
                   :title="n.title"
-                  @click="reveal(n)"
+                  @click="goTo(n)"
                 >
                   {{ n.title }}
                 </UButton>
@@ -502,11 +422,24 @@ function revealDecision(n: Notification) {
                 @update:model-value="effortByCard[n.id] = $event"
               />
               <div class="mt-2 flex items-center gap-1.5">
+                <!-- The action, where marking read is not one: opens what the title opens. -->
+                <!-- Soft, not solid: the inbox lists many cards, and a solid button on each would put
+                     many primaries in one view. -->
                 <UButton
-                  data-testid="notification-act"
+                  v-if="goToLabels.get(n.id)"
+                  data-testid="notification-go-to"
                   :color="accent(n)"
                   variant="soft"
                   size="xs"
+                  @click="goTo(n)"
+                >
+                  {{ goToLabels.get(n.id) }}
+                </UButton>
+                <UButton
+                  data-testid="notification-act"
+                  :color="goToLabels.get(n.id) ? 'neutral' : accent(n)"
+                  :variant="goToLabels.get(n.id) ? 'outline' : 'soft'"
+                  size="xs"
                   :loading="busy === n.id"
                   :disabled="!access.canExecuteRuns.value"
                   :title="access.canExecuteRuns.value ? undefined : t('access.noRunExecute')"

package/app/components/pipeline/PipelinePicker.vue

@@ -21,6 +21,12 @@ const props = withDefaults(
      * chosen row — and the row is left out entirely.
      */
     noneLabel?: string
+    /**
+     * What the preview pane says about the "none" row. Defaults to the full form's meaning ("no
+     * default; you choose when you run it"); a surface whose "none" row means the workspace default
+     * names what that default resolves to instead.
+     */
+    noneHint?: string
     /**
      * Default-trigger text while nothing is selected. Defaults to {@link noneLabel}, which reads
      * correctly when the "none" row IS the empty state; a surface without that row supplies its
@@ -30,7 +36,7 @@ const props = withDefaults(
     /** Extra classes for the default trigger button (e.g. full-width in the modal). */
     triggerClass?: string
   }>(),
-  { noneLabel: undefined, placeholder: undefined, triggerClass: '' },
+  { noneLabel: undefined, noneHint: undefined, placeholder: undefined, triggerClass: '' },
 )
 
 const emit = defineEmits<{ 'update:modelValue': [string] }>()
@@ -59,7 +65,7 @@ const previewPipeline = computed<Pipeline | null>(() => {
  */
 const emptyHint = computed(() =>
   props.noneLabel !== undefined && (hoverId.value ?? props.modelValue) === ''
-    ? t('pipeline.picker.noneHint')
+    ? (props.noneHint ?? t('pipeline.picker.noneHint'))
     : t('pipeline.picker.hoverHint'),
 )