@cat-factory/app 0.82.1 → 0.82.2

package/app/composables/useBlockDeletion.ts

@@ -28,10 +28,23 @@ export function useBlockDeletion() {
         : block.level === 'module'
           ? 'module'
           : 'service'
-    return {
-      title: t(`panels.inspector.confirmDelete.${kind}.title`),
-      body: t(`panels.inspector.confirmDelete.${kind}.body`, { name: block.title }),
+    const title = t(`panels.inspector.confirmDelete.${kind}.title`)
+    // For a container (service/module) state the exact cascade size so the blast radius is
+    // explicit — "and everything inside it" hides how many tasks/modules go with it.
+    if (kind === 'module' || kind === 'service') {
+      const count = board.descendantsOf(block.id).length
+      if (count > 0) {
+        return {
+          title,
+          body: t(
+            'panels.inspector.confirmDelete.containerBodyWithCount',
+            { name: block.title, count },
+            count,
+          ),
+        }
+      }
     }
+    return { title, body: t(`panels.inspector.confirmDelete.${kind}.body`, { name: block.title }) }
   }
 
   async function deleteBlock(block: Block | undefined | null): Promise<boolean> {
@@ -54,8 +67,11 @@ export function useBlockDeletion() {
       void recurring.remove(schedule.id)
       return true
     }
-    execution.cancel(block.id)
-    void board.removeBlock(block.id)
+    // Cancelling the run is irreversible, so defer it into the delete's commit: it fires only
+    // once the (deferred) delete actually lands, so an undo within the window leaves a running
+    // pipeline intact rather than restoring a block whose run was already torn down. Target the
+    // workspace the block was deleted from in case the user switched mid-window.
+    void board.removeBlock(block.id, { onCommit: (wsId) => execution.cancel(block.id, wsId) })
     return true
   }
 

package/app/composables/useBlockQueries.ts

@@ -71,6 +71,23 @@ export function useBlockQueries(blocks: Ref<Block[]>) {
     return [...direct, ...nested]
   }
 
+  /**
+   * Every block nested under a container (transitive), excluding the container
+   * itself — the exact set a delete cascades over. Used to state the blast radius
+   * in the delete confirmation. Structural children only (via `parentId`), so a
+   * non-structural epic membership is not counted.
+   */
+  function descendantsOf(id: string): Block[] {
+    const out: Block[] = []
+    const stack = [...childrenOf(id)]
+    while (stack.length > 0) {
+      const b = stack.pop()!
+      out.push(b)
+      stack.push(...childrenOf(b.id))
+    }
+    return out
+  }
+
   /** The top-level service a block ultimately belongs to. */
   function serviceOf(block: Block): Block | undefined {
     let cur: Block | undefined = block
@@ -200,6 +217,7 @@ export function useBlockQueries(blocks: Ref<Block[]>) {
     modulesOf,
     initiativesOf,
     allTasksUnder,
+    descendantsOf,
     serviceOf,
     unmetDeps,
     isRunnable,

package/app/stores/board.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import { setActivePinia, createPinia } from 'pinia'
 import type { Block, BlockStatus } from '~/types/domain'
 import { useBoardStore } from '~/stores/board'
@@ -89,6 +89,26 @@ describe('board store read getters', () => {
     ).toEqual(['t2', 't3'])
   })
 
+  it('descendantsOf returns the transitive structural subtree, excluding the root', () => {
+    store.hydrate([
+      frame('f1'),
+      moduleBlock('m1', 'f1'),
+      task('t1', 'f1'),
+      task('t2', 'm1'),
+      frame('f2'),
+      task('t3', 'f2'),
+    ])
+    expect(
+      store
+        .descendantsOf('f1')
+        .map((b) => b.id)
+        .sort(),
+    ).toEqual(['m1', 't1', 't2'])
+    // a leaf task has no descendants; unknown ids are a safe empty
+    expect(store.descendantsOf('t1')).toEqual([])
+    expect(store.descendantsOf('missing')).toEqual([])
+  })
+
   it('epicMembers groups blocks by their epicId (indexed lookup)', () => {
     store.hydrate([
       frame('f1'),
@@ -289,4 +309,179 @@ describe('board store optimistic rollback', () => {
     expect(store.getBlock('t1')?.title).toBe('orig')
     expect(store.getBlock('t1')?.description).toBe('keep')
   })
+
+  it('reparentBlock offers an undo that moves the block back to its previous home', async () => {
+    vi.stubGlobal('useApi', () => ({
+      reparentBlock: async (
+        _ws: string,
+        id: string,
+        body: { parentId: string; position: unknown },
+      ) => task(id, body.parentId, { position: body.position as { x: number; y: number } }),
+    }))
+    interface ToastAction {
+      onClick: () => void
+    }
+    const actions: ToastAction[] = []
+    vi.stubGlobal('useToast', () => ({
+      add: (t: { actions?: ToastAction[] }) => {
+        if (t.actions) actions.push(...t.actions)
+      },
+    }))
+    setActivePinia(createPinia())
+    useWorkspaceStore().workspaceId = 'ws1'
+    const store = useBoardStore()
+    store.hydrate([
+      frame('f1'),
+      moduleBlock('m1', 'f1'),
+      task('t1', 'f1', { position: { x: 1, y: 2 } }),
+    ])
+    await store.reparentBlock('t1', 'm1', { x: 5, y: 6 })
+    expect(store.getBlock('t1')?.parentId).toBe('m1')
+    // the undo action returns the block to its original parent + position
+    expect(actions).toHaveLength(1)
+    actions[0]!.onClick()
+    await vi.waitFor(() => {
+      expect(store.getBlock('t1')?.parentId).toBe('f1')
+      expect(store.getBlock('t1')?.position).toEqual({ x: 1, y: 2 })
+    })
+    // the undo move is itself non-undoable, so no second toast is queued
+    expect(actions).toHaveLength(1)
+  })
+})
+
+describe('board store deferred delete + undo', () => {
+  interface ToastAction {
+    onClick: () => void
+  }
+  /** Build a store with a stubbed api/toast, capturing the undo action offered on delete. */
+  function setup(removeImpl: () => Promise<void>) {
+    const removeSpy = vi.fn(removeImpl)
+    const addSpy = vi.fn()
+    const actions: ToastAction[] = []
+    vi.stubGlobal('useApi', () => ({ removeBlock: removeSpy }))
+    vi.stubGlobal('useToast', () => ({
+      add: (t: { actions?: ToastAction[] }) => {
+        addSpy(t)
+        if (t.actions) actions.push(...t.actions)
+      },
+    }))
+    setActivePinia(createPinia())
+    useWorkspaceStore().workspaceId = 'ws1'
+    return { store: useBoardStore(), removeSpy, addSpy, actions }
+  }
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('hides the subtree immediately but defers the backend delete', () => {
+    const { store, removeSpy } = setup(async () => {})
+    store.hydrate([frame('f1'), moduleBlock('m1', 'f1'), task('t1', 'm1')])
+    store.removeBlock('f1')
+    // the whole subtree disappears at once…
+    expect(store.getBlock('f1')).toBeUndefined()
+    expect(store.getBlock('m1')).toBeUndefined()
+    expect(store.getBlock('t1')).toBeUndefined()
+    // …but nothing is deleted server-side yet.
+    expect(removeSpy).not.toHaveBeenCalled()
+  })
+
+  it('keeps a pending-delete subtree hidden across a coarse refresh, and prunes its edges', () => {
+    const { store } = setup(async () => {})
+    store.hydrate([frame('f1'), task('t1', 'f1'), task('t2', 'f1', { dependsOn: ['t1'] })])
+    store.removeBlock('t1')
+    // A full re-hydrate (e.g. a `board` live event) that still carries the deleted block and
+    // the now-dangling dependency edge must not resurrect either.
+    store.hydrate([frame('f1'), task('t1', 'f1'), task('t2', 'f1', { dependsOn: ['t1'] })])
+    expect(store.getBlock('t1')).toBeUndefined()
+    expect(store.getBlock('t2')?.dependsOn).toEqual([])
+  })
+
+  it('ignores a live upsert for a block awaiting its deferred delete', () => {
+    const { store } = setup(async () => {})
+    store.hydrate([frame('f1'), task('t1', 'f1')])
+    store.removeBlock('t1')
+    store.upsert(task('t1', 'f1', { title: 'resurrected' }))
+    expect(store.getBlock('t1')).toBeUndefined()
+  })
+
+  it('undo cancels the pending delete and restores the subtree', async () => {
+    const { store, removeSpy, actions } = setup(async () => {})
+    store.hydrate([frame('f1'), moduleBlock('m1', 'f1'), task('t1', 'm1')])
+    store.removeBlock('f1')
+    expect(actions).toHaveLength(1)
+    actions[0]!.onClick()
+    expect(store.getBlock('f1')?.id).toBe('f1')
+    expect(store.getBlock('t1')?.id).toBe('t1')
+    // the deferred delete never fires after an undo
+    await vi.runAllTimersAsync()
+    expect(removeSpy).not.toHaveBeenCalled()
+  })
+
+  it('fires the backend delete for the captured workspace once the window elapses', async () => {
+    const { store, removeSpy } = setup(async () => {})
+    store.hydrate([frame('f1')])
+    store.removeBlock('f1')
+    await vi.runAllTimersAsync()
+    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')))
+    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' }))
+  })
+
+  it('does not reattach a failed deferred delete onto a different workspace', async () => {
+    const { store } = setup(() => Promise.reject(new Error('boom')))
+    store.hydrate([frame('f1'), task('t1', 'f1')])
+    store.removeBlock('f1')
+    // The user switches workspace during the undo window; when the delete then fails, the
+    // ws1 subtree must NOT be injected onto the ws2 board now on screen.
+    useWorkspaceStore().workspaceId = 'ws2'
+    await vi.runAllTimersAsync()
+    expect(store.getBlock('f1')).toBeUndefined()
+    expect(store.getBlock('t1')).toBeUndefined()
+  })
+
+  it('runs onCommit with the captured workspace only when the window elapses', async () => {
+    const { store } = setup(async () => {})
+    const onCommit = vi.fn(async () => {})
+    store.hydrate([frame('f1')])
+    store.removeBlock('f1', { onCommit })
+    await vi.runAllTimersAsync()
+    expect(onCommit).toHaveBeenCalledWith('ws1')
+  })
+
+  it('skips onCommit (the irreversible side effect) when the delete is undone', async () => {
+    const { store, actions } = setup(async () => {})
+    const onCommit = vi.fn(async () => {})
+    store.hydrate([frame('f1')])
+    store.removeBlock('f1', { onCommit })
+    actions[0]!.onClick() // undo before the window elapses
+    await vi.runAllTimersAsync()
+    expect(onCommit).not.toHaveBeenCalled()
+  })
+
+  it('undo re-adds pruned edges without clobbering ones gained during the window', () => {
+    const { store, actions } = setup(async () => {})
+    store.hydrate([
+      frame('f1'),
+      task('t1', 'f1'),
+      task('t2', 'f1', { dependsOn: ['t1'] }),
+      task('t3', 'f1'),
+    ])
+    store.removeBlock('t1')
+    // A live event adds a new dependency to the survivor mid-window (t1's edge was pruned).
+    store.upsert(task('t2', 'f1', { dependsOn: ['t3'] }))
+    actions[0]!.onClick() // undo restores t1 and its edge, keeping the newly-added t3 edge
+    expect(store.getBlock('t2')?.dependsOn.slice().sort()).toEqual(['t1', 't3'])
+  })
 })

package/app/stores/board.ts

@@ -36,13 +36,55 @@ export const useBoardStore = defineStore('board', () => {
   // global i18n instance (the same handle `plugins/locale.client.ts` uses) rather than
   // `useI18n()`, which requires an active component instance.
   const nuxtApp = useNuxtApp()
-  const tr = (key: string): string => (nuxtApp.$i18n as { t: (k: string) => string }).t(key)
+  const tr = (key: string, params?: Record<string, unknown>): string =>
+    (nuxtApp.$i18n as { t: (k: string, p?: Record<string, unknown>) => string }).t(
+      key,
+      params ?? {},
+    )
   const blocks = ref<Block[]>([])
 
   // Pure derivations (hierarchy, status/progress, sizing) live in the composable.
   const queries = useBlockQueries(blocks)
   const { getBlock } = queries
 
+  /**
+   * How long a deleted block stays undoable. The backend delete is DEFERRED for this
+   * window (a real "undo", not a client illusion) — the block is hidden immediately but
+   * only actually deleted once the window elapses, so undo just cancels the pending call.
+   */
+  const UNDO_WINDOW_MS = 6000
+  /**
+   * Blocks hidden by an optimistic delete whose backend call hasn't fired yet, keyed by
+   * the deleted root's id. Their subtree stays filtered out of every incoming server
+   * snapshot (`hydrate`) and single-block live event (`upsert`) for the undo window, so a
+   * coarse refresh or a stray event can't resurrect a block the user just deleted.
+   */
+  const pendingRemovals = new Map<
+    string,
+    { snap: RemovalSnapshot; timer: ReturnType<typeof setTimeout>; wsId: string }
+  >()
+  // Flat set of every id in a pending removal (root + descendants), for O(1) checks in the
+  // hot upsert path. Kept in lockstep with `pendingRemovals`.
+  const pendingDoomed = new Set<string>()
+
+  /**
+   * Drop any pending-removal subtree from a reconciled block list and prune survivors'
+   * edges to it — the same detach the backend will perform once the deferred delete fires.
+   * Applied to every hydrate so the undo window survives a full refresh.
+   */
+  function applyPendingRemovals(list: Block[]): Block[] {
+    if (pendingDoomed.size === 0) return list
+    const survivors = list.filter((b) => !pendingDoomed.has(b.id))
+    for (const b of survivors) {
+      if (b.dependsOn.some((d) => pendingDoomed.has(d))) {
+        b.dependsOn = b.dependsOn.filter((d) => !pendingDoomed.has(d))
+      }
+      if (b.epicId != null && pendingDoomed.has(b.epicId)) b.epicId = null
+      if (b.initiativeId != null && pendingDoomed.has(b.initiativeId)) b.initiativeId = null
+    }
+    return survivors
+  }
+
   /**
    * Reconcile the cached blocks against a server snapshot, reusing the existing
    * object for any block whose content is unchanged. The server stays authoritative
@@ -67,14 +109,18 @@ export const useBoardStore = defineStore('board', () => {
   }
   function hydrate(next: Block[]) {
     const prev = new Map(blocks.value.map((b) => [b.id, b]))
-    blocks.value = next.map((n) => {
+    const reconciled = next.map((n) => {
       const existing = prev.get(n.id)
       return existing && jsonFor(existing) === jsonFor(n) ? existing : n
     })
+    // Keep blocks the user just deleted hidden while their delete is still pending.
+    blocks.value = applyPendingRemovals(reconciled)
   }
 
   /** Insert or replace a block returned by the backend. */
   function upsert(block: Block) {
+    // A live event for a block awaiting its deferred delete must not resurrect it.
+    if (pendingDoomed.has(block.id)) return
     const i = blocks.value.findIndex((b) => b.id === block.id)
     if (i >= 0) blocks.value[i] = block
     else blocks.value.push(block)
@@ -199,11 +245,16 @@ export const useBoardStore = defineStore('board', () => {
     return block
   }
 
-  /** Move a block into a new container at a new local position. */
+  /**
+   * Move a block into a new container at a new local position. Drag-reparent commits
+   * silently on a small overshoot, so a successful move (into a *different* container,
+   * not an undo of one) offers a one-click undo back to its previous home.
+   */
   async function reparentBlock(
     id: string,
     newParentId: string,
     position: { x: number; y: number },
+    opts: { undoable?: boolean } = { undoable: true },
   ) {
     const b = getBlock(id)
     const parent = getBlock(newParentId)
@@ -217,6 +268,7 @@ export const useBoardStore = defineStore('board', () => {
     // block in the wrong container (a structural lie that survives until re-hydrate).
     const prevParentId = b.parentId
     const prevPosition = b.position
+    const name = b.title
     b.parentId = newParentId
     b.position = position
     try {
@@ -226,6 +278,24 @@ export const useBoardStore = defineStore('board', () => {
           position,
         }),
       )
+      // Offer an undo back to the previous container (a drag overshoot is easy). The undo
+      // move is itself non-undoable so the toast doesn't ping-pong.
+      if (opts.undoable && prevParentId) {
+        toast.add({
+          title: tr('board.toast.moved', { name }),
+          icon: 'i-lucide-move',
+          color: 'neutral',
+          duration: UNDO_WINDOW_MS,
+          actions: [
+            {
+              label: tr('common.undo'),
+              icon: 'i-lucide-undo-2',
+              onClick: () =>
+                void reparentBlock(id, prevParentId, prevPosition, { undoable: false }),
+            },
+          ],
+        })
+      }
     } catch (e) {
       b.parentId = prevParentId
       b.position = prevPosition
@@ -291,35 +361,99 @@ export const useBoardStore = defineStore('board', () => {
   /** Re-insert a detached subtree and restore its broken edges (delete rollback). */
   function reattach(snap: RemovalSnapshot) {
     for (const b of snap.removed) if (!getBlock(b.id)) blocks.value.push(b)
+    const restored = new Set(snap.removed.map((b) => b.id))
     for (const e of snap.edges) {
       const b = getBlock(e.id)
-      if (b) {
-        b.dependsOn = e.dependsOn
-        b.epicId = e.epicId
+      if (!b) continue
+      // Re-establish only the links that pointed at a now-restored block, merged with
+      // whatever the survivor gained meanwhile — so a delayed undo (the delete is deferred by
+      // a window during which a live event may add edges) doesn't clobber a newer dependency /
+      // epic / initiative link with the stale detach-time snapshot.
+      const readd = e.dependsOn.filter((d) => restored.has(d) && !b.dependsOn.includes(d))
+      if (readd.length) b.dependsOn = [...b.dependsOn, ...readd]
+      if (b.epicId == null && e.epicId != null && restored.has(e.epicId)) b.epicId = e.epicId
+      if (b.initiativeId == null && e.initiativeId != null && restored.has(e.initiativeId)) {
         b.initiativeId = e.initiativeId
       }
     }
   }
 
   /**
-   * Delete a block. The subtree is hidden IMMEDIATELY (optimistic) so the board
-   * feels instant; if the backend rejects the delete we put it back and surface a
-   * toast rather than silently leaving a ghost.
+   * Delete a block. The subtree is hidden IMMEDIATELY (optimistic) so the board feels
+   * instant, and the real backend delete is DEFERRED by {@link UNDO_WINDOW_MS} so the
+   * accompanying "Deleted — Undo" toast can cancel it in place (a genuine undo, since
+   * nothing was destroyed server-side yet). The subtree stays filtered out of any
+   * hydrate/upsert in the meantime (see {@link applyPendingRemovals}). If the deferred
+   * call ultimately fails we put the subtree back and surface an error toast.
    */
-  async function removeBlock(id: string) {
+  function removeBlock(
+    id: string,
+    opts: { onCommit?: (wsId: string) => void | Promise<void> } = {},
+  ) {
+    const block = getBlock(id)
     const snap = detach(id)
-    if (!snap) return
-    try {
-      await api.removeBlock(useWorkspaceStore().requireId(), id)
-    } catch (e) {
-      reattach(snap)
-      toast.add({
-        title: tr('board.toast.deleteFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
+    if (!block || !snap) return
+    // Capture the workspace now: the deferred delete must target the workspace the block
+    // was deleted from even if the user has since switched.
+    const wsId = useWorkspaceStore().requireId()
+    for (const b of snap.removed) pendingDoomed.add(b.id)
+
+    const finalize = async () => {
+      const pending = pendingRemovals.get(id)
+      if (!pending) return
+      pendingRemovals.delete(id)
+      try {
+        // Any irreversible side effect the delete implies (e.g. cancelling the block's run)
+        // is deferred to here so it fires only once the delete truly commits — undo within
+        // the window then leaves the run untouched instead of restoring an already-cancelled one.
+        await opts.onCommit?.(pending.wsId)
+        await api.removeBlock(pending.wsId, id)
+        // Stop filtering the subtree only after the server has actually dropped it, so a
+        // snapshot that raced the in-flight delete can't briefly resurrect it.
+        for (const b of pending.snap.removed) pendingDoomed.delete(b.id)
+      } catch (e) {
+        for (const b of pending.snap.removed) pendingDoomed.delete(b.id)
+        // Only restore into the board the block was deleted from; a mid-window workspace
+        // 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',
+        })
+      }
     }
+    const timer = setTimeout(() => void finalize(), UNDO_WINDOW_MS)
+    pendingRemovals.set(id, { snap, timer, wsId })
+
+    toast.add({
+      title: tr('board.toast.deleted', { name: block.title }),
+      icon: 'i-lucide-trash-2',
+      color: 'neutral',
+      duration: UNDO_WINDOW_MS,
+      actions: [
+        {
+          label: tr('common.undo'),
+          icon: 'i-lucide-undo-2',
+          onClick: () => undoRemove(id),
+        },
+      ],
+    })
+  }
+
+  /** Cancel a still-pending delete and restore the hidden subtree. */
+  function undoRemove(id: string) {
+    const pending = pendingRemovals.get(id)
+    if (!pending) return
+    clearTimeout(pending.timer)
+    pendingRemovals.delete(id)
+    for (const b of pending.snap.removed) pendingDoomed.delete(b.id)
+    // Don't resurrect the subtree into a different workspace if the user navigated away
+    // mid-window; the delete was already cancelled, which is the safe outcome there.
+    if (useWorkspaceStore().workspaceId !== pending.wsId) return
+    reattach(pending.snap)
   }
 
   /**
@@ -357,7 +491,7 @@ export const useBoardStore = defineStore('board', () => {
       // spot the server never stored (a lie that survives until the next re-hydrate).
       b.position = prevPosition
       toast.add({
-        title: 'Could not move',
+        title: tr('board.toast.moveFailed'),
         description: e instanceof Error ? e.message : String(e),
         icon: 'i-lucide-triangle-alert',
         color: 'error',

package/app/stores/execution.ts

@@ -304,10 +304,14 @@ export const useExecutionStore = defineStore('execution', () => {
     }
   }
 
-  /** Cancel the execution running against a block and reset it to planned. */
-  async function cancel(blockId: string) {
+  /**
+   * Cancel the execution running against a block and reset it to planned. `workspaceId`
+   * defaults to the current workspace but can be pinned by callers that cancel a run for a
+   * board the user may have since navigated away from (e.g. a deferred delete's commit).
+   */
+  async function cancel(blockId: string, workspaceId?: string) {
     const ws = useWorkspaceStore()
-    await api.cancelExecution(ws.requireId(), blockId)
+    await api.cancelExecution(workspaceId ?? ws.requireId(), blockId)
     instances.value = instances.value.filter((e) => e.blockId !== blockId)
     await ws.refresh()
   }

package/i18n/locales/en.json

@@ -59,7 +59,8 @@
     },
     "@clear": {
       "description": "Verb meaning empty / reset a stored value (a config, a saved connection), NOT the adjective 'transparent / obvious'. Used as a destructive-action button label."
-    }
+    },
+    "undo": "Undo"
   },
   "nav": {
     "menu": "Navigation menu",
@@ -95,7 +96,9 @@
       "moveFailed": "Could not move",
       "deleteFailed": "Could not delete",
       "linkFailed": "Could not link tasks",
-      "recurringDeleteFailed": "Could not delete recurring pipeline"
+      "recurringDeleteFailed": "Could not delete recurring pipeline",
+      "deleted": "Deleted \"{name}\"",
+      "moved": "Moved \"{name}\""
     },
     "repoTypes": {
       "service": "Service",
@@ -985,7 +988,8 @@
         "recurring": {
           "title": "Delete this recurring pipeline?",
           "body": "\"{name}\", its schedule and its run history will be removed. This can't be undone."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" and the {count} item inside it will be removed. This can't be undone. | \"{name}\" and the {count} items inside it will be removed. This can't be undone."
       },
       "titlePlaceholder": "Title…",
       "reworkedRequirements": "Reworked requirements",

package/i18n/locales/es.json

@@ -50,7 +50,8 @@
       "revoked": "{name} revocado",
       "cleared": "{name} borrado",
       "destroyed": "{name} destruido"
-    }
+    },
+    "undo": "Deshacer"
   },
   "nav": {
     "menu": "Menú de navegación",
@@ -80,7 +81,9 @@
       "moveFailed": "No se pudo mover",
       "deleteFailed": "No se pudo eliminar",
       "linkFailed": "No se pudieron vincular las tareas",
-      "recurringDeleteFailed": "No se pudo eliminar el pipeline recurrente"
+      "recurringDeleteFailed": "No se pudo eliminar el pipeline recurrente",
+      "deleted": "\"{name}\" eliminado",
+      "moved": "\"{name}\" movido"
     },
     "repoTypes": {
       "service": "Servicio",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "¿Eliminar este pipeline recurrente?",
           "body": "Se eliminarán \"{name}\", su programación y su historial de ejecución. Esta acción no se puede deshacer."
-        }
+        },
+        "containerBodyWithCount": "Se eliminará \"{name}\" y el {count} elemento que contiene. Esta acción no se puede deshacer. | Se eliminará \"{name}\" y los {count} elementos que contiene. Esta acción no se puede deshacer."
       }
     }
   },

package/i18n/locales/fr.json

@@ -50,7 +50,8 @@
       "revoked": "{name} révoqué",
       "cleared": "{name} effacé",
       "destroyed": "{name} détruit"
-    }
+    },
+    "undo": "Annuler"
   },
   "nav": {
     "menu": "Menu de navigation",
@@ -80,7 +81,9 @@
       "moveFailed": "Impossible de déplacer",
       "deleteFailed": "Impossible de supprimer",
       "linkFailed": "Impossible de lier les tâches",
-      "recurringDeleteFailed": "Impossible de supprimer le pipeline récurrent"
+      "recurringDeleteFailed": "Impossible de supprimer le pipeline récurrent",
+      "deleted": "\"{name}\" supprimé",
+      "moved": "\"{name}\" déplacé"
     },
     "repoTypes": {
       "service": "Service",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "Supprimer ce pipeline récurrent ?",
           "body": "\"{name}\", sa planification et son historique d'exécution seront supprimés. Cette action est irréversible."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" et le {count} élément qu'il contient seront supprimés. Cette action est irréversible. | \"{name}\" et les {count} éléments qu'il contient seront supprimés. Cette action est irréversible."
       }
     }
   },

package/i18n/locales/he.json

@@ -50,7 +50,8 @@
       "revoked": "{name} בוטל",
       "cleared": "{name} נוקה",
       "destroyed": "{name} הושמד"
-    }
+    },
+    "undo": "בטל"
   },
   "nav": {
     "menu": "תפריט ניווט",
@@ -80,7 +81,9 @@
       "moveFailed": "לא ניתן היה להעביר",
       "deleteFailed": "לא ניתן היה למחוק",
       "linkFailed": "לא ניתן היה לקשר משימות",
-      "recurringDeleteFailed": "לא ניתן היה למחוק את הצינור החוזר"
+      "recurringDeleteFailed": "לא ניתן היה למחוק את הצינור החוזר",
+      "deleted": "\"{name}\" נמחק",
+      "moved": "\"{name}\" הועבר"
     },
     "repoTypes": {
       "service": "שירות",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "למחוק את ה־pipeline החוזר הזה?",
           "body": "\"{name}\", התזמון שלו והיסטוריית ההרצות יימחקו. לא ניתן לבטל פעולה זו."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" ו-{count} פריט שבתוכו יימחקו. לא ניתן לבטל פעולה זו. | \"{name}\" ו-{count} פריטים שבתוכו יימחקו. לא ניתן לבטל פעולה זו."
       }
     }
   },

