fix: pasting a file path lands what dropping it would, and covered-board gestures stand down behind modals

Two more findings from the same felt-surface sweep as #523, both
live-reproduced and e2e-pinned:

- Paste/drop parity: pasting a local file path (text) landed a sticky
  note containing the raw path string, while dropping the same file
  landed the real thing. The drop hook's landing half is now exposed
  (landFiles) and the board paste door routes single-line absolute
  paths (quoted and file:// forms normalized) through it -- identical
  routing, plugin claims, extension enablement, folder-import handoff,
  and card fallback. A path that doesn't resolve on disk still falls
  back to the note, never a dead end. Generalizes #523's image-path
  paste to every file kind the drop door knows.

- Modal stand-down (the goal-0183 gesture-leak class, third strike):
  the board's window-level paste door stayed live while a card page
  covered the board -- pasting with focus on no field landed a note
  INVISIBLY behind the dialog (reproduced live). New shared/modalGate
  helper; the atlas paste/clone-clipboard doors, the composition
  canvas clipboard doors, and the board's Delete/Backspace handler
  (extracted to useAtlasDeleteKey at the 500-line seam) all stand
  down while a role=dialog/alertdialog surface is open. Anchored
  popovers render role=none and deliberately stay unaffected.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012im1JxQQV2ahnXzZDdVmZq

Author: alicoding

frontend/e2e/atlas-paste-convert.spec.ts

@@ -1,6 +1,9 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import { test, expect } from './fixtures/server'
 import { deleteViaPageMenu } from './fixtures/atlasPage'
-import { openCard } from './fixtures/atlasBoard'
+import { closeCard, deleteSticky, openCard } from './fixtures/atlasBoard'
 import { clickRowAction } from './inventoryRow'
 import { contextMenu } from './fixtures/contextMenu'
 
@@ -54,6 +57,19 @@ async function pasteHTML(page: import('@playwright/test').Page, html: string, pl
   }, { html, text: plainTextSibling })
 }
 
+// pastePlainText injects text/plain VERBATIM (unlike pasteText below,
+// which URI-encodes to mimic the diagram tool's own copy format) --
+// the shape a copied file path or ordinary prose actually has.
+async function pastePlainText(page: import('@playwright/test').Page, raw: string) {
+  // eslint-disable-next-line no-restricted-syntax -- cursor-position-only gesture, not a checkable interaction (pasteText's own comment below has the full reasoning)
+  await page.mouse.move(1000, 220)
+  await page.evaluate((t) => {
+    const dt = new DataTransfer()
+    dt.setData('text/plain', t)
+    window.dispatchEvent(new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true }))
+  }, raw)
+}
+
 async function pasteText(page: import('@playwright/test').Page, raw: string) {
   // The paste anchors at the pointer (a paste inside a frame files
   // into it, by design) -- aim at open canvas so the entities land at
@@ -186,3 +202,90 @@ test('a table copied from an M365 app (HTML clipboard flavor) lands a board-loca
   await clickRowAction(page, listRow, 'Delete')
   await expect(listRow).toHaveCount(0)
 })
