diff --git a/internal/session/snapshot.go b/internal/session/snapshot.go
index 8fb6fa0..5062046 100644
--- a/internal/session/snapshot.go
+++ b/internal/session/snapshot.go
@@ -65,6 +65,46 @@ type Snapshot struct {
 var reviveMarker = []byte(
 	"\r\n\x1b[2m── daemon restarted · previous shell ended here ──\x1b[0m\r\n\r\n")
 
+// settleModes puts the emulator back into a state a fresh shell can be
+// trusted in, and is written after the replayed scrollback and before the
+// marker.
+//
+// A snapshot's ring is the bytes the dead shell wrote, and a program that was
+// killed with the daemon wrote no epilogue: the sequence that turned a mode
+// on is in the ring and the sequence that turns it back off was never
+// written at all. Replay that into a client and its emulator ends the replay
+// holding modes that belong to a program which no longer exists, with a
+// brand new prompt behind them.
+//
+// The mouse block is the one that bites hardest, because it puts bytes on the
+// wire with nobody typing. Mouse tracking left on means every pointer move
+// over the terminal is encoded and sent, and the shell has no idea what an
+// SGR report is, so it lands at the prompt as "35;61;22M35;61;21M…" — one
+// run per pixel of travel. Focus reporting is the same trick with fewer
+// bytes: ^[[I and ^[[O every time the tab is looked at. Application cursor
+// keys is the quiet one, where the arrows send SS3 to a shell expecting CSI.
+//
+// The rest is display state rather than input, and is here because a shell
+// nobody can read is its own kind of broken: a leftover scrolling region
+// pins the new prompt inside a window the old program chose, the line-drawing
+// charset renders every word as box art, and a hidden cursor stays hidden.
+//
+// The alternate screen is deliberately *not* left, though a dead full-screen
+// program will have been in it. Leaving it would swap in a main buffer whose
+// contents were evicted from the ring long ago, so the price of a tidier
+// terminal would be showing the person an empty one where their scrollback
+// used to be. What they have now is the last frame of the program that died,
+// which is at least what they were looking at.
+var settleModes = []byte(
+	// Mouse reporting, every protocol and every encoding.
+	"\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l\x1b[?1016l" +
+		// Focus reporting, bracketed paste, application cursor keys.
+		"\x1b[?1004l\x1b[?2004l\x1b[?1l" +
+		// Autowrap, a visible cursor, the full scrolling region.
+		"\x1b[?7h\x1b[?25h\x1b[r" +
+		// US-ASCII back in G0, and default attributes.
+		"\x1b(B\x1b[m")
+
 // reviveNote writes the seam, plus — when the snapshot knew of one — the
 // command that picks the interrupted conversation back up.
 //
@@ -156,8 +196,11 @@ func (r *Registry) Revive(snap Snapshot) (*Session, error) {
 		cwd, _ = os.UserHomeDir()
 	}
 	note := reviveNote(snap.ClaudeSession)
-	preload := make([]byte, 0, len(snap.Ring)+len(note))
+	preload := make([]byte, 0, len(snap.Ring)+len(settleModes)+len(note))
 	preload = append(preload, snap.Ring...)
+	// After the scrollback, so the replay cannot undo it, and before the
+	// marker, so the seam is the first thing the settled terminal draws.
+	preload = append(preload, settleModes...)
 	preload = append(preload, note...)
 	return r.start(
 		SpawnOpts{Cwd: cwd, Cols: snap.Cols, Rows: snap.Rows},
diff --git a/internal/session/snapshot_test.go b/internal/session/snapshot_test.go
index 349b8e4..dac60b8 100644
--- a/internal/session/snapshot_test.go
+++ b/internal/session/snapshot_test.go
@@ -103,6 +103,54 @@ func TestReviveRestoresIdentityAndScrollback(t *testing.T) {
 	}
 }
 
+// TestReviveSettlesTheModesTheDeadShellLeftBehind is the fix for a session
+// that came back reporting the pointer.
+//
+// The shell that died was inside a program holding mouse tracking on, and a
+// killed program writes no reset. Replay that ring into a client and its
+// emulator turns mouse reporting on with a fresh prompt behind it: every
+// pointer move becomes an SGR report typed at the shell, which is what
+// "35;61;22M35;61;21M…" at a prompt is. The same is true of focus reporting
+// and of a leftover scrolling region or charset, none of which the new shell
+// asked for and none of which it will clear.
+func TestReviveSettlesTheModesTheDeadShellLeftBehind(t *testing.T) {
+	r := NewRegistry(nil)
+	s, err := r.Revive(Snapshot{
+		V:    1,
+		ID:   "cafebabe00000006",
+		Cwd:  t.TempDir(),
+		Ring: []byte("a program was here\x1b[?1003h\x1b[?1006h\x1b[?1004h"),
+	})
+	if err != nil {
+		t.Fatalf("Revive: %v", err)
+	}
+	t.Cleanup(func() { _ = s.Close() })
+
+	sub := s.Subscribe(0)
+	defer s.Unsubscribe(sub)
+
+	for _, mode := range []string{
+		"\x1b[?1000l", "\x1b[?1002l", "\x1b[?1003l",
+		"\x1b[?1005l", "\x1b[?1006l", "\x1b[?1015l", "\x1b[?1016l",
+		"\x1b[?1004l", "\x1b[?2004l", "\x1b[?1l",
+		"\x1b[?7h", "\x1b[?25h", "\x1b[r", "\x1b(B", "\x1b[m",
+	} {
+		if !bytes.Contains(sub.Backlog, []byte(mode)) {
+			t.Fatalf("the revived backlog never clears %q: %q", mode, sub.Backlog)
+		}
+	}
+
+	// Order is the whole point: clearing before the replay would be undone by
+	// the very bytes it exists to answer for.
+	settle := bytes.Index(sub.Backlog, []byte("\x1b[?1003l"))
+	stale := bytes.Index(sub.Backlog, []byte("\x1b[?1003h"))
+	marker := bytes.Index(sub.Backlog, []byte("daemon restarted"))
+	if stale < 0 || !(stale < settle && settle < marker) {
+		t.Fatalf("want the stale set, then the reset, then the marker; got %d, %d, %d in %q",
+			stale, settle, marker, sub.Backlog)
+	}
+}
+
 func TestReviveFallsBackToHomeWhenTheCwdIsGone(t *testing.T) {
 	r := NewRegistry(nil)
 	s, err := r.Revive(Snapshot{V: 1, ID: "cafebabe00000002", Cwd: "/no/such/dir/anywhere"})
diff --git a/web/src/components/key-bar.tsx b/web/src/components/key-bar.tsx
index cf8adee..4af1d45 100644
--- a/web/src/components/key-bar.tsx
+++ b/web/src/components/key-bar.tsx
@@ -32,15 +32,13 @@ export function KeyBar(props: {
   ctrl: boolean
   onCtrl: () => void
   onKey: (key: BarKey) => void
-  onPaste: () => void
 }) {
-  const chip =
-    'min-h-12 shrink-0 rounded-md px-3 py-1.5 font-mono text-sm/4 transition-colors select-none'
+  const chip = 'rounded-md px-2.5 py-1.5 font-mono text-sm/4 transition-colors select-none'
   return (
     <div
       data-flue-keybar=""
       className={cn(
-        'absolute bottom-3 left-1/2 z-10 flex max-w-[calc(100%-1.5rem)] -translate-x-1/2 items-center gap-x-1 overflow-x-auto overscroll-x-contain',
+        'absolute bottom-3 left-1/2 z-10 flex -translate-x-1/2 items-center gap-x-1',
         'rounded-lg bg-(--chip-bg) p-1 shadow-lg ring-1 ring-(--chip-ring) backdrop-blur-sm',
       )}
     >
@@ -64,20 +62,6 @@ export function KeyBar(props: {
       >
         ctrl
       </button>
-      <button
-        type="button"
-        title="Paste from clipboard"
-        onPointerDown={(e) => {
-          e.preventDefault()
-          props.onPaste()
-        }}
-        onClick={(e) => {
-          if (e.detail === 0) props.onPaste()
-        }}
-        className={cn(chip, 'text-(--chip-dim) hover:text-(--chip-fg) active:bg-(--chip-wash)')}
-      >
-        paste
-      </button>
       {KEYS.map((k) => (
         <button
           key={k.key}
diff --git a/web/src/components/terminal.test.tsx b/web/src/components/terminal.test.tsx
index 7a5a29a..b6a6956 100644
--- a/web/src/components/terminal.test.tsx
+++ b/web/src/components/terminal.test.tsx
@@ -10,8 +10,6 @@ import { createFakeEmulator, type FakeEmulator } from '@/testing/emulator'
 import { attached, fakeClient, sizeChanged, type FakeSocket } from '@/testing/socket'
 import { RESIZE_SETTLE_MS, Terminal, TERMINAL_SHORTCUT_HINT } from './terminal'
 
-const REAL_CLIPBOARD = Object.getOwnPropertyDescriptor(navigator, 'clipboard')
-
 /**
  * One emulator per mount, all of them kept.
  *
@@ -119,8 +117,6 @@ afterEach(() => {
   document.documentElement.style.backgroundColor = ''
   document.body.style.backgroundColor = ''
   localStorage.clear()
-  if (REAL_CLIPBOARD) Object.defineProperty(navigator, 'clipboard', REAL_CLIPBOARD)
-  else Reflect.deleteProperty(navigator, 'clipboard')
 })
 
 /**
@@ -187,6 +183,43 @@ describe('Terminal', () => {
     expect(em.live().text()).toBe('\x1bcfresh')
   })
 
+  it('stops reporting the pointer once the replayed backlog has drained', () => {
+    // The bug: a daemon restart replays a snapshot's scrollback, and that
+    // scrollback carries the mouse-tracking sequence of a program that was
+    // killed with the daemon and so never wrote its own reset. The emulator
+    // ends the replay armed, with a brand new shell behind it, and every
+    // pointer move over the terminal is an SGR report typed at the prompt.
+    const { sock, em } = mountTerminal((e) => <Terminal sessionId="s1" createEmulator={e.create} />)
+
+    act(() => sock.emitControl(attached({ ref: 1, id: 's1', seq: 0, head: 8 })))
+    act(() => sock.emitOutput(1, 'backlog!'))
+
+    // After the backlog, never before it: clearing the modes first would be
+    // undone by the very bytes that set them.
+    expect(em.live().reportingStops).toEqual([1])
+  })
+
+  it('leaves the modes alone until the whole backlog is in', () => {
+    const { sock, em } = mountTerminal((e) => <Terminal sessionId="s1" createEmulator={e.create} />)
+
+    act(() => sock.emitControl(attached({ ref: 1, id: 's1', seq: 0, head: 12 })))
+    act(() => sock.emitOutput(1, 'part'))
+
+    expect(em.live().reportingStops).toEqual([])
+  })
+
+  it('says nothing about the modes when there is no backlog to replay', () => {
+    // A freshly spawned session has head === seq. Nothing was replayed, so
+    // there is no stale state to answer for, and a program that armed
+    // tracking on its first line must keep it.
+    const { sock, em } = mountTerminal((e) => <Terminal sessionId="s1" createEmulator={e.create} />)
+
+    act(() => sock.emitControl(attached({ ref: 1, id: 's1', seq: 0 })))
+    act(() => sock.emitOutput(1, '\x1b[?1003h'))
+
+    expect(em.live().reportingStops).toEqual([])
+  })
+
   it('does not reset when the attach is an ordinary continuation', () => {
     const { sock, em } = mountTerminal((e) => <Terminal sessionId="s1" createEmulator={e.create} />)
 
@@ -1461,61 +1494,6 @@ describe('Terminal', () => {
       expect(key('ctrl').getAttribute('aria-pressed')).toBe('false')
     })
 
-    it('pastes through the emulator from the mobile clipboard', async () => {
-      coarsePointer()
-      const readText = vi.fn().mockResolvedValue('git status\n')
-      Object.defineProperty(navigator, 'clipboard', {
-        configurable: true,
-        value: { readText },
-      })
-      const { sock, em } = mountTerminal((e) => (
-        <Terminal sessionId="s1" createEmulator={e.create} />
-      ))
-      act(() => sock.emitControl(attached({ ref: 1, id: 's1' })))
-
-      fireEvent.pointerDown(key('paste'))
-
-      await waitFor(() => expect(em.live().pasted).toEqual(['git status\n']))
-      expect(readText).toHaveBeenCalledTimes(1)
-      expect(sock.input()).toEqual([{ ref: 1, text: 'git status\n' }])
-    })
-
-    it('does not apply the latched Ctrl modifier to a one-character paste', async () => {
-      coarsePointer()
-      Object.defineProperty(navigator, 'clipboard', {
-        configurable: true,
-        value: { readText: vi.fn().mockResolvedValue('c') },
-      })
-      const { sock } = mountTerminal((e) => (
-        <Terminal sessionId="s1" createEmulator={e.create} />
-      ))
-      act(() => sock.emitControl(attached({ ref: 1, id: 's1' })))
-
-      fireEvent.pointerDown(key('ctrl'))
-      fireEvent.pointerDown(key('paste'))
-
-      await waitFor(() => expect(sock.input()).toEqual([{ ref: 1, text: 'c' }]))
-      expect(key('ctrl').getAttribute('aria-pressed')).toBe('false')
-    })
-
-    it('explains when the browser refuses the clipboard', async () => {
-      coarsePointer()
-      Object.defineProperty(navigator, 'clipboard', {
-        configurable: true,
-        value: { readText: vi.fn().mockRejectedValue(new Error('denied')) },
-      })
-      const { sock } = mountTerminal((e) => (
-        <Terminal sessionId="s1" createEmulator={e.create} />
-      ))
-      act(() => sock.emitControl(attached({ ref: 1, id: 's1' })))
-
-      fireEvent.pointerDown(key('paste'))
-
-      expect((await screen.findByRole('alert')).textContent).toBe(
-        'This browser would not hand flue the clipboard.',
-      )
-    })
-
     it('drops bar keys pressed before the attach comes back', () => {
       coarsePointer()
       const { sock } = mountTerminal((e) => <Terminal sessionId="s1" createEmulator={e.create} />)
@@ -1526,7 +1504,7 @@ describe('Terminal', () => {
     it('reserves bottom room in the inset so the bar covers no rows', () => {
       coarsePointer()
       mountTerminal((e) => <Terminal sessionId="s1" createEmulator={e.create} />)
-      expect(inset().className).toContain('bottom-20')
+      expect(inset().className).toContain('bottom-16')
     })
   })
 })
diff --git a/web/src/components/terminal.tsx b/web/src/components/terminal.tsx
index 8c82b5d..8ac8fdb 100644
--- a/web/src/components/terminal.tsx
+++ b/web/src/components/terminal.tsx
@@ -169,7 +169,6 @@ export function Terminal({
   const ctrlArmedRef = useRef(ctrlArmed)
   ctrlArmedRef.current = ctrlArmed
   const [exitCode, setExitCode] = useState<number | null>(null)
-  const [pasteProblem, setPasteProblem] = useState<string | null>(null)
   // This session's directory, for Restart and the new-session link. From the
   // session list, because `attached` does not carry it.
   const [cwd, setCwd] = useState<string | null>(null)
@@ -195,7 +194,6 @@ export function Terminal({
     restart: (dir: string | null) => void
     applyTheme: (id: string) => void
     sendKey: (key: BarKey) => void
-    paste: () => void
   } | null>(null)
   // The latest onRestarted, readable from inside the effect without putting
   // a prop identity in its dependency array.
@@ -246,7 +244,6 @@ export function Terminal({
 
     const palette = resolveTheme(themeIdRef.current, prefersDark())
     const emulator = createEmulator({ cols: 80, rows: 24, theme: palette })
-    let alive = true
     emulator.attachTo(surface)
     emulator.focus()
     paintGround(palette.background)
@@ -271,6 +268,19 @@ export function Terminal({
     // the shell's stdin. head === seq on a fresh spawn opens it immediately.
     let consumed = 0
     let muteUntil = 0
+    // Whether a replayed backlog is still arriving under this attachment.
+    //
+    // The gate above keeps the emulator's *answers* off the wire while the
+    // scrollback replays. This is the other half of the same problem: a
+    // replay also re-runs every mode change in that scrollback, and the
+    // modes outlive it. A shell killed with the daemon inside a
+    // mouse-tracking program wrote the sequence that turned tracking on and
+    // never the one that turns it off, so replaying its snapshot leaves this
+    // emulator reporting the pointer at a fresh prompt — see stopReporting.
+    // Turned off the moment the backlog has been consumed, which is where
+    // the reset goes; false already on a fresh spawn, whose head === seq
+    // means there is nothing replayed to answer for.
+    let replaying = false
     // The attachment's epoch, stepped with every reseed. Each done callback
     // below closes over the value it was written under: one enqueued under a
     // previous attachment can fire after the reseed, and its bytes are
@@ -620,6 +630,7 @@ export function Terminal({
         epoch++
         consumed = a.seq
         muteUntil = a.head
+        replaying = a.head > a.seq
         if (a.truncated) emulator.write(RESET)
         emulator.resize(a.cols, a.rows)
         tabOsc = a.title
@@ -636,7 +647,15 @@ export function Terminal({
         if (r !== ref) return
         const e = epoch
         emulator.write(bytes, () => {
-          if (e === epoch) consumed += bytes.length
+          if (e !== epoch) return
+          consumed += bytes.length
+          // In the done callback and not at frame arrival, for the same
+          // reason the gate is: this has to land after the parser has read
+          // the backlog, or the modes it clears are set again behind it.
+          if (replaying && consumed >= muteUntil) {
+            replaying = false
+            emulator.stopReporting()
+          }
         })
       }),
     )
@@ -766,37 +785,6 @@ export function Terminal({
         }
         client.sendInput(ref, bytes)
       },
-      paste: () => {
-        if (ref === null || consumed < muteUntil) {
-          setPasteProblem('The terminal is not ready for input yet.')
-          return
-        }
-        const clipboard = navigator.clipboard
-        if (!clipboard?.readText) {
-          setPasteProblem('This browser does not allow reading the clipboard here.')
-          return
-        }
-        // A latched hardware modifier does not alter a clipboard paste. Clear
-        // ours before xterm emits the prepared text through onData, or a
-        // one-character paste such as "c" could turn into Ctrl+C.
-        ctrlArmedRef.current = false
-        setCtrlArmed(false)
-        void clipboard.readText().then(
-          (text) => {
-            if (!alive) return
-            if (text === '') {
-              setPasteProblem('The clipboard is empty.')
-              return
-            }
-            setPasteProblem(null)
-            emulator.paste(text)
-            emulator.focus()
-          },
-          () => {
-            if (alive) setPasteProblem('This browser would not hand flue the clipboard.')
-          },
-        )
-      },
     }
 
     // Another tab choosing a theme lands here: the preference is global, and
@@ -817,7 +805,6 @@ export function Terminal({
     client.list()
 
     return () => {
-      alive = false
       actionsRef.current = null
       for (const off of offs) off()
       inner.removeEventListener('touchstart', touchStart)
@@ -893,7 +880,7 @@ export function Terminal({
         data-flue-inset=""
         className={cn(
           'flue-term-gesture absolute inset-3 transition-opacity',
-          coarse && 'bottom-20',
+          coarse && 'bottom-16',
           phase === 'exited' && 'opacity-60',
         )}
       >
@@ -908,21 +895,12 @@ export function Terminal({
           ctrl={ctrlArmed}
           onCtrl={() => setCtrlArmed((v) => !v)}
           onKey={(k) => actionsRef.current?.sendKey(k)}
-          onPaste={() => actionsRef.current?.paste()}
         />
       )}
-      {pasteProblem !== null && (
-        <p
-          role="alert"
-          className="absolute right-3 bottom-20 left-3 z-20 rounded-md bg-(--chip-bg) px-3 py-2 text-center text-sm text-(--chip-fg) shadow-lg ring-1 ring-(--chip-ring)"
-        >
-          {pasteProblem}
-        </p>
-      )}
       {/* z-10: xterm's own layers carry z-indexes, and an unindexed sibling
           loses to them — the controls must win the stack or the scrollbar
           eats their clicks. */}
-      <div className="absolute top-3 right-3 z-10 flex max-w-[calc(100%-1.5rem)] items-start gap-x-2 overflow-x-auto overscroll-x-contain">
+      <div className="absolute top-3 right-3 z-10 flex items-start gap-x-2">
         <ThemeMenu value={themeId} dark={dark} onChange={handleTheme} />
         {/*
           The way to another session without leaving this one.
@@ -939,7 +917,7 @@ export function Terminal({
           onClick={() => switcher.open()}
           title={`Switch session · ${chordLabel}`}
           className={cn(
-            'inline-flex size-12 shrink-0 items-center justify-center rounded-lg sm:size-auto sm:px-2.5 sm:py-1.5',
+            'rounded-lg px-2.5 py-1.5',
             'bg-(--chip-bg) text-(--chip-dim) shadow-lg ring-1 ring-(--chip-ring) backdrop-blur-sm',
             'transition-colors hover:text-(--chip-fg)',
           )}
@@ -959,7 +937,7 @@ export function Terminal({
           rel="noopener"
           title="Open the dashboard"
           className={cn(
-            'inline-flex size-12 shrink-0 items-center justify-center rounded-lg sm:size-auto sm:px-2.5 sm:py-1.5',
+            'rounded-lg px-2.5 py-1.5',
             'bg-(--chip-bg) text-(--chip-dim) shadow-lg ring-1 ring-(--chip-ring) backdrop-blur-sm',
             'transition-colors hover:text-(--chip-fg)',
           )}
@@ -983,7 +961,7 @@ export function Terminal({
           onClick={() => onNewSession?.(cwd)}
           title="New session here"
           className={cn(
-            'inline-flex size-12 shrink-0 items-center justify-center rounded-lg sm:size-auto sm:px-2.5 sm:py-1.5',
+            'rounded-lg px-2.5 py-1.5',
             'bg-(--chip-bg) text-(--chip-dim) shadow-lg ring-1 ring-(--chip-ring) backdrop-blur-sm',
             'transition-colors hover:text-(--chip-fg)',
           )}
@@ -1004,7 +982,7 @@ export function Terminal({
             className={cn(
               // /4 line-height: 16px text box + py-1.5 = the same 28px as the
               // icon buttons beside it (size-4 in py-1.5), one strip height.
-              'shrink-0 rounded-lg px-3 py-1.5 text-base/4 font-medium sm:text-sm/4',
+              'rounded-lg px-3 py-1.5 text-base/4 font-medium sm:text-sm/4',
               'bg-(--chip-bg) text-(--chip-fg) shadow-lg ring-1 ring-(--chip-ring) backdrop-blur-sm',
             )}
           >
diff --git a/web/src/components/theme-menu.tsx b/web/src/components/theme-menu.tsx
index 53df0c2..d7187c9 100644
--- a/web/src/components/theme-menu.tsx
+++ b/web/src/components/theme-menu.tsx
@@ -48,7 +48,7 @@ export function ThemeMenu({
           title="Terminal theme"
           style={chipStyle}
           className={cn(
-            'inline-flex size-12 shrink-0 items-center justify-center rounded-lg sm:size-auto sm:px-2.5 sm:py-1.5',
+            'rounded-lg px-2.5 py-1.5',
             'bg-(--chip-bg) text-(--chip-dim) shadow-lg ring-1 ring-(--chip-ring) backdrop-blur-sm',
             'transition-colors hover:text-(--chip-fg) data-[state=open]:text-(--chip-fg)',
           )}
diff --git a/web/src/emulator/emulator.test.ts b/web/src/emulator/emulator.test.ts
index cf93d9c..19ef0fd 100644
--- a/web/src/emulator/emulator.test.ts
+++ b/web/src/emulator/emulator.test.ts
@@ -123,33 +123,45 @@ describe('Emulator interface', () => {
     em.dispose()
   })
 
-  it('normalises pasted newlines through xterm', () => {
+  it('stops reporting the pointer a replayed program had asked for', async () => {
+    // The bug this is the floor for: a snapshot's scrollback carries the
+    // mouse-tracking sequence of a program that died with the daemon, so
+    // replaying it arms an emulator sitting in front of a fresh shell. From
+    // there every mouse move is an SGR report typed at the prompt.
     const el = document.createElement('div')
     document.body.appendChild(el)
     const em = createXtermEmulator({ cols: 10, rows: 4 })
     em.attachTo(el)
     const seen: string[] = []
     em.onData((b) => seen.push(new TextDecoder().decode(b)))
-
-    em.paste('one\ntwo\r\nthree')
-
-    expect(seen.join('')).toBe('one\rtwo\rthree')
+    await settled(em, '\x1b[?1003h\x1b[?1006h\x1b[?1004h')
+
+    expect(em.reportsPointer()).toBe(true)
+    // Everything the arming itself put on the wire is the bug, not the fix —
+    // an unfocused terminal answers ESC[?1004h with a focus-out report right
+    // away, which is exactly the kind of typing-with-nobody-there this
+    // clears. What matters below is that the clearing adds none of its own.
+    seen.length = 0
+    em.stopReporting()
+    await settled(em, '')
+
+    expect(em.reportsPointer()).toBe(false)
+    expect(seen.join('')).toBe('')
     em.dispose()
     el.remove()
   })
 
-  it('honours a program that enabled bracketed-paste mode', async () => {
+  it('leaves a live program its pointer reporting', async () => {
+    // stopReporting is aimed at a replay, never at output. A program that
+    // turns tracking on after the backlog has drained keeps it.
     const el = document.createElement('div')
     document.body.appendChild(el)
     const em = createXtermEmulator({ cols: 10, rows: 4 })
     em.attachTo(el)
-    const seen: string[] = []
-    em.onData((b) => seen.push(new TextDecoder().decode(b)))
-    await settled(em, '\x1b[?2004h')
-
-    em.paste('safe')
+    em.stopReporting()
+    await settled(em, '\x1b[?1002h')
 
-    expect(seen.join('')).toBe('\x1b[200~safe\x1b[201~')
+    expect(em.reportsPointer()).toBe(true)
     em.dispose()
     el.remove()
   })
@@ -187,11 +199,12 @@ describe('Emulator interface', () => {
     em.dispose()
 
     expect(() => em.focus()).not.toThrow()
-    expect(() => em.paste('ignored')).not.toThrow()
+    expect(() => em.stopReporting()).not.toThrow()
     expect(() => em.setTheme({ background: '#000000' })).not.toThrow()
     expect(em.contentSize()).toBeNull()
     expect(() => em.answerQueries(true)).not.toThrow()
     expect(em.applicationCursorKeys()).toBe(false)
+    expect(em.reportsPointer()).toBe(false)
   })
 
   it('attaches to an element with no WebGL context available', () => {
diff --git a/web/src/emulator/types.ts b/web/src/emulator/types.ts
index 4c5d010..169fbc7 100644
--- a/web/src/emulator/types.ts
+++ b/web/src/emulator/types.ts
@@ -107,14 +107,33 @@ export interface Emulator {
    */
   onData(cb: (bytes: Uint8Array) => void): void
   /**
-   * Paste text as terminal input.
+   * Forget the reporting modes a replayed backlog turned on.
    *
-   * This is distinct from feeding raw bytes: a terminal normalises pasted
-   * newlines and wraps the text when the program has enabled bracketed-paste
-   * mode. Mobile clipboard controls must go through the emulator so they keep
-   * those semantics.
+   * A session's scrollback is bytes, not state, so replaying it re-runs
+   * every mode change the shell ever wrote — including the ones belonging to
+   * a program that has since exited or been killed with the daemon. Mouse
+   * tracking and focus reporting are the two that matter, because they are
+   * the only modes that put bytes on the wire with nobody typing: an armed
+   * emulator sends an SGR report for every pointer move, and the shell
+   * behind it receives that as somebody typing "35;61;22M" at the prompt.
+   *
+   * Only those two, and deliberately. Application cursor keys and bracketed
+   * paste are also replayable and also stale, but they change what a
+   * keystroke means rather than inventing keystrokes, so clearing them
+   * against a live program would break arrows and pastes in a client that
+   * had nothing wrong with it. See settleModes in internal/session for the
+   * wider reset, which runs where there is no live program to break.
+   *
+   * Local to this emulator. Nothing reaches the shell.
+   */
+  stopReporting(): void
+  /**
+   * Whether this emulator would report pointer movement to the program.
+   *
+   * Exists so the reset above can be tested for what it does rather than for
+   * the bytes it writes.
    */
-  paste(text: string): void
+  reportsPointer(): boolean
   /**
    * Mount into the DOM.
    *
diff --git a/web/src/emulator/xterm.ts b/web/src/emulator/xterm.ts
index 43c257c..bc0c2fe 100644
--- a/web/src/emulator/xterm.ts
+++ b/web/src/emulator/xterm.ts
@@ -44,6 +44,19 @@ export const TERMINAL_FONT_FAMILY =
  */
 export const NEWLINE_CHORD_BYTES = '\x1b\r'
 
+/**
+ * Every mouse protocol off, every mouse encoding off, focus reporting off.
+ *
+ * The set is exhaustive on purpose. The protocols (1000 press-only, 1002
+ * drag, 1003 any motion) and the encodings (1005 UTF-8, 1006 SGR, 1015
+ * urxvt, 1016 SGR-pixels) are separate switches in the terminal, and a
+ * program may have set any combination of them; clearing the protocol a
+ * particular program happened to use is how this fix would work on one
+ * machine and not the next.
+ */
+const STOP_REPORTING =
+  '\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l\x1b[?1016l\x1b[?1004l'
+
 /**
  * xterm.js behind the Emulator seam.
  *
@@ -171,9 +184,19 @@ export function createXtermEmulator(opts: XtermOptions = {}): Emulator {
       term.onData((data) => cb(encoder.encode(data)))
     },
 
-    paste(text: string) {
+    stopReporting() {
       if (disposed) return
-      term.paste(text)
+      // Written as output rather than set on xterm's services, because the
+      // parser is the only supported way in and because it keeps the ordering
+      // honest: this lands in the stream where the caller put it, so live
+      // output arriving after it is applied after it. A program that turns
+      // tracking back on a moment later still gets tracking.
+      term.write(STOP_REPORTING)
+    },
+
+    reportsPointer() {
+      if (disposed) return false
+      return term.modes.mouseTrackingMode !== 'none'
     },
 
     attachTo(el: HTMLElement) {
diff --git a/web/src/styles.build.test.ts b/web/src/styles.build.test.ts
index cfca633..7c234c0 100644
--- a/web/src/styles.build.test.ts
+++ b/web/src/styles.build.test.ts
@@ -119,6 +119,36 @@ describe('compiled stylesheet', () => {
     expect(css).toContain('touch-action:pinch-zoom')
     expect(css).not.toContain('touch-action:none')
   })
+
+  it('gives a touch device a pressable box over the terminal', () => {
+    // What makes a long-press Paste possible at all: xterm ships its input
+    // as a zero-sized element parked off-page, and a finger cannot land on
+    // it. This is also the rule most likely to be lost silently — it beats
+    // inline style, and only `!important` does that, so a tidy-up that drops
+    // the annotations would leave a stylesheet that still builds and a
+    // gesture that no longer works.
+    // The last one, not the first: xterm.css names the same element, and the
+    // whole point of flue's rule is that it comes after and overrides it.
+    const at = css.lastIndexOf('.xterm-helper-textarea')
+    expect(at).toBeGreaterThan(-1)
+    const rule = css.slice(at, css.indexOf('}', at))
+    for (const decl of [
+      'inline-size:100%!important',
+      'block-size:100%!important',
+      // Without this the browser rings the focused element, and the element
+      // now has the terminal's box — so it reads as a blue line drawn around
+      // the whole terminal for as long as the session is being typed into.
+      'outline:none!important',
+    ]) {
+      expect(rule).toContain(decl)
+    }
+    // And only where there is no mouse to lose a text selection to.
+    expect(css.slice(0, at)).toContain('pointer:coarse')
+    // Unlayered, so it outranks xterm.css whatever the specificity — the
+    // import at the top of styles.css puts that sheet in `layer(base)`
+    // precisely so rules like this one can win.
+    expect(css.slice(at).indexOf('@layer')).not.toBe(0)
+  })
 })
 
 /**
diff --git a/web/src/styles.css b/web/src/styles.css
index 318aeab..09632ad 100644
--- a/web/src/styles.css
+++ b/web/src/styles.css
@@ -444,3 +444,77 @@
 .flue-term-surface .xterm .xterm-scrollable-element > .scrollbar {
   display: none;
 }
+
+/*
+ * A long press that reaches real editable text, so a phone offers its own
+ * Paste.
+ *
+ * A terminal is a div, and no operating system offers a paste menu over a
+ * div. xterm does keep its input in a real textarea, but ships it as a
+ * zero-sized box parked off to the far side of the page — enough for a
+ * keyboard to type into, never enough for a finger to land on. So a phone
+ * has nowhere to press, which is why flue grew a paste chip in the key bar
+ * instead, and why that chip fired on pointerdown and threw the clipboard
+ * into the terminal whenever a thumb brushed the bar.
+ *
+ * Giving the textarea the terminal's own box hands the press somewhere to
+ * go. The callout is the platform's, so what it offers is what the platform
+ * decided to offer; the paste that comes back travels xterm's own paste
+ * path, which is what keeps newline handling and bracketed-paste mode
+ * right. Typing is unmoved: the same element received it before.
+ *
+ * Coarse pointers only. On a desktop this element would sit over the screen
+ * and eat the drag that selects text.
+ *
+ * `!important` throughout, and unavoidable: xterm writes this element's
+ * placement and stacking as inline style every time the cursor moves, to
+ * park an IME popup beside the caret. The cost is that the popup is now
+ * placed against the whole terminal rather than the caret, which on a phone
+ * is a keyboard the OS positions for itself.
+ */
+@media (pointer: coarse) {
+  .flue-term-surface .xterm .xterm-helpers {
+    inline-size: 100%;
+    block-size: 100%;
+    /* The layer is a coordinate space, not a target. Only its textarea
+     * answers a touch, or this would swallow every press meant for the
+     * terminal underneath. */
+    pointer-events: none;
+  }
+
+  .flue-term-surface .xterm .xterm-helper-textarea {
+    inset-block-start: 0 !important;
+    inset-inline-start: 0 !important;
+    inline-size: 100% !important;
+    block-size: 100% !important;
+    line-height: normal !important;
+    /* Sixteen pixels exactly, and it is not a typographic choice: iOS zooms
+     * the whole page in when a person focuses a form control smaller than
+     * this, and a terminal that jumped to 150% on every tap would be a worse
+     * bug than the one above. Nothing renders it — the element is empty and
+     * its ink is transparent — so this is a threshold, not a size. */
+    font-size: 16px !important;
+    /* Above xterm's own canvases, which is what the helpers layer is for;
+     * xterm's inline -5 would put it behind them. */
+    z-index: 1 !important;
+    pointer-events: auto;
+    /* Present rather than see-through: a fully transparent control is not
+     * reliably offered a callout. Nothing shows, because the element is
+     * empty except mid-composition and every ink colour here is none. */
+    opacity: 1 !important;
+    color: transparent;
+    caret-color: transparent;
+    background-color: transparent;
+    -webkit-text-fill-color: transparent;
+    /* No focus ring, and no accessibility owed by dropping it. A browser
+     * draws one around a focused control to say where typing will land, and
+     * this control is a proxy: it has the terminal's box, so the ring is a
+     * blue line around the whole terminal, and what it would be announcing
+     * is already announced by the block cursor blinking in the cells. It
+     * only became visible when the box did — parked off-page at zero size,
+     * this element had been focused and outlined all along. */
+    outline: none !important;
+    /* Safari draws its own, separately, and ignores the line above. */
+    -webkit-tap-highlight-color: transparent;
+  }
+}
diff --git a/web/src/testing/emulator.ts b/web/src/testing/emulator.ts
index d1f9aed..53e13c3 100644
--- a/web/src/testing/emulator.ts
+++ b/web/src/testing/emulator.ts
@@ -27,8 +27,16 @@ export interface FakeEmulator extends Emulator {
   appCursor: boolean
   /** Simulate the user typing. */
   send(text: string): void
-  /** Text handed to paste(), in order. */
-  readonly pasted: string[]
+  /**
+   * Where each stopReporting() call landed, as a count of written chunks.
+   *
+   * A count rather than a flag because the ordering against the output
+   * stream is the property worth testing: clearing the modes before a
+   * replayed backlog has been written would be undone by the backlog.
+   */
+  readonly reportingStops: number[]
+  /** What reportsPointer() answers; set by hand like measured. */
+  pointerReports: boolean
 }
 
 /**
@@ -47,13 +55,13 @@ export function createFakeEmulator(opts: FakeEmulatorOptions = {}): FakeEmulator
   const written: string[] = []
   const themes: TerminalTheme[] = []
   const queryAnswers: boolean[] = []
-  const pasted: string[] = []
+  const reportingStops: number[] = []
 
   const self: FakeEmulator = {
     written,
     themes,
     queryAnswers,
-    pasted,
+    reportingStops,
     cols: opts.cols ?? 80,
     rows: opts.rows ?? 24,
     mountedOn: null,
@@ -62,6 +70,7 @@ export function createFakeEmulator(opts: FakeEmulatorOptions = {}): FakeEmulator
     scrolled: 0,
     measured: null,
     appCursor: false,
+    pointerReports: false,
 
     text: () => written.join(''),
 
@@ -94,11 +103,13 @@ export function createFakeEmulator(opts: FakeEmulatorOptions = {}): FakeEmulator
       listeners.push(cb)
     },
 
-    paste(text: string) {
-      pasted.push(text)
-      self.send(text)
+    stopReporting() {
+      reportingStops.push(written.length)
+      mutable(self).pointerReports = false
     },
 
+    reportsPointer: () => self.pointerReports,
+
     attachTo(el: HTMLElement) {
       mutable(self).mountedOn = el
     },