@cat-factory/app 0.261.3 → 0.261.5

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 }

package/app/stores/board/context.ts

@@ -31,8 +31,8 @@ export const UNDO_WINDOW_MS = 6000
  * the `board` store setup and threaded into {@link createBoardMutations} / {@link createBoardRemoval}
  * so the split operations stay behaviourally identical to the original single-closure store — the
  * factories are cohesive extractions purely to keep each function within the size budget, not new
- * seams. `api`/`toast`/`tr` are the store's own resolved handles (a store runs outside a component
- * `setup`, so `tr` bridges to the Nuxt app's global i18n instance).
+ * seams. `api`/`toast`/`tr`/`present` are the store's own resolved handles (a store runs outside a
+ * component `setup`, so `tr` bridges to the Nuxt app's global i18n instance).
  */
 export interface BoardWriteContext {
   blocks: Ref<Block[]>
@@ -43,4 +43,11 @@ export interface BoardWriteContext {
   api: ReturnType<typeof useApi>
   toast: ReturnType<typeof useToast>
   tr: (key: string, params?: Record<string, unknown>) => string
+  /**
+   * The SPA's one failure-toast funnel (`usePipelineErrorToast().present`), threaded like `toast`
+   * because it is resolved in the store setup. Every rolled-back write reports through it rather
+   * than building its own `{ title, description: err.message }`, so a board failure reads the same
+   * as every other one: translated copy, and the raw detail copyable behind the disclosure.
+   */
+  present: (error: unknown, titleKey?: string) => void
 }

package/app/stores/board/dependencies.ts

@@ -8,7 +8,7 @@ import type { BoardWriteContext } from './context'
  * the split is purely to keep every function within the size budget.
  */
 export function createBoardDependencies(ctx: BoardWriteContext) {
-  const { getBlock, upsert, api, toast, tr } = ctx
+  const { getBlock, upsert, api, present } = ctx
 
   /**
    * Toggle a dependency edge target -> source (target dependsOn source). The backend
@@ -20,12 +20,7 @@ export function createBoardDependencies(ctx: BoardWriteContext) {
     try {
       upsert(await api.toggleDependency(useWorkspaceStore().requireId(), targetId, { sourceId }))
     } catch (e) {
-      toast.add({
-        title: tr('board.toast.linkFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      present(e, 'board.toast.linkFailed')
     }
   }
 
@@ -39,12 +34,7 @@ export function createBoardDependencies(ctx: BoardWriteContext) {
     } catch (e) {
       // Mirror `toggleDependency`: a failure must surface (and leave the edge visible) rather
       // than rejecting unhandled with no feedback.
-      toast.add({
-        title: tr('board.toast.unlinkFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      present(e, 'board.toast.unlinkFailed')
     }
   }
 

package/app/stores/board/mutations.ts

@@ -17,7 +17,7 @@ import type { BoardWriteContext } from './context'
  * {@link createBoardPlacement}.
  */
 export function createBoardMutations(ctx: BoardWriteContext) {
-  const { getBlock, upsert, api, toast, tr } = ctx
+  const { getBlock, upsert, api, present } = ctx
 
   async function addBlock(type: BlockType, position: { x: number; y: number }): Promise<Block> {
     const block = await api.addFrame(useWorkspaceStore().requireId(), { type, position })
@@ -127,12 +127,7 @@ export function createBoardMutations(ctx: BoardWriteContext) {
       upsert(await api.assignToEpic(useWorkspaceStore().requireId(), taskId, { epicId }))
     } catch (e) {
       t.epicId = prev
-      toast.add({
-        title: tr('board.toast.epicFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      present(e, 'board.toast.epicFailed')
     }
   }
 

package/app/stores/board/placement.ts

@@ -34,7 +34,7 @@ function blockAsPatchable(block: Block): PatchSnapshot {
  * in-closure functions, and the split is purely to keep every function within the size budget.
  */
 export function createBoardPlacement(ctx: BoardWriteContext) {
-  const { blocks, getBlock, upsert, api, toast, tr } = ctx
+  const { blocks, getBlock, upsert, api, toast, tr, present } = ctx
 
   /**
    * Move a block into a new container at a new local position. Drag-reparent commits
@@ -94,12 +94,14 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
       // can act on rather than a fault. The backend sends the machine-readable reason and no
       // translated prose, so map it here; anything else keeps the raw message as the last resort.
       const refusal = moveRefusalKey(e)
-      toast.add({
-        title: tr('board.toast.moveFailed'),
-        description: refusal ? tr(refusal) : e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      if (refusal) {
+        toast.add({
+          title: tr('board.toast.moveFailed'),
+          description: tr(refusal),
+          icon: 'i-lucide-triangle-alert',
+          color: 'error',
+        })
+      } else present(e, 'board.toast.moveFailed')
     }
   }
 
@@ -137,12 +139,7 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
       // Restore the pre-drag position — a rejected move must not leave the block at a
       // spot the server never stored (a lie that survives until the next re-hydrate).
       b.position = prevPosition
-      toast.add({
-        title: tr('board.toast.moveFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      present(e, 'board.toast.moveFailed')
     }
   }
 
@@ -198,12 +195,7 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
       upsert(await api.resizeBlock(useWorkspaceStore().requireId(), id, bounds))
     } catch (e) {
       previewResize(id, from.position, from.size)
-      toast.add({
-        title: tr('board.toast.resizeFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      present(e, 'board.toast.resizeFailed')
     }
   }
 
@@ -244,12 +236,7 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
           if (cur[key] === patch[key]) cur[key] = prev[key]
         }
       }
-      toast.add({
-        title: tr('board.toast.updateFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+      present(e, 'board.toast.updateFailed')
       return false
     }
   }

package/app/stores/board/removal.ts

@@ -11,7 +11,7 @@ import { UNDO_WINDOW_MS } from './context'
  * stays internal — it is only wired into the delete toast's undo action.
  */
 export function createBoardRemoval(ctx: BoardWriteContext) {
-  const { blocks, getBlock, pendingRemovals, pendingDoomed, api, toast, tr } = ctx
+  const { blocks, getBlock, pendingRemovals, pendingDoomed, api, toast, tr, present } = ctx
 
   /**
    * Optimistically drop a block and its descendants from the cache, returning a
@@ -142,12 +142,7 @@ export function createBoardRemoval(ctx: BoardWriteContext) {
         // switch must not inject the old subtree onto the workspace now on screen (it
         // re-hydrates from the server there on the next refresh anyway).
         if (useWorkspaceStore().workspaceId === pending.wsId) reattach(pending.snap)
-        toast.add({
-          title: tr('board.toast.deleteFailed'),
-          description: e instanceof Error ? e.message : String(e),
-          icon: 'i-lucide-triangle-alert',
-          color: 'error',
-        })
+        present(e, 'board.toast.deleteFailed')
       }
     }
     const timer = setTimeout(() => void finalize(), UNDO_WINDOW_MS)

package/app/stores/board.spec.ts

@@ -246,11 +246,15 @@ describe('board store read getters', () => {
     expect(() => store.previewMove('missing', { x: 1, y: 1 })).not.toThrow()
   })
 
-  it('updateBlock restores the patched fields and toasts when the write fails', async () => {
-    // Capture the toast the store surfaces on failure. Re-stub before creating the store so it
-    // binds this spy (the store resolves `useToast()` once at setup).
+  it('updateBlock restores the patched fields and reports the failure when the write fails', async () => {
+    // Capture what the store surfaces on failure. Every rolled-back write drains into the shared
+    // failure funnel (`usePipelineErrorToast().present`) rather than building its own toast, so the
+    // assertion is on the funnel and on the TITLE KEY it was given. Re-stub before creating the
+    // store: it resolves both handles once at setup.
     const addSpy = vi.fn()
+    const presentSpy = vi.fn()
     vi.stubGlobal('useToast', () => ({ add: addSpy }))
+    vi.stubGlobal('usePipelineErrorToast', () => ({ present: presentSpy }))
     setActivePinia(createPinia())
     const s = useBoardStore()
     s.hydrate([frame('f1', { title: 'Original', description: 'orig' })])
@@ -263,7 +267,7 @@ describe('board store read getters', () => {
     )
     expect(s.getBlock('f1')?.title).toBe('Original')
     expect(s.getBlock('f1')?.description).toBe('orig')
-    expect(addSpy).toHaveBeenCalledWith(expect.objectContaining({ color: 'error' }))
+    expect(presentSpy).toHaveBeenCalledWith(expect.any(Error), 'board.toast.updateFailed')
   })
 
   it('updateBlock reports a no-op for a block that is not on the board', async () => {
@@ -428,6 +432,7 @@ describe('board store deferred delete + undo', () => {
   function setup(removeImpl: () => Promise<void>) {
     const removeSpy = vi.fn(removeImpl)
     const addSpy = vi.fn()
+    const presentSpy = vi.fn()
     const actions: ToastAction[] = []
     vi.stubGlobal('useApi', () => ({ removeBlock: removeSpy }))
     vi.stubGlobal('useToast', () => ({
@@ -436,9 +441,10 @@ describe('board store deferred delete + undo', () => {
         if (t.actions) actions.push(...t.actions)
       },
     }))
+    vi.stubGlobal('usePipelineErrorToast', () => ({ present: presentSpy }))
     setActivePinia(createPinia())
     useWorkspaceStore().workspaceId = 'ws1'
-    return { store: useBoardStore(), removeSpy, addSpy, actions }
+    return { store: useBoardStore(), removeSpy, addSpy, presentSpy, actions }
   }
 
   beforeEach(() => {
@@ -500,14 +506,15 @@ describe('board store deferred delete + undo', () => {
     expect(removeSpy).toHaveBeenCalledWith('ws1', 'f1')
   })
 
-  it('restores the subtree and toasts an error if the deferred delete fails', async () => {
-    const { store, addSpy } = setup(() => Promise.reject(new Error('boom')))
+  it('restores the subtree and reports the failure if the deferred delete fails', async () => {
+    const { store, presentSpy } = setup(() => Promise.reject(new Error('boom')))
     store.hydrate([frame('f1'), task('t1', 'f1')])
     store.removeBlock('f1')
     await vi.runAllTimersAsync()
     expect(store.getBlock('f1')?.id).toBe('f1')
     expect(store.getBlock('t1')?.id).toBe('t1')
-    expect(addSpy).toHaveBeenCalledWith(expect.objectContaining({ color: 'error' }))
+    // Through the shared funnel, named by its title key (see `updateBlock`'s case above).
+    expect(presentSpy).toHaveBeenCalledWith(expect.any(Error), 'board.toast.deleteFailed')
   })
 
   it('does not reattach a failed deferred delete onto a different workspace', async () => {

package/app/stores/board.ts

@@ -141,7 +141,17 @@ export const useBoardStore = defineStore('board', () => {
   // The write operations, split into cohesive factories sharing the state above (a size-only
   // extraction — behaviour is identical to the former in-closure functions). `undoRemove` stays
   // internal to the removal factory (only its delete toast wires it), so it is NOT re-exported.
-  const context = { blocks, getBlock, upsert, pendingRemovals, pendingDoomed, api, toast, tr }
+  const context = {
+    blocks,
+    getBlock,
+    upsert,
+    pendingRemovals,
+    pendingDoomed,
+    api,
+    toast,
+    tr,
+    present: usePipelineErrorToast().present,
+  }
   const mutations = createBoardMutations(context)
   const placement = createBoardPlacement(context)
   const { detach, reattach, removeBlock } = createBoardRemoval(context)