diff --git a/relay/src/directory.ts b/relay/src/directory.ts
index 7f865d5..3f697da 100644
--- a/relay/src/directory.ts
+++ b/relay/src/directory.ts
@@ -107,7 +107,7 @@ export class FleetDirectory extends DurableObject<Env> {
     // one PUT, which is one send per socket, against a fleet that has left
     // half-dead sockets behind or a secret-holder opening them in a loop. A
     // one-operator fleet reaches double digits.
-    if (this.ctx.getWebSockets('daemon').length >= MAX_DAEMON_SOCKETS) {
+    if (this.ctx.getWebSockets('daemon').length >= this.maxDaemonSockets()) {
       return new Response('{"error":"too many directory sockets"}', {
         status: 503,
         headers: JSON_NO_STORE,
@@ -155,7 +155,7 @@ export class FleetDirectory extends DurableObject<Env> {
       return stored(key, 200)
     }
     const count = (have.get(COUNT_KEY) as number | undefined) ?? 0
-    if (count >= MAX_ENTRIES) return full()
+    if (count >= this.maxEntries()) return full()
     const version = (have.get(VERSION_KEY) as number | undefined) ?? 0
     // One multi-key put: the blob, the count and the version land together or
     // not at all.
@@ -327,6 +327,23 @@ export class FleetDirectory extends DurableObject<Env> {
       // Already closing.
     }
   }
+
+  /**
+   * The cap, read the way the hub reads its deadlines: the binding when there
+   * is one, the constant when there is not, and the constant again for a
+   * binding that is not a usable number. Nothing in production binds it; see
+   * DIRECTORY_MAX_ENTRIES in src/index.ts for why the seam exists at all.
+   */
+  private maxEntries(): number {
+    const n = Number(this.env.DIRECTORY_MAX_ENTRIES ?? MAX_ENTRIES)
+    return Number.isFinite(n) && n > 0 ? n : MAX_ENTRIES
+  }
+
+  /** The socket ceiling, read exactly as the entry cap above is. */
+  private maxDaemonSockets(): number {
+    const n = Number(this.env.DIRECTORY_MAX_DAEMON_SOCKETS ?? MAX_DAEMON_SOCKETS)
+    return Number.isFinite(n) && n > 0 ? n : MAX_DAEMON_SOCKETS
+  }
 }
 
 /** The storage prefix for blobs; the rest of the key is the digest. */
diff --git a/relay/src/index.ts b/relay/src/index.ts
index 17ad2e3..835ba96 100644
--- a/relay/src/index.ts
+++ b/relay/src/index.ts
@@ -24,6 +24,23 @@ export interface Env {
    * closes it, in ms — the same test seam. Unset in production, where the hub
    * defaults to five minutes (src/hub.ts, CLIENT_IDLE_MS). */
   CLIENT_IDLE_TIMEOUT_MS?: string | number
+  /** How many entries one fleet directory will hold — the same test seam
+   * (vitest binds a small number). Unset in production, where it is 512
+   * (src/directory.ts, MAX_ENTRIES), and the reasoning for that number is
+   * written down beside it.
+   *
+   * It is a seam because the cap is only reachable by filling it, and filling
+   * it is 512 sequential round trips through a Durable Object — five seconds
+   * of a runner's time on a good day, and over vitest's own deadline on a
+   * loaded one. Binding it is the difference between a test about the cap and
+   * a bet on how fast the machine is. */
+  DIRECTORY_MAX_ENTRIES?: string | number
+  /** How many push sockets one fleet directory will hold — the same test seam
+   * for the same reason. Unset in production, where it is 256
+   * (src/directory.ts, MAX_DAEMON_SOCKETS). Reaching that cap means opening
+   * 256 WebSockets one at a time and holding them all open, which is the other
+   * test in this file that timed out on CI and passed on a laptop. */
+  DIRECTORY_MAX_DAEMON_SOCKETS?: string | number
   /** The version of the flue that deployed this Worker, stamped by the
    * deploy as a plain-text binding (internal/relaydeploy, VersionVar) and
    * reported on /api/health. It is how a daemon sees that this relay is
diff --git a/relay/test/directory.test.ts b/relay/test/directory.test.ts
index fde227f..1d0398c 100644
--- a/relay/test/directory.test.ts
+++ b/relay/test/directory.test.ts
@@ -20,11 +20,33 @@ import { BASE, Leg, machineId, sleep, TEST_SECRET, within } from './harness'
 /** Mirrors MAX_BLOB_BYTES in src/directory.ts. */
 const MAX_BLOB_BYTES = 4096
 
-/** Mirrors MAX_ENTRIES in src/directory.ts. */
-const MAX_ENTRIES = 512
+/**
+ * Mirrors DIRECTORY_MAX_ENTRIES in vitest.config.ts, *not* MAX_ENTRIES in
+ * src/directory.ts — the cap is a test seam, and this is the bound half of it.
+ *
+ * Production is 512, and the arithmetic that picks it is written down beside
+ * the constant. It is not the number to test against: the only way to test a
+ * cap is to reach it, and reaching 512 is 512 sequential round trips through a
+ * Durable Object — around five seconds on a quiet machine and past vitest's
+ * own five-second deadline on a loaded one, which is how these tests came to
+ * fail in CI and pass on a laptop. This reaches the same branch in a fraction
+ * of that; what is under test is the refusal, not the size of the number.
+ *
+ * It has headroom on purpose. The shared directory — the one `SELF` routes to,
+ * which nearly every other test in this file writes into — holds ten entries
+ * by the end of the run, and a bound it could reach would start refusing PUTs
+ * in tests that are not about the cap at all. That failure reads as "the push
+ * never came", nowhere near the number that caused it.
+ */
+const MAX_ENTRIES = 64
 
-/** Mirrors MAX_DAEMON_SOCKETS in src/directory.ts. */
-const MAX_DAEMON_SOCKETS = 256
+/**
+ * Mirrors DIRECTORY_MAX_DAEMON_SOCKETS in vitest.config.ts, for the reason
+ * MAX_ENTRIES above is bound: production is 256, and reaching it means opening
+ * 256 WebSockets one at a time and holding all of them open. What is under
+ * test is the refusal at the ceiling, not where the ceiling is.
+ */
+const MAX_DAEMON_SOCKETS = 8
 
 const DIRECTORY = `${BASE}/directory`
 
diff --git a/relay/vitest.config.ts b/relay/vitest.config.ts
index d50c3b4..946d8af 100644
--- a/relay/vitest.config.ts
+++ b/relay/vitest.config.ts
@@ -42,6 +42,17 @@ export default defineConfig({
           HANDSHAKE_TIMEOUT_MS: 600_000,
           CLIENT_IDLE_TIMEOUT_MS: 600_000,
           PAIR_TIMEOUT_MS: 250,
+          // The directory's entry cap, bound small for the same reason the
+          // deadlines above are bound at all: the only way to test a cap is to
+          // reach it, and reaching the production 512 is 512 sequential round
+          // trips through a Durable Object — five seconds on a quiet machine
+          // and past vitest's own deadline on a loaded one. test/directory.ts
+          // mirrors this number; production binds nothing and gets 512.
+          DIRECTORY_MAX_ENTRIES: 64,
+          // And the socket ceiling, bound small for the same reason: reaching
+          // 256 means opening 256 WebSockets one at a time and holding every
+          // one of them open. test/directory.ts mirrors this number too.
+          DIRECTORY_MAX_DAEMON_SOCKETS: 8,
           DAEMON_SECRET: 'test-secret',
           // The deploy stamps this (internal/relaydeploy, VersionVar); binding
           // it here is what lets the health test pin the passthrough.
diff --git a/web/src/components/new-session-dialog.test.tsx b/web/src/components/new-session-dialog.test.tsx
new file mode 100644
index 0000000..d747d92
--- /dev/null
+++ b/web/src/components/new-session-dialog.test.tsx
@@ -0,0 +1,187 @@
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { NewSessionRequest } from '@/sessions/new-session'
+import { NewSessionDialog, type NewSessionDialogProps } from './new-session-dialog'
+
+const MACHINES = [
+  { id: 'local', name: 'mesa.local' },
+  { id: 'attic-pi', name: 'Attic Pi' },
+]
+
+function show(over: Partial<NewSessionDialogProps> = {}) {
+  const props: NewSessionDialogProps = {
+    open: true,
+    initial: {},
+    machines: MACHINES,
+    known: [],
+    onSubmit: vi.fn(),
+    onClose: vi.fn(),
+    ...over,
+  }
+  const view = render(<NewSessionDialog {...props} />)
+  const submitted = () => (props.onSubmit as ReturnType<typeof vi.fn>).mock.calls[0]?.[0] as
+    | NewSessionRequest
+    | undefined
+  return { ...view, props, submitted, rerender: view.rerender }
+}
+
+const start = () => userEvent.click(screen.getByRole('button', { name: 'Start session' }))
+
+describe('NewSessionDialog', () => {
+  it('submits the ridden machine and nothing else when nothing is typed', async () => {
+    // The bar this had to clear to be allowed in front of a one-click button:
+    // opening it and pressing Start must be the old behaviour exactly.
+    const { submitted } = show({ initial: { machineId: 'local' } })
+
+    await start()
+
+    expect(submitted()).toEqual({ machineId: 'local', cwd: '', name: '', tags: [] })
+  })
+
+  it('carries a name, a directory and tags', async () => {
+    const user = userEvent.setup()
+    const { submitted } = show({ initial: { machineId: 'local' } })
+
+    await user.type(screen.getByLabelText('Name'), 'deploy')
+    await user.type(screen.getByLabelText('Directory'), '/srv/app')
+    await user.type(screen.getByLabelText('Tags'), 'ops{Enter}api{Enter}')
+    await start()
+
+    expect(submitted()).toEqual({
+      machineId: 'local',
+      cwd: '/srv/app',
+      name: 'deploy',
+      tags: ['ops', 'api'],
+    })
+  })
+
+  it('counts a tag typed but never entered', async () => {
+    // Somebody who typed a tag and reached straight for Start is done, and a
+    // dialog that threw the keystroke away would be disagreeing with them in
+    // silence — the chips are gone before anyone can read what was sent.
+    const user = userEvent.setup()
+    const { submitted } = show()
+
+    await user.type(screen.getByLabelText('Tags'), 'staging')
+    await start()
+
+    expect(submitted()?.tags).toEqual(['staging'])
+  })
+
+  it('does not start a session on the Enter that finishes a tag', async () => {
+    // The tag field sits inside a real form, so its own Enter has to be
+    // stopped: a set the reader was still assembling is not an answer.
+    const user = userEvent.setup()
+    const { props } = show()
+
+    await user.type(screen.getByLabelText('Tags'), 'ops{Enter}')
+
+    expect(props.onSubmit).not.toHaveBeenCalled()
+    expect(screen.getByRole('button', { name: 'Remove ops' })).toBeTruthy()
+  })
+
+  it('submits on Enter from the name field, like every other form', async () => {
+    const user = userEvent.setup()
+    const { submitted } = show({ initial: { machineId: 'attic-pi' } })
+
+    await user.type(screen.getByLabelText('Name'), 'quick{Enter}')
+
+    expect(submitted()).toEqual({ machineId: 'attic-pi', cwd: '', name: 'quick', tags: [] })
+  })
+
+  it('opens on what the press implied, and lets it be edited', async () => {
+    const user = userEvent.setup()
+    const { submitted } = show({
+      initial: { machineId: 'attic-pi', cwd: '/srv', tags: ['api'] },
+    })
+
+    expect(screen.getByLabelText('Directory')).toHaveProperty('value', '/srv')
+
+    // A prefill and not a decision: the chip is there to be taken off again.
+    await user.click(screen.getByRole('button', { name: 'Remove api' }))
+    await start()
+
+    expect(submitted()).toEqual({ machineId: 'attic-pi', cwd: '/srv', name: '', tags: [] })
+  })
+
+  it('offers the fleet’s own tags, minus the ones already chosen', async () => {
+    const user = userEvent.setup()
+    const { submitted } = show({ known: ['api', 'ops'], initial: { tags: ['api'] } })
+
+    expect(screen.queryByRole('button', { name: 'Add api' })).toBeNull()
+    await user.click(screen.getByRole('button', { name: 'Add ops' }))
+    await start()
+
+    expect(submitted()?.tags).toEqual(['api', 'ops'])
+  })
+
+  it('puts the chosen tags under their field, not above its heading', async () => {
+    // Leading chips are right for a dialog whose whole subject is tags. Here
+    // they read as a stray line belonging to the field before them: "No tags
+    // yet." landed between the Directory input and a heading called Tags.
+    const user = userEvent.setup()
+    show()
+
+    await user.type(screen.getByLabelText('Tags'), 'ops{Enter}')
+
+    const field = screen.getByLabelText('Tags')
+    const chip = screen.getByRole('button', { name: 'Remove ops' })
+    expect(field.compareDocumentPosition(chip) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy()
+  })
+
+  it('asks which machine only when there is a choice to make', () => {
+    const { unmount } = show({ machines: [MACHINES[0]!] })
+    expect(screen.queryByRole('combobox', { name: 'Machine' })).toBeNull()
+    unmount()
+
+    show()
+    expect(screen.getByRole('combobox', { name: 'Machine' })).toBeTruthy()
+  })
+
+  it('falls back to the first machine when the press named one that has gone', async () => {
+    // A heading for a machine that dropped between render and click. Without
+    // the fallback the trigger renders blank over a form pointing at an id no
+    // option carries.
+    const { submitted } = show({ initial: { machineId: 'vanished' } })
+
+    await start()
+
+    expect(submitted()?.machineId).toBe('local')
+  })
+
+  it('takes the machine the fleet has not named yet, once it names it', async () => {
+    // The terminal screen subscribes to the fleet and the first delivery can
+    // land after this has rendered. A machine chosen once, at mount, would
+    // leave the picker empty for good.
+    const { rerender, submitted, props } = show({ machines: [], initial: { machineId: 'local' } })
+
+    expect(screen.getByText(/no machine is reachable/i)).toBeTruthy()
+
+    rerender(<NewSessionDialog {...props} machines={MACHINES} />)
+    await start()
+
+    expect(submitted()?.machineId).toBe('local')
+  })
+
+  it('refuses in words when no machine is reachable', async () => {
+    const { props } = show({ machines: [] })
+
+    expect(screen.getByRole('button', { name: 'Start session' })).toHaveProperty('disabled', true)
+
+    await start()
+
+    expect(props.onSubmit).not.toHaveBeenCalled()
+  })
+
+  it('closes itself after a submit, and on Cancel', async () => {
+    const { props } = show({ initial: { machineId: 'local' } })
+
+    await start()
+    expect(props.onClose).toHaveBeenCalledTimes(1)
+
+    await userEvent.click(screen.getByRole('button', { name: 'Cancel' }))
+    expect(props.onClose).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/web/src/components/new-session-dialog.tsx b/web/src/components/new-session-dialog.tsx
new file mode 100644
index 0000000..4db11be
--- /dev/null
+++ b/web/src/components/new-session-dialog.tsx
@@ -0,0 +1,265 @@
+import { useId, useRef, useState, type RefObject } from 'react'
+
+import { TagField, withTag } from '@/components/tag-field'
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select'
+import type { NewSessionRequest } from '@/sessions/new-session'
+
+/** A machine this dialog may start a session on. */
+export interface NewSessionMachine {
+  id: string
+  /** What to call it. Empty falls back to the id, as every other screen does. */
+  name: string
+}
+
+export interface NewSessionDialogProps {
+  open: boolean
+  /**
+   * What the press that opened this already implies: the machine of the
+   * heading, the directory of the terminal underneath, the tag of the group.
+   * Everything absent opens empty.
+   */
+  initial: Partial<NewSessionRequest>
+  /** The machines that can carry one. An empty list disables the dialog. */
+  machines: NewSessionMachine[]
+  /** Every tag in use across the fleet, offered as one-click additions. */
+  known: string[]
+  /** Called with the whole request. The caller decides where it opens. */
+  onSubmit(want: NewSessionRequest): void
+  /** Dismissal, however it happened, including after a submit. */
+  onClose(): void
+}
+
+/**
+ * The one place a session is asked for.
+ *
+ * It exists because of the order the daemon imposes: `spawn` carries no
+ * metadata, so a name and a tag can only be applied after the session already
+ * exists. Left to that order, naming a session means starting it, watching a
+ * terminal come up, going back to the list and renaming the row — and nobody
+ * does that, so sessions stay called after whatever shell they run. Asking
+ * first turns the same two round trips into one form: what is typed here is
+ * carried to the page that starts the session, which applies it the moment
+ * there is an id to apply it to.
+ *
+ * Nothing is required. Every field opens either empty or on what the press
+ * implied, and submitting all four untouched is exactly the old one-click
+ * behaviour — which is the bar this had to clear to be allowed in front of it.
+ *
+ * The form state lives one component down, inside the content Radix unmounts
+ * on close, for the reason the rename dialog gives: the next open builds a new
+ * form over new props, so a name abandoned on one press cannot follow the
+ * reader to the next.
+ */
+export function NewSessionDialog({
+  open,
+  initial,
+  machines,
+  known,
+  onSubmit,
+  onClose,
+}: NewSessionDialogProps) {
+  const field = useRef<HTMLInputElement>(null)
+
+  return (
+    <Dialog
+      open={open}
+      onOpenChange={(next) => {
+        // Escape, the overlay, and the corner X all arrive here as `false`.
+        // The dialog is controlled by the caller, so this is a request to
+        // close rather than a closing.
+        if (!next) onClose()
+      }}
+    >
+      <DialogContent
+        onOpenAutoFocus={(event) => {
+          // The name, which is the field this dialog exists for. Left to
+          // itself Radix takes the first thing it can reach, and where that
+          // lands depends on which prefills happened to render.
+          event.preventDefault()
+          field.current?.focus()
+        }}
+      >
+        <DialogHeader>
+          <DialogTitle>New session</DialogTitle>
+          <DialogDescription>
+            Everything here is optional. The session opens in a tab of its own.
+          </DialogDescription>
+        </DialogHeader>
+        <NewSessionForm
+          field={field}
+          initial={initial}
+          machines={machines}
+          known={known}
+          onCancel={onClose}
+          onSubmit={(want) => {
+            onSubmit(want)
+            onClose()
+          }}
+        />
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+/**
+ * The four fields and the two buttons.
+ *
+ * A real form element, so Enter starts the session the way Enter submits
+ * everywhere else — the browser's own implicit submission, reached identically
+ * by the button and by the keyboard. The tag field stops its own Enter (see
+ * TagField), which is what keeps "finish this tag" from meaning "start now".
+ *
+ * The machine picker renders only when there is a choice to make. A fleet of
+ * one is the ordinary case, and a select holding a single option is a control
+ * that asks a question with one answer.
+ */
+function NewSessionForm({
+  field,
+  initial,
+  machines,
+  known,
+  onSubmit,
+  onCancel,
+}: {
+  field: RefObject<HTMLInputElement | null>
+  initial: Partial<NewSessionRequest>
+  machines: NewSessionMachine[]
+  known: string[]
+  onSubmit(want: NewSessionRequest): void
+  onCancel(): void
+}) {
+  const nameId = useId()
+  const cwdId = useId()
+  const machineId = useId()
+
+  const [name, setName] = useState(initial.name ?? '')
+  const [cwd, setCwd] = useState(initial.cwd ?? '')
+  const [tags, setTags] = useState<string[]>(() => [...(initial.tags ?? [])])
+  const [draft, setDraft] = useState('')
+  /**
+   * The machine the reader picked, or null for "nobody has picked one".
+   *
+   * Null rather than a seeded id, so `on` below stays a *derivation* of the
+   * list rather than a snapshot of it taken once. The list moves: a machine
+   * can drop while the form is open, and on the terminal screen the fleet's
+   * first delivery can land after the dialog has already rendered. A seeded
+   * value would leave the trigger blank and the form pointing at an id no
+   * option carries.
+   */
+  const [picked, setPicked] = useState<string | null>(null)
+  const wanted = picked ?? initial.machineId
+  const on = machines.find((m) => m.id === wanted)?.id ?? machines[0]?.id ?? ''
+
+  const nothingReachable = machines.length === 0
+
+  return (
+    <form
+      className="grid gap-4"
+      onSubmit={(event) => {
+        event.preventDefault()
+        if (nothingReachable) return
+        // The tag field is part of the answer: somebody who typed a tag and
+        // reached straight for Start is done, and throwing that keystroke away
+        // on the way out would be disagreeing with them in silence.
+        onSubmit({ machineId: on, cwd: cwd.trim(), name: name.trim(), tags: withTag(tags, draft) })
+      }}
+    >
+      <div className="grid gap-1.5">
+        <label htmlFor={nameId} className="text-sm font-medium text-zinc-950 dark:text-white">
+          Name
+        </label>
+        <Input
+          id={nameId}
+          ref={field}
+          value={name}
+          autoComplete="off"
+          placeholder="Leave empty to use the title the program announces"
+          onChange={(event) => setName(event.target.value)}
+        />
+      </div>
+
+      <div className="grid gap-1.5">
+        <label htmlFor={cwdId} className="text-sm font-medium text-zinc-950 dark:text-white">
+          Directory
+        </label>
+        <Input
+          id={cwdId}
+          value={cwd}
+          autoComplete="off"
+          spellCheck={false}
+          placeholder="Leave empty for the daemon's own default"
+          onChange={(event) => setCwd(event.target.value)}
+          className="font-mono"
+        />
+      </div>
+
+      {machines.length > 1 && (
+        <div className="grid gap-1.5">
+          <label htmlFor={machineId} className="text-sm font-medium text-zinc-950 dark:text-white">
+            Machine
+          </label>
+          <Select value={on} onValueChange={setPicked}>
+            <SelectTrigger id={machineId} aria-label="Machine" className="w-full">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              {machines.map((m) => (
+                <SelectItem key={m.id} value={m.id}>
+                  {m.name || m.id}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+      )}
+
+      <TagField
+        tags={tags}
+        onTags={setTags}
+        draft={draft}
+        onDraft={setDraft}
+        known={known}
+        label="Tags"
+        empty="No tags yet."
+        // One field among four, so the chips follow it. Leading, they read as
+        // a stray line belonging to the field above rather than as this one's
+        // answer.
+        chipsFirst={false}
+      />
+
+      {nothingReachable && (
+        // Said rather than hidden. The dialog opens from a button that was
+        // pressed, and a form that silently refused would leave the reader
+        // pressing Start at a fleet that is not there.
+        <p role="status" className="text-sm text-muted-foreground">
+          No machine is reachable, so nothing can be started right now.
+        </p>
+      )}
+
+      <DialogFooter>
+        <Button type="button" variant="outline" onClick={onCancel}>
+          Cancel
+        </Button>
+        <Button type="submit" disabled={nothingReachable}>
+          Start session
+        </Button>
+      </DialogFooter>
+    </form>
+  )
+}
diff --git a/web/src/components/session-table.test.tsx b/web/src/components/session-table.test.tsx
index 13cbb86..7790c5b 100644
--- a/web/src/components/session-table.test.tsx
+++ b/web/src/components/session-table.test.tsx
@@ -129,7 +129,11 @@ describe('SessionTable', () => {
       })
 
       const names = screen.getAllByRole('link').map((a) => a.getAttribute('aria-label'))
-      expect(names).toEqual(['Open zeta', 'Open alpha', 'Open mid'])
+      expect(names).toEqual([
+        'Open zeta in a new tab',
+        'Open alpha in a new tab',
+        'Open mid in a new tab',
+      ])
     })
 
     it('asks for a toggle rather than deciding one', async () => {
@@ -170,7 +174,7 @@ describe('SessionTable', () => {
       // 'name' as always on, whatever the columns preference says.
       await renderTable({ columns: ['state'] })
 
-      expect(screen.getByRole('link', { name: 'Open zsh' })).toBeTruthy()
+      expect(screen.getByRole('link', { name: 'Open zsh in a new tab' })).toBeTruthy()
       expect(screen.getByText('zsh')).toBeTruthy()
     })
 
@@ -364,25 +368,28 @@ describe('SessionTable', () => {
   })
 
   describe('opening', () => {
-    it('makes the whole row one link to its session', async () => {
-      const { router } = await renderTable()
+    it('makes the whole row one link to its session, in a tab of its own', async () => {
+      await renderTable()
 
-      const link = screen.getByRole('link', { name: 'Open zsh' })
+      const link = screen.getByRole('link', { name: 'Open zsh in a new tab' })
       // A real href on a real anchor: this is what a middle click, a copied
       // address and a Ctrl/Cmd click all read.
       expect(link.getAttribute('href')).toBe('/d/m1/s/a1')
-
-      await userEvent.click(link)
-      expect(router.state.location.pathname).toBe('/d/m1/s/a1')
+      expect(link.getAttribute('target')).toBe('_blank')
+      expect(link.getAttribute('rel')).toBe('noopener')
     })
 
-    it('leaves a modified click to the browser, which owns the new tab', async () => {
-      // Ctrl/Cmd and middle clicks mean "a new tab" and only the browser can
-      // honour that. The router must not swallow them — TanStack's Link
-      // stands aside for a modified click, so the location holds still here
-      // while a real browser would be opening the terminal beside this tab.
+    it('leaves the click to the browser, which owns the new tab', async () => {
+      // A target the router honours by standing aside — TanStack's Link hands
+      // any click with a target other than _self straight to the browser — so
+      // the location holds still here while a real browser opens the terminal
+      // beside this list. Ctrl, Cmd and middle clicks were already the
+      // browser's, and stay that way.
       const { router } = await renderTable()
-      const link = screen.getByRole('link', { name: 'Open zsh' })
+      const link = screen.getByRole('link', { name: 'Open zsh in a new tab' })
+
+      await userEvent.click(link)
+      expect(router.state.location.pathname).toBe('/sessions')
 
       fireEvent.click(link, { ctrlKey: true })
       expect(router.state.location.pathname).toBe('/sessions')
diff --git a/web/src/components/session-table.tsx b/web/src/components/session-table.tsx
index 60069b5..2ee872a 100644
--- a/web/src/components/session-table.tsx
+++ b/web/src/components/session-table.tsx
@@ -184,7 +184,17 @@ function SessionRow({
     <Link
       to={TERMINAL_PATH}
       params={{ deviceId: s.machineId, sessionId: s.id }}
-      aria-label={`Open ${name}`}
+      // A tab of its own, because a session is a tab: this list is the thing
+      // people come back to between sessions, and opening one over it meant
+      // the way back was the browser's back button — which drops the terminal
+      // and its scrollback with it. The router hands the click straight to the
+      // browser once a target is set, so this is a real new tab and not a
+      // navigation dressed up as one.
+      target="_blank"
+      rel="noopener"
+      // Said out loud rather than left to the target attribute, which screen
+      // readers announce inconsistently and some not at all.
+      aria-label={`Open ${name} in a new tab`}
       className="flex min-w-0 flex-1 items-baseline gap-x-2 outline-none after:absolute after:inset-0 after:rounded-md focus-visible:after:outline-2 focus-visible:after:-outline-offset-1 focus-visible:after:outline-ring"
     >
       <span className="truncate text-base/6 font-medium text-zinc-950 sm:text-control dark:text-white">
diff --git a/web/src/components/tag-editor.tsx b/web/src/components/tag-editor.tsx
index 5dfd351..bea03ba 100644
--- a/web/src/components/tag-editor.tsx
+++ b/web/src/components/tag-editor.tsx
@@ -1,7 +1,6 @@
-import { useId, useRef, useState, type RefObject } from 'react'
-import { PlusIcon, XMarkIcon } from '@heroicons/react/16/solid'
+import { useRef, useState, type RefObject } from 'react'
 
-import { Badge } from '@/components/ui/badge'
+import { TagField, withTag } from '@/components/tag-field'
 import { Button } from '@/components/ui/button'
 import {
   Dialog,
@@ -11,7 +10,6 @@ import {
   DialogHeader,
   DialogTitle,
 } from '@/components/ui/dialog'
-import { Input } from '@/components/ui/input'
 
 export interface TagEditorProps {
   open: boolean
@@ -86,25 +84,6 @@ export function TagEditor({ open, current, known, onSubmit, onClose }: TagEditor
   )
 }
 
-/**
- * The set with one more tag in it: trimmed, and unchanged if the tag is blank
- * or already there.
- *
- * Three routes reach this rule and it cannot hold for two of them — a typed
- * Enter, a clicked suggestion, and Save over a field the reader never pressed
- * Enter on. That third one is the reason this is a function rather than four
- * lines inside the first handler that needed them.
- *
- * The comparison is exact rather than case-folded: `API` and `api` are two
- * strings until the daemon says otherwise, and folding them here would drop a
- * tag the reader had just watched themselves type.
- */
-function withTag(held: string[], tag: string): string[] {
-  const clean = tag.trim()
-  if (clean === '' || held.includes(clean)) return held
-  return [...held, clean]
-}
-
 /**
  * The chips, the field, the suggestions, and the two buttons.
  *
@@ -117,7 +96,8 @@ function withTag(held: string[], tag: string): string[] {
  * State seeded once from `current` and never resynced: the content this sits
  * in is unmounted on close, so the seeding happens exactly when the dialog
  * opens and a set abandoned on one session cannot follow the reader to the
- * next.
+ * next. The draft is held here rather than inside the field for the reason
+ * Save's own comment gives — it is part of the answer.
  */
 function TagForm({
   field,
@@ -132,100 +112,19 @@ function TagForm({
   onSubmit(tags: string[]): void
   onCancel(): void
 }) {
-  const fieldId = useId()
-  const suggestionsId = useId()
   const [tags, setTags] = useState<string[]>(() => [...current])
   const [draft, setDraft] = useState('')
 
-  /** A typed Enter and a clicked suggestion, both of which empty the field. */
-  const add = (tag: string) => {
-    setDraft('')
-    setTags((held) => withTag(held, tag))
-  }
-
-  // What the fleet knows, minus what this session already carries, narrowed by
-  // what has been typed so far. A prefix rather than a substring: a reader
-  // typing `de` is reaching for a tag they can already half-remember, and
-  // matching the middle of words would answer with tags they were not naming.
-  const needle = draft.trim().toLowerCase()
-  const offered = known.filter(
-    (tag) => !tags.includes(tag) && tag.toLowerCase().startsWith(needle),
-  )
-
   return (
     <div className="grid gap-4">
-      <div className="flex flex-wrap items-center gap-1.5">
-        {tags.length === 0 ? (
-          <p className="text-sm text-muted-foreground">No tags yet.</p>
-        ) : (
-          tags.map((tag) => (
-            /*
-              The chip is the remove control, which is why its accessible name
-              says so: the word on screen is the tag, and a reader hearing
-              only "api, button" would have no idea that pressing it takes the
-              tag away. The X, and the destructive tint under the pointer, say
-              the same thing to the eye.
-            */
-            <Badge key={tag} asChild variant="secondary">
-              <button
-                type="button"
-                aria-label={`Remove ${tag}`}
-                onClick={() => setTags((held) => held.filter((other) => other !== tag))}
-                className="cursor-pointer hover:bg-destructive/10 hover:text-destructive dark:hover:bg-destructive/20"
-              >
-                {tag}
-                <XMarkIcon data-icon="inline-end" aria-hidden="true" />
-              </button>
-            </Badge>
-          ))
-        )}
-      </div>
-
-      <div className="grid gap-1.5">
-        <label htmlFor={fieldId} className="text-sm font-medium text-zinc-950 dark:text-white">
-          Add tag
-        </label>
-        <Input
-          id={fieldId}
-          ref={field}
-          value={draft}
-          autoComplete="off"
-          placeholder="Type a tag, then press Enter"
-          onChange={(event) => setDraft(event.target.value)}
-          onKeyDown={(event) => {
-            if (event.key !== 'Enter') return
-            // Nothing above would submit on Enter today, but this field will
-            // one day sit inside something that does.
-            event.preventDefault()
-            add(draft)
-          }}
-        />
-      </div>
-
-      {offered.length > 0 && (
-        <div role="group" aria-labelledby={suggestionsId} className="grid gap-1.5">
-          <p id={suggestionsId} className="text-xs text-muted-foreground">
-            Suggestions
-          </p>
-          {/* Capped in height and scrolled: a fleet with forty tags in it
-              must not push Save off the bottom of the screen. */}
-          <div className="flex max-h-24 flex-wrap gap-1.5 overflow-y-auto">
-            {offered.map((tag) => (
-              <Button
-                key={tag}
-                type="button"
-                variant="outline"
-                size="xs"
-                aria-label={`Add ${tag}`}
-                onClick={() => add(tag)}
-              >
-                <PlusIcon data-icon="inline-start" aria-hidden="true" />
-                {tag}
-              </Button>
-            ))}
-          </div>
-        </div>
-      )}
+      <TagField
+        field={field}
+        tags={tags}
+        onTags={setTags}
+        draft={draft}
+        onDraft={setDraft}
+        known={known}
+      />
 
       <DialogFooter>
         <Button type="button" variant="outline" onClick={onCancel}>
diff --git a/web/src/components/tag-field.tsx b/web/src/components/tag-field.tsx
new file mode 100644
index 0000000..c149d41
--- /dev/null
+++ b/web/src/components/tag-field.tsx
@@ -0,0 +1,189 @@
+import { useId, type RefObject } from 'react'
+import { PlusIcon, XMarkIcon } from '@heroicons/react/16/solid'
+
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+
+/**
+ * The set with one more tag in it: trimmed, and unchanged if the tag is blank
+ * or already there.
+ *
+ * Three routes reach this rule and it cannot hold for two of them — a typed
+ * Enter, a clicked suggestion, and a Save over a field the reader never
+ * pressed Enter on. That third one is the reason this is a function rather
+ * than four lines inside the first handler that needed them, and the reason it
+ * is exported: every caller of TagField owes its reader the same courtesy of
+ * counting a half-typed tag as part of the answer.
+ *
+ * The comparison is exact rather than case-folded: `API` and `api` are two
+ * strings until the daemon says otherwise, and folding them here would drop a
+ * tag the reader had just watched themselves type.
+ */
+export function withTag(held: string[], tag: string): string[] {
+  const clean = tag.trim()
+  if (clean === '' || held.includes(clean)) return held
+  return [...held, clean]
+}
+
+export interface TagFieldProps {
+  /** The tags chosen so far. */
+  tags: string[]
+  onTags(tags: string[]): void
+  /** What is half-typed in the field. Owned above, because Save must see it. */
+  draft: string
+  onDraft(draft: string): void
+  /** Every tag in use across the fleet, offered as one-click additions. */
+  known: string[]
+  /** The field itself, for a dialog that opens focus on it. */
+  field?: RefObject<HTMLInputElement | null>
+  /** What the field is called. The surrounding form owns the wording. */
+  label?: string
+  /** What an empty set says. */
+  empty?: string
+  /**
+   * Whether the chips lead or follow the field.
+   *
+   * Leading is right for a dialog whose whole subject is tags: the title says
+   * what the screen is, and what is already there should be the first thing
+   * under it. Following is right for one field among several, where a row of
+   * chips above the label reads as a stray sentence belonging to the field
+   * before it — which is exactly how "No tags yet." landed between a
+   * directory and a heading called Tags.
+   */
+  chipsFirst?: boolean
+}
+
+/**
+ * Tag chips, a field to add to them, and the fleet's own tags as buttons.
+ *
+ * The suggestions are the reason it exists. Tags are free text, and free text
+ * drifts — `api`, `apis`, `api-server` — until grouping by tag produces three
+ * headings for one idea. So every tag in use across the fleet is offered as a
+ * button, and reusing one costs a single click while inventing one costs a
+ * sentence of typing. The order of the two is the whole argument.
+ *
+ * What happens to a typed tag here is politeness, not validation: blanks are
+ * dropped, a repeat is a no-op, surrounding space is cut. The daemon settles
+ * all of it again on arrival — it trims, dedupes and sorts — so none of this
+ * is the last word. It only keeps the chips in front of the reader honest
+ * between the keystroke and the next snapshot.
+ *
+ * Fully controlled, draft included, and that second half is not tidiness: the
+ * forms above this decide what a Save does with a field nobody pressed Enter
+ * on, and a draft held privately here would be a keystroke they could not
+ * reach. Enter adds a tag and is stopped here, so a field sitting inside a
+ * real form cannot submit it by accident — a set the reader was still
+ * assembling is not an answer.
+ */
+export function TagField({
+  tags,
+  onTags,
+  draft,
+  onDraft,
+  known,
+  field,
+  label = 'Add tag',
+  empty = 'No tags yet.',
+  chipsFirst = true,
+}: TagFieldProps) {
+  const fieldId = useId()
+  const suggestionsId = useId()
+
+  /** A typed Enter and a clicked suggestion, both of which empty the field. */
+  const add = (tag: string) => {
+    onDraft('')
+    onTags(withTag(tags, tag))
+  }
+
+  // What the fleet knows, minus what is already chosen, narrowed by what has
+  // been typed so far. A prefix rather than a substring: a reader typing `de`
+  // is reaching for a tag they can already half-remember, and matching the
+  // middle of words would answer with tags they were not naming.
+  const needle = draft.trim().toLowerCase()
+  const offered = known.filter((tag) => !tags.includes(tag) && tag.toLowerCase().startsWith(needle))
+
+  const chips = (
+    <div className="flex flex-wrap items-center gap-1.5">
+      {tags.length === 0 ? (
+        <p className="text-sm text-muted-foreground">{empty}</p>
+      ) : (
+        tags.map((tag) => (
+          /*
+            The chip is the remove control, which is why its accessible name
+            says so: the word on screen is the tag, and a reader hearing only
+            "api, button" would have no idea that pressing it takes the tag
+            away. The X, and the destructive tint under the pointer, say the
+            same thing to the eye.
+          */
+          <Badge key={tag} asChild variant="secondary">
+            <button
+              type="button"
+              aria-label={`Remove ${tag}`}
+              onClick={() => onTags(tags.filter((other) => other !== tag))}
+              className="cursor-pointer hover:bg-destructive/10 hover:text-destructive dark:hover:bg-destructive/20"
+            >
+              {tag}
+              <XMarkIcon data-icon="inline-end" aria-hidden="true" />
+            </button>
+          </Badge>
+        ))
+      )}
+    </div>
+  )
+
+  return (
+    <div className="grid gap-4">
+      {chipsFirst && chips}
+
+      <div className="grid gap-1.5">
+        <label htmlFor={fieldId} className="text-sm font-medium text-zinc-950 dark:text-white">
+          {label}
+        </label>
+        <Input
+          id={fieldId}
+          ref={field}
+          value={draft}
+          autoComplete="off"
+          placeholder="Type a tag, then press Enter"
+          onChange={(event) => onDraft(event.target.value)}
+          onKeyDown={(event) => {
+            if (event.key !== 'Enter') return
+            // Stopped whether or not it adds anything. This field sits inside a
+            // real form in the new-session dialog, and an Enter left to bubble
+            // would submit that form — starting a session on the keystroke that
+            // was meant to finish a tag.
+            event.preventDefault()
+            add(draft)
+          }}
+        />
+        {!chipsFirst && chips}
+      </div>
+
+      {offered.length > 0 && (
+        <div role="group" aria-labelledby={suggestionsId} className="grid gap-1.5">
+          <p id={suggestionsId} className="text-xs text-muted-foreground">
+            Suggestions
+          </p>
+          {/* Capped in height and scrolled: a fleet with forty tags in it must
+              not push the buttons off the bottom of the screen. */}
+          <div className="flex max-h-24 flex-wrap gap-1.5 overflow-y-auto">
+            {offered.map((tag) => (
+              <Button
+                key={tag}
+                type="button"
+                variant="outline"
+                size="xs"
+                aria-label={`Add ${tag}`}
+                onClick={() => add(tag)}
+              >
+                <PlusIcon data-icon="inline-start" aria-hidden="true" />
+                {tag}
+              </Button>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/web/src/components/terminal.test.tsx b/web/src/components/terminal.test.tsx
index a13ea7a..3f8e01a 100644
--- a/web/src/components/terminal.test.tsx
+++ b/web/src/components/terminal.test.tsx
@@ -1,5 +1,6 @@
 import { StrictMode, type ReactNode } from 'react'
 import { act, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { FlueClientProvider } from '@/client/provider'
@@ -1658,9 +1659,16 @@ describe('the terminal theme', () => {
   })
 })
 
-describe('the new-session link', () => {
-  it('carries the session’s directory and opens a new tab', () => {
-    const { sock } = mountTerminal((em) => <Terminal sessionId="s1" createEmulator={em.create} />)
+describe('the new-session control', () => {
+  it('hands this session’s directory up, for whoever owns the form', async () => {
+    // It used to be a link to `/?cwd=`, which is the dashboard — so a session
+    // started from a terminal came up behind the whole list. The chip asks
+    // above it now, and the directory is the one thing only this component
+    // knows: the list is where a session's cwd arrives.
+    const onNewSession = vi.fn()
+    const { sock } = mountTerminal((em) => (
+      <Terminal sessionId="s1" createEmulator={em.create} onNewSession={onNewSession} />
+    ))
 
     // Asked for on mount: the list is where the cwd comes from.
     expect(sock.ofType('list')).toHaveLength(1)
@@ -1669,8 +1677,22 @@ describe('the new-session link', () => {
       sock.emitControl({ type: 'sessions', sessions: [session({ cwd: '/tmp/with space' })] }),
     )
 
-    const link = screen.getByRole('link', { name: 'New session in this directory' })
-    expect(link.getAttribute('href')).toBe(`/?cwd=${encodeURIComponent('/tmp/with space')}`)
-    expect(link.getAttribute('target')).toBe('_blank')
+    await userEvent.click(screen.getByRole('button', { name: 'New session in this directory' }))
+
+    expect(onNewSession).toHaveBeenCalledWith('/tmp/with space')
+  })
+
+  it('says so rather than guessing when the list has not answered yet', async () => {
+    // Null, not ''. The form prefills its directory field from this, and an
+    // empty string there reads as "the reader cleared it" — which is a
+    // different instruction to the daemon than "nothing is known".
+    const onNewSession = vi.fn()
+    mountTerminal((em) => (
+      <Terminal sessionId="s1" createEmulator={em.create} onNewSession={onNewSession} />
+    ))
+
+    await userEvent.click(screen.getByRole('button', { name: 'New session in this directory' }))
+
+    expect(onNewSession).toHaveBeenCalledWith(null)
   })
 })
diff --git a/web/src/components/terminal.tsx b/web/src/components/terminal.tsx
index 73d52fb..de6af04 100644
--- a/web/src/components/terminal.tsx
+++ b/web/src/components/terminal.tsx
@@ -51,6 +51,16 @@ export interface TerminalProps {
   onRestarted?: (sessionId: string) => void
   /** Called after Close has closed the dead session; navigate away here. */
   onClosed?: () => void
+  /**
+   * Called by the `+` in the control strip, with this session's directory when
+   * the list has said what it is.
+   *
+   * The dialog it opens lives above this component, not in it, and that is the
+   * same bargain the rest of the file keeps: the form needs the fleet's
+   * machines and the fleet's tags, and a terminal that knew the fleet existed
+   * would be a terminal that could not be mounted without one.
+   */
+  onNewSession?: (cwd: string | null) => void
 }
 
 /** Named so the test and the markup cannot drift apart. */
@@ -124,6 +134,7 @@ export function Terminal({
   createEmulator = createXtermEmulator,
   onRestarted,
   onClosed,
+  onNewSession,
 }: TerminalProps) {
   const client = useFlueClient()
   const switcher = useSwitcher()
@@ -883,15 +894,11 @@ export function Terminal({
           <ArrowLeftRightIcon aria-hidden="true" className="size-4" />
           <span className="sr-only">Switch session</span>
         </button>
-        {/*
-          A real link, so a middle or cmd click behaves browser-natively. It
-          opens in a new tab by default so this session stays put; the root
-          route spawns into ?cwd= on mount and navigates itself.
-        */}
         {/*
           The way back to the rest of flue — sessions, devices, remote — in
-          the same chip the strip's other controls wear. A new tab, like the
-          + beside it: this tab is a session and stays one.
+          the same chip the strip's other controls wear. A real link, so a
+          middle or cmd click behaves browser-natively, and a new tab by
+          default: this tab is a session and stays one.
         */}
         <a
           href="/"
@@ -907,13 +914,21 @@ export function Terminal({
           <LayoutGridIcon aria-hidden="true" className="size-4" />
           <span className="sr-only">Open the flue dashboard</span>
         </a>
-        <a
-          href={cwd ? `/?cwd=${encodeURIComponent(cwd)}` : '/'}
-          target="_blank"
-          rel="noopener"
+        {/*
+          A button, and it used to be a link to `/?cwd=` — which is the
+          dashboard, so a session started from here came up behind the whole
+          list for as long as the daemon took to answer. It asks first now:
+          the dialog above this component collects a name and tags while there
+          is still a form to collect them on, and the page it opens starts the
+          session on its own ground.
+
+          The same box as the theme trigger — an icon in px-2.5 py-1.5 — so the
+          cluster reads as one control strip, not two heights.
+        */}
+        <button
+          type="button"
+          onClick={() => onNewSession?.(cwd)}
           title="New session here"
-          // The same box as the theme trigger — an icon in px-2.5 py-1.5 —
-          // so the cluster reads as one control strip, not two heights.
           className={cn(
             'rounded-lg px-2.5 py-1.5',
             'bg-(--chip-bg) text-(--chip-dim) shadow-lg ring-1 ring-(--chip-ring) backdrop-blur-sm',
@@ -922,7 +937,7 @@ export function Terminal({
         >
           <PlusIcon aria-hidden="true" className="size-4" />
           <span className="sr-only">New session in this directory</span>
-        </a>
+        </button>
         {phase !== 'live' && (
           // Dark in both themes, like the pane it floats over usually is; the
           // translucent ground and backdrop-blur keep it legible over whatever
diff --git a/web/src/emulator/emulator.test.ts b/web/src/emulator/emulator.test.ts
index 2909a19..02a1c98 100644
--- a/web/src/emulator/emulator.test.ts
+++ b/web/src/emulator/emulator.test.ts
@@ -3,7 +3,14 @@ import { dirname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { Terminal } from '@xterm/xterm'
 import { describe, expect, it, vi } from 'vitest'
-import { createXtermEmulator, extractGrid, loadWebglRenderer, openTerminalLink, TERMINAL_FONT_FAMILY } from './xterm'
+import {
+  createXtermEmulator,
+  extractGrid,
+  loadWebglRenderer,
+  NEWLINE_CHORD_BYTES,
+  openTerminalLink,
+  TERMINAL_FONT_FAMILY,
+} from './xterm'
 import type { Emulator } from './types'
 
 /**
@@ -259,6 +266,98 @@ describe('openTerminalLink', () => {
   })
 })
 
+describe('Shift+Enter', () => {
+  /**
+   * Mount an emulator and hand back what it sends and the element xterm
+   * listens for keys on.
+   *
+   * The helper textarea is where every real keystroke lands: xterm keeps the
+   * caret in it and reads keydown from it, so dispatching anywhere else would
+   * measure a listener nobody uses.
+   */
+  function mounted() {
+    const el = document.createElement('div')
+    document.body.appendChild(el)
+    const em = createXtermEmulator({ cols: 20, rows: 4 })
+    em.attachTo(el)
+    const out: string[] = []
+    em.onData((b) => out.push(new TextDecoder().decode(b)))
+    const textarea = el.querySelector('textarea')!
+    const press = (init: KeyboardEventInit) =>
+      textarea.dispatchEvent(
+        new KeyboardEvent('keydown', {
+          key: 'Enter',
+          keyCode: 13,
+          bubbles: true,
+          cancelable: true,
+          ...init,
+        }),
+      )
+    return {
+      press,
+      sent: () => out.join(''),
+      done: () => {
+        em.dispose()
+        el.remove()
+      },
+    }
+  }
+
+  it('sends ESC CR, so an agent CLI takes a newline instead of a submit', () => {
+    // The bug this exists for: xterm encodes Enter as a bare CR whatever
+    // Shift is doing, and Claude Code and Codex both read a bare CR as
+    // "send this message". A newline mid-prompt was unreachable in a browser.
+    const t = mounted()
+    t.press({ shiftKey: true })
+    expect(t.sent()).toBe(NEWLINE_CHORD_BYTES)
+    t.done()
+  })
+
+  it('leaves the browser out of it, so no line break lands in the helper', () => {
+    // xterm's caret lives in a real textarea. An Enter left to the browser
+    // puts a line break in that element's value, and xterm's own input
+    // listener then reads a value it never wrote.
+    const t = mounted()
+    const event = new KeyboardEvent('keydown', {
+      key: 'Enter',
+      keyCode: 13,
+      shiftKey: true,
+      bubbles: true,
+      cancelable: true,
+    })
+    document.querySelector('textarea')!.dispatchEvent(event)
+    expect(event.defaultPrevented).toBe(true)
+    t.done()
+  })
+
+  it('leaves a plain Enter as the carriage return every shell expects', () => {
+    const t = mounted()
+    t.press({})
+    expect(t.sent()).toBe('\r')
+    t.done()
+  })
+
+  it('keeps its hands off the focus-mode chord', () => {
+    // Ctrl+Shift+Enter belongs to the terminal view, which takes it on the
+    // way down (components/terminal.tsx). Claiming it here as a newline would
+    // mean the two agree only by accident of listener order.
+    const t = mounted()
+    t.press({ shiftKey: true, ctrlKey: true })
+    expect(t.sent()).not.toBe(NEWLINE_CHORD_BYTES)
+    t.done()
+  })
+
+  it('sends the same bytes for Alt+Enter, which is xterm doing it', () => {
+    // Not a claim about this handler — a check that the sequence chosen is
+    // the one xterm already emits for the other chord that means "newline",
+    // so both spellings arrive at the CLI as one thing.
+    const t = mounted()
+    t.press({ altKey: true })
+    expect(t.sent()).toBe(NEWLINE_CHORD_BYTES)
+    t.done()
+  })
+})
+
 describe('device-query suppression', () => {
   const bytes = (s: string) => new TextEncoder().encode(s)
 
diff --git a/web/src/emulator/xterm.ts b/web/src/emulator/xterm.ts
index 8ccb51c..fe45c64 100644
--- a/web/src/emulator/xterm.ts
+++ b/web/src/emulator/xterm.ts
@@ -27,6 +27,23 @@ const SCREEN_SELECTOR = '.xterm-screen'
 export const TERMINAL_FONT_FAMILY =
   "ui-monospace, 'SFMono-Regular', 'SF Mono', Menlo, Consolas, monospace"
 
+/**
+ * What a "newline, do not send yet" chord puts on the wire: ESC then CR.
+ *
+ * There is no such thing at the VT level. Enter is a carriage return and
+ * Shift does not change that — xterm.js is faithful to the hardware and
+ * encodes both the same way, which is why Shift+Enter in a browser terminal
+ * submits an agent's prompt rather than adding a line to it.
+ *
+ * ESC CR is the sequence the CLIs themselves settled on. A line editor reads
+ * it as Alt+Enter, `claude /terminal-setup` writes exactly these two bytes
+ * into VS Code's keybindings.json for `shift+enter`, and iTerm2, Ghostty,
+ * WezTerm, Kitty, Warp and Windows Terminal send it out of the box — which is
+ * what "Shift+Enter is natively supported" means in those tools. So this is
+ * flue matching a convention, not inventing one.
+ */
+export const NEWLINE_CHORD_BYTES = '\x1b\r'
+
 /**
  * xterm.js behind the Emulator seam.
  *
@@ -64,6 +81,32 @@ export function createXtermEmulator(opts: XtermOptions = {}): Emulator {
   // through the same guard so there is exactly one place that opens links.
   term.loadAddon(new WebLinksAddon((_event, uri) => openTerminalLink(uri)))
 
+  /*
+   * Shift+Enter, which xterm has no notion of.
+   *
+   * Here rather than in the terminal view, and that is the whole argument for
+   * this seam: the view's own keydown handler has no way to put bytes on the
+   * wire without reaching past it. `term.input` sends them through onData, so
+   * the key bar's latched Ctrl and the replay mute gate both still apply, and
+   * the daemon counts the keystroke as activity exactly as it would any other.
+   *
+   * keydown alone — keyup and keypress arrive for the same press, and either
+   * would send the sequence a second time. Ctrl, Alt and Cmd are all excluded:
+   * Ctrl+Shift+Enter is the view's focus-mode chord, and Alt+Enter already
+   * produces these bytes through xterm's own encoder.
+   */
+  term.attachCustomKeyEventHandler((e) => {
+    if (e.type !== 'keydown') return true
+    if (e.key !== 'Enter' || !e.shiftKey || e.ctrlKey || e.altKey || e.metaKey) return true
+    // xterm keeps the caret in a real textarea, and refusing the event is not
+    // the same as cancelling it: left to the browser, this Enter writes a line
+    // into that element and xterm's input listener then reads a value nothing
+    // typed. xterm's own cancel never runs, because `false` returns above it.
+    e.preventDefault()
+    term.input(NEWLINE_CHORD_BYTES, true)
+    return false
+  })
+
   const encoder = new TextEncoder()
   let disposed = false
 
diff --git a/web/src/router.test.tsx b/web/src/router.test.tsx
index e9a1833..defff74 100644
--- a/web/src/router.test.tsx
+++ b/web/src/router.test.tsx
@@ -1,12 +1,33 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { act, render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
 import { RouterProvider } from '@tanstack/react-router'
+import type { SessionInfo } from './client/protocol'
 import { FlueClientProvider } from './client/provider'
 import { FleetClient } from './fleet/fleet'
 import { FleetProvider } from './fleet/provider'
 import { fakeClient } from './testing/socket'
 import { createFlueRouter, TERMINAL_ROUTE_ID } from './router'
 
+/** One session row, with everything a case did not care about filled in. */
+function session(over: Partial<SessionInfo> & { id: string }): SessionInfo {
+  return {
+    title: 'zsh',
+    name: '',
+    tags: [],
+    pinned: false,
+    cwd: '/Users/karn/code/flue',
+    cmd: ['zsh', '-l'],
+    state: 'running',
+    exitCode: 0,
+    cols: 80,
+    rows: 24,
+    createdAt: '2026-07-28T09:00:00Z',
+    lastActive: '2026-07-28T10:00:00Z',
+    ...over,
+  }
+}
+
 function routeIds(path: string): string[] {
   return createFlueRouter()
     .matchRoutes(path, {})
@@ -257,15 +278,14 @@ describe('createFlueRouter', () => {
     expect(screen.queryByRole('navigation')).toBeNull()
     expect(screen.queryByRole('main')).toBeNull()
     expect(document.querySelector('[data-slot="sidebar"]')).toBeNull()
-    // The only links are the terminal's own control strip — the way back to
-    // the dashboard and the new-session control, both part of the terminal,
-    // not chrome around it. Anything beyond these two is chrome creeping
-    // back in.
+    // The only link is the terminal's own way back to the dashboard: part of
+    // the terminal, not chrome around it. Anything beyond it is chrome
+    // creeping back in. The new-session control beside it is a button, not a
+    // link, because it asks for a name and tags before anything is started.
     const links = screen.queryAllByRole('link')
-    expect(links).toHaveLength(2)
-    const texts = links.map((l) => l.textContent ?? '')
-    expect(texts.some((t) => t.includes('dashboard'))).toBe(true)
-    expect(texts.some((t) => t.includes('New session'))).toBe(true)
+    expect(links).toHaveLength(1)
+    expect(links[0]!.textContent ?? '').toContain('dashboard')
+    expect(screen.getByRole('button', { name: 'New session in this directory' })).toBeTruthy()
   })
 
   it('hands the session id from the path to the terminal', async () => {
@@ -363,6 +383,48 @@ describe('createFlueRouter', () => {
     expect(local.sockets[0]!.ofType('attach')).toEqual([])
   })
 
+  it('starts a session from inside a terminal without going via the dashboard', async () => {
+    // The `+` in the control strip used to be a link to `/?cwd=`, which is the
+    // sessions dashboard — so a session started from a terminal came up behind
+    // the whole list. It asks first now, and the address it opens is the
+    // new-session page, which renders one pill on the terminal's own ground.
+    //
+    // At the router level rather than in the component, because the pieces
+    // that have to agree live in three files: the chip reports the directory,
+    // the route hosts the form and the fleet fills it, and the builder writes
+    // the address.
+    const open = vi.fn().mockReturnValue({})
+    vi.stubGlobal('open', open)
+    const user = userEvent.setup()
+    const { local, attic } = await renderFleet('/d/local/s/abc123')
+    act(() => local.sockets[0]!.open())
+    act(() => attic.sockets[0]!.open())
+    act(() =>
+      local.sockets[0]!.emitControl({
+        type: 'sessions',
+        sessions: [session({ id: 'abc123', cwd: '/srv/app', tags: ['api'] })],
+      }),
+    )
+
+    await user.click(screen.getByRole('button', { name: 'New session in this directory' }))
+
+    // This session's machine and this session's directory, because that is
+    // what a `+` inside a session means.
+    expect(screen.getByLabelText('Directory')).toHaveProperty('value', '/srv/app')
+    // And the fleet behind it: the other machine is on offer, and the tag this
+    // fleet already uses is a click rather than a sentence of typing.
+    expect(screen.getByRole('combobox', { name: 'Machine' })).toBeTruthy()
+    await user.click(screen.getByRole('button', { name: 'Add api' }))
+    await user.click(screen.getByRole('button', { name: 'Start session' }))
+
+    const url = new URL(open.mock.calls[0]![0] as string, 'http://localhost')
+    expect(url.pathname).toBe('/new')
+    expect(url.searchParams.get('d')).toBe('local')
+    expect(url.searchParams.get('cwd')).toBe('/srv/app')
+    expect(JSON.parse(url.searchParams.get('tags')!)).toEqual(['api'])
+    expect(open.mock.calls[0]![1]).toBe('_blank')
+  })
+
   it('mounts the terminal the moment the fleet adopts the machine', async () => {
     // F5 on a remote machine's terminal is the bookmark case: at first render
     // the fleet holds only the local source — remote sources are built only
diff --git a/web/src/router.tsx b/web/src/router.tsx
index 9b62e0c..cfac6f2 100644
--- a/web/src/router.tsx
+++ b/web/src/router.tsx
@@ -10,11 +10,13 @@ import { FleetProvider } from '@/fleet/provider'
 import { AppShell } from '@/components/app-shell'
 import { DevicesRoute } from '@/routes/devices'
 import { MachinesRoute } from '@/routes/machines'
+import { NewSessionRoute } from '@/routes/new-session'
 import { PairRoute } from '@/routes/pair'
 import { RemoteRoute } from '@/routes/remote'
 import { SessionsRoute } from '@/routes/sessions'
 import { SettingsRoute } from '@/routes/settings'
 import { TerminalRoute } from '@/routes/terminal'
+import { NEW_SESSION_PATH, validateNewSessionSearch } from '@/sessions/new-session'
 import { SwitcherProvider } from '@/switcher/provider'
 
 /** The pairing page's path. Its own constant because two routing decisions
@@ -202,6 +204,22 @@ const terminalRoute = createRoute({
   component: TerminalRoute,
 })
 
+/**
+ * The page that starts a session, beside the terminal and outside the shell on
+ * purpose: it is the terminal a moment before there is one, it replaces itself
+ * with that terminal, and app chrome around it would be a dashboard flashing
+ * past on the way — which is the exact complaint it was built to answer.
+ *
+ * The schema is `validateNewSessionSearch`'s, so the narrowing lives beside
+ * the builder that writes these links and the two cannot drift.
+ */
+const newSessionRoute = createRoute({
+  getParentRoute: () => rootRoute,
+  path: NEW_SESSION_PATH,
+  validateSearch: validateNewSessionSearch,
+  component: NewSessionRoute,
+})
+
 /**
  * The machine picker's own address, beside the terminal and outside the shell:
  * it is the relay door, and a door with a sidebar of links to one machine's
@@ -262,6 +280,7 @@ const pairRoute = createRoute({
 const routeTree = rootRoute.addChildren([
   shellRoute.addChildren([indexRoute, sessionsRoute, devicesRoute, remoteRoute, settingsRoute]),
   terminalRoute,
+  newSessionRoute,
   machinesRoute,
   pairRoute,
 ])
diff --git a/web/src/routes/new-session.test.tsx b/web/src/routes/new-session.test.tsx
new file mode 100644
index 0000000..6393217
--- /dev/null
+++ b/web/src/routes/new-session.test.tsx
@@ -0,0 +1,221 @@
+import { act, render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import {
+  createMemoryHistory,
+  createRootRoute,
+  createRoute,
+  createRouter,
+  Outlet,
+  RouterProvider,
+} from '@tanstack/react-router'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { FleetClient } from '@/fleet/fleet'
+import { FleetProvider } from '@/fleet/provider'
+import { attached, fakeClient } from '@/testing/socket'
+import { validateNewSessionSearch } from '@/sessions/new-session'
+import { NewSessionRoute } from './new-session'
+
+/**
+ * Mount the page at an address, over a scripted fleet of two machines.
+ *
+ * The address is the whole input to this route — it takes no props — so every
+ * case here is written as a URL, which is also exactly how the dialog reaches
+ * it in the app.
+ *
+ * The socket opens after the first render, because that is what a cold tab is:
+ * this page is reached by window.open, so its client starts connecting at the
+ * moment it mounts and the spawn cannot go out until the socket is up.
+ *
+ * `from` is the other arrival: a tab that is already connected and navigates
+ * here, which is what a blocked popup falls back to. The page then mounts into
+ * an open socket and spawns from its effect body rather than from a status
+ * change — a different code path, and the one the double-mount guard is for.
+ */
+async function mountNew(
+  url: string,
+  { open = true, from }: { open?: boolean; from?: string } = {},
+) {
+  const local = fakeClient()
+  const attic = fakeClient()
+  const fleet = new FleetClient([
+    { id: 'local', name: '', client: local.client, pinned: false },
+    { id: 'attic-pi', name: 'Attic Pi', client: attic.client, pinned: false },
+  ])
+
+  const rootRoute = createRootRoute({ component: () => <Outlet /> })
+  const routeTree = rootRoute.addChildren([
+    createRoute({
+      getParentRoute: () => rootRoute,
+      path: '/new',
+      validateSearch: validateNewSessionSearch,
+      component: NewSessionRoute,
+    }),
+    ...['/', '/d/$deviceId/s/$sessionId'].map((path) =>
+      createRoute({ getParentRoute: () => rootRoute, path, component: () => null }),
+    ),
+  ])
+  const router = createRouter({
+    routeTree,
+    history: createMemoryHistory({ initialEntries: [from ?? url] }),
+  })
+  await router.load()
+
+  let view!: ReturnType<typeof render>
+  await act(async () => {
+    view = render(
+      <FleetProvider fleet={fleet}>
+        <RouterProvider router={router as never} />
+      </FleetProvider>,
+    )
+  })
+  const sock = local.sockets[0]!
+  if (open) act(() => sock.open())
+  if (from !== undefined) await act(async () => void (await router.navigate({ to: url })))
+
+  return { ...view, router, sock, attic, local }
+}
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('NewSessionRoute', () => {
+  it('spawns on the ridden machine and replaces itself with the terminal', async () => {
+    const { sock, router } = await mountNew('/new')
+
+    expect(sock.ofType('spawn')).toEqual([{ type: 'spawn', cols: 80, rows: 24, reqId: 1 }])
+
+    await act(async () => sock.emitControl(attached({ ref: 3, id: 'fresh1', reqId: 1 })))
+
+    // The daemon attaches whoever spawns, and this page renders no terminal —
+    // the route it hands over to attaches on its own, so keeping the ref would
+    // leave one tab holding two attachments to one session.
+    expect(sock.ofType('detach')).toEqual([{ type: 'detach', ref: 3 }])
+    await waitFor(() => expect(router.state.location.pathname).toBe('/d/local/s/fresh1'))
+  })
+
+  it('leaves nothing behind the back button', async () => {
+    // A `replace`, so going back leaves rather than landing on this page again
+    // — which would start a second session for one press.
+    const { sock, router } = await mountNew('/new')
+    await act(async () => sock.emitControl(attached({ ref: 1, id: 'fresh1', reqId: 1 })))
+    await waitFor(() => expect(router.state.location.pathname).toBe('/d/local/s/fresh1'))
+
+    await act(async () => void router.history.back())
+
+    expect(router.state.location.pathname).not.toBe('/new')
+  })
+
+  it('starts in the directory the address named', async () => {
+    const { sock } = await mountNew('/new?cwd=%2FUsers%2Fkarn%2Fproj')
+
+    expect(sock.ofType('spawn')).toEqual([
+      { type: 'spawn', cwd: '/Users/karn/proj', cols: 80, rows: 24, reqId: 1 },
+    ])
+  })
+
+  it('starts on the machine the address named', async () => {
+    const { sock, attic } = await mountNew('/new?d=attic-pi')
+    act(() => attic.sockets[0]!.open())
+
+    expect(sock.ofType('spawn')).toEqual([])
+    expect(attic.sockets[0]!.ofType('spawn')).toHaveLength(1)
+  })
+
+  it('applies the name and tags the moment there is an id to apply them to', async () => {
+    // The whole reason this page exists rather than a click handler: `spawn`
+    // carries no metadata at all, so the earliest moment either can be sent is
+    // the `attached` that answers it.
+    const { sock } = await mountNew('/new?name=deploy&tags=%5B%22api%22%2C%22ops%22%5D')
+
+    expect(sock.ofType('update')).toEqual([])
+
+    await act(async () => sock.emitControl(attached({ ref: 1, id: 'fresh1', reqId: 1 })))
+
+    expect(sock.ofType('update')).toEqual([
+      { type: 'update', id: 'fresh1', name: 'deploy', tags: ['api', 'ops'] },
+    ])
+  })
+
+  it('says nothing about metadata nobody asked for', async () => {
+    // `name: ''` and `tags: []` are two deliberate clears on the wire. Sending
+    // them for a session that was never given either would be this page making
+    // an edit on the reader's behalf.
+    const { sock } = await mountNew('/new')
+
+    await act(async () => sock.emitControl(attached({ ref: 1, id: 'fresh1', reqId: 1 })))
+
+    expect(sock.ofType('update')).toEqual([])
+  })
+
+  it('holds the spawn until the socket is up', async () => {
+    // What every real visit is: this page is reached by window.open, so it
+    // mounts into a client that is still dialling.
+    const { sock } = await mountNew('/new', { open: false })
+    expect(sock.ofType('spawn')).toEqual([])
+    expect(screen.getByRole('status').textContent).toMatch(/connecting/i)
+
+    act(() => sock.open())
+
+    expect(sock.ofType('spawn')).toHaveLength(1)
+    expect(screen.getByRole('status').textContent).toMatch(/starting/i)
+  })
+
+  it('says why when the daemon refuses, and offers another go', async () => {
+    const { sock } = await mountNew('/new?cwd=%2Fnope')
+
+    await act(async () =>
+      sock.emitControl({
+        type: 'error',
+        code: 'spawn_failed',
+        msg: 'chdir /nope: no such file',
+        reqId: 1,
+      }),
+    )
+
+    expect(screen.getByRole('status').textContent).toContain('chdir /nope')
+
+    await userEvent.click(screen.getByRole('button', { name: 'Retry' }))
+
+    expect(sock.ofType('spawn')).toHaveLength(2)
+  })
+
+  it('does not quietly ask again when the connection takes the answer away', async () => {
+    // Whether the daemon got as far as starting a shell is unknowable from
+    // here. A silent retry would leave a session behind for every answer an
+    // outage swallowed, so this says what happened and waits to be asked.
+    //
+    // A real redial, not just a close: the client dials a *new* socket after
+    // its backoff, and it is that socket coming up — a genuine second `open`
+    // — that would send the second spawn if nothing stopped it.
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    vi.spyOn(Math, 'random').mockReturnValue(0)
+    const { sock, local } = await mountNew('/new')
+    expect(sock.ofType('spawn')).toHaveLength(1)
+
+    act(() => sock.close())
+    await act(() => vi.advanceTimersByTimeAsync(125))
+    act(() => local.sockets[1]!.open())
+
+    expect(local.sockets[1]!.ofType('spawn')).toEqual([])
+    expect(screen.getByRole('status').textContent).toMatch(/before the daemon answered/i)
+    vi.useRealTimers()
+  })
+
+  it('refuses an address naming a machine this browser does not hold', async () => {
+    const { sock } = await mountNew('/new?d=somebody-elses-laptop')
+
+    expect(sock.ofType('spawn')).toEqual([])
+    expect(screen.getByRole('status').textContent).toMatch(/not paired/i)
+  })
+
+  it('ignores an attached it did not ask for', async () => {
+    const { sock, router } = await mountNew('/new')
+
+    act(() => sock.emitControl(attached({ ref: 9, id: 'someone-else' })))
+
+    expect(sock.ofType('detach')).toEqual([])
+    expect(router.state.location.pathname).toBe('/new')
+  })
+})
diff --git a/web/src/routes/new-session.tsx b/web/src/routes/new-session.tsx
new file mode 100644
index 0000000..833606c
--- /dev/null
+++ b/web/src/routes/new-session.tsx
@@ -0,0 +1,259 @@
+import { useEffect, useRef, useState, type ReactNode } from 'react'
+import { useNavigate, useSearch } from '@tanstack/react-router'
+
+import { Button } from '@/components/ui/button'
+import { useFleet } from '@/fleet/provider'
+import { LOCAL_MACHINE_ID } from '@/fleet/types'
+import { cn } from '@/lib/utils'
+import type { NewSessionSearch } from '@/sessions/new-session'
+
+/**
+ * The terminal's path, written out rather than imported from src/router.tsx —
+ * importing it would close a cycle, since the router imports this component.
+ * The literal is not unchecked: `to` is typed against the registered route
+ * tree, so a path that drifts is a compile error.
+ */
+const TERMINAL_PATH = '/d/$deviceId/s/$sessionId' as const
+
+/** This page's own path, and its route id, for the typed search hook. */
+const NEW_SESSION_PATH = '/new' as const
+
+/**
+ * The error a spawn is answered with when it is not answered with a session.
+ * `internal/daemon/conn.go`, `case wire.Spawn`: the error path returns before
+ * `attachTo`, so a failed spawn produces this and nothing else, ever.
+ */
+const SPAWN_FAILED = 'spawn_failed'
+
+/** What this page is doing, which is the whole of what it renders. */
+type Phase =
+  /** The machine is not carrying a socket yet. Every cold tab starts here. */
+  | { kind: 'waiting' }
+  /** Asked, unanswered. */
+  | { kind: 'starting' }
+  /** The daemon refused, or the connection went before it answered. */
+  | { kind: 'failed'; why: string }
+  /** An address naming a machine the fleet does not hold. */
+  | { kind: 'unknown' }
+
+/**
+ * The page that starts a session and then gets out of the way.
+ *
+ * It exists because starting one takes a round trip. `spawn` carries no id —
+ * the daemon invents it and says so in `attached` — so a screen that wanted to
+ * open the new session in its own tab had to spawn, wait, and then call
+ * window.open from the reply, which Safari refuses outright and Chrome refuses
+ * once the gesture has aged out. A link to this page opens on the click
+ * itself, and the asking happens here, where nothing is racing a popup
+ * blocker.
+ *
+ * It also replaces `/?cwd=` as the way the terminal's own `+` starts one. That
+ * address is the sessions dashboard, so a new session used to come up behind
+ * the entire list — page, shell, rows and all — for as long as the daemon took
+ * to answer. This renders one pill on the terminal's own ground, and replaces
+ * itself with the terminal the moment there is a session to show.
+ *
+ * Name and tags are applied here rather than left to the reader, and they have
+ * to be: `spawn` carries no metadata at all, so the earliest moment either can
+ * be sent is the first in which the session has an id.
+ *
+ * `replace`, so the back button leaves rather than starting a second session.
+ */
+export function NewSessionRoute() {
+  const fromUrl = useSearch({ from: NEW_SESSION_PATH })
+  const navigate = useNavigate()
+  const fleet = useFleet()
+
+  /**
+   * The request, read off the address once and held.
+   *
+   * A ref rather than the hook's own answer, and not for tidiness: the effect
+   * below acts on `tags`, which is an array, and an array in a dependency list
+   * is compared by identity. One re-render that hands back a fresh one would
+   * re-run the whole effect, and the only thing standing between that and a
+   * second shell would be the guard inside it. This page reads the URL exactly
+   * once, so saying so is both honest and the fix.
+   */
+  const want = useRef<NewSessionSearch | undefined>(undefined)
+  want.current ??= fromUrl
+  const search = want.current
+
+  const machineId = search.d ?? LOCAL_MACHINE_ID
+  const [phase, setPhase] = useState<Phase>({ kind: 'waiting' })
+  /**
+   * Which attempt this is. Retry bumps it, which re-runs the effect below
+   * with a fresh guard — and only ever on a press, because a page that
+   * re-spawned by itself on every reconnect would leave a session behind for
+   * each reply the outage carried away.
+   */
+  const [attempt, setAttempt] = useState(0)
+
+  /**
+   * The attempt a spawn has already been sent for, and the request it went out
+   * under.
+   *
+   * Refs rather than state, and that is what makes one press one session. The
+   * effect below can be entered more than once for a single attempt — the
+   * socket opening after the effect body has already looked at it, a mount
+   * effect double-invoked in development — and the daemon deduplicates
+   * nothing, because `spawn` carries no key it could deduplicate on. A guard
+   * in state would be reset by the very remount it is there to survive.
+   *
+   * The reqId is a ref for the second half of the same story: whichever run of
+   * the effect is listening has to recognise the answer to a spawn an earlier
+   * one sent.
+   *
+   * The suite covers the socket half of that — a redial after a spawn that
+   * was never answered sends nothing on the new socket — and not the
+   * development remount, which cannot be staged: TanStack renders a match
+   * through its own Suspense boundary, and React does not simulate a remount
+   * inside one, so a StrictMode wrapper in a test proves nothing either way.
+   */
+  const sentFor = useRef(-1)
+  const reqId = useRef<number | null>(null)
+
+  useEffect(() => {
+    const client = fleet.clientFor(machineId)
+    if (client === null) {
+      setPhase({ kind: 'unknown' })
+      return
+    }
+
+    const send = () => {
+      if (sentFor.current === attempt) return
+      // 80x24 is a starting point, not a decision; the terminal corrects it
+      // the moment it can measure a pane.
+      const id = client.spawn({ cwd: search.cwd, cols: 80, rows: 24 })
+      // Null is a socket that is down. The status listener below sends on the
+      // next open, which is what a cold tab always takes.
+      if (id === null) return
+      sentFor.current = attempt
+      reqId.current = id
+      setPhase({ kind: 'starting' })
+    }
+
+    const offs = [
+      client.onAttached((a) => {
+        if (a.reqId !== reqId.current) return
+        reqId.current = null
+        // The one moment either of these can be sent: `spawn` carries no
+        // metadata, so until now there was no id to address the edit to.
+        const patch: { id: string; name?: string; tags?: string[] } = { id: a.id }
+        if (search.name !== undefined) patch.name = search.name
+        if (search.tags !== undefined) patch.tags = search.tags
+        if (patch.name !== undefined || patch.tags !== undefined) client.update(patch)
+        // Hand the ref straight back: this page renders no terminal, and the
+        // route it navigates to attaches on its own.
+        client.detach(a.ref)
+        void navigate({
+          to: TERMINAL_PATH,
+          params: { deviceId: machineId, sessionId: a.id },
+          replace: true,
+        })
+      }),
+      client.onError((e) => {
+        if (e.reqId !== reqId.current) return
+        reqId.current = null
+        if (e.code === SPAWN_FAILED) setPhase({ kind: 'failed', why: e.msg })
+      }),
+      client.onStatus((s) => {
+        if (s === 'open') {
+          send()
+          return
+        }
+        // A reply does not survive its socket. Whether the daemon got as far
+        // as starting a shell is genuinely unknown from here, which is why
+        // this says what happened rather than asking again: a silent retry
+        // would leave a session behind for every answer an outage swallowed.
+        if (reqId.current === null) return
+        client.abandon(reqId.current)
+        reqId.current = null
+        setPhase({
+          kind: 'failed',
+          why: 'The connection went before the daemon answered. It may have started one anyway — check the sessions list before trying again.',
+        })
+      }),
+    ]
+
+    if (client.status === 'open') send()
+
+    return () => {
+      for (const off of offs) off()
+    }
+    // `search` is the held ref above, stable for the life of the page, so it
+    // is deliberately absent from here: what re-runs this is a retry and
+    // nothing else.
+  }, [fleet, machineId, navigate, attempt])
+
+  return (
+    <Pane>
+      {phase.kind === 'unknown' ? (
+        <Pill dim>This machine is not paired on this browser</Pill>
+      ) : phase.kind === 'failed' ? (
+        <Pill dim detail={phase.why}>
+          Could not start a session
+          <Button
+            variant="ghost"
+            size="sm"
+            className="-my-1 text-inherit hover:bg-white/10 hover:text-inherit"
+            onClick={() => setAttempt((n) => n + 1)}
+          >
+            Retry
+          </Button>
+        </Pill>
+      ) : (
+        <Pill>{phase.kind === 'waiting' ? 'Connecting to the flue daemon…' : 'Starting…'}</Pill>
+      )}
+    </Pane>
+  )
+}
+
+/**
+ * The terminal's own ground, so the session this becomes does not arrive as a
+ * change of scenery. This route sits outside AppShell for the same reason the
+ * terminal does: what it is on its way to being *is* the tab.
+ */
+function Pane({ children }: { children: ReactNode }) {
+  return (
+    <div className="relative h-full w-full overflow-hidden bg-white dark:bg-zinc-950">
+      <div className="absolute top-3 right-3 z-10">{children}</div>
+    </div>
+  )
+}
+
+/**
+ * The terminal's status pill, in the same corner and the same clothes: dark in
+ * both themes, over a translucent ground. The dot pulses while an answer is
+ * still expected and holds still once waiting will not change anything, which
+ * is the same sentence the terminal's own pill tells.
+ */
+function Pill({
+  children,
+  detail,
+  dim = false,
+}: {
+  children: ReactNode
+  detail?: string
+  dim?: boolean
+}) {
+  return (
+    <div
+      role="status"
+      className="max-w-xs rounded-lg bg-zinc-900/90 px-3 py-1.5 text-base/4 font-medium text-zinc-100 shadow-lg ring-1 ring-white/10 backdrop-blur-sm sm:text-sm/4"
+    >
+      <span className="flex items-center gap-x-2">
+        <span
+          aria-hidden="true"
+          className={cn(
+            'size-1.5 shrink-0 rounded-full',
+            dim ? 'bg-zinc-500' : 'bg-zinc-100 motion-safe:animate-pulse',
+          )}
+        />
+        {children}
+      </span>
+      {detail !== undefined && detail !== '' && (
+        <span className="mt-0.5 block pl-3.5 text-xs/5 font-normal text-zinc-400">{detail}</span>
+      )}
+    </div>
+  )
+}
diff --git a/web/src/routes/sessions.test.tsx b/web/src/routes/sessions.test.tsx
index 5a73502..8ab1d0f 100644
--- a/web/src/routes/sessions.test.tsx
+++ b/web/src/routes/sessions.test.tsx
@@ -88,7 +88,7 @@ async function mountSessions({ open = true, strict = false, solo = false } = {})
     ...['/', '/sessions'].map((path) =>
       createRoute({ getParentRoute: () => rootRoute, path, component: routeComponent }),
     ),
-    ...['/devices', '/settings', '/d/$deviceId/s/$sessionId'].map((path) =>
+    ...['/devices', '/settings', '/new', '/d/$deviceId/s/$sessionId'].map((path) =>
       createRoute({ getParentRoute: () => rootRoute, path, component: () => null }),
     ),
   ])
@@ -189,7 +189,7 @@ describe('SessionsRoute', () => {
 
     expect(screen.queryByText('mesa.local', { selector: '[data-slot="badge"]' })).toBeNull()
     // The row is still there and still named — only the chip went.
-    expect(screen.getByRole('link', { name: 'Open zsh' })).toBeTruthy()
+    expect(screen.getByRole('link', { name: 'Open zsh in a new tab' })).toBeTruthy()
     solo.unmount()
 
     // Two machines, and it is back: it now tells two rows apart.
@@ -271,12 +271,16 @@ describe('SessionsRoute', () => {
     listed(sock, [])
 
     // The row is a link, not a button: its href carries the machine that owns
-    // the session, which is also what a Ctrl/Cmd click hands the browser.
-    const row = screen.getByRole('link', { name: 'Open remote-one' })
+    // the session, and it opens in a tab of its own so this list — the thing
+    // people come back to between sessions — stays where it was.
+    const row = screen.getByRole('link', { name: 'Open remote-one in a new tab' })
     expect(row.getAttribute('href')).toBe('/d/attic-pi/s/abc123')
-    await userEvent.click(row)
+    expect(row.getAttribute('target')).toBe('_blank')
 
-    await waitFor(() => expect(router.state.location.pathname).toBe('/d/attic-pi/s/abc123'))
+    // And the router stands aside for it, which is what makes that a real new
+    // tab rather than a navigation wearing the attribute.
+    await userEvent.click(row)
+    expect(router.state.location.pathname).toBe('/sessions')
   })
 
   describe('metadata actions', () => {
@@ -585,7 +589,7 @@ describe('SessionsRoute', () => {
       expect(screen.queryByText(/this fleet/)).toBeNull()
       // And the machine itself is on screen, working, which is the whole of
       // what that state is.
-      expect(screen.getByRole('link', { name: 'Open zsh' })).toBeTruthy()
+      expect(screen.getByRole('link', { name: 'Open zsh in a new tab' })).toBeTruthy()
     })
 
     it('takes the band down when its machine leaves the relay', async () => {
@@ -689,44 +693,113 @@ describe('SessionsRoute', () => {
   })
 
   describe('starting sessions', () => {
-    it('spawns on the ridden machine from the primary button, only on a click', async () => {
+    /**
+     * Watch the tab this screen opens.
+     *
+     * Nothing on this screen spawns any more: a press opens the new-session
+     * dialog, and submitting it opens `/new` in a tab of its own, which is
+     * where the spawn happens. See sessions/new-session.ts for why that has to
+     * be a page rather than a reply this screen waits on.
+     */
+    function watchOpen() {
+      const open = vi.fn().mockReturnValue({})
+      vi.stubGlobal('open', open)
+      return {
+        opened: () => (open.mock.calls[0]?.[0] as string | undefined) ?? null,
+        target: () => open.mock.calls[0]?.[1] as string | undefined,
+        count: () => open.mock.calls.length,
+      }
+    }
+
+    /** Fill nothing in and press Start. */
+    const start = () => userEvent.click(screen.getByRole('button', { name: 'Start session' }))
+
+    it('opens the dialog on the ridden machine, and starts nothing by itself', async () => {
+      const tabs = watchOpen()
       const { sock } = await mountSessions()
-      expect(sock.ofType('spawn')).toEqual([])
 
       await userEvent.click(newSession())
 
-      expect(sock.ofType('spawn')).toEqual([{ type: 'spawn', cols: 80, rows: 24, reqId: 1 }])
+      // A form, not a shell: the press has asked a question, and the daemon
+      // has not been told anything yet.
+      expect(screen.getByRole('dialog')).toBeTruthy()
+      expect(sock.ofType('spawn')).toEqual([])
+      expect(tabs.count()).toBe(0)
+
+      await start()
+
+      expect(sock.ofType('spawn')).toEqual([])
+      expect(tabs.opened()).toBe('/new?d=local')
+      expect(tabs.target()).toBe('_blank')
     })
 
-    it('spawns on the first online machine when the ridden one is down', async () => {
+    it('falls back to the first online machine when the ridden one is down', async () => {
+      const tabs = watchOpen()
       const { attic } = await mountSessions({ open: false })
       act(() => attic.sockets[0]!.open())
 
       await userEvent.click(newSession())
+      await start()
 
-      expect(attic.sockets[0]!.ofType('spawn')).toHaveLength(1)
+      expect(tabs.opened()).toBe('/new?d=attic-pi')
     })
 
-    it('spawns on the machine picked from the chevron menu, then opens there', async () => {
+    it('opens on the machine picked from the chevron menu', async () => {
+      const tabs = watchOpen()
       const user = userEvent.setup()
-      const { sock, attic, router } = await mountSessions()
+      const { attic } = await mountSessions()
       act(() => attic.sockets[0]!.open())
 
       await user.click(
         screen.getByRole('button', { name: 'Choose a machine for the new session' }),
       )
       await user.click(screen.getByRole('menuitem', { name: 'Attic Pi' }))
+      await start()
 
-      expect(attic.sockets[0]!.ofType('spawn')).toHaveLength(1)
-      expect(sock.ofType('spawn')).toEqual([])
+      expect(tabs.opened()).toBe('/new?d=attic-pi')
+    })
 
-      act(() => attic.sockets[0]!.emitControl(attached({ ref: 4, id: 'fresh9', reqId: 1 })))
+    it('carries a name and tags the reader typed', async () => {
+      // The whole reason the dialog is in front of the press: `spawn` carries
+      // no metadata, so a name and a tag can only be applied after the session
+      // exists — and nobody goes back to a list to do that. Asked here, they
+      // ride the address to the page that starts it.
+      const tabs = watchOpen()
+      const user = userEvent.setup()
+      await mountSessions()
 
-      expect(attic.sockets[0]!.ofType('detach')).toEqual([{ type: 'detach', ref: 4 }])
-      await waitFor(() => expect(router.state.location.pathname).toBe('/d/attic-pi/s/fresh9'))
+      await user.click(newSession())
+      await user.type(screen.getByLabelText('Name'), 'deploy')
+      await user.type(screen.getByLabelText('Tags'), 'ops{Enter}')
+      await start()
+
+      const url = new URL(tabs.opened()!, 'http://localhost')
+      expect(url.pathname).toBe('/new')
+      expect(url.searchParams.get('name')).toBe('deploy')
+      // An array, JSON-shaped, because that is what the router's own search
+      // serialiser writes and what the page parses back — so a tag with a
+      // comma in it survives the trip.
+      expect(JSON.parse(url.searchParams.get('tags')!)).toEqual(['ops'])
     })
 
-    it('spawns into a machine group from its heading', async () => {
+    it('counts a tag typed but never entered as part of the answer', async () => {
+      // Somebody who typed a tag and reached straight for Start is done.
+      // Throwing that keystroke away would be disagreeing with them in
+      // silence — the chips are gone before anyone can read what was sent.
+      const tabs = watchOpen()
+      const user = userEvent.setup()
+      await mountSessions()
+
+      await user.click(newSession())
+      await user.type(screen.getByLabelText('Tags'), 'staging')
+      await start()
+
+      const url = new URL(tabs.opened()!, 'http://localhost')
+      expect(JSON.parse(url.searchParams.get('tags')!)).toEqual(['staging'])
+    })
+
+    it('prefills the dialog from a machine heading', async () => {
+      const tabs = watchOpen()
       const { attic, sock, welcomeLocal } = await mountSessions()
       welcomeLocal()
       act(() => attic.sockets[0]!.open())
@@ -734,15 +807,17 @@ describe('SessionsRoute', () => {
       listed(attic.sockets[0]!, [info({ id: 's2' })])
 
       await userEvent.click(screen.getByRole('button', { name: 'New session on Attic Pi' }))
+      await start()
 
-      expect(attic.sockets[0]!.ofType('spawn')).toHaveLength(1)
-      expect(sock.ofType('spawn')).toEqual([])
+      expect(tabs.opened()).toBe('/new?d=attic-pi')
     })
 
-    it('spawns into a tag group tagged with that group\'s tag', async () => {
+    it("prefills the dialog with a tag heading's own tag", async () => {
       // The heading names a property its rows share, so the `+` on it makes
       // one of *these* — which for a tag means a session that will land under
-      // the same heading rather than under "No tag" beside it.
+      // the same heading rather than under "No tag" beside it. It is a prefill
+      // and not a decision: the chip is there to be taken off again.
+      const tabs = watchOpen()
       const user = userEvent.setup()
       const { sock, welcomeLocal } = await mountSessions()
       welcomeLocal()
@@ -753,20 +828,16 @@ describe('SessionsRoute', () => {
 
       await user.click(screen.getByRole('button', { name: 'New session tagged api' }))
 
-      expect(sock.ofType('spawn')).toHaveLength(1)
-      // `spawn` carries no metadata, so the tag can only be applied once the
-      // session exists — which is the `attached` that answers it.
-      expect(sock.ofType('update')).toEqual([])
-      // Async, unlike the emits above: this `attached` answers a spawn, so it
-      // also starts the navigation to the new session, and the router's
-      // continuations land a microtask after a synchronous act exits. The
-      // update frame itself is sent synchronously, before the screen changes.
-      await act(async () => sock.emitControl(attached({ ref: 3, id: 'fresh1', reqId: 1 })))
-
-      expect(sock.ofType('update')).toEqual([{ type: 'update', id: 'fresh1', tags: ['api'] }])
+      expect(screen.getByRole('button', { name: 'Remove api' })).toBeTruthy()
+
+      await start()
+
+      const url = new URL(tabs.opened()!, 'http://localhost')
+      expect(JSON.parse(url.searchParams.get('tags')!)).toEqual(['api'])
     })
 
-    it('spawns into a directory group in that group\'s directory', async () => {
+    it("prefills the dialog with a directory heading's own directory", async () => {
+      const tabs = watchOpen()
       const user = userEvent.setup()
       const { sock, welcomeLocal } = await mountSessions()
       welcomeLocal()
@@ -779,9 +850,28 @@ describe('SessionsRoute', () => {
         screen.getByRole('button', { name: 'New session in /Users/karn/code/flue' }),
       )
 
-      expect(sock.ofType('spawn')).toEqual([
-        { type: 'spawn', cwd: '/Users/karn/code/flue', cols: 80, rows: 24, reqId: 1 },
-      ])
+      expect(screen.getByLabelText('Directory')).toHaveProperty('value', '/Users/karn/code/flue')
+
+      await start()
+
+      const url = new URL(tabs.opened()!, 'http://localhost')
+      expect(url.searchParams.get('cwd')).toBe('/Users/karn/code/flue')
+    })
+
+    it('forgets an abandoned draft rather than carrying it to the next press', async () => {
+      // One dialog serves every way of asking. A name half-typed under one
+      // heading and then cancelled must not turn up under the next — the worst
+      // kind of bug, the kind that saves.
+      const user = userEvent.setup()
+      await mountSessions()
+
+      await user.click(newSession())
+      await user.type(screen.getByLabelText('Name'), 'abandoned')
+      await user.click(screen.getByRole('button', { name: 'Cancel' }))
+
+      await user.click(newSession())
+
+      expect(screen.getByLabelText('Name')).toHaveProperty('value', '')
     })
 
     it('offers no spawn control on the Exited heading', async () => {
@@ -805,20 +895,6 @@ describe('SessionsRoute', () => {
       expect(screen.getAllByRole('button', { name: 'New session' })).toHaveLength(2)
     })
 
-    it('hands back the attachment the daemon gave it, then opens the new session', async () => {
-      // The daemon attaches whoever spawns. This screen renders no terminal,
-      // and the terminal route attaches on its own — so keeping the ref would
-      // leave one tab holding two attachments to one session, the one shape
-      // FlueClient's reattach plan cannot carry.
-      const { sock, router } = await mountSessions()
-      await userEvent.click(newSession())
-
-      act(() => sock.emitControl(attached({ ref: 4, id: 'fresh1', reqId: 1 })))
-
-      expect(sock.ofType('detach')).toEqual([{ type: 'detach', ref: 4 }])
-      await waitFor(() => expect(router.state.location.pathname).toBe('/d/local/s/fresh1'))
-    })
-
     it('ignores an attached it did not ask for', async () => {
       const { sock, router } = await mountSessions()
 
@@ -828,59 +904,25 @@ describe('SessionsRoute', () => {
       expect(router.state.location.pathname).toBe('/sessions')
     })
 
-    it('starts one session per click, not one per impatient click', async () => {
-      const { sock } = await mountSessions()
-
-      await userEvent.click(newSession())
-      await userEvent.click(newSession())
-
-      expect(sock.ofType('spawn')).toHaveLength(1)
-    })
-
-    it('lets the user try again once a spawn has been answered', async () => {
-      const { sock } = await mountSessions()
-      await userEvent.click(newSession())
-      act(() => sock.emitControl({ type: 'error', code: 'spawn_failed', msg: 'nope', reqId: 1 }))
-
-      await userEvent.click(newSession())
-
-      expect(sock.ofType('spawn')).toHaveLength(2)
-    })
-
-    it('hands back a spawn answered after the screen has gone', async () => {
-      const { sock, goTo } = await mountSessions()
-      await userEvent.click(newSession())
-
-      await goTo('/settings')
-      expect(onScreen()).toBe(false)
-      act(() => sock.emitControl(attached({ ref: 7, id: 'orphan', reqId: 1 })))
-
-      expect(sock.ofType('detach')).toEqual([{ type: 'detach', ref: 7 }])
-    })
+    it('refuses in words when no machine is reachable', async () => {
+      // The dialog opens from a button that was pressed, so a form that
+      // silently did nothing would leave the reader pressing Start at a fleet
+      // that is not there.
+      const tabs = watchOpen()
+      const { sock } = await mountSessions({ open: false })
 
-    it('says so when the daemon refuses to start a session', async () => {
-      const { sock } = await mountSessions()
       await userEvent.click(newSession())
 
-      act(() =>
-        sock.emitControl({
-          type: 'error',
-          code: 'spawn_failed',
-          msg: 'chdir /nope: no such file',
-          reqId: 1,
-        }),
+      expect(screen.getByText(/no machine is reachable/i)).toBeTruthy()
+      expect(screen.getByRole('button', { name: 'Start session' })).toHaveProperty(
+        'disabled',
+        true,
       )
 
-      expect(screen.getByRole('status').textContent).toContain('chdir /nope')
-    })
-
-    it('does not silently drop a spawn when no machine is reachable', async () => {
-      const { sock } = await mountSessions({ open: false })
-
-      await userEvent.click(newSession())
+      await start()
 
       expect(sock.ofType('spawn')).toEqual([])
-      expect(screen.getByRole('status').textContent).toMatch(/not connected/i)
+      expect(tabs.count()).toBe(0)
     })
 
     it('keeps the teal on the new-session control alone', async () => {
diff --git a/web/src/routes/sessions.tsx b/web/src/routes/sessions.tsx
index ab14feb..2022928 100644
--- a/web/src/routes/sessions.tsx
+++ b/web/src/routes/sessions.tsx
@@ -5,6 +5,7 @@ import { ChevronDownIcon } from '@heroicons/react/16/solid'
 import type { FlueClient } from '@/client/client'
 import { BulkBar } from '@/components/bulk-bar'
 import { DisplayOptions } from '@/components/display-options'
+import { NewSessionDialog } from '@/components/new-session-dialog'
 import { PageHeader } from '@/components/page-header'
 import { RenameDialog } from '@/components/rename-dialog'
 import { SessionSearch } from '@/components/session-search'
@@ -26,6 +27,7 @@ import { keyOf, LOCAL_MACHINE_ID, type FleetSession, type MachineState } from '@
 import { useRefetchOnFocus } from '@/hooks/use-refetch-on-focus'
 import { takeCwd } from '@/lib/url'
 import { cn } from '@/lib/utils'
+import { useOpenNewSession, type NewSessionOrigin } from '@/sessions/open-new-session'
 import {
   applyView,
   DEFAULT_VIEW,
@@ -154,6 +156,7 @@ interface PendingSpawn {
 export function SessionsRoute() {
   const fleet = useFleet()
   const navigate = useNavigate()
+  const openNewSession = useOpenNewSession()
 
   /**
    * The fleet's last word: null until it has said anything at all, which is
@@ -221,13 +224,21 @@ export function SessionsRoute() {
 
   const [notice, setNotice] = useState<string | null>(null)
 
+  /**
+   * What the new-session dialog is open on, or null for closed. The value is
+   * whatever the press implied — a machine, a directory, a tag — and it is the
+   * dialog's starting point rather than its answer.
+   */
+  const [creating, setCreating] = useState<NewSessionOrigin | null>(null)
+
   /**
    * The spawns this screen asked for and has not yet seen answered. A ref,
-   * because their listeners settle them without re-rendering anything but
-   * `starting`, which shadows its emptiness for the one button that renders.
+   * because their listeners settle them without re-rendering anything: this
+   * screen no longer spawns from a button, so the only entry that ever lands
+   * here is the one `flue open` hands over in `?cwd=`, and nothing on screen
+   * is waiting on it.
    */
   const pending = useRef(new Set<PendingSpawn>())
-  const [starting, setStarting] = useState(false)
 
   /**
    * The directory flue open asked for, taken from the URL exactly once —
@@ -243,25 +254,23 @@ export function SessionsRoute() {
    * and write it off when its connection goes. The listeners are registered
    * per spawn, on the client that carries it, because the fleet grows machines
    * over time and a single mount-time subscription could not name them all.
+   *
+   * The one caller left is `flue open`'s handover below. Every spawn a *press*
+   * asks for is made by the new-session page instead, in the tab it opens —
+   * see sessions/new-session.ts for why that has to be a page and not a reply
+   * this screen waits on.
    */
   const adopt = useCallback(
-    (client: FlueClient, machineId: string, reqId: number, tag?: string) => {
+    (client: FlueClient, machineId: string, reqId: number) => {
       const entry: PendingSpawn = { reqId, client, offs: [] }
       const settle = () => {
         if (!pending.current.delete(entry)) return
         for (const off of entry.offs) off()
-        setStarting(pending.current.size > 0)
       }
       entry.offs.push(
         client.onAttached((a) => {
           if (a.reqId !== reqId) return
           settle()
-          // A session started from a tag's heading belongs under that heading,
-          // and `spawn` carries no metadata — so the tag is applied the moment
-          // the session exists and not before. It has to be here rather than
-          // beside the spawn for the obvious reason: until `attached` lands
-          // there is no id to address the edit to.
-          if (tag !== undefined) client.update({ id: a.id, tags: [tag] })
           // Hand the ref straight back: this screen renders no terminal, and
           // the route it navigates to attaches on its own.
           client.detach(a.ref)
@@ -283,27 +292,10 @@ export function SessionsRoute() {
         }),
       )
       pending.current.add(entry)
-      setStarting(true)
     },
     [navigate],
   )
 
-  const spawnOn = useCallback(
-    (machineId: string | undefined, opts: { cwd?: string; tag?: string } = {}) => {
-      setNotice(null)
-      const client = machineId === undefined ? null : fleet.clientFor(machineId)
-      // 80x24 is a starting point, not a decision; the terminal corrects it
-      // the moment it can measure a pane.
-      const reqId = client?.spawn({ cwd: opts.cwd, cols: 80, rows: 24 }) ?? null
-      if (client === null || reqId === null || machineId === undefined) {
-        setNotice('Not connected to the flue daemon, so nothing was started.')
-        return
-      }
-      adopt(client, machineId, reqId, opts.tag)
-    },
-    [adopt, fleet],
-  )
-
   const spawnPendingCwd = useCallback(() => {
     const cwd = pendingCwd.current
     if (typeof cwd !== 'string') return
@@ -442,12 +434,20 @@ export function SessionsRoute() {
    * test rather than by clicking headings. Only the machine is resolved here,
    * because only this screen knows which machine a heading that names none
    * should fall back to — the same `primaryTarget` the toolbar's own button
-   * spawns on.
+   * opens on.
+   *
+   * What the heading implies is a prefill and not a decision: the dialog opens
+   * on it and the reader may edit any of it, which is how a `+` under "api"
+   * can still start something tagged `api` and `staging`.
    */
   const spawnInGroup = (group: Group) => {
     const want = spawnFromGroup(view.grouping, group.key)
     if (want === null) return
-    spawnOn(want.machineId ?? primaryTarget, { cwd: want.cwd, tag: want.tag })
+    setCreating({
+      machineId: want.machineId ?? primaryTarget,
+      cwd: want.cwd,
+      tags: want.tag === undefined ? [] : [want.tag],
+    })
   }
 
   /**
@@ -655,14 +655,15 @@ export function SessionsRoute() {
             <DisplayOptions view={view} onChange={setView} />
             {/*
               The one filled control on this screen, and a split one: the
-              primary half spawns where a new session most likely belongs —
-              the machine this tab rides, else the first one up — and the
-              chevron half names the rest of the fleet. It takes its teal
+              primary half opens on the machine a new session most likely
+              belongs to — the one this tab rides, else the first one up — and
+              the chevron half names the rest of the fleet. It takes its teal
               from --primary rather than naming a colour.
 
-              Held shut while a spawn is unanswered. Without it, a second
-              click starts a second shell whose `attached` arrives after this
-              screen has navigated away on the first.
+              Neither half starts anything by itself any more. Both open the
+              dialog, which is where a name and a tag can be chosen while
+              there is still a form to choose them on; the session itself is
+              started by the page that dialog opens.
             */}
             {/*
               The default size, not `sm`, and that is a fact about the row
@@ -675,8 +676,7 @@ export function SessionsRoute() {
             */}
             <div className="flex items-center">
               <Button
-                disabled={starting}
-                onClick={() => spawnOn(primaryTarget)}
+                onClick={() => setCreating({ machineId: primaryTarget })}
                 className="rounded-r-none"
               >
                 New session
@@ -684,7 +684,6 @@ export function SessionsRoute() {
               <DropdownMenu>
                 <DropdownMenuTrigger asChild>
                   <Button
-                    disabled={starting}
                     aria-label="Choose a machine for the new session"
                     className="-ml-px rounded-l-none px-1"
                   >
@@ -696,7 +695,7 @@ export function SessionsRoute() {
                     <DropdownMenuItem disabled>No machine is reachable</DropdownMenuItem>
                   ) : (
                     online.map((m) => (
-                      <DropdownMenuItem key={m.id} onSelect={() => spawnOn(m.id)}>
+                      <DropdownMenuItem key={m.id} onSelect={() => setCreating({ machineId: m.id })}>
                         {m.name || m.id}
                       </DropdownMenuItem>
                     ))
@@ -767,6 +766,21 @@ export function SessionsRoute() {
       {view.grouping === 'machine' &&
         revoked.map((m) => <RevokedBand key={m.id} machines={[m]} />)}
 
+      {/*
+        One dialog for every way of asking, and it takes the whole fleet's
+        online machines rather than the one a press implied: the press is a
+        prefill, and a reader who opened it under the wrong heading should not
+        have to close it to fix that.
+      */}
+      <NewSessionDialog
+        open={creating !== null}
+        initial={creating ?? {}}
+        machines={online.map((m) => ({ id: m.id, name: m.name }))}
+        known={knownTags}
+        onSubmit={openNewSession}
+        onClose={() => setCreating(null)}
+      />
+
       <RenameDialog
         open={renaming !== null}
         initial={renaming?.name ?? ''}
diff --git a/web/src/routes/terminal.tsx b/web/src/routes/terminal.tsx
index 6f1d83d..8eca592 100644
--- a/web/src/routes/terminal.tsx
+++ b/web/src/routes/terminal.tsx
@@ -1,9 +1,12 @@
-import { useCallback, useSyncExternalStore } from 'react'
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react'
 import { useNavigate, useParams } from '@tanstack/react-router'
 
 import { FlueClientContext } from '@/client/provider'
+import { NewSessionDialog } from '@/components/new-session-dialog'
 import { Terminal } from '@/components/terminal'
 import { useFleet } from '@/fleet/provider'
+import type { MachineState } from '@/fleet/types'
+import { useOpenNewSession, type NewSessionOrigin } from '@/sessions/open-new-session'
 
 /**
  * The terminal route.
@@ -33,6 +36,14 @@ export function TerminalRoute() {
   const { deviceId, sessionId } = useParams({ from: '/d/$deviceId/s/$sessionId' })
   const navigate = useNavigate()
   const fleet = useFleet()
+  const openNewSession = useOpenNewSession()
+  /**
+   * What the `+` in the terminal's control strip is asking for, or null for
+   * closed. The dialog is hosted here rather than inside `<Terminal>` because
+   * it needs the fleet's machines and the fleet's tags, and that component is
+   * deliberately built to work without knowing a fleet exists.
+   */
+  const [creating, setCreating] = useState<NewSessionOrigin | null>(null)
   // Resolved through a subscription, not read once, because the answer moves:
   // a direct load of a remote machine's session renders before the fleet has
   // adopted its remote sources — those are built only after the local
@@ -46,6 +57,9 @@ export function TerminalRoute() {
     useCallback((onChange: () => void) => fleet.onFleet(onChange), [fleet]),
     () => fleet.clientFor(deviceId),
   )
+  // What the dialog needs to fill its machine picker and its tag suggestions.
+  const fleetForForm = useFormFleet(fleet)
+
   // A machine the fleet does not hold: never paired on this browser, or its
   // pinned key gone. Said in a pill, the way the terminal answers a session
   // the daemon has never heard of — though unlike that answer this one is
@@ -72,11 +86,81 @@ export function TerminalRoute() {
           })
         }
         onClosed={() => void navigate({ to: '/', replace: true })}
+        // This machine and this directory, because that is what a `+` inside a
+        // session means. Both are only a prefill — the dialog offers the rest
+        // of the fleet, and a session started from here need not be a sibling.
+        onNewSession={(cwd) => setCreating({ machineId: deviceId, cwd: cwd ?? '' })}
+      />
+      <NewSessionDialog
+        open={creating !== null}
+        initial={creating ?? {}}
+        machines={fleetForForm.machines}
+        known={fleetForForm.tags}
+        onSubmit={openNewSession}
+        onClose={() => setCreating(null)}
       />
     </FlueClientContext.Provider>
   )
 }
 
+/** What the new-session form needs off the fleet, and nothing else. */
+interface FormFleet {
+  machines: Array<{ id: string; name: string }>
+  tags: string[]
+}
+
+const NO_FLEET: FormFleet = { machines: [], tags: [] }
+
+/** Whether two of those say the same thing, machine for machine and tag for tag. */
+function sameFleet(a: FormFleet, b: FormFleet): boolean {
+  return (
+    a.machines.length === b.machines.length &&
+    a.tags.length === b.tags.length &&
+    a.machines.every((m, at) => m.id === b.machines[at]?.id && m.name === b.machines[at]?.name) &&
+    a.tags.every((t, at) => t === b.tags[at])
+  )
+}
+
+/**
+ * The fleet's online machines and every tag in use across it.
+ *
+ * Subscribed from mount rather than while the dialog is open, and the
+ * comparison above is what makes that affordable: the fleet emits every poll
+ * tick, three seconds apart, and almost none of those change either list — so
+ * holding the previous object turns a steady drip of re-renders into one per
+ * genuine change. The terminal is under this route, and it is the one screen
+ * in the app that has to stay smooth.
+ *
+ * Subscribing early is not merely cheaper than the alternative, it is the only
+ * thing that makes the picker correct: a listener wired when the dialog opens
+ * would have nothing to show until the next tick, because the fleet replays
+ * nothing at subscribe time — and an empty picker reads as "no machine is
+ * reachable", which would be a lie told at exactly the wrong moment.
+ *
+ * The machines are narrowed to the online ones for the same reason the
+ * dashboard narrows them: offering a machine that cannot answer is a choice
+ * that fails after the form has closed.
+ */
+function useFormFleet(fleet: ReturnType<typeof useFleet>): FormFleet {
+  const [state, setState] = useState<FormFleet>(NO_FLEET)
+
+  useEffect(
+    () =>
+      fleet.onFleet((sessions, machines: MachineState[]) => {
+        const next: FormFleet = {
+          machines: machines
+            .filter((m) => m.status === 'online')
+            .map((m) => ({ id: m.id, name: m.name })),
+          tags: [...new Set(sessions.flatMap((s) => s.tags))].sort(),
+        }
+        setState((prev) => (sameFleet(prev, next) ? prev : next))
+      }),
+    [fleet],
+  )
+
+  return state
+}
+
 /**
  * The missing-machine treatment, matched to the missing-session one: the same
  * full-bleed pane the terminal renders, the same pill in the same corner, a
diff --git a/web/src/sessions/new-session.test.ts b/web/src/sessions/new-session.test.ts
new file mode 100644
index 0000000..89f69d3
--- /dev/null
+++ b/web/src/sessions/new-session.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest'
+
+import { newSessionSearch, validateNewSessionSearch } from './new-session'
+
+describe('newSessionSearch', () => {
+  it('carries everything that was actually asked for', () => {
+    expect(
+      newSessionSearch({
+        machineId: 'attic-pi',
+        cwd: '/Users/karn/code/flue',
+        name: 'deploy',
+        tags: ['ops', 'api'],
+      }),
+    ).toEqual({
+      d: 'attic-pi',
+      cwd: '/Users/karn/code/flue',
+      name: 'deploy',
+      tags: ['ops', 'api'],
+    })
+  })
+
+  it('omits an empty answer rather than sending it blank', () => {
+    // The same rule `flue open` follows for an empty cwd. A parameter that is
+    // sometimes '' and sometimes absent is one more case for the page to tell
+    // apart, and both already mean "nothing was asked for".
+    expect(newSessionSearch({ machineId: '', cwd: '   ', name: '  ', tags: [] })).toEqual({})
+    expect(newSessionSearch({})).toEqual({})
+  })
+
+  it('trims what the reader typed, and drops a tag that was only spaces', () => {
+    expect(newSessionSearch({ cwd: '  /tmp  ', name: '  build  ', tags: ['  api  ', '   '] }))
+      .toEqual({ cwd: '/tmp', name: 'build', tags: ['api'] })
+  })
+
+  it('keeps tags a list, so a tag with a comma in it stays one tag', () => {
+    // The reason this is an array and not a joined string: the daemon takes
+    // free text, and joining would quietly turn one tag into two.
+    expect(newSessionSearch({ tags: ['a,b'] }).tags).toEqual(['a,b'])
+  })
+})
+
+describe('validateNewSessionSearch', () => {
+  it('takes the four fields it knows, whole', () => {
+    expect(
+      validateNewSessionSearch({ d: 'local', cwd: '/tmp', name: 'x', tags: ['api'] }),
+    ).toEqual({ d: 'local', cwd: '/tmp', name: 'x', tags: ['api'] })
+  })
+
+  it('ignores anything that is not the shape the page can act on', () => {
+    // A link can be edited by hand and a parameter given twice parses to an
+    // array, so none of this is hypothetical. What is dropped lands on the
+    // page's own defaults: this machine, the daemon's directory, no metadata.
+    expect(
+      validateNewSessionSearch({
+        d: ['local', 'attic-pi'],
+        cwd: 7,
+        name: null,
+        tags: 'api',
+        stray: 'ignored',
+      }),
+    ).toEqual({})
+  })
+
+  it('drops the blanks out of a tag list, and the list if nothing survives', () => {
+    expect(validateNewSessionSearch({ tags: ['api', '', '  ', 3] })).toEqual({ tags: ['api'] })
+    expect(validateNewSessionSearch({ tags: ['', '  '] })).toEqual({})
+  })
+
+  it('treats an empty string as absent, exactly as the builder does', () => {
+    expect(validateNewSessionSearch({ d: '', cwd: '', name: '' })).toEqual({})
+  })
+})
diff --git a/web/src/sessions/new-session.ts b/web/src/sessions/new-session.ts
new file mode 100644
index 0000000..2269f00
--- /dev/null
+++ b/web/src/sessions/new-session.ts
@@ -0,0 +1,91 @@
+/**
+ * The address that starts a session, and the shape of what it carries.
+ *
+ * A route rather than a click handler, and that is the whole design. Starting
+ * a session takes a round trip — `spawn` has no id in it, the daemon answers
+ * with one — so a screen that spawned and then opened a tab would be calling
+ * window.open from a continuation, which Safari refuses outright and Chrome
+ * refuses once the gesture has aged out. Putting the *request* in a URL means
+ * the tab opens on the click itself and does its own asking, so nothing
+ * depends on how long a daemon takes to answer.
+ *
+ * It also answers the complaint this was written for. The old `+` pointed at
+ * `/?cwd=`, so a new session came up behind the whole dashboard — page, shell,
+ * session list — for as long as the spawn took. This page renders one pill.
+ */
+
+/**
+ * The path, written out here so the route, the two screens that link to it and
+ * this module's builder all read the same literal. `to` is typed against the
+ * registered route tree wherever it is used, so a path that drifts is a
+ * compile error rather than a dead link.
+ */
+export const NEW_SESSION_PATH = '/new' as const
+
+/** What a link to the new-session page may say about the session it wants. */
+export interface NewSessionSearch {
+  /** The machine to start on: the fleet's machineId, `local` for this one. */
+  d?: string
+  /** The directory to start in. Absent means the daemon's own default. */
+  cwd?: string
+  /** A name to apply the moment the session exists. */
+  name?: string
+  /** Tags to apply alongside it. */
+  tags?: string[]
+}
+
+/** Everything the new-session dialog collects, before the empties are dropped. */
+export interface NewSessionRequest {
+  machineId: string
+  cwd: string
+  name: string
+  tags: string[]
+}
+
+/**
+ * The request as search parameters, with every empty answer left out.
+ *
+ * Omitted rather than sent blank, for the reason `flue open` omits an empty
+ * `cwd`: a parameter that is sometimes '' and sometimes absent is one more
+ * case for the page to tell apart, and both of those already mean "nothing was
+ * asked for". Name and tags are the same story — the daemon is only told about
+ * them when there is something to tell.
+ *
+ * Tags stay an array rather than being joined. The router's own search
+ * serialiser writes arrays as JSON and reads them back the same way, so a tag
+ * with a comma in it survives the trip; a joined string would quietly become
+ * two tags.
+ */
+export function newSessionSearch(want: Partial<NewSessionRequest>): NewSessionSearch {
+  const search: NewSessionSearch = {}
+  const name = want.name?.trim() ?? ''
+  const tags = (want.tags ?? []).map((t) => t.trim()).filter((t) => t !== '')
+  if (want.machineId !== undefined && want.machineId !== '') search.d = want.machineId
+  if (want.cwd !== undefined && want.cwd.trim() !== '') search.cwd = want.cwd.trim()
+  if (name !== '') search.name = name
+  if (tags.length > 0) search.tags = tags
+  return search
+}
+
+/**
+ * What the page will act on, out of whatever arrived in the address bar.
+ *
+ * Every field is narrowed rather than trusted. A route's search is its
+ * parent's merged with its own, the root route has no schema, and a link can
+ * be edited by hand or repeated — a parameter given twice parses to an array,
+ * and a number stays a number — so what reaches the component is a raw parse
+ * of somebody else's typing. Anything that is not the shape this page can use
+ * is dropped, which lands on the page's own defaults: this machine, the
+ * daemon's default directory, no name, no tags.
+ */
+export function validateNewSessionSearch(search: Record<string, unknown>): NewSessionSearch {
+  const out: NewSessionSearch = {}
+  if (typeof search.d === 'string' && search.d !== '') out.d = search.d
+  if (typeof search.cwd === 'string' && search.cwd !== '') out.cwd = search.cwd
+  if (typeof search.name === 'string' && search.name !== '') out.name = search.name
+  if (Array.isArray(search.tags)) {
+    const tags = search.tags.filter((t): t is string => typeof t === 'string' && t.trim() !== '')
+    if (tags.length > 0) out.tags = tags
+  }
+  return out
+}
diff --git a/web/src/sessions/open-new-session.ts b/web/src/sessions/open-new-session.ts
new file mode 100644
index 0000000..b18daa5
--- /dev/null
+++ b/web/src/sessions/open-new-session.ts
@@ -0,0 +1,48 @@
+import { useCallback } from 'react'
+import { useRouter } from '@tanstack/react-router'
+
+import {
+  NEW_SESSION_PATH,
+  newSessionSearch,
+  type NewSessionRequest,
+} from '@/sessions/new-session'
+
+/**
+ * What a press already implies about the session it is asking for: the machine
+ * of the heading it sits under, the directory of the terminal beneath it, the
+ * tag of the group. Everything absent opens the dialog empty.
+ */
+export type NewSessionOrigin = Partial<NewSessionRequest>
+
+/**
+ * Open the new-session page in a new tab.
+ *
+ * The address is built by the router rather than by hand, and that is the
+ * point of the hook: the page narrows what arrives with `validateNewSessionSearch`,
+ * the router's own serialiser is what writes arrays and strings into a query,
+ * and going through `buildLocation` is what makes the two halves agree by
+ * construction. A tag with a comma in it survives; a hand-joined string would
+ * quietly become two tags.
+ *
+ * Called straight out of a click or a form submission, never out of a reply,
+ * which is the whole reason the page exists — see the note on NewSessionRoute.
+ *
+ * A blocked popup falls back to this tab rather than to nothing at all. It is
+ * not what was asked for, but a button that visibly does nothing is worse than
+ * a button that does the old thing, and the reader can still get back with the
+ * browser's own back button.
+ */
+export function useOpenNewSession(): (want: NewSessionRequest) => void {
+  const router = useRouter()
+  return useCallback(
+    (want: NewSessionRequest) => {
+      const href = router.buildLocation({
+        to: NEW_SESSION_PATH,
+        search: newSessionSearch(want),
+      }).href
+      const tab = window.open(href, '_blank', 'noopener')
+      if (tab === null) void router.navigate({ to: href })
+    },
+    [router],
+  )
+}