package/i18n/locales/ja.json

@@ -50,7 +50,8 @@
       "revoked": "{name} を取り消しました",
       "cleared": "{name} をクリアしました",
       "destroyed": "{name} を破棄しました"
-    }
+    },
+    "undo": "元に戻す"
   },
   "nav": {
     "menu": "ナビゲーションメニュー",
@@ -80,7 +81,9 @@
       "moveFailed": "移動できませんでした",
       "deleteFailed": "削除できませんでした",
       "linkFailed": "タスクをリンクできませんでした",
-      "recurringDeleteFailed": "定期パイプラインを削除できませんでした"
+      "recurringDeleteFailed": "定期パイプラインを削除できませんでした",
+      "deleted": "\"{name}\" を削除しました",
+      "moved": "\"{name}\" を移動しました"
     },
     "repoTypes": {
       "service": "サービス",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "この定期パイプラインを削除しますか？",
           "body": "「{name}」、そのスケジュール、実行履歴が削除されます。この操作は取り消せません。"
-        }
+        },
+        "containerBodyWithCount": "「{name}」とその中の {count} 件の項目が削除されます。この操作は取り消せません。 | 「{name}」とその中の {count} 件の項目が削除されます。この操作は取り消せません。"
       }
     }
   },

package/i18n/locales/pl.json

