@cat-factory/app 0.275.0 → 0.277.0

package/app/composables/useArtifactBlobs.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from 'vitest'
+import { useArtifactBlobs } from '~/composables/useArtifactBlobs'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+// What a resolved artifact reports about ITSELF, and why the answer is not the declaration that
+// came with it.
+//
+// A stored asset carries two media types: the one the producing agent declared (optional,
+// model-authored, a claim about a file) and the one the server SERVES the bytes as, after
+// `blobResponseHeaders` has clamped anything outside the inline-image list down to
+// `application/octet-stream`. Only the second is a fact about the response, so it is the one a
+// surface may decide picture-versus-file from. Deciding from the declaration is wrong in both
+// directions: an undeclared PNG renders as a generic file, and a mis-declared bundle renders as a
+// broken `<img>` that reports itself as loaded, because the fetch genuinely succeeded.
+
+function stubApi(contentType: string): { calls: number } {
+  const state = { calls: 0 }
+  vi.stubGlobal('useApi', () => ({
+    fetchArtifactBlob: async (_ws: string, id: string) => {
+      state.calls += 1
+      return { url: `blob:${id}`, contentType }
+    },
+  }))
+  return state
+}
+
+function blobs(contentType: string) {
+  const calls = stubApi(contentType)
+  useWorkspaceStore().workspaceId = 'ws_1'
+  return { blobs: useArtifactBlobs(), calls }
+}
+
+describe('useArtifactBlobs', () => {
+  it('records the media type the server served, beside the URL', async () => {
+    const { blobs: cache } = blobs('image/png')
+    await cache.resolve('art_1')
+    expect(cache.urlFor('art_1')).toBe('blob:art_1')
+    expect(cache.typeFor('art_1')).toBe('image/png')
+  })
+
+  it('reports the clamped type for bytes the server refused to serve inline', async () => {
+    // A GLB, a zip, a PDF, or an image type the allow-list does not carry: the response is an
+    // attachment, and a row that pointed an `<img>` at it would render a broken frame with the
+    // load reported as successful.
+    const { blobs: cache } = blobs('application/octet-stream')
+    await cache.resolve('art_1')
+    expect(cache.typeFor('art_1')).toBe('application/octet-stream')
+  })
+
+  it('knows nothing about a type until the bytes are in hand', async () => {
+    // The loading state has no answer to give, which is what keeps a surface from committing to
+    // picture-or-file before the response says which.
+    const { blobs: cache } = blobs('image/png')
+    expect(cache.typeFor('art_1')).toBeUndefined()
+    await cache.resolve('art_1')
+    expect(cache.typeFor('art_1')).toBe('image/png')
+  })
+
+  it('drops the recorded type on a retry, so a re-fetch cannot be read through the old one', async () => {
+    const { blobs: cache } = blobs('image/png')
+    await cache.resolve('art_1')
+    const pending = cache.retry('art_1')
+    expect(cache.typeFor('art_1')).toBeUndefined()
+    await pending
+    expect(cache.typeFor('art_1')).toBe('image/png')
+  })
+
+  it('forgets every type when the owning component unmounts', async () => {
+    // The cache is per component and `revokeAll` is what releases the bytes; a type left behind
+    // would outlive the URL it describes.
+    const { blobs: cache } = blobs('image/png')
+    await cache.resolve('art_1')
+    cache.revokeAll()
+    expect(cache.typeFor('art_1')).toBeUndefined()
+  })
+})

package/app/composables/useArtifactBlobs.ts