+
+// Regression: pasting a local file PATH (text) landed a sticky note
+// containing the raw path string, while DROPPING the same file landed
+// the real thing (goal 0179's founding rule). A pasted path now routes
+// through the drop door's own landing pipeline: .md becomes a mirrored
+// document card, .drawio a diagram board object -- and a path that
+// doesn't resolve on disk still falls back to the note, never a dead
+// end.
+test('pasting a file path lands what dropping the file would; a dead path still falls back to a note', async ({ page }) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mill-e2e-paste-path-'))
+  const mdPath = path.join(dir, 'ZzE2ePastedDocPath.md')
+  fs.writeFileSync(mdPath, '# Pasted doc\n\nbody\n')
+  const drawioPath = path.join(dir, 'ZzE2ePastedDiagramPath.drawio')
+  fs.writeFileSync(drawioPath, '<mxfile><diagram name="P">'
+    + '<mxGraphModel><root><mxCell id="0"/><mxCell id="1" parent="0"/>'
+    + '<mxCell id="2" value="Box" vertex="1" parent="1"><mxGeometry x="0" y="0" width="80" height="40"/></mxCell>'
+    + '</root></mxGraphModel></diagram></mxfile>')
+  try {
+    await page.goto('/')
+    await page.getByRole('link', { name: 'Atlas' }).click()
+    await expect(page.getByTestId('atlas-board')).toBeVisible()
+
+    // .md path -> mirrored document card, exactly like dropping the file.
+    await pastePlainText(page, mdPath)
+    const card = page.getByTestId('atlas-note-card').filter({ hasText: 'ZzE2ePastedDocPath' })
+    await expect(card).toBeVisible()
+    await expect(page.getByTestId('atlas-sticky-note').filter({ hasText: 'ZzE2ePastedDocPath' })).toHaveCount(0)
+
+    // .drawio path -> diagram board object, never a card or note.
+    await pastePlainText(page, drawioPath)
+    const diagram = page.locator('[data-testid="atlas-board-object"][data-object-kind="diagram"]')
+    await expect(diagram).toHaveCount(1)
+    await expect(page.getByTestId('atlas-note-card').filter({ hasText: 'ZzE2ePastedDiagramPath' })).toHaveCount(0)
+
+    // A path-shaped string that doesn't exist stays ordinary text: the
+    // note fallback, so nothing a user pastes ever vanishes.
+    const deadPath = path.join(dir, 'ZzE2eDeadPath.md')
+    await pastePlainText(page, deadPath)
+    const note = page.getByTestId('atlas-sticky-note').filter({ hasText: 'ZzE2eDeadPath' })
+    await expect(note).toBeVisible()
+
+    // Cleanup (shared pool): note, diagram object, card.
+    await deleteSticky(page, note)
+    await deleteObjectViaMenu(diagram)
+    await expect(diagram).toHaveCount(0)
+    await card.click({ button: 'right' })
+    const menu = contextMenu(page)
+    await expect(menu).toBeVisible()
+    await menu.getByText('Delete', { exact: true }).click()
+    await expect(card).toHaveCount(0)
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+// Regression: the board's window-level paste door stayed live while a
+// card page (a modal dialog) covered the board -- pasting with focus
+// on no field landed a sticky note INVISIBLY behind the dialog. The
+// door now stands down while a modal surface is open, and comes back
+// the moment it closes.
+test('pasting while a card page is open lands nothing behind it; the door returns on close', async ({ page }) => {
+  await page.goto('/')
+  await page.getByRole('link', { name: 'Atlas' }).click()
+  await expect(page.getByTestId('atlas-board')).toBeVisible()
+
+  const card = page.getByTestId('atlas-note-card').filter({ hasText: 'Discovery workstream' }).first()
+  await openCard(page, card)
+  const overlay = page.locator('[data-component="atlas-card-overlay"]')
+  await expect(overlay).toBeVisible()
+  // Land focus on nothing editable: click the page's own header region
+  // (the real state a user reaches by clicking any non-field area).
+  await page.getByTestId('atlas-page-header').click()
+
+  await pastePlainText(page, 'ZzE2eModalGateProbe')
+  // No observable "nothing happened" signal exists to await -- a fixed
+  // settle window is the only way to assert the note did NOT land.
+  await page.waitForTimeout(800) // asserting a no-op: no observable condition exists to await
+  await expect(page.getByTestId('atlas-sticky-note').filter({ hasText: 'ZzE2eModalGateProbe' })).toHaveCount(0)
+
+  await closeCard(page, overlay)
+
+  // The same paste with the board foreground again lands its note.
+  await pastePlainText(page, 'ZzE2eModalGateProbe')
+  const note = page.getByTestId('atlas-sticky-note').filter({ hasText: 'ZzE2eModalGateProbe' })
+  await expect(note).toBeVisible()
+  await deleteSticky(page, note)
+})

frontend/src/atlas/AtlasBoard.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState, type DragEvent } from 'react'
 import { useRenderStormGuard } from '../shared/renderStormGuard'
+import { useAtlasDeleteKey } from './useAtlasDeleteKey'
 import { useTranslation } from 'react-i18next'
 import { ReactFlow, ReactFlowProvider, useNodesState, useReactFlow } from '@xyflow/react'
 import '@xyflow/react/dist/style.css'
@@ -126,24 +127,7 @@ function AtlasBoardInner({ boardFilter, onBoardFilterChange, filterMatchCount, f
   const selection = useAtlasSelection({ cards, notes, objects, onMultiSelectContextMenu })
   const wrapperClicks = useAtlasPaneClick({ tablePicker, topLevelBoxes, screenToFlowPosition, onCreateTableSized, placeAt: creation.placeAt })
 
-  // Delete/Backspace over a live selection -> the shared confirm
-  // (never fires from editable elements; single or multi).
-  useEffect(() => {
-    const onKeyDown = (e: KeyboardEvent) => {
-      if (e.key !== 'Delete' && e.key !== 'Backspace') return
-      const el = document.activeElement
-      if (el instanceof HTMLElement && (el.isContentEditable || el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.tagName === 'SELECT')) return
-      const sel = selection.selectedIDsRef.current
-      if (sel.length === 0) return
-      e.preventDefault()
-      const cardIDs = sel.filter((id) => cards.some((c) => c.ID === id))
-      const noteIDs = sel.filter((id) => notes.some((n) => n.ID === id))
-      const objectIDs = sel.filter((id) => objects.some((o) => o.ID === id))
-      if (cardIDs.length + noteIDs.length + objectIDs.length > 0) onDeleteSelection(cardIDs, noteIDs, objectIDs)
-    }
-    window.addEventListener('keydown', onKeyDown)
-    return () => window.removeEventListener('keydown', onKeyDown)
-  }, [cards, notes, objects, onDeleteSelection, selection.selectedIDsRef])
+  useAtlasDeleteKey({ cards, notes, objects, selectedIDsRef: selection.selectedIDsRef, onDeleteSelection })
 
   // Zoom chip / group-header click / Enter on a region frame (routed
   // here through AtlasGroupNode's own data.onDrill) all fly the camera
@@ -183,7 +167,7 @@ function AtlasBoardInner({ boardFilter, onBoardFilterChange, filterMatchCount, f
 
   // The capture doors (goal 0081 slice A3): own hook files, 500-line cap.
   const fileDrop = useAtlasNativeFileDrop({ parentID, topLevelBoxes, screenToFlowPosition, setPulsedID, reduceMotion })
-  useAtlasPaste({ topLevelBoxes, screenToFlowPosition, viewedID, onPasteConverted, onNoteCreated: selection.selectNote })
+  useAtlasPaste({ topLevelBoxes, screenToFlowPosition, viewedID, onPasteConverted, onNoteCreated: selection.selectNote, landFiles: fileDrop.landFiles })
   useAtlasClipboard({ allCards, allNotes, links, kinds, selectedCardIDs: selection.selectedCards, selectedNoteIDs: selection.selectedNotes, topLevelBoxes, screenToFlowPosition, viewedID, readOnly, showToast: onQuietToast })
 
   // Handle honesty: no kind restricts linking, so zero legal targets means a board with nothing else on it.

frontend/src/atlas/atlasCreateHelpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { imagePathFromClipboardText, normalizeLocalPathInput, resolveDefaultKindID, resolveNoteCommitText, titleFromFilename, titleFromNoteText } from './atlasCreateHelpers'
+import { imagePathFromClipboardText, localPathFromPastedText, normalizeLocalPathInput, resolveDefaultKindID, resolveNoteCommitText, titleFromFilename, titleFromNoteText } from './atlasCreateHelpers'
 import type { Kind } from '../../bindings/github.com/alicoding/mill/internal/domain/atlas/models'
 
 function kind(id: string): Kind {
@@ -167,3 +167,43 @@ describe('imagePathFromClipboardText', () => {
     expect(imagePathFromClipboardText('', '   ')).toBeNull()
   })
 })
+
+describe('localPathFromPastedText', () => {
+  // The board paste door's file-drop gate: pasting a local file path
+  // must route like dropping that file, and nothing else may.
+  it('accepts an absolute path', () => {
+    expect(localPathFromPastedText('/Users/me/notes/plan.md')).toBe('/Users/me/notes/plan.md')
+  })
+
+  it('accepts a quoted absolute path', () => {
+    expect(localPathFromPastedText('"/Users/me/My Docs/plan.md"')).toBe('/Users/me/My Docs/plan.md')
+  })
+
+  it('accepts a file:// URL, percent-decoded', () => {
+    expect(localPathFromPastedText('file:///Users/me/My%20Docs/plan.md')).toBe('/Users/me/My Docs/plan.md')
+  })
+
+  it('accepts a directory path (no extension required)', () => {
+    expect(localPathFromPastedText('/Users/me/project')).toBe('/Users/me/project')
+  })
+
+  it('rejects multi-line text even when the first line is a path', () => {
+    expect(localPathFromPastedText('/Users/me/plan.md\nand more prose')).toBeNull()
+  })
+
+  it('rejects relative paths', () => {
+    expect(localPathFromPastedText('notes/plan.md')).toBeNull()
+  })
+
+  it('rejects http URLs', () => {
+    expect(localPathFromPastedText('https://example.com/plan.md')).toBeNull()
+  })
+
+  it('rejects ordinary prose', () => {
+    expect(localPathFromPastedText('meet at the usual place')).toBeNull()
+  })
+
+  it('rejects empty and whitespace text', () => {
+    expect(localPathFromPastedText('   ')).toBeNull()
+  })
+})

frontend/src/atlas/atlasCreateHelpers.ts

@@ -94,6 +94,24 @@ export function imagePathFromClipboardText(...candidates: string[]): string | nu
   return null
 }
 
+// localPathFromPastedText resolves a pasted text/plain clipboard into
+// a local ABSOLUTE file path, or null when the text isn't path-shaped
+// -- the board paste door's gate before treating a paste as a file
+// drop. Deliberately stricter than imagePathFromClipboardText above:
+// the WHOLE text must be one line (the first line of pasted prose must
+// never silently swallow the rest), and only absolute paths qualify.
+// Wrapping quotes are stripped (a terminal-copied path) and file://
+// URLs normalize through the same helper the picker uses. SHAPE only:
+// whether the path actually exists is the backend's decision
+// (ResolveFileDropRoute), and a dead path falls back to ordinary text.
+export function localPathFromPastedText(text: string): string | null {
+  const trimmed = text.trim()
+  if (trimmed === '' || /[\r\n]/.test(trimmed)) return null
+  const unquoted = /^(['"]).*\1$/.test(trimmed) ? trimmed.slice(1, -1) : trimmed
+  const path = normalizeLocalPathInput(unquoted)
+  return path.startsWith('/') ? path : null
+}
+
 // resolveNoteCommitText decides whether a re-edited note's text should
 // persist, and exactly what to persist (goal 0226's round-trip
 // contract): null skips the write entirely (an existing note's own

frontend/src/atlas/useAtlasClipboard.ts

@@ -7,6 +7,7 @@ import { childrenOf } from './atlasGrouping'
 import { frameContainingPoint } from './atlasFramePoint'
 import type { FrameBox } from './useAtlasDragFiling'
 import { parseAtlasClonePayload, serializeAtlasSelection, type AtlasClonePayload } from './atlasClipboard'
+import { modalSurfaceOpen } from '../shared/modalGate'
 
 // createClones performs the payload's writes: cards parents-before-
 // children (co-copied structure re-parents onto fresh clone ids, pass
@@ -83,6 +84,9 @@ export function useAtlasClipboard({ allCards, allNotes, links, kinds, selectedCa
 
     const onCopy = (e: ClipboardEvent) => {
       const s = stateRef.current
+      // A modal above the board owns the screen: copying here would
+      // silently overwrite the clipboard with a HIDDEN board selection.
+      if (modalSurfaceOpen()) return
       if (isEditableTarget(document.activeElement)) return
       if (window.getSelection()?.toString()) return
       const payload = serializeAtlasSelection(s.allCards, s.allNotes, s.links, s.selectedCardIDs, s.selectedNoteIDs)
@@ -138,6 +142,9 @@ export function useAtlasClipboard({ allCards, allNotes, links, kinds, selectedCa
     const onPaste = (e: ClipboardEvent) => {
       const s = stateRef.current
       if (s.readOnly) return
+      // Same modal stand-down as onCopy: pasted clones would land
+      // invisibly behind the open dialog.
+      if (modalSurfaceOpen()) return
       if (isEditableTarget(document.activeElement)) return
       const payload = parseAtlasClonePayload(e.clipboardData?.getData('text/plain') ?? '')
       if (!payload) return

frontend/src/atlas/useAtlasDeleteKey.ts

@@ -0,0 +1,37 @@
+import { useEffect, type RefObject } from 'react'
+import type { Card, Note, BoardObject } from '../../bindings/github.com/alicoding/mill/internal/domain/atlas/models'
+import { modalSurfaceOpen } from '../shared/modalGate'
+
+// Delete/Backspace over a live board selection -> the shared
+// delete path (quick-delete-with-undo for notes/objects, the confirm
+// for cards; single or multi). Split out of AtlasBoard.tsx along its
+// own effect seam (the 500-line convention). Never fires from
+// editable elements, and stands down entirely while a modal dialog
+// owns the screen (shared/modalGate.ts, the goal-0183 gesture-leak
+// class): a Delete reaching the COVERED board would destroy a
+// selection the user can't even see behind the dialog.
+export function useAtlasDeleteKey({ cards, notes, objects, selectedIDsRef, onDeleteSelection }: {
+  cards: Card[]
+  notes: Note[]
+  objects: BoardObject[]
+  selectedIDsRef: RefObject<string[]>
+  onDeleteSelection: (cardIDs: string[], noteIDs: string[], objectIDs?: string[]) => void
+}) {
+  useEffect(() => {
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (e.key !== 'Delete' && e.key !== 'Backspace') return
+      if (modalSurfaceOpen()) return
+      const el = document.activeElement
+      if (el instanceof HTMLElement && (el.isContentEditable || el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.tagName === 'SELECT')) return
+      const sel = selectedIDsRef.current
+      if (sel.length === 0) return
+      e.preventDefault()
+      const cardIDs = sel.filter((id) => cards.some((c) => c.ID === id))
+      const noteIDs = sel.filter((id) => notes.some((n) => n.ID === id))
+      const objectIDs = sel.filter((id) => objects.some((o) => o.ID === id))
+      if (cardIDs.length + noteIDs.length + objectIDs.length > 0) onDeleteSelection(cardIDs, noteIDs, objectIDs)
+    }
+    window.addEventListener('keydown', onKeyDown)
+    return () => window.removeEventListener('keydown', onKeyDown)
+  }, [cards, notes, objects, onDeleteSelection, selectedIDsRef])
+}

frontend/src/atlas/useAtlasNativeFileDrop.ts

@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import { Events } from '@wailsio/runtime'
 import { AtlasService } from '../shared/bindings'
@@ -78,15 +78,19 @@ export function useAtlasNativeFileDrop({ parentID, topLevelBoxes, screenToFlowPo
     stateRef.current = { parentID, topLevelBoxes, screenToFlowPosition, requestFolderImport, setPulsedID, reduceMotion, diagramObjectCreate, imageObjectCreate, sheetObjectCreate }
   }, [parentID, topLevelBoxes, screenToFlowPosition, requestFolderImport, setPulsedID, reduceMotion, diagramObjectCreate, imageObjectCreate, sheetObjectCreate])
 
-  useEffect(() => {
-    return Events.On(FILE_DROP_EVENT_NAME, (evt) => {
-      const payload = evt.data as { filenames?: string[]; x?: number; y?: number; context?: string } | undefined
-      if (!payload || payload.context !== FILE_DROP_CONTEXT_BOARD || !payload.filenames?.length) return
-      const { topLevelBoxes: boxes, screenToFlowPosition: toFlow, parentID: currentParentID, requestFolderImport: request, setPulsedID: pulse, reduceMotion: reduced, diagramObjectCreate: diagramCreate, imageObjectCreate: imageCreate, sheetObjectCreate: sheetCreate } = stateRef.current
-      const point = toFlow({ x: payload.x ?? 0, y: payload.y ?? 0 })
-      const targetParentID = frameContainingPoint(boxes, point) ?? currentParentID
+  // The drop door's LANDING half, split from the OS drop gesture so the
+  // board's paste door can land a pasted file PATH through the exact
+  // same pipeline (routing, plugin claims, extension enablement, folder
+  // import, the card fallback's pulse/duplicate notice). Returns the
+  // un-caught promise: each gesture owns its own failure answer -- the
+  // OS drop shows dropError below, a pasted path falls back to the
+  // ordinary text-paste flow (useAtlasPaste.ts).
+  const landFiles = useCallback((filenames: string[], screenPoint: { x: number; y: number }) => {
+    const { topLevelBoxes: boxes, screenToFlowPosition: toFlow, parentID: currentParentID, requestFolderImport: request, setPulsedID: pulse, reduceMotion: reduced, diagramObjectCreate: diagramCreate, imageObjectCreate: imageCreate, sheetObjectCreate: sheetCreate } = stateRef.current
+    const point = toFlow(screenPoint)
+    const targetParentID = frameContainingPoint(boxes, point) ?? currentParentID
 
-      AtlasService.ResolveFileDropRoute(payload.filenames)
+    return AtlasService.ResolveFileDropRoute(filenames)
         .then((route) => {
           if (route.Kind === 'import') {
             request(route.Path, targetParentID)
@@ -128,9 +132,16 @@ export function useAtlasNativeFileDrop({ parentID, topLevelBoxes, screenToFlowPo
                 }))
           }
         })
+  }, [t])
+
+  useEffect(() => {
+    return Events.On(FILE_DROP_EVENT_NAME, (evt) => {
+      const payload = evt.data as { filenames?: string[]; x?: number; y?: number; context?: string } | undefined
+      if (!payload || payload.context !== FILE_DROP_CONTEXT_BOARD || !payload.filenames?.length) return
+      void landFiles(payload.filenames, { x: payload.x ?? 0, y: payload.y ?? 0 })
         .catch(() => setDropError(t('capture.dropError')))
     })
-  }, [t])
+  }, [t, landFiles])
 
   useEffect(() => {
     if (!dropError) return
@@ -144,5 +155,5 @@ export function useAtlasNativeFileDrop({ parentID, topLevelBoxes, screenToFlowPo
     return () => window.clearTimeout(timer)
   }, [dropDuplicateNotice])
 
-  return { dropError, dropDuplicateNotice }
+  return { dropError, dropDuplicateNotice, landFiles }
 }