@cat-factory/app 0.261.2 → 0.261.4

package/app/components/skills/SkillLibraryManager.vue

@@ -16,6 +16,7 @@ const props = defineProps<{ accountId: string }>()
 const library = useSkillLibrary(props.accountId)
 const github = useGitHubStore()
 const toast = useToast()
+const { present } = usePipelineErrorToast()
 const { t, d } = useI18n()
 const { confirm } = useConfirm()
 
@@ -33,15 +34,6 @@ watch(
 // the integration is off) the form falls back to manual text entry.
 const githubReady = computed(() => github.available === true && github.connected)
 
-function notifyError(title: string, e: unknown) {
-  toast.add({
-    title,
-    description: e instanceof Error ? e.message : String(e),
-    icon: 'i-lucide-triangle-alert',
-    color: 'error',
-  })
-}
-
 // 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)
@@ -102,7 +94,7 @@ async function linkSource() {
     resetSourceDraft()
     toast.add({ title: t('skills.toast.sourceLinked'), icon: 'i-lucide-git-branch' })
   } catch (e) {
-    notifyError(t('skills.toast.linkSourceFailed'), e)
+    present(e, 'skills.toast.linkSourceFailed')
   } finally {
     linkingSource.value = false
   }
@@ -121,7 +113,7 @@ async function syncSource(id: string) {
         color: 'info',
       })
     } catch (e) {
-      notifyError(t('skills.toast.syncFailed'), e)
+      present(e, 'skills.toast.syncFailed')
     }
   })
 }
@@ -135,7 +127,7 @@ async function checkSource(id: string) {
         icon: status.changed ? 'i-lucide-bell-dot' : 'i-lucide-check',
       })
     } catch (e) {
-      notifyError(t('skills.toast.checkSourceFailed'), e)
+      present(e, 'skills.toast.checkSourceFailed')
     }
   })
 }
@@ -156,7 +148,7 @@ async function unlinkSource(id: string) {
       await library.unlinkSource(id)
       toast.add({ title: t('skills.toast.sourceUnlinked'), icon: 'i-lucide-unplug' })
     } catch (e) {
-      notifyError(t('skills.toast.unlinkSourceFailed'), e)
+      present(e, 'skills.toast.unlinkSourceFailed')
     }
   })
 }

package/app/components/slack/SlackPanel.vue

@@ -20,6 +20,7 @@ import SecretInput from '~/components/common/SecretInput.vue'
 const ui = useUiStore()
 const slack = useSlackStore()
 const toast = useToast()
+const { present } = usePipelineErrorToast()
 const { t } = useI18n()
 const { confirm } = useConfirm()
 
@@ -90,15 +91,6 @@ const tokenInput = ref('')
 const busy = ref(false)
 const connectingOAuth = ref(false)
 
-function notifyError(title: string, e: unknown) {
-  toast.add({
-    title,
-    description: e instanceof Error ? e.message : String(e),
-    icon: 'i-lucide-triangle-alert',
-    color: 'error',
-  })
-}
-
 // Load everything the panel needs whenever it opens and Slack is connected.
 watch(
   () => open.value,
@@ -112,7 +104,7 @@ watch(
       mentionsEnabled.value = slack.settings?.mentionsEnabled ?? false
       mapping.value = slack.memberMapping.map((e) => toMemberRow(e, nextUid()))
     } catch (e) {
-      notifyError(t('slack.error.loadSettings'), e)
+      present(e, 'slack.error.loadSettings')
     }
   },
   // Lazy v-if mount: the panel mounts with `open` already true, so load immediately.
@@ -127,7 +119,7 @@ async function connectViaOAuth() {
     window.location.href = await slack.installUrl()
   } catch (e) {
     connectingOAuth.value = false
-    notifyError(t('slack.error.startOAuth'), e)
+    present(e, 'slack.error.startOAuth')
   }
 }
 
@@ -138,7 +130,7 @@ async function connectWithToken() {
     tokenInput.value = ''
     toast.add({ title: t('slack.toast.connected'), icon: 'i-lucide-check', color: 'success' })
   } catch (e) {
-    notifyError(t('slack.error.connect'), e)
+    present(e, 'slack.error.connect')
   }
 }
 