@@ -23,6 +23,17 @@ export function useArtifactBlobs() {
 
   /** artifactId → object URL (reactive so templates re-render when a blob resolves). */
   const urls = reactive<Record<string, string>>({})
+  /**
+   * artifactId → the media type the SERVER served these bytes as.
+   *
+   * The one a surface may decide from. A stored artifact also carries a DECLARED content type,
+   * which for an asset is the agent's own claim about the file it uploaded and is optional; the
+   * serve path meanwhile clamps anything outside the inline-image list to
+   * `application/octet-stream`. So a row deciding picture-versus-file from the declaration gets it
+   * wrong in both directions: an undeclared PNG renders as a generic file, and a mis-declared
+   * bundle renders as a broken `<img>` with the load reported as successful.
+   */
+  const types = reactive<Record<string, string>>({})
   /** artifactId → fetch status, drives loading / error / retry affordances. */
   const status = reactive<Record<string, ArtifactBlobStatus>>({})
   /** In-flight promises, so concurrent `resolve(id)` calls share one fetch + one blob. */
@@ -43,6 +54,11 @@ export function useArtifactBlobs() {
     return id ? (status[id] ?? 'idle') : 'idle'
   }
 
+  /** The media type the server served this artifact as, once its bytes are in hand. */
+  function typeFor(id: string | null | undefined): string | undefined {
+    return id ? types[id] : undefined
+  }
+
   /** Resolve an artifact to an object URL (cached + deduped). Returns null on failure. */
   function resolve(id: string | null | undefined): Promise<string | null> {
     if (!id || disposed) return Promise.resolve(null)
@@ -53,19 +69,22 @@ export function useArtifactBlobs() {
 
     status[id] = 'loading'
     const p = api
-      .fetchArtifactBlobUrl(ws.requireId(), id)
-      .then((url) => {
+      .fetchArtifactBlob(ws.requireId(), id)
+      .then(({ url, contentType }) => {
         // The owner unmounted while this was in flight: revoke the freshly-minted URL
         // instead of stranding it in the cleared cache.
         if (disposed) {
           try {
             URL.revokeObjectURL(url)
           } catch {
-            // Already revoked / unsupported environment — nothing to do.
+            // Already revoked / unsupported environment, nothing to do.
           }
           return null
         }
         urls[id] = url
+        // Written BEFORE the status flips to `ready`, so a watcher reacting to the status never
+        // reads a resolved artifact whose served type has not landed yet.
+        if (contentType) types[id] = contentType
         status[id] = 'ready'
         return url
       })
@@ -91,6 +110,7 @@ export function useArtifactBlobs() {
       }
     }
     delete urls[id]
+    delete types[id]
     status[id] = 'idle'
     inFlight.delete(id)
     return resolve(id)
@@ -110,11 +130,12 @@ export function useArtifactBlobs() {
       }
     }
     for (const k of Object.keys(urls)) delete urls[k]
+    for (const k of Object.keys(types)) delete types[k]
     for (const k of Object.keys(status)) delete status[k]
     inFlight.clear()
   }
 
-  return { urls, status, urlFor, statusFor, resolve, retry, revokeAll }
+  return { urls, types, status, urlFor, statusFor, typeFor, resolve, retry, revokeAll }
 }
 
 export type ArtifactBlobs = ReturnType<typeof useArtifactBlobs>

package/app/composables/useBlockDrag.ts

@@ -9,11 +9,18 @@ const draggingId = ref<string | null>(null)
 
 /**
  * Pointer-driven dragging for blocks positioned inside a container's 2D canvas
- * (tasks inside services/modules, modules inside services) and for free-floating
- * service frames (via their header handle). Movement is divided by the board zoom
- * so the block tracks the cursor. When `reparent` is set, the drop point is
- * hit-tested against `[data-drop-zone]` ancestors so a task can be dragged from a
- * service into a module (or back out).
+ * (initiative cards inside services) and for free-floating service frames (via
+ * their header handle). Movement is divided by the board zoom so the block tracks
+ * the cursor. When `reparent` is set, the drop point is hit-tested against
+ * `[data-drop-zone]` ancestors so a block can be dragged from a service into a
+ * module (or back out).
+ *
+ * A TASK is a `positioned: false` drag, because tasks are laid out in swimlanes and
+ * carry no coordinates a reader can see. Such a drag previews nothing and commits
+ * nothing on a same-container drop: its ONLY effect is a reparent, which is what a
+ * task drag is still for (moving work between services, and into or out of a module).
+ * A position write there would persist coordinates nothing renders and emit a board
+ * event for a change with no visible result.
  */
 export function useBlockDrag() {
   const board = useBoardStore()
@@ -23,7 +30,7 @@ export function useBlockDrag() {
   function startDrag(
     block: Block,
     e: PointerEvent,
-    opts: { reparent?: boolean; clamp?: boolean } = {},
+    opts: { reparent?: boolean; clamp?: boolean; positioned?: boolean } = {},
   ) {
     if (e.button !== 0) return
     // Read-only viewers can pan/inspect but never move or reparent a block — the drag
@@ -35,9 +42,11 @@ export function useBlockDrag() {
     const startX = e.clientX
     const startY = e.clientY
     const orig = { ...block.position }
-    // Container-local blocks (tasks/modules) are clamped to their parent's origin;
-    // frames live in free-floating flow space, so they opt out via `clamp: false`.
+    // Container-local blocks (initiative cards) are clamped to their parent's origin;
+    // frames live in free-floating flow space, so they opt out via `clamp: false`. Inert for
+    // a `positioned: false` drag, which never writes a position at all.
     const clamp = opts.clamp ?? true
+    const positioned = opts.positioned ?? true
     draggingId.value = block.id
     // Position is only previewed locally while dragging and persisted once on
     // release. Writing every move raced — a late, out-of-order response could land
@@ -51,7 +60,10 @@ export function useBlockDrag() {
       const ny = orig.y + (ev.clientY - startY) / z
       moved = true
       last = { x: clamp ? Math.max(0, nx) : nx, y: clamp ? Math.max(0, ny) : ny }
-      board.previewMove(block.id, last)
+      // A lane task has nowhere to preview TO: its place in the column is derived from its
+      // status and the reader's sort, so following the cursor would be a lie the drop then
+      // undoes. The `draggingId` state the card dims itself with is the whole feedback.
+      if (positioned) board.previewMove(block.id, last)
     }
     const onUp = (ev: PointerEvent) => {
       window.removeEventListener('pointermove', onMove)
@@ -60,9 +72,9 @@ export function useBlockDrag() {
         // A successful reparent persists the move itself; otherwise commit the final
         // position in place. Either way it's a single write, not one per frame. Run
         // the hit-test BEFORE clearing draggingId so the dragged element is still
-        // marked non-interactive (see DraggableTask) and the zone beneath resolves.
-        const reparented = opts.reparent && reparentAt(block, ev.clientX, ev.clientY)
-        if (!reparented) void board.moveBlock(block.id, last)
+        // marked non-interactive (see LaneTask) and the zone beneath resolves.
+        const reparented = opts.reparent && reparentAt(block, ev.clientX, ev.clientY, positioned)
+        if (!reparented && positioned) void board.moveBlock(block.id, last)
       }
       draggingId.value = null
     }
@@ -71,10 +83,15 @@ export function useBlockDrag() {
   }
 
   /** Returns true when the block was dropped into a *different* container. */
-  function reparentAt(block: Block, clientX: number, clientY: number): boolean {
+  function reparentAt(
+    block: Block,
+    clientX: number,
+    clientY: number,
+    positioned: boolean,
+  ): boolean {
     const el = document.querySelector(`[data-block-id="${block.id}"]`) as HTMLElement | null
     if (!el) return false
-    // The dragged block is already non-interactive while dragging (DraggableTask
+    // The dragged block is already non-interactive while dragging (LaneTask
     // drops pointer-events on the whole wrapper, handle included); belt-and-braces,
     // also neutralise this node so elementFromPoint resolves the zone beneath it.
     const prev = el.style.pointerEvents
@@ -87,14 +104,27 @@ export function useBlockDrag() {
     const newParent = zoneEl.getAttribute('data-drop-zone')!
     if (newParent === block.parentId) return false // same container — caller commits position
 
+    void board.reparentBlock(block.id, newParent, positionIn(zoneEl, el, positioned))
+    return true
+  }
+
+  /**
+   * Where the dropped block lands in its new container.
+   *
+   * A lane task gets the origin, not the coordinates it happened to be released over.
+   * Its place in the new container is derived from its status and the reader's sort, so a
+   * captured offset would be a coordinate nothing reads and every later reader would have
+   * to wonder whether it meant something.
+   */
+  function positionIn(zoneEl: HTMLElement, el: HTMLElement, positioned: boolean) {
+    if (!positioned) return { x: 0, y: 0 }
     const z = ui.zoom || 1
     const zr = zoneEl.getBoundingClientRect()
     const er = el.getBoundingClientRect()
-    void board.reparentBlock(block.id, newParent, {
+    return {
       x: Math.max(0, (er.left - zr.left) / z),
       y: Math.max(0, (er.top - zr.top) / z),
-    })
-    return true
+    }
   }
 
   return { draggingId, startDrag }

package/app/composables/useBlockQueries.ts

@@ -1,5 +1,6 @@
 import { computed, type Ref } from 'vue'
 import type { Block, BlockStatus } from '~/types/domain'
+import { frameContentSize, LANE_GEOMETRY } from '~/utils/laneGeometry'
 
 /**
  * Pure, read-only queries over a board's blocks. Extracted from the board store
@@ -162,33 +163,35 @@ export function useBlockQueries(blocks: Ref<Block[]>) {
   }
 
   /**
-   * The natural extent of a container's inner 2D canvas — the smallest size that
-   * still fits all its children. This is the floor a resizable frame can never be
-   * dragged below (so tasks/modules are never clipped).
+   * The natural extent of a frame's inner canvas — the smallest size that fits its swimlanes
+   * and its initiative band. This is the floor a resizable frame can never be dragged below.
+   *
+   * Task positions are deliberately NOT consulted any more. Tasks are laid out in status
+   * lanes, so the frame's size is a function of the LANE GEOMETRY, not of where cards happen
+   * to sit, and each lane SCROLLS rather than growing without bound. That decoupling is what
+   * fixes the old behaviour where a service accumulating work grew a taller and taller frame
+   * until it dwarfed its neighbours, and it is also what keeps this function pure over blocks:
+   * a lane's population depends on run state, which this layer cannot see and must not need to.
+   *
+   * The arithmetic itself lives in `frameContentSize` so the placement helper, which sizes a
+   * frame that does not exist yet, reserves the same footprint this one will render at.
    */
   function contentSize(id: string): { w: number; h: number } {
     const b = getBlock(id)
-    const isModule = b?.level === 'module'
-    const TASK_W = 210
-    const TASK_H = 160
-    const headerH = isModule ? 30 : 0
-    let w = isModule ? 200 : 360
-    let inner = isModule ? 60 : 220
-    for (const t of tasksOf(id)) {
-      w = Math.max(w, t.position.x + TASK_W + 12)
-      inner = Math.max(inner, t.position.y + TASK_H + 12)
-    }
-    for (const m of modulesOf(id)) {
-      const s = containerSize(m.id)
-      w = Math.max(w, m.position.x + s.w + 12)
-      inner = Math.max(inner, m.position.y + s.h + 12)
-    }
-    // Initiative cards render inside the frame's drop zone like tasks (230×~170).
-    for (const i of initiativesOf(id)) {
-      w = Math.max(w, i.position.x + 230 + 12)
-      inner = Math.max(inner, i.position.y + 170 + 12)
-    }
-    return { w, h: inner + headerH }
+    // A module is no longer drawn as a box (its tasks appear in the frame's lanes, grouped by
+    // module name), so it has no canvas of its own. A minimal size keeps any incidental caller
+    // honest rather than returning zero, which would read as "measured, and empty".
+    if (b?.level === 'module') return { w: LANE_GEOMETRY.laneWidth, h: 0 }
+
+    const initiatives = initiativesOf(id)
+    return frameContentSize({
+      // The predicate `BlockNode` renders the lanes on: an empty service shows one "add the first
+      // task" panel instead, and reserving lane-sized space for it would leave the frame two and
+      // a half times taller than its own contents.
+      hasChildren:
+        allTasksUnder(id).length > 0 || modulesOf(id).length > 0 || initiatives.length > 0,
+      initiatives: initiatives.length,
+    })
   }
 
   /**

package/app/composables/useFrameLanes.ts

@@ -0,0 +1,177 @@
+import { computed, type Ref } from 'vue'
+import { collectReviewDebt } from '@cat-factory/contracts'
+import type { Block } from '~/types/domain'
+import {
+  groupLaneTasks,
+  runActivityAt,
+  runWaitingSince,
+  sortLaneTasks,
+  type LaneGroup,
+  type LaneTaskEntry,
+} from '~/utils/laneSort'
+import {
+  classifyTask,
+  selectDoneLaneTasks,
+  TASK_LANES,
+  type DoneLaneSelection,
+  type TaskLane,
+} from '~/utils/swimlanes'
+
+/** One rendered lane: its identity, its groups, and the count its header states. */
+export interface RenderedLane {
+  readonly lane: TaskLane
+  readonly groups: LaneGroup[]
+  /** Every task classified into this lane, BEFORE the Done lane's caps. */
+  readonly total: number
+}
+
+/** A lane entry plus the lane it was classified into. */
+interface ClassifiedEntry {
+  readonly entry: LaneTaskEntry
+  readonly lane: TaskLane
+}
+
+/**
+ * Assemble a service frame's tasks into swimlanes.
+ *
+ * This is the store-facing half of the lane model: it resolves every input the pure
+ * `classifyTask` / `sortLaneTasks` / `groupLaneTasks` functions need and nothing more, so the
+ * classification and ordering rules stay testable without a Pinia instance. It also keeps the
+ * per-frame cost linear in the frame's tasks: every cross-block lookup below is a Map read off
+ * an index the stores already maintain, never a scan per task.
+ */
+export function useFrameLanes(frameId: Ref<string>) {
+  const board = useBoardStore()
+  const execution = useExecutionStore()
+  const agentRuns = useAgentRunsStore()
+  const notifications = useNotificationsStore()
+  const settings = useWorkspaceSettingsStore()
+  const laneView = useLaneViewStore()
+  const reviews = useReviewStage()
+
+  /** Tasks directly in the frame plus those inside its modules: a module renders no box now. */
+  const tasks = computed(() => board.allTasksUnder(frameId.value))
+
+  /** Module name → the module BLOCK that materialises it, so a group header can be a drop zone. */
+  const moduleBlockIdByName = computed(
+    () => new Map(board.modulesOf(frameId.value).map((m) => [m.title, m.id])),
+  )
+
+  /**
+   * Per-block "waiting since", derived once from the workspace's open review-wait cards by the
+   * same `collectReviewDebt` the backend's friction check uses. It is the fallback source for
+   * the park surfaces that stamp no `step.pausedAt`; deriving it once rather than per task is
+   * what keeps this assembly linear.
+   */
+  const waitingSinceByBlock = computed(
+    () => new Map(collectReviewDebt(notifications.open).map((d) => [d.blockId, d.waitingSince])),
+  )
+
+  /**
+   * The module a task belongs to: the module BLOCK's title when it already lives in one, else
+   * the module it DECLARES. The engine only materialises the block on merge
+   * (`applyModuleAssignment`), so keying on the parent alone would leave every unmerged task in
+   * "no module" while its own card names one.
+   */
+  function moduleNameOf(task: Block): string | null {
+    const parent = task.parentId ? board.getBlock(task.parentId) : undefined
+    if (parent?.level === 'module') return parent.title
+    return task.moduleName?.trim() || null
+  }
+
+  function classify(task: Block, order: number): ClassifiedEntry {
+    const run = execution.getByBlock(task.id) ?? null
+    const decisions = execution.decisionsByBlock.get(task.id) ?? []
+    const allApprovals = execution.approvalsByBlock.get(task.id) ?? []
+    // The same suppression the card and the frame badge apply: an iterative reviewer mid-cycle
+    // holds a pending approval while the driver folds answers in, and nobody is waiting on it.
+    const humanApprovals = allApprovals.filter((a) => !reviews.isBackground(a.agentKind, a.blockId))
+
+    const { lane, reason } = classifyTask({
+      status: task.status,
+      // Read from the coarse per-block summary, which also covers a bootstrap run.
+      runFailed: agentRuns.byBlock[task.id]?.status === 'failed',
+      run,
+      // A park is background exactly when everything asking was suppressed AND nothing else
+      // asks. With no approvals at all it is NOT background: it is a park on a surface this
+      // layer cannot name, which `classifyTask` reports as `parked` rather than as work.
+      parkIsBackground:
+        decisions.length === 0 &&
+        humanApprovals.length === 0 &&
+        allApprovals.length > humanApprovals.length,
+      pendingDecision: decisions.length > 0,
+      pendingApproval: humanApprovals.length > 0,
+      hasUnmetDeps: board.unmetDeps(task.id).length > 0,
+    })
+
+    return {
+      lane,
+      entry: {
+        task,
+        reason,
+        order,
+        activityAt: runActivityAt(run),
+        waitingSince: runWaitingSince(run, waitingSinceByBlock.value.get(task.id) ?? null),
+        moduleName: moduleNameOf(task),
+        initiativeName: task.initiativeId
+          ? (board.getBlock(task.initiativeId)?.title ?? null)
+          : null,
+        epicName: board.epicOf(task)?.title ?? null,
+      },
+    }
+  }
+
+  /** Every task bucketed by lane, in board order, before sorting. */
+  const byLane = computed(() => {
+    const buckets = new Map<TaskLane, LaneTaskEntry[]>(TASK_LANES.map((lane) => [lane, []]))
+    tasks.value.forEach((task, order) => {
+      const { lane, entry } = classify(task, order)
+      buckets.get(lane)!.push(entry)
+    })
+    return buckets
+  })
+
+  /**
+   * What the Done lane renders, and a full account of what it withheld.
+   *
+   * Computed even while the lane is collapsed, because the collapsed header states the TOTAL:
+   * "this service has finished 312 tasks" is the fact the lane exists to carry, and a header
+   * counting only what it happens to render would understate it by two orders of magnitude.
+   *
+   * `Date.now()` is read non-reactively, as `useReviewDebt` does. The cutoff is re-evaluated
+   * whenever the board, the runs or the settings change, which on a live board is constantly; a
+   * ticking clock purely so a card could vanish mid-session would be motion nobody asked for.
+   */
+  const doneSelection = computed<DoneLaneSelection>(() =>
+    selectDoneLaneTasks(
+      (byLane.value.get('done') ?? []).map((e) => e.task),
+      {
+        maxItems: settings.settings.doneLaneMaxItems,
+        retentionDays: settings.settings.doneLaneRetentionDays,
+      },
+      Date.now(),
+    ),
+  )
+
+  const lanes = computed<RenderedLane[]>(() =>
+    TASK_LANES.map((lane) => {
+      const bucket = byLane.value.get(lane) ?? []
+      // Only the Done lane is capped; every other lane renders everything in it.
+      const visible = lane === 'done' ? admittedByCaps(bucket, doneSelection.value) : bucket
+      const ordered = sortLaneTasks(visible, laneView.sortKey, lane)
+      return {
+        lane,
+        groups: groupLaneTasks(ordered, laneView.groupKey, moduleBlockIdByName.value),
+        total: bucket.length,
+      }
+    }),
+  )
+
+  return { lanes, doneSelection }
+}
+
+/** The entries whose task survived the Done lane's caps. */
+function admittedByCaps(entries: LaneTaskEntry[], selection: DoneLaneSelection): LaneTaskEntry[] {
+  const admitted = new Set(selection.shown.map((task) => task.id))
+  return entries.filter((e) => admitted.has(e.task.id))
+}

package/app/composables/useTaskExpansion.ts

@@ -75,7 +75,7 @@ export function useTaskExpansion(container: Ref<HTMLElement | null>, activity: B
   //
   // Blocks with no pipeline to show are filtered out here rather than left to the card:
   // a frame, a module, or a task with no run expands to nothing, and granting it would
-  // still lift an empty card over its neighbours (see DraggableTask's z-index).
+  // still lift an empty card over its neighbours (see LaneTask's z-index).
   function hoveredTaskId(): string | null {
     if (!pointer) return null
     const hit = document.elementFromPoint(pointer.x, pointer.y)

package/app/stores/board/placement.ts

@@ -1,4 +1,5 @@
 import type { UpdateBlockInput } from '@cat-factory/contracts'
+import { moduleNameInContainer } from '@cat-factory/contracts'
 import { useServicesStore } from '~/stores/services'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { createBoardDependencies } from './dependencies'
@@ -59,9 +60,14 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
     // block in the wrong container (a structural lie that survives until re-hydrate).
     const prevParentId = b.parentId
     const prevPosition = b.position
+    const prevModuleName = b.moduleName
     const name = b.title
     b.parentId = newParentId
     b.position = position
+    // The server re-stamps a moved task's declared module from its new container, so predict the
+    // same answer here: without it the card lands in the lane group it was dragged OUT of and
+    // jumps to the right one when the response arrives.
+    if (b.level === 'task') b.moduleName = moduleNameInContainer(parent)
     try {
       upsert(
         await api.reparentBlock(useWorkspaceStore().requireId(), id, {
@@ -90,6 +96,7 @@ export function createBoardPlacement(ctx: BoardWriteContext) {
     } catch (e) {
       b.parentId = prevParentId
       b.position = prevPosition
+      b.moduleName = prevModuleName
       // A cross-home drag can be refused on merge-preset grounds, which is a condition the mover
       // 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.