@@ -50,7 +50,8 @@
       "revoked": "Unieważniono {name}",
       "cleared": "Wyczyszczono {name}",
       "destroyed": "Zniszczono {name}"
-    }
+    },
+    "undo": "Cofnij"
   },
   "nav": {
     "menu": "Menu nawigacji",
@@ -80,7 +81,9 @@
       "moveFailed": "Nie udało się przenieść",
       "deleteFailed": "Nie udało się usunąć",
       "linkFailed": "Nie udało się powiązać zadań",
-      "recurringDeleteFailed": "Nie udało się usunąć cyklicznego pipeline'u"
+      "recurringDeleteFailed": "Nie udało się usunąć cyklicznego pipeline'u",
+      "deleted": "Usunięto \"{name}\"",
+      "moved": "Przeniesiono \"{name}\""
     },
     "repoTypes": {
       "service": "Usługa",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "Usunąć ten cykliczny pipeline?",
           "body": "\"{name}\", jego harmonogram i historia uruchomień zostaną usunięte. Tej operacji nie można cofnąć."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" i {count} element w środku zostaną usunięte. Tej operacji nie można cofnąć. | \"{name}\" i {count} elementy w środku zostaną usunięte. Tej operacji nie można cofnąć. | \"{name}\" i {count} elementów w środku zostanie usuniętych. Tej operacji nie można cofnąć."
       }
     }
   },