@@ -154,7 +146,7 @@ async function disconnect() {
   try {
     await slack.disconnect()
   } catch (e) {
-    notifyError(t('slack.error.disconnect'), e)
+    present(e, 'slack.error.disconnect')
   }
 }
 
@@ -167,7 +159,7 @@ async function saveRouting() {
     })
     toast.add({ title: t('slack.toast.routingSaved'), icon: 'i-lucide-check', color: 'success' })
   } catch (e) {
-    notifyError(t('slack.error.saveRouting'), e)
+    present(e, 'slack.error.saveRouting')
   } finally {
     busy.value = false
   }
@@ -199,7 +191,7 @@ async function saveMapping() {
     mapping.value = slack.memberMapping.map((e) => toMemberRow(e, nextUid()))
     toast.add({ title: t('slack.toast.mapSaved'), icon: 'i-lucide-check', color: 'success' })
   } catch (e) {
-    notifyError(t('slack.error.saveMap'), e)
+    present(e, 'slack.error.saveMap')
   } finally {
     busy.value = false
   }

package/app/components/tasks/BugHuntModal.vue

@@ -43,6 +43,7 @@ const ui = useUiStore()
 const tasks = useTasksStore()
 const hunt = useBugHuntStore()
 const toast = useToast()
+const { present } = usePipelineErrorToast()
 
 const open = computed({
   get: () => ui.bugHunt !== null,
@@ -212,12 +213,7 @@ async function adopt(candidate: BugHuntCandidate) {
       icon: 'i-lucide-bug-play',
     })
   } catch (e) {
-    toast.add({
-      title: t('bugHunt.adoptFailed'),
-      description: e instanceof Error ? e.message : String(e),
-      icon: 'i-lucide-triangle-alert',
-      color: 'error',
-    })
+    present(e, 'bugHunt.adoptFailed')
   }
 }
 

package/app/components/tasks/TaskImportModal.vue

@@ -22,6 +22,7 @@ const { t } = useI18n()
 const ui = useUiStore()
 const tasks = useTasksStore()
 const toast = useToast()
+const { present } = usePipelineErrorToast()
 
 const open = computed({
   get: () => ui.taskImport !== null,
@@ -112,12 +113,7 @@ async function doSpawnEpic() {
       icon: 'i-lucide-layers',
     })
   } catch (e) {
-    toast.add({
-      title: t('tasks.import.epicFailed'),
-      description: e instanceof Error ? e.message : String(e),
-      icon: 'i-lucide-triangle-alert',
-      color: 'error',
-    })
+    present(e, 'tasks.import.epicFailed')
   } finally {
     importing.value = false
   }

package/app/components/tasks/TaskSourceConnectModal.vue

@@ -17,6 +17,7 @@ const { t } = useI18n()
 const ui = useUiStore()
 const tasks = useTasksStore()
 const toast = useToast()
+const { present } = usePipelineErrorToast()
 const { confirmAction } = useConfirmAction()
 
 const source = computed(() => ui.taskConnect?.source ?? null)
@@ -70,12 +71,7 @@ async function submit() {
     // Re-probe so `available`/`enabled` reflect the new connection.
     await tasks.probe()
   } catch (e) {
-    toast.add({
-      title: t('tasks.connect.connectFailed'),
-      description: e instanceof Error ? e.message : String(e),
-      icon: 'i-lucide-triangle-alert',
-      color: 'error',
-    })
+    present(e, 'tasks.connect.connectFailed')
   } finally {
     saving.value = false
   }
@@ -88,12 +84,7 @@ async function startOAuth() {
     // Only Linear wires an OAuth flow today; the browser navigates away on success.
     if (source.value === 'linear') await tasks.startLinearOAuth()
   } catch (e) {
-    toast.add({
-      title: t('tasks.connect.connectFailed'),
-      description: e instanceof Error ? e.message : String(e),
-      icon: 'i-lucide-triangle-alert',
-      color: 'error',
-    })
+    present(e, 'tasks.connect.connectFailed')
     oauthStarting.value = false
   }
 }
@@ -117,12 +108,7 @@ async function toggleEnabled(enabled: boolean) {
   try {
     await tasks.setEnabled(source.value, enabled)
   } catch (e) {
-    toast.add({
-      title: t('tasks.connect.updateFailed'),
-      description: e instanceof Error ? e.message : String(e),
-      icon: 'i-lucide-triangle-alert',
-      color: 'error',
-    })
+    present(e, 'tasks.connect.updateFailed')
   } finally {
     togglingEnabled.value = false
   }

package/app/composables/useBlockDeletion.ts

@@ -16,6 +16,7 @@ export function useBlockDeletion() {
   const ui = useUiStore()
   const recurring = useRecurringPipelinesStore()
   const toast = useToast()
+  const { present } = usePipelineErrorToast()
   const { confirm } = useConfirm()
   const { t } = useI18n()
   const access = useWorkspaceAccess()
@@ -57,12 +58,7 @@ export function useBlockDeletion() {
         color: 'neutral',
       })
     } catch (e) {
-      toast.add({
-        title: t('board.toast.archiveFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      present(e, 'board.toast.archiveFailed')
     }
     return true
   }

package/app/composables/useCopyToClipboard.ts

@@ -9,7 +9,13 @@
 import { useClipboard } from '@vueuse/core'
 
 export function useCopyToClipboard() {
-  const { t } = useI18n()
+  // Resolved through the Nuxt app's global i18n instance rather than `useI18n()`, which requires an
+  // active component instance. This composable is reached from the failure-toast funnel, which is
+  // itself instantiated in STORE setup (`stores/execution.ts`, `stores/board.ts`), and a Pinia
+  // setup store runs its body on the first `useStore()` anywhere, which is not necessarily a
+  // component. `useI18n()` there throws `MUST_BE_CALL_SETUP_TOP`, and a throw in a store body takes
+  // the whole app to Nuxt's error page. Same reason, and the same fix, as `usePipelineErrorToast`.
+  const { t } = useNuxtApp().$i18n as ReturnType<typeof useI18n>
   const toast = useToast()
   const { copy: writeClipboard, isSupported } = useClipboard()
 

package/app/composables/usePipelineErrorToast.spec.ts

@@ -7,6 +7,25 @@ import {
 import { ApiError } from '~/composables/api/errors'
 import en from '../../i18n/locales/en.json'
 
+/**
+ * The clipboard seam is mocked so the COPIED TEXT is assertable (and so the spec needs no
+ * `navigator.clipboard`). What the copy action carries is the whole point of it: a reader pastes
+ * that string into a bug report, and if the `requestId` is missing from it there is nothing joining
+ * the report to the one server log line that explains the failure.
+ */
+const copied: string[] = []
+vi.mock('~/composables/useCopyToClipboard', () => ({
+  useCopyToClipboard: () => ({
+    copy: async (text: string) => void copied.push(text),
+    copyAction: (text: string) => ({
+      label: 'common.copyDetails',
+      icon: 'i-lucide-clipboard',
+      onClick: () => void copied.push(text),
+    }),
+    isSupported: { value: true },
+  }),
+}))
+
 /**
  * The i18n pilot: the pipeline-error toast resolves user-facing copy from
  * `errors.conflict.*` message KEYS by the backend's machine-readable `reason` — both the
@@ -93,21 +112,30 @@ describe('usePipelineErrorToast', () => {
     expect(arg.description).toBe('errors.conflict.description.dependencies_unmet')
   })
 
-  it('falls back to the caller fallback key + raw message for an UNKNOWN reason', () => {
+  it('keeps raw prose as DETAIL for an UNKNOWN reason, never as the headline', () => {
+    // An unmapped reason is the path a reason this build has never heard of takes, so it is the
+    // one that most needs the funnel's two properties rather than the least: translated copy up
+    // front, the backend's untranslated prose behind the disclosure.
     usePipelineErrorToast().present(
       conflict('totally_unknown_reason', {}, 'raw detail'),
       'errors.action.retryFailed',
     )
     const arg = add.mock.calls[0]![0]
     expect(arg.title).toBe('errors.action.retryFailed')
-    // Unmapped reason ⇒ raw backend prose is the last-resort description.
-    expect(arg.description).toBe('raw detail')
-    expect(arg.actions).toBeUndefined()
+    expect(arg.description).toBe('errors.conflict.fallbackMessage')
+    arg.actions[0].onClick()
+    expect(update).toHaveBeenCalledWith(
+      'toast-1',
+      expect.objectContaining({ description: 'raw detail' }),
+    )
   })
 
   it('shows the fallback message for an unknown reason with no backend message', () => {
     usePipelineErrorToast().present(conflict('totally_unknown_reason'))
-    expect(add.mock.calls[0]![0].description).toBe('errors.conflict.fallbackMessage')
+    const arg = add.mock.calls[0]![0]
+    expect(arg.description).toBe('errors.conflict.fallbackMessage')
+    // Nothing to disclose ⇒ no reveal, but the copy action is still the point.
+    expect(arg.actions).toHaveLength(1)
   })
 
   it('offers a jump action for a reason with a UI remedy (github_not_connected → connect GitHub)', () => {
@@ -122,11 +150,15 @@ describe('usePipelineErrorToast', () => {
     expect(ui.openGitHub).toHaveBeenCalledOnce()
   })
 
-  it('leaves a reason without a UI remedy as a plain (auto-dismissing) toast', () => {
+  it('keeps a conflict on screen and copyable even with no UI remedy to jump to', () => {
+    // A conflict is a failure like any other: the reader has to be able to finish it, quote it,
+    // and paste it into a report. A remedy-less reason used to be the one that auto-dismissed.
     usePipelineErrorToast().present(conflict('dependencies_unmet'))
     const arg = add.mock.calls[0]![0]
-    expect(arg.duration).toBeUndefined()
-    expect(arg.actions).toBeUndefined()
+    expect(arg.duration).toBe(0)
+    expect(arg.actions.map((a: { label: string }) => a.label)).toEqual(['common.copyDetails'])
+    arg.actions[0].onClick()
+    expect(copied.at(-1)).toContain('errors.conflict.description.dependencies_unmet')
   })
 
   it('interpolates the model list for providers_unconfigured and offers the AI setup jump', () => {
@@ -159,24 +191,48 @@ describe('usePipelineErrorToast', () => {
     expect(add.mock.calls[0]![0].description).toBe('errors.generic.description.unavailable')
   })
 
-  it('reveals the raw detail in place when "Show details" is clicked, and makes it sticky', () => {
+  it('reveals the raw detail in place when "Show details" is clicked', () => {
     usePipelineErrorToast().present(
       new ApiError(503, { error: { code: 'unavailable', message: 'Task sources not configured' } }),
     )
     const arg = add.mock.calls[0]![0]
-    // Auto-dismissing until the user asks for detail: no `duration` override up front.
-    expect(arg.duration).toBeUndefined()
     expect(arg.actions[0].label).toBe('errors.generic.showDetail')
     arg.actions[0].onClick()
-    // Same toast, not a second one; sticky, and the button is dropped so it can't be re-clicked.
+    // The SAME toast, not a second one, so the two readings can't sit on screen disagreeing. The
+    // disclosure button is dropped (it would now be a no-op) and the copy action is re-passed,
+    // because `update` merges over the existing toast and copying is still the point.
     expect(add).toHaveBeenCalledTimes(1)
     expect(update).toHaveBeenCalledWith('toast-1', {
       description: 'Task sources not configured',
-      duration: 0,
-      actions: [],
+      actions: [expect.objectContaining({ label: 'common.copyDetails' })],
     })
   })
 
+  it('does NOT auto-dismiss, and can be copied whole in one click', () => {
+    // Both properties are the reason a failure goes through this funnel at all: the toast a user
+    // needs to read, quote or act on used to vanish after ~5s, and its detail could only be
+    // retyped off the screen. `duration: 0` keeps it until dismissed (it still has a close
+    // button); the copy action carries the failed action, the failure class, the backend prose and
+    // the requestId in one string.
+    usePipelineErrorToast().present(
+      new ApiError(503, {
+        error: { code: 'unavailable', message: 'Task sources not configured', requestId: 'req-9' },
+      }),
+      'errors.action.startFailed',
+    )
+    const arg = add.mock.calls[0]![0]
+    expect(arg.duration).toBe(0)
+    const copy = arg.actions.find((a: { label: string }) => a.label === 'common.copyDetails')
+    copy.onClick()
+    expect(copied[copied.length - 1]).toBe(
+      [
+        'errors.action.startFailed',
+        'errors.generic.description.unavailable',
+        'Task sources not configured · errors.generic.requestId',
+      ].join('\n'),
+    )
+  })
+
   it('folds validation issues and the requestId into the revealed detail', () => {
     usePipelineErrorToast().present(
       new ApiError(400, {
@@ -199,7 +255,7 @@ describe('usePipelineErrorToast', () => {
     )
   })
 
-  it('offers no disclosure when there is no detail to reveal', () => {
+  it('offers no disclosure when there is no detail to reveal, but still offers the copy', () => {
     usePipelineErrorToast().present(new ApiError(503, { error: { code: 'unavailable' } }))
     const arg = add.mock.calls[0]![0]
     // `ApiError` synthesises `Request failed (HTTP 503)` when the envelope carries no message,
@@ -207,7 +263,11 @@ describe('usePipelineErrorToast', () => {
     expect(arg.description).toBe('errors.generic.description.unavailable')
     expect(arg.actions[0].label).toBe('errors.generic.showDetail')
     usePipelineErrorToast().present(null)
-    expect(add.mock.calls[1]![0].actions).toBeUndefined()
+    // A disclosure that reveals nothing is worse than none, but the two translated lines are still
+    // worth copying: they name the action that failed and the class of failure.
+    expect(add.mock.calls[1]![0].actions).toEqual([
+      expect.objectContaining({ label: 'common.copyDetails' }),
+    ])
   })
 })
 

package/app/composables/usePipelineErrorToast.ts

@@ -25,6 +25,9 @@
  */
 
 import { createBespokeConflictToasts } from '~/composables/pipelineErrorToast/bespokeConflicts'
+// Imported by path rather than left to Nuxt's auto-import: this module is also loaded directly by
+// unit tests (and from store setup), where the auto-import globals are not installed.
+import { useCopyToClipboard } from '~/composables/useCopyToClipboard'
 import type { ApiErrorCode, ConflictReason, UnavailableReason } from '@cat-factory/contracts'
 import { apiErrorEnvelope, apiErrorReason, apiErrorStatus } from './api/errors'
 
@@ -424,6 +427,9 @@ export function usePipelineErrorToast() {
   // tier 1 only sees literal keys written in a `<script setup>`, never in a `.ts` composable —
   // the drift guard here is the exhaustive `CONFLICT_INFO` / `ApiErrorCode` records above.
   const { t, te } = useNuxtApp().$i18n as ReturnType<typeof useI18n>
+  // The shared clipboard seam (feedback toast included), so "Copy details" behaves like every other
+  // copy affordance in the product instead of silently failing where the API is unavailable.
+  const { copyAction } = useCopyToClipboard()
 
   // The five bespoke conflict reasons (a runtime-interpolated body + a "configure X" jump each)
   // live in a sibling factory over the same toast/ui/i18n handles, so this composable stays
@@ -434,43 +440,63 @@ export function usePipelineErrorToast() {
    * Per-reason copy from the exhaustive map: a translated title + description, and a jump
    * action for the reasons a UI panel can fix. `te` (translation-exists) guards every lookup,
    * so a key missing from the active locale falls back rather than leaking a raw key: the
-   * title falls to the caller's key, the description to the raw backend `message`. An unknown
-   * reason (not in the map) gets the same generic title + raw-message fallback.
+   * title falls to the caller's key, the description to the generic conflict line.
+   *
+   * A conflict is a FAILURE, so it carries the two properties `presentGenericFailure` documents
+   * below and for the same reasons: it does not auto-dismiss, and its detail is copyable. The
+   * backend's own prose is DETAIL here rather than the headline, which matters most on the
+   * unknown-reason path: that is where a reason this SPA build has never heard of lands, so
+   * leaving it as the description meant the newest failures were the ones shown untranslated,
+   * uncopyable, and gone in five seconds.
    */
-  function presentMappedConflict(conflict: ParsedConflict, fallbackTitleKey: string): void {
+  function presentMappedConflict(
+    conflict: ParsedConflict,
+    fallbackTitleKey: string,
+    titleParams?: Record<string, unknown>,
+  ): void {
     const info = conflict.reason
       ? CONFLICT_INFO[conflict.reason as Exclude<ConflictReason, BespokeConflictReason>]
       : undefined
-    if (info) {
-      toast.add({
-        title: te(info.titleKey) ? t(info.titleKey) : t(fallbackTitleKey),
-        description: te(info.descriptionKey)
-          ? t(info.descriptionKey)
-          : (conflict.message ?? t('errors.conflict.fallbackMessage')),
-        color: 'warning',
-        icon: 'i-lucide-triangle-alert',
-        // A reason with a jump action becomes an actionable, sticky toast (like the bespoke
-        // conflicts above) so the one-click remedy doesn't auto-dismiss before it's reached.
-        ...(info.action
-          ? {
-              duration: 0,
-              actions: [
-                {
-                  label: t(info.action.labelKey),
-                  icon: info.action.icon,
-                  onClick: () => info.action?.run(ui),
-                },
-              ],
-            }
-          : {}),
-      })
-      return
-    }
-    toast.add({
-      title: t(fallbackTitleKey),
-      description: conflict.message ?? t('errors.conflict.fallbackMessage'),
+    const title =
+      info && te(info.titleKey) ? t(info.titleKey) : t(fallbackTitleKey, titleParams ?? {})
+    const description =
+      info && te(info.descriptionKey)
+        ? t(info.descriptionKey)
+        : t('errors.conflict.fallbackMessage')
+    // The backend's prose, kept only when it adds something the translated line doesn't already say.
+    const detail = conflict.message && conflict.message !== description ? conflict.message : ''
+    const report = [title, description, detail].filter((part) => part.length > 0).join('\n')
+    const added = toast.add({
+      title,
+      description,
       color: 'warning',
       icon: 'i-lucide-triangle-alert',
+      duration: 0,
+      ui: { description: 'select-text' },
+      actions: [
+        // A reason with a jump action leads with its one-click remedy; the detail reveal and the
+        // copy follow it, so the primary affordance stays first in the row.
+        ...(info?.action
+          ? [
+              {
+                label: t(info.action.labelKey),
+                icon: info.action.icon,
+                onClick: () => info.action?.run(ui),
+              },
+            ]
+          : []),
+        ...(detail
+          ? [
+              {
+                label: t('errors.generic.showDetail'),
+                icon: 'i-lucide-info',
+                onClick: () =>
+                  toast.update(added.id, { description: detail, actions: [copyAction(report)] }),
+              },
+            ]
+          : []),
+        copyAction(report),
+      ],
     })
   }
 
@@ -479,15 +505,32 @@ export function usePipelineErrorToast() {
    * behind a "Show details" button that swaps it into the same toast (G2).
    *
    * The reveal is an UPDATE rather than a second toast so the two readings can't sit on screen
-   * disagreeing, and it makes the toast sticky at the same time — the detail is what someone
-   * copies into a bug report, and a ~5s auto-dismiss takes it away mid-copy. `actions: []` has to
-   * be passed explicitly: `update` merges over the existing toast, so an omitted `actions` would
-   * leave a "Show details" button that is now a no-op.
+   * disagreeing. `actions: []` is passed explicitly on the reveal: `update` merges over the
+   * existing toast, so an omitted `actions` would leave a "Show details" button that is now a
+   * no-op. The COPY action is re-passed, because it is still the point after the reveal.
+   *
+   * Two properties of this toast are the whole reason a failure goes through this funnel rather
+   * than a hand-built `toast.add`, and both were learned from someone trying to report a bug:
+   *
+   * - It does NOT auto-dismiss. A failure is the one toast a user needs to finish reading, quote,
+   *   or act on, and a ~5s dismissal took the detail away mid-sentence. It carries a close button
+   *   like every other toast, so staying is a decision the reader makes.
+   * - The detail is COPYABLE with one click, through the shared clipboard seam (so the copy's own
+   *   success/failure is reported rather than silently no-op'ing in an insecure context). Selecting
+   *   text inside a toast is fiddly at the best of times and impossible once it has gone, and what
+   *   the person needs to paste is the whole of it: the failed action, the class of failure, the
+   *   backend's prose, and above all the `requestId` that joins it to the one server log line
+   *   explaining it. Retyping that id off a screenshot is how a report arrives without it.
    *
    * No detail worth showing (a network fault with an unhelpful `message` and no correlation id)
-   * ⇒ no button at all, rather than a disclosure that reveals nothing.
+   * ⇒ no disclosure and nothing to copy beyond the two translated lines, which the copy action
+   * still carries.
    */
-  function presentGenericFailure(error: unknown, fallbackTitleKey: string): void {
+  function presentGenericFailure(
+    error: unknown,
+    fallbackTitleKey: string,
+    titleParams?: Record<string, unknown>,
+  ): void {
     const failure = describeGenericFailure(error)
     const detail = [
       failure.message,
@@ -499,38 +542,54 @@ export function usePipelineErrorToast() {
     // No `te` guard: the key comes from a Record exhaustive over the wire union and every entry
     // ships in the base `en` catalog, so a locale missing it renders English via `fallbackLocale`
     // (better than the raw prose this replaced) and a bare key can never leak.
+    const title = t(fallbackTitleKey, titleParams ?? {})
+    const description = t(failure.descriptionKey)
+    const report = [title, description, detail].filter((part) => part.length > 0).join('\n')
     const added = toast.add({
-      title: t(fallbackTitleKey),
-      description: t(failure.descriptionKey),
+      title,
+      description,
       color: 'error',
       icon: 'i-lucide-triangle-alert',
-      ...(detail
-        ? {
-            actions: [
+      duration: 0,
+      // Selectable in place too: the copy button is the reliable path, but a reader who only wants
+      // the request id should be able to drag over it.
+      ui: { description: 'select-text' },
+      actions: [
+        ...(detail
+          ? [
               {
                 label: t('errors.generic.showDetail'),
                 icon: 'i-lucide-info',
                 onClick: () =>
-                  toast.update(added.id, { description: detail, duration: 0, actions: [] }),
+                  toast.update(added.id, {
+                    description: detail,
+                    actions: [copyAction(report)],
+                  }),
               },
-            ],
-          }
-        : {}),
+            ]
+          : []),
+        copyAction(report),
+      ],
     })
   }
 
   /**
    * Present `error` as a toast. `fallbackTitleKey` is an i18n message key used for
-   * non-conflict failures and any conflict reason without a dedicated title.
+   * non-conflict failures and any conflict reason without a dedicated title; `titleParams` carries
+   * that key's interpolation when it takes any (a title naming the thing that failed).
    */
-  function present(error: unknown, fallbackTitleKey = 'common.actionFailed'): void {
+  function present(
+    error: unknown,
+    fallbackTitleKey = 'common.actionFailed',
+    titleParams?: Record<string, unknown>,
+  ): void {
     const conflict = parseConflict(error)
     if (conflict) {
       if (presentBespokeConflict(conflict)) return
-      presentMappedConflict(conflict, fallbackTitleKey)
+      presentMappedConflict(conflict, fallbackTitleKey, titleParams)
       return
     }
-    presentGenericFailure(error, fallbackTitleKey)
+    presentGenericFailure(error, fallbackTitleKey, titleParams)
   }
 
   return { present }