package/i18n/locales/tr.json

@@ -50,7 +50,8 @@
       "revoked": "{name} iptal edildi",
       "cleared": "{name} temizlendi",
       "destroyed": "{name} yok edildi"
-    }
+    },
+    "undo": "Geri al"
   },
   "nav": {
     "menu": "Gezinme menüsü",
@@ -80,7 +81,9 @@
       "moveFailed": "Taşınamadı",
       "deleteFailed": "Silinemedi",
       "linkFailed": "Görevler bağlanamadı",
-      "recurringDeleteFailed": "Yinelenen pipeline silinemedi"
+      "recurringDeleteFailed": "Yinelenen pipeline silinemedi",
+      "deleted": "\"{name}\" silindi",
+      "moved": "\"{name}\" taşındı"
     },
     "repoTypes": {
       "service": "Servis",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "Bu yinelenen pipeline silinsin mi?",
           "body": "\"{name}\", zamanlaması ve çalıştırma geçmişi kaldırılacak. Bu işlem geri alınamaz."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" ve içindeki {count} öğe kaldırılacak. Bu işlem geri alınamaz. | \"{name}\" ve içindeki {count} öğe kaldırılacak. Bu işlem geri alınamaz."
       }
     }
   },

package/i18n/locales/uk.json

@@ -50,7 +50,8 @@
       "revoked": "{name} відкликано",
       "cleared": "{name} очищено",
       "destroyed": "{name} знищено"
-    }
+    },
+    "undo": "Відмінити"
   },
   "nav": {
     "menu": "Меню навігації",
@@ -80,7 +81,9 @@
       "moveFailed": "Не вдалося перемістити",
       "deleteFailed": "Не вдалося видалити",
       "linkFailed": "Не вдалося звʼязати завдання",
-      "recurringDeleteFailed": "Не вдалося видалити повторюваний пайплайн"
+      "recurringDeleteFailed": "Не вдалося видалити повторюваний пайплайн",
+      "deleted": "\"{name}\" видалено",
+      "moved": "\"{name}\" переміщено"
     },
     "repoTypes": {
       "service": "Сервіс",
@@ -960,7 +963,8 @@
         "recurring": {
           "title": "Видалити цей повторюваний pipeline?",
           "body": "\"{name}\", його розклад та історію запусків буде видалено. Цю дію не можна скасувати."
-        }
+        },
+        "containerBodyWithCount": "\"{name}\" і {count} елемент усередині буде видалено. Цю дію не можна скасувати. | \"{name}\" і {count} елементи всередині буде видалено. Цю дію не можна скасувати. | \"{name}\" і {count} елементів усередині буде видалено. Цю дію не можна скасувати."
       }
     }
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.82.1",
+  "version": "0.82.2",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",