diff --git a/.ai/contexts/session-cache.md b/.ai/contexts/session-cache.md
index af8777a1..fa8a1102 100644
--- a/.ai/contexts/session-cache.md
+++ b/.ai/contexts/session-cache.md
@@ -794,7 +794,7 @@ also returns `blocked` (why nothing could be read, or null) and the normalised `
 - `liveness`: at least one live descriptor. `inject`: a live descriptor with a `messagingSocketPath` that is a POSIX
   absolute path. `attach`: a live descriptor naming a tmux pane with a valid pid (the adapter's own test).
   The tiers are independent requirements: the reported tier is the highest available one, not the highest contiguous one.
-- `launch` is never available: starting a session from here is not implemented.
+- `launch`: available under the same rule as attach (probe `tmux: true`, or a live descriptor naming a tmux pane, and not `tmux: false`), and unlike the other tiers it is not withdrawn by a failed last refresh (launch runs its own ssh, as Send does); its reason otherwise starts with "needs tmux on the host". See "Remote hosts — launching a session".
 - A tier that needs a live session reads as missing on an idle host; that is "nothing to read it from", not "unsupported".
 - `annotateRemoteAttachable` (main.js) puts the profile on the project (`remoteHostProfile`). After 3 consecutive failed
   cycles (`attachBlockReason`), it sets `remoteAttachable: false` plus `remoteAttachBlocked` (the last error) on the
@@ -828,6 +828,18 @@ also returns `blocked` (why nothing could be read, or null) and the normalised `
   `session.remoteSendBlocked` disables the button with the reason in its title.
 - Stop has no gate (`test/annotate-remote-tier-gates.test.js` and `test/dom-sidebar-remote-tier-gates.test.js` pin it).
 
+## Remote hosts — launching a session (issues #218, #222)
+
+`remote-launch.js` builds the one ssh command and orchestrates launch then attach; the renderer side is `showRemoteLaunchDialog` (dialogs.js) and `launchRemoteSession` (app.js), the IPC is `remote-launch-session`.
+
+- **The command is `sh -c '<script>'`** (`shellSingleQuote`, as `remote-send.js`), so a fish or csh login shell never parses it. The script checks `[ -d "$cwd" ]`, `command -v tmux`, `command -v claude` with exit codes 9, 10, 11 (each mapped to its own message), then `exec tmux new-session -d -P -F '#{session_name}:#{window_id}.#{pane_id} #{pane_pid}' -s switchboard-<uuid8> -c "$cwd" 'claude --session-id <uuid> [flags]'`. The exact string is pinned in `test/remote-launch.test.js`.
+- **Validation, not escaping, is the guard.** The cwd must match `CWD_RE` (absolute; letters, digits, space, `. _ + @ : , = / -`; no `..` segment; at most 4096 bytes). That set has no quote, `$`, backtick, backslash, newline or leading `-`, so the single-quoting is a second layer, not the only one. The uuid is matched by regex, the tmux name derives from it, the permission mode is checked against an allow-list. The same checks run in the renderer (UX), in `handleLaunchRequest` and in the adapter.
+- **Why attach straight to the created pane.** `-P -F` prints the pane's `session:@window.%pane` and `pane_pid`. `handleLaunchRequest` hands `{ pid, tmux, sessionId, cwd }` to the existing `remoteAttachAdapter.attach`, which discovers the socket from `/proc/<pid>/environ` and runs the same pid-reuse guard (the pane's command line contains `claude`). No wait for the descriptor to show up in the next refresh; `refreshHostNow` is fired afterwards so the row's real descriptor replaces the pending one.
+- **The id is generated locally** (`crypto.randomUUID` in the renderer, validated again in main) and passed as `--session-id`, so the pending sidebar row and the later descriptor share one id.
+- **Stop is unchanged.** The pane target we created has a pane component, so `buildStopCommand` emits `kill-pane` (pinned for this exact target shape in `remote-launch.test.js`); never `kill-session`. Killing the only pane of the only window ends the tmux session as a side effect of tmux itself.
+- **A failed attach after a successful launch** leaves the tmux session running on the host; the error names it, and it appears in the sidebar at the next refresh.
+- Not verified here: a real host (the tests use a fake runner, plus a real `sh` with stubbed `tmux`/`claude`), tmux older than the `-P -F` form, and a `claude` that exits at once (the pane then closes and attach fails with the probe error).
+
 ## Remote hosts — sending a prompt (issue #219)
 
 `remote-send.js` writes one prompt to a live, unattached remote session through
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 44efe4f8..a732d1cc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ What changes for you in each release of Switchboard. How to write an entry: [doc
 ### New
 - A session's **Touched** tab, next to Changes in the terminal header, lists the files its file tools (Edit, Write, MultiEdit, NotebookEdit) touched, its subagents' included, with what is on disk now (present, gone, unreadable) and the tools and agents behind each. It works outside any git repository. It is not the complete set of files the session changed: files changed through Bash commands or scripts are not listed, and the tab says so. Local sessions only. (#309)
 - With Debug mode on, the activity trace now records how hard each terminal is being drawn: once a second per session, how many writes reached it, how large they were and how often its glyph atlas was rebuilt, to tell a legitimately busy terminal from a runaway one. (#175)
+- On a remote host with `tmux`, the project's `+` now starts a new Claude session there: pick or type a directory on the host, choose a permission mode, and Switchboard starts it in a tmux session and attaches to it. The directory must already exist on the host, `claude` must be on the PATH of an ssh command, and signing in is done on the host. (#218, #222)
 ### Changed
 - A single trigger is no longer typed into a dialog such as a permission prompt or a question: with `wait: "none"` (write now, the default) it holds while the CLI shows a dialog, and with `wait: "idle"` until the CLI is at its prompt, up to its `timeout_ms`; then it fails `not sent` with a `reason` that says a dialog is open instead of being written into it. `wait: "none"` still writes at once while the CLI is busy. Without a readable CLI descriptor it is written as before. Input you type yourself in the terminal is never held back. (#379)
 - Switchboard now checks once per host, at the first successful refresh and then every six hours (every 30 minutes while one is missing), whether `tmux` and `inotifywait` are installed. A host with `tmux` and no session running no longer shows attach as missing; a host without `tmux` no longer offers to attach to a session and opens its transcript, saying why in the tooltip; and the host's tooltip says when live updates are off because `inotifywait` is missing. On a remote host, the new-session button's tooltip now gives the reason, and Send a prompt… is disabled, with the reason, while no live session on the host reports a messaging socket. Stop is never disabled. (#218)
diff --git a/docs/remote-hosts.md b/docs/remote-hosts.md
index b80f435f..36791d0e 100644
--- a/docs/remote-hosts.md
+++ b/docs/remote-hosts.md
@@ -105,8 +105,9 @@ growing delay when it fails.
 ## In the sidebar
 
 A remote host's projects are listed like local ones, with the alias as a badge
-on each session. Their `+` is disabled (*Read-only mirror of &lt;alias&gt; — new
-sessions must be started on that host*).
+on each session. Their `+` starts a new session on the host when it has
+`tmux` (see [Launch a session](#launch-a-session)); without it the button is
+disabled and its tooltip says the host needs tmux.
 
 ### Status
 
@@ -141,8 +142,9 @@ What the tier gates:
   knows) and the descriptor names a pane. Otherwise it opens its transcript, with
   the reason in its tooltip. After three failed refreshes in a row it also opens
   its transcript, whatever the probe said.
-- **New session** stays disabled on a remote host; its tooltip gives the launch
-  tier's reason: starting a session from here is not implemented.
+- **New session** is enabled when the host has `tmux` (probe answer, or a live
+  session naming a tmux pane). Otherwise it is disabled and its tooltip gives the
+  launch tier's reason: the host needs tmux.
 - **Send a prompt…** is disabled, with the inject reason in its tooltip, while no
   live session on the host reports a messaging socket. A host whose refresh
   failed does not disable it: it runs its own ssh.
@@ -217,6 +219,35 @@ travels on ssh's standard input only, never on a command line.
   which Switchboard does not read.
 - A session attached in a terminal is refused: type in the terminal.
 
+## Launch a session
+
+The `+` of a remote project opens a dialog: the directory (a list of the host's
+known project paths, or any absolute path typed) and the permission mode, with
+Dangerous Skip as locally. Start runs one `ssh` that checks the directory
+exists (`test -d`), that `tmux` and `claude` are found, then starts
+`claude --session-id <uuid>` in a new detached tmux session named
+`switchboard-<first 8 of the uuid>`, in that directory. The uuid is generated
+by Switchboard. Switchboard then attaches to the new pane the way it attaches to
+any running session, so you land in it.
+
+- Only tmux hosts can launch. There is no launch without a multiplexer. A failed
+  last refresh does not disable it: it runs its own ssh.
+- A directory that does not exist on the host refuses the launch, and the
+  terminal tab says so.
+- Authentication is done on the host, by you. Switchboard copies no credential;
+  a CLI that is not logged in shows its own login prompt in the pane.
+- `claude` must be on the `PATH` of a non-interactive ssh command. When it is
+  only added by an interactive shell profile, the launch says it was not found.
+- The directory may only contain letters, digits, space and `. _ + @ : , = / -`,
+  must be absolute and must not contain a `..` segment. Anything else is refused
+  before ssh runs.
+- Only the permission mode maps to a CLI flag. The local dialog's worktree, Chrome,
+  sandbox, pre-launch command and additional directories do not apply to a remote
+  launch.
+- Stop works as for any remote session: it kills the pane, never the tmux
+  session. Closing the only pane of a session ends that session.
+- Linux hosts only, as for attach.
+
 ## Known limits
 
 Session ids are not namespaced per host. Two hosts with a session of the same
diff --git a/eslint.config.js b/eslint.config.js
index e80e0e07..baa02629 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -114,6 +114,7 @@ const rendererCrossFileGlobals = {
   confirmAndStopSession: 'readonly',
   pollActiveSessions: 'readonly',
   showNewSessionPopover: 'readonly',
+  showRemoteLaunchDialog: 'readonly',
   openSettingsViewer: 'readonly',
   wireActivityTraceToggle: 'readonly',
   wireActivityReportingToggle: 'readonly',
@@ -281,6 +282,7 @@ const rendererCrossFileGlobals = {
   setSessionSandboxed: 'readonly',
   destroySession: 'readonly',
   launchNewSession: 'readonly',
+  launchRemoteSession: 'readonly',
   launchTerminalSession: 'readonly',
   launchScheduleCreator: 'readonly',
   resolveDefaultSessionOptions: 'readonly',
diff --git a/main.js b/main.js
index d1f2b13b..5a4cd49c 100644
--- a/main.js
+++ b/main.js
@@ -82,7 +82,8 @@ const { handleTerminalInput } = require('./terminal-input');
 const { createTriggerContext } = require('./trigger-context');
 const { createTmuxAttachAdapter } = require('./remote-attach');
 const { createRemoteStopAdapter } = require('./remote-stop');
-const { attachBlockReason, sendBlockReason } = require('./remote-host-profile');
+const { attachBlockReason, sendBlockReason, launchBlockReason } = require('./remote-host-profile');
+const { createRemoteLaunchAdapter, handleLaunchRequest } = require('./remote-launch');
 const { createRemoteSendAdapter, handleSendRequest } = require('./remote-send');
 const { createGitChangesRunner, localGitEnv } = require('./git-changes-runner');
 const { runToExit } = require('./run-to-exit');
@@ -564,6 +565,9 @@ const remoteStopAdapter = createRemoteStopAdapter({ log });
 // see .ai/contexts/session-cache.md ("Remote hosts — sending a prompt")
 const remoteSendAdapter = createRemoteSendAdapter({ log });
 
+// see .ai/contexts/session-cache.md ("Remote hosts — launching a session")
+const remoteLaunchAdapter = createRemoteLaunchAdapter({ log });
+
 // Joins the sidebar's remote sessions to the indexer's live descriptors so the
 // renderer can route a click without ever naming an attach mechanism itself
 // — see .ai/contexts/session-cache.md ("Remote hosts — tmux attach").
@@ -1693,6 +1697,27 @@ ipcMain.handle('remote-stop-session', async (_event, payload) => {
   return result;
 });
 
+// --- IPC: remote-launch-session ---
+// see .ai/contexts/session-cache.md ("Remote hosts — launching a session")
+ipcMain.handle('remote-launch-session', async (_event, payload) => {
+  if (!mainWindow) return { ok: false, error: 'no window' };
+  const rawId = payload && payload.sessionId;
+  const sessionId = typeof rawId === 'string' ? rawId.toLowerCase() : null;
+  if (sessionId && activeSessions.has(sessionId)) return { ok: false, error: 'invalid request' };
+  const result = await handleLaunchRequest(payload, {
+    hasHost: (alias) => enabledHosts((getSetting('global') || {}).remoteHosts).some(h => h.alias === alias),
+    launchBlockReason: (alias) => launchBlockReason(remoteIndexer.getRemoteHostProfile(alias)),
+    adapter: remoteLaunchAdapter,
+    attach: (alias, descriptor, size) => remoteAttachAdapter.attach(alias, descriptor, size),
+  });
+  if (!result.ok) return { ok: false, error: result.error };
+  const session = registerRemoteAttachSession(result.descriptor.sessionId, {
+    alias: payload.alias, projectPath: result.descriptor.cwd, cwd: result.descriptor.cwd, ptyProcess: result.attachResult.ptyProcess,
+  });
+  remoteIndexer.refreshHostNow(payload.alias, { force: true }).catch(() => {});
+  return { ok: true, remote: true, generation: session.generation };
+});
+
 // --- IPC: remote-send-prompt ---
 // see .ai/contexts/session-cache.md ("Remote hosts — sending a prompt")
 ipcMain.handle('remote-send-prompt', (_event, payload) => handleSendRequest(payload, {
@@ -2315,6 +2340,24 @@ function wireSessionPty(session, sessionId, ptyProcess) {
 }
 
 // --- IPC: open-terminal ---
+function registerRemoteAttachSession(sessionId, { alias, projectPath, cwd, ptyProcess }) {
+  const remoteSession = {
+    pty: ptyProcess,
+    // handle: {write, isAlive} — see .ai/contexts/trigger-watcher.md, "Session handle"
+    handle: ptyProcess,
+    host: alias, kind: 'remote-attach',
+    rendererAttached: true, exited: false,
+    outputBuffer: [], outputBufferSize: 0, altScreen: false,
+    projectPath, firstResize: true,
+    cwd,
+    isPlainTerminal: false,
+    _openedAt: Date.now(),
+  };
+  activeSessions.set(sessionId, remoteSession);
+  wireSessionPty(remoteSession, sessionId, ptyProcess);
+  return remoteSession;
+}
+
 ipcMain.handle('open-terminal', async (_event, sessionId, projectPath, isNew, sessionOptions, initialSize) => {
   if (!mainWindow) return { ok: false, error: 'no window' };
 
@@ -2365,20 +2408,9 @@ ipcMain.handle('open-terminal', async (_event, sessionId, projectPath, isNew, se
       if (!attachResult.ok) return { ok: false, error: attachResult.error || REMOTE_READ_ONLY };
 
       const remoteCwd = (descriptor && typeof descriptor.cwd === 'string') ? descriptor.cwd : null;
-      const remoteSession = {
-        pty: attachResult.ptyProcess,
-        // handle: {write, isAlive} — see .ai/contexts/trigger-watcher.md, "Session handle"
-        handle: attachResult.ptyProcess,
-        host: alias, kind: 'remote-attach',
-        rendererAttached: true, exited: false,
-        outputBuffer: [], outputBufferSize: 0, altScreen: false,
-        projectPath, firstResize: true,
-        cwd: remoteCwd,
-        isPlainTerminal: false,
-        _openedAt: Date.now(),
-      };
-      activeSessions.set(sessionId, remoteSession);
-      wireSessionPty(remoteSession, sessionId, attachResult.ptyProcess);
+      const remoteSession = registerRemoteAttachSession(sessionId, {
+        alias, projectPath, cwd: remoteCwd, ptyProcess: attachResult.ptyProcess,
+      });
       return { ok: true, reattached: false, remote: true, sandbox: false, generation: remoteSession.generation };
     }
   }
diff --git a/preload.js b/preload.js
index 794f0495..21a7ee43 100644
--- a/preload.js
+++ b/preload.js
@@ -22,6 +22,7 @@ contextBridge.exposeInMainWorld('api', {
   stopSession: (id) => ipcRenderer.invoke('stop-session', id),
   // see .ai/contexts/session-state.md ("The two lifecycle verbs: detach and stop")
   remoteStopSession: (alias, sessionId) => ipcRenderer.invoke('remote-stop-session', { alias, sessionId }),
+  remoteLaunchSession: (payload) => ipcRenderer.invoke('remote-launch-session', payload),
   remoteSendPrompt: (alias, sessionId, text) => ipcRenderer.invoke('remote-send-prompt', { alias, sessionId, text }),
   toggleStar: (id) => ipcRenderer.invoke('toggle-star', id),
   renameSession: (id, name) => ipcRenderer.invoke('rename-session', id, name),
diff --git a/public/app.js b/public/app.js
index 25e99c49..795e1913 100644
--- a/public/app.js
+++ b/public/app.js
@@ -1115,10 +1115,12 @@ async function loadProjects({ resort = false } = {}) {
       hasReinjected = true;
       // Still pending — re-inject into cached data
       for (const projList of [cachedProjects, cachedAllProjects]) {
-        let proj = projList.find(p => p.projectPath === pending.projectPath);
+        const pendingAlias = pending.session.remoteAlias || null;
+        let proj = projList.find(p => p.projectPath === pending.projectPath && (p.remoteAlias || null) === pendingAlias);
         if (!proj) {
           // Project not in list (no other sessions) — create a synthetic entry
           proj = { folder: pending.folder, projectPath: pending.projectPath, sessions: [] };
+          if (pendingAlias) proj.remoteAlias = pendingAlias;
           projList.unshift(proj);
         }
         if (!proj.sessions.some(s => s.sessionId === sid)) {
@@ -1206,6 +1208,51 @@ async function launchNewSession(project, sessionOptions) {
   pollActiveSessions();
 }
 
+// see .ai/contexts/session-cache.md ("Remote hosts — launching a session")
+async function launchRemoteSession(project, { cwd, options }) {
+  const alias = project.remoteAlias;
+  const sessionId = crypto.randomUUID();
+  const session = {
+    sessionId,
+    summary: 'New session',
+    firstPrompt: '',
+    projectPath: cwd,
+    name: null,
+    starred: 0,
+    archived: 0,
+    messageCount: 0,
+    modified: new Date().toISOString(),
+    created: new Date().toISOString(),
+    remoteAlias: alias,
+  };
+
+  const folder = alias + '::' + encodeProjectPath(cwd);
+  pendingSessions.set(sessionId, { session, projectPath: cwd, folder });
+  sessionMap.set(sessionId, session);
+  for (const projList of [cachedProjects, cachedAllProjects]) {
+    let proj = projList.find(p => p.remoteAlias === alias && p.projectPath === cwd);
+    if (!proj) {
+      proj = { folder, projectPath: cwd, remoteAlias: alias, sessions: [] };
+      projList.unshift(proj);
+    }
+    proj.sessions.unshift(session);
+  }
+  refreshSidebar();
+
+  const entry = createTerminalEntry(session);
+  const result = await window.api.remoteLaunchSession({ alias, sessionId, cwd, options, initialSize: entry.initialSize });
+  if (!result.ok) {
+    entry.terminal.write(`\r\nError: ${result.error}\r\n`);
+    entry.closed = true;
+    showSession(sessionId);
+    return;
+  }
+  syncPtySizeAfterOpen(entry);
+  showSession(sessionId);
+  schedulePersistWorkingSet();
+  pollActiveSessions();
+}
+
 // Legacy alias
 function openNewSession(project) {
   return launchNewSession(project);
diff --git a/public/dialogs.js b/public/dialogs.js
index 04e61086..1995512a 100644
--- a/public/dialogs.js
+++ b/public/dialogs.js
@@ -317,6 +317,107 @@ async function showNewSessionDialog(project) {
   document.addEventListener('keydown', onKey);
 }
 
+const REMOTE_LAUNCH_PATH_RE = /^\/[A-Za-z0-9._+@:,=/ -]*$/;
+
+function knownRemotePaths(alias) {
+  const paths = new Set();
+  for (const p of cachedProjects) {
+    if (p.remoteAlias === alias && p.projectPath) paths.add(p.projectPath);
+  }
+  return [...paths].sort();
+}
+
+// see .ai/contexts/session-cache.md ("Remote hosts — launching a session")
+function showRemoteLaunchDialog(project) {
+  const alias = project.remoteAlias;
+  const overlay = document.createElement('div');
+  overlay.className = 'new-session-overlay';
+  const dialog = document.createElement('div');
+  dialog.className = 'new-session-dialog';
+
+  let selectedMode = null;
+  let dangerousSkip = false;
+
+  function renderModeGrid() {
+    return PERMISSION_MODES.map(m => {
+      const isSelected = !dangerousSkip && selectedMode === m.value;
+      return `<button class="permission-option${isSelected ? ' selected' : ''}" data-mode="${m.value}"><span class="perm-name">${m.label}</span><span class="perm-desc">${m.desc}</span></button>`;
+    }).join('') +
+    `<button class="permission-option dangerous${dangerousSkip ? ' selected' : ''}" data-mode="dangerous-skip"><span class="perm-name">Dangerous Skip</span><span class="perm-desc">Skip all safety prompts (use with caution)</span></button>`;
+  }
+
+  const pathOptions = knownRemotePaths(alias).map(p => `<option value="${escapeHtml(p)}"></option>`).join('');
+  dialog.innerHTML = `
+    <h3>New Session on ${escapeHtml(alias)}</h3>
+    <div class="new-session-body">
+    <div class="settings-field settings-field-wide">
+      <div class="settings-field-info">
+        <span class="settings-label">Directory on ${escapeHtml(alias)}</span>
+        <div class="settings-description">Pick a known project or type an absolute path. It must exist on the host.</div>
+      </div>
+      <div class="settings-field-control">
+        <input type="text" class="settings-input" id="rld-path" list="rld-paths" value="${escapeHtml(project.projectPath || '')}">
+        <datalist id="rld-paths">${pathOptions}</datalist>
+      </div>
+    </div>
+    <div class="settings-field">
+      <div class="settings-label">Permission Mode</div>
+      <div class="permission-grid" id="rld-mode-grid">${renderModeGrid()}</div>
+    </div>
+    <div class="new-session-error" id="rld-error"></div>
+    </div>
+    <div class="new-session-actions">
+      <button class="new-session-cancel-btn">Cancel</button>
+      <button class="new-session-start-btn">Start</button>
+    </div>
+  `;
+  overlay.appendChild(dialog);
+  document.body.appendChild(overlay);
+
+  const modeGrid = dialog.querySelector('#rld-mode-grid');
+  modeGrid.addEventListener('click', (e) => {
+    const btn = e.target.closest('.permission-option');
+    if (!btn) return;
+    const mode = btn.dataset.mode;
+    if (mode === 'dangerous-skip') {
+      dangerousSkip = !dangerousSkip;
+      if (dangerousSkip) selectedMode = null;
+    } else {
+      dangerousSkip = false;
+      selectedMode = mode === 'null' ? null : mode;
+    }
+    modeGrid.innerHTML = renderModeGrid();
+  });
+
+  function close() {
+    overlay.remove();
+    document.removeEventListener('keydown', onKey);
+  }
+
+  function start() {
+    const cwd = dialog.querySelector('#rld-path').value.trim();
+    if (!REMOTE_LAUNCH_PATH_RE.test(cwd)) {
+      dialog.querySelector('#rld-error').textContent = 'Enter an absolute path made of letters, digits, space and . _ + @ : , = / -';
+      return;
+    }
+    const options = {};
+    if (dangerousSkip) options.dangerouslySkipPermissions = true;
+    else if (selectedMode) options.permissionMode = selectedMode;
+    close();
+    launchRemoteSession(project, { cwd, options });
+  }
+
+  dialog.querySelector('.new-session-cancel-btn').onclick = close;
+  dialog.querySelector('.new-session-start-btn').onclick = start;
+  overlay.addEventListener('click', (e) => { if (e.target === overlay) close(); });
+
+  function onKey(e) {
+    if (e.key === 'Escape') close();
+    if (e.key === 'Enter' && e.target.matches('input')) start();
+  }
+  document.addEventListener('keydown', onKey);
+}
+
 async function showResumeSessionDialog(session) {
   const effective = await window.api.getEffectiveSettings(session.projectPath);
 
diff --git a/public/sidebar.js b/public/sidebar.js
index 748a7e69..23cf8001 100644
--- a/public/sidebar.js
+++ b/public/sidebar.js
@@ -6,7 +6,7 @@
 // sessionBusyState, cachedProjects, cachedAllProjects, gridCards, gridViewActive (app.js)
 // Depends on: cleanDisplayName, formatDate, escapeHtml (utils.js), ICONS (icons.js),
 // showSession (terminal-manager.js), confirmAndStopSession, pollActiveSessions,
-// showNewSessionPopover, openSettingsViewer, showResumeSessionDialog,
+// showNewSessionPopover, showRemoteLaunchDialog, openSettingsViewer, showResumeSessionDialog,
 // showJsonlViewer, forkSession, openSession, loadProjects (app.js/dialogs.js), resolveSessionStop, isRemoteSessionAlive, stopBeforeArchive (stop-session-ui.js)
 
 function slugId(slug) {
@@ -890,12 +890,16 @@ function renderProjects(projects, resort) {
     newBtn.className = 'project-new-btn';
     newBtn.innerHTML = '<svg width="12" height="12" viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="1.5"><line x1="6" y1="2" x2="6" y2="10"/><line x1="2" y1="6" x2="10" y2="6"/></svg>';
     if (project.remoteAlias) {
-      newBtn.disabled = true;
       const launch = project.remoteHostProfile && Array.isArray(project.remoteHostProfile.tiers)
         && project.remoteHostProfile.tiers.find(t => t.tier === 'launch');
-      newBtn.title = launch && launch.reason
-        ? 'New session unavailable on ' + project.remoteAlias + ': ' + launch.reason
-        : 'Read-only mirror of ' + project.remoteAlias + ' — new sessions must be started on that host';
+      if (launch && launch.available) {
+        newBtn.title = 'New session on ' + project.remoteAlias;
+      } else {
+        newBtn.disabled = true;
+        newBtn.title = launch && launch.reason
+          ? 'New session unavailable on ' + project.remoteAlias + ': ' + launch.reason
+          : 'Read-only mirror of ' + project.remoteAlias + ' — new sessions must be started on that host';
+      }
     } else {
       newBtn.title = 'New session';
     }
@@ -1064,7 +1068,10 @@ function rebindSidebarEvents(projects) {
     const newBtn = header.querySelector('.project-new-btn');
     if (newBtn) {
       if (project.remoteAlias) {
-        newBtn.onclick = (e) => e.stopPropagation();
+        newBtn.onclick = (e) => {
+          e.stopPropagation();
+          if (!newBtn.disabled) showRemoteLaunchDialog(project);
+        };
       } else {
         newBtn.onclick = (e) => { e.stopPropagation(); showNewSessionPopover(project, newBtn); };
       }
diff --git a/public/style.css b/public/style.css
index 282aeb0f..16671508 100644
--- a/public/style.css
+++ b/public/style.css
@@ -4186,6 +4186,12 @@ body { display: flex; flex-direction: column; }
   word-break: break-word;
 }
 
+.new-session-error {
+  color: #e8a838;
+  font-size: 12px;
+  min-height: 16px;
+}
+
 .new-session-actions {
   display: flex;
   justify-content: flex-end;
diff --git a/remote-host-profile.js b/remote-host-profile.js
index 50de059b..c4cfc796 100644
--- a/remote-host-profile.js
+++ b/remote-host-profile.js
@@ -5,6 +5,7 @@ const { parseTmuxField, isValidPid } = require('./remote-attach');
 
 const ATTACH_BLOCK_AFTER_FAILURES = 3;
 const TIERS = ['observe', 'liveness', 'inject', 'attach', 'launch'];
+const LAUNCH_NEEDS_TMUX_REASON = 'needs tmux on the host';
 const TMUX_MISSING_REASON = 'tmux is not installed on this host (command -v tmux found nothing)';
 
 function hasPosixSocketPath(descriptor) {
@@ -20,6 +21,12 @@ function toolFlag(value) {
   return value === true || value === false ? value : null;
 }
 
+function launchReason(tools, descriptors) {
+  if (tools.tmux === false) return LAUNCH_NEEDS_TMUX_REASON + ': ' + TMUX_MISSING_REASON;
+  if (tools.tmux === true || descriptors.some(namesTmuxPane)) return null;
+  return LAUNCH_NEEDS_TMUX_REASON + ' (not confirmed: no probe answer yet and no live session names a tmux pane)';
+}
+
 function normalizeTools(tools) {
   const t = tools && typeof tools === 'object' ? tools : {};
   return { tmux: toolFlag(t.tmux), inotifywait: toolFlag(t.inotifywait) };
@@ -49,6 +56,7 @@ function computeHostProfile(input) {
   const reasons = {};
   if (blocked) {
     for (const tier of TIERS) reasons[tier] = blocked;
+    if (error) reasons.launch = launchReason(tools, descriptors);
   } else {
     reasons.observe = null;
     reasons.liveness = descriptors.length > 0 ? null
@@ -58,7 +66,7 @@ function computeHostProfile(input) {
     if (tools.tmux === false) reasons.attach = TMUX_MISSING_REASON;
     else if (tools.tmux === true || descriptors.some(namesTmuxPane)) reasons.attach = null;
     else reasons.attach = 'no live session names a tmux pane in its descriptor (start it inside tmux)';
-    reasons.launch = 'new sessions cannot be started from here; they must be started on the host';
+    reasons.launch = launchReason(tools, descriptors);
   }
 
   const tiers = TIERS.map(tier => ({ tier, available: reasons[tier] === null, reason: reasons[tier] }));
@@ -84,11 +92,16 @@ function attachBlockReason(profile, consecutiveFailures) {
   return null;
 }
 
+function launchBlockReason(profile) {
+  if (!profile) return 'not yet synced with this host';
+  return tierReason(profile, 'launch');
+}
+
 function sendBlockReason(profile) {
   if (!profile || profile.blocked) return null;
   return tierReason(profile, 'inject');
 }
 
 module.exports = {
-  computeHostProfile, attachBlockReason, sendBlockReason, ATTACH_BLOCK_AFTER_FAILURES, TIERS, TMUX_MISSING_REASON,
+  computeHostProfile, attachBlockReason, sendBlockReason, launchBlockReason, ATTACH_BLOCK_AFTER_FAILURES, TIERS, TMUX_MISSING_REASON,
 };
diff --git a/remote-launch.js b/remote-launch.js
new file mode 100644
index 00000000..6efb55af
--- /dev/null
+++ b/remote-launch.js
@@ -0,0 +1,160 @@
+// remote-launch.js — see .ai/contexts/session-cache.md ("Remote hosts — launching a session")
+'use strict';
+
+const {
+  isValidPid,
+  parseTmuxField,
+  shellSingleQuote,
+  defaultRunRemoteCommand,
+} = require('./remote-attach');
+const { isValidAlias } = require('./remote-hosts');
+
+const DEFAULT_LAUNCH_TIMEOUT_MS = 20000;
+const NO_DIR_EXIT_CODE = 9;
+const NO_TMUX_EXIT_CODE = 10;
+const NO_CLAUDE_EXIT_CODE = 11;
+const MAX_CWD_BYTES = 4096;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const CWD_RE = /^\/[A-Za-z0-9._+@:,=/ -]*$/;
+const PERMISSION_MODES = ['auto', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions'];
+const LAUNCH_OUTPUT_RE = /^([A-Za-z0-9._-]{1,64}:@\d{1,10}\.%\d{1,10}) (\d{1,10})$/;
+const LIST_FORMAT = '#{session_name}:#{window_id}.#{pane_id} #{pane_pid}';
+
+function validateSessionId(value) {
+  if (typeof value !== 'string' || !UUID_RE.test(value)) return { ok: false, error: 'the session id is not a uuid' };
+  return { ok: true };
+}
+
+function validateLaunchCwd(value) {
+  if (typeof value !== 'string' || !value.startsWith('/')) return { ok: false, error: 'the directory must be an absolute path' };
+  if (Buffer.byteLength(value) > MAX_CWD_BYTES) return { ok: false, error: 'the directory path is too long' };
+  if (!CWD_RE.test(value)) {
+    return { ok: false, error: 'the directory may only contain these characters: letters, digits, space and . _ + @ : , = / -' };
+  }
+  if (value.split('/').includes('..')) return { ok: false, error: 'the directory must not contain a .. segment' };
+  return { ok: true };
+}
+
+function tmuxSessionName(sessionId) {
+  return `switchboard-${sessionId.slice(0, 8).toLowerCase()}`;
+}
+
+function buildClaudeArgs(options) {
+  const o = options && typeof options === 'object' ? options : {};
+  if (o.dangerouslySkipPermissions === true) return { ok: true, args: ['--dangerously-skip-permissions'] };
+  if (o.permissionMode == null) return { ok: true, args: [] };
+  if (!PERMISSION_MODES.includes(o.permissionMode)) return { ok: false, error: 'unknown permission mode' };
+  return { ok: true, args: ['--permission-mode', o.permissionMode] };
+}
+
+function buildLaunchScript({ sessionId, cwd, options }) {
+  const id = validateSessionId(sessionId);
+  if (!id.ok) throw new Error(id.error);
+  const dir = validateLaunchCwd(cwd);
+  if (!dir.ok) throw new Error(dir.error);
+  const flags = buildClaudeArgs(options);
+  if (!flags.ok) throw new Error(flags.error);
+  const claude = ['claude', '--session-id', sessionId.toLowerCase(), ...flags.args].join(' ');
+  return `cwd=${shellSingleQuote(cwd)}; [ -d "$cwd" ] || exit ${NO_DIR_EXIT_CODE}; ` +
+    `command -v tmux >/dev/null 2>&1 || exit ${NO_TMUX_EXIT_CODE}; ` +
+    `command -v claude >/dev/null 2>&1 || exit ${NO_CLAUDE_EXIT_CODE}; ` +
+    `exec tmux new-session -d -P -F '${LIST_FORMAT}' -s ${tmuxSessionName(sessionId)} -c "$cwd" ${shellSingleQuote(claude)}`;
+}
+
+function buildLaunchCommand(request) {
+  return `sh -c ${shellSingleQuote(buildLaunchScript(request))}`;
+}
+
+function parseLaunchOutput(stdout) {
+  if (typeof stdout !== 'string') return null;
+  const lines = stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+  const m = LAUNCH_OUTPUT_RE.exec(lines.length ? lines[lines.length - 1] : '');
+  if (!m || !parseTmuxField(m[1])) return null;
+  const pid = Number.parseInt(m[2], 10);
+  return isValidPid(pid) ? { tmux: m[1], pid } : null;
+}
+
+function createRemoteLaunchAdapter(opts = {}) {
+  const runRemoteCommand = opts.runRemoteCommand || defaultRunRemoteCommand;
+  const log = opts.log || { info() {}, warn() {}, error() {} };
+
+  async function launch(alias, request) {
+    const id = validateSessionId(request && request.sessionId);
+    if (!id.ok) return id;
+    const dir = validateLaunchCwd(request.cwd);
+    if (!dir.ok) return dir;
+    const flags = buildClaudeArgs(request.options);
+    if (!flags.ok) return flags;
+
+    let result;
+    try {
+      result = await runRemoteCommand(alias, buildLaunchCommand(request), { timeoutMs: DEFAULT_LAUNCH_TIMEOUT_MS });
+    } catch (err) {
+      return { ok: false, error: `launch failed: ${err.message}` };
+    }
+    if (!result) return { ok: false, error: 'launch failed: no response' };
+    if (result.timedOut) return { ok: false, error: `launch timed out on ${alias} — the session may have started` };
+    if (result.code === NO_DIR_EXIT_CODE) return { ok: false, error: `directory ${request.cwd} does not exist on ${alias}` };
+    if (result.code === NO_TMUX_EXIT_CODE) return { ok: false, error: `tmux is not installed on ${alias}` };
+    if (result.code === NO_CLAUDE_EXIT_CODE) {
+      return { ok: false, error: `claude was not found on the PATH of an ssh command on ${alias}` };
+    }
+    if (result.code !== 0) {
+      const reason = (result.stderr || '').trim() || 'no stderr';
+      return { ok: false, error: `launch failed (exit ${result.code}): ${reason}` };
+    }
+    const parsed = parseLaunchOutput(result.stdout);
+    if (!parsed) {
+      return { ok: false, error: `launch ran on ${alias} but its tmux target could not be read (session ${tmuxSessionName(request.sessionId)})` };
+    }
+    log.info(`[remote-launch:${alias}] started ${parsed.tmux} (pid ${parsed.pid}) in ${request.cwd}`);
+    return { ok: true, descriptor: { sessionId: request.sessionId.toLowerCase(), pid: parsed.pid, tmux: parsed.tmux, cwd: request.cwd } };
+  }
+
+  return { launch };
+}
+
+function normalizeSize(size) {
+  const ok = size && Number.isInteger(size.cols) && size.cols > 0 && Number.isInteger(size.rows) && size.rows > 0;
+  return ok ? { cols: size.cols, rows: size.rows } : null;
+}
+
+async function handleLaunchRequest(payload, deps) {
+  const alias = payload && payload.alias;
+  if (typeof alias !== 'string' || !isValidAlias(alias) || !deps.hasHost(alias)) return { ok: false, error: 'invalid request' };
+  const id = validateSessionId(payload.sessionId);
+  if (!id.ok) return id;
+  const dir = validateLaunchCwd(payload.cwd);
+  if (!dir.ok) return dir;
+  const flags = buildClaudeArgs(payload.options);
+  if (!flags.ok) return flags;
+
+  const blocked = deps.launchBlockReason(alias);
+  if (blocked) return { ok: false, error: blocked };
+
+  const launched = await deps.adapter.launch(alias, { sessionId: payload.sessionId, cwd: payload.cwd, options: payload.options });
+  if (!launched.ok) return launched;
+
+  const attachResult = await deps.attach(alias, launched.descriptor, normalizeSize(payload.initialSize));
+  if (!attachResult || !attachResult.ok) {
+    const why = (attachResult && attachResult.error) || 'no response';
+    return { ok: false, error: `the session was started on ${alias} as ${launched.descriptor.tmux} but attaching failed: ${why}` };
+  }
+  return { ok: true, descriptor: launched.descriptor, attachResult };
+}
+
+module.exports = {
+  validateLaunchCwd,
+  validateSessionId,
+  buildClaudeArgs,
+  buildLaunchScript,
+  buildLaunchCommand,
+  parseLaunchOutput,
+  tmuxSessionName,
+  createRemoteLaunchAdapter,
+  handleLaunchRequest,
+  NO_DIR_EXIT_CODE,
+  NO_TMUX_EXIT_CODE,
+  NO_CLAUDE_EXIT_CODE,
+  PERMISSION_MODES,
+};
diff --git a/test/annotate-remote-attachable-local-status.test.js b/test/annotate-remote-attachable-local-status.test.js
index 49006d0c..6656ffe3 100644
--- a/test/annotate-remote-attachable-local-status.test.js
+++ b/test/annotate-remote-attachable-local-status.test.js
@@ -145,7 +145,7 @@ test('a session on a host that failed three refreshes in a row is not attachable
   assert.equal(session.remoteAttachable, false);
   assert.match(session.remoteAttachBlocked, /connect timed out/);
   assert.equal(session.remoteStopBlocked, undefined, 'stop runs its own ssh and is never blocked by a poll failure');
-  assert.equal(projects[0].remoteHostProfile.tier, 'none');
+  assert.equal(projects[0].remoteHostProfile.tier, 'launch');
 });
 
 test('a single failed refresh does not block attach, while the project profile still states the error', () => {
@@ -158,7 +158,7 @@ test('a single failed refresh does not block attach, while the project profile s
   const session = projects[0].sessions[0];
   assert.equal(session.remoteAttachable, true);
   assert.equal(session.remoteAttachBlocked, null);
-  assert.match(projects[0].remoteHostProfile.missing[0].reason, /connect timed out/);
+  assert.match(projects[0].remoteHostProfile.tiers.find(t => t.tier === 'observe').reason, /connect timed out/);
 });
 
 test('a session on a healthy host carries no blocking reason and the project carries the host profile', () => {
@@ -175,7 +175,7 @@ test('a session on a healthy host carries no blocking reason and the project car
   const session = projects[0].sessions[0];
   assert.equal(session.remoteAttachable, true);
   assert.equal(session.remoteAttachBlocked, null);
-  assert.equal(projects[0].remoteHostProfile.tier, 'attach');
+  assert.equal(projects[0].remoteHostProfile.tier, 'launch');
 });
 
 test('a remote session carries the descriptor waitingFor, and null when the descriptor has none or is gone', () => {
diff --git a/test/app-pending-remote-reinject.test.js b/test/app-pending-remote-reinject.test.js
new file mode 100644
index 00000000..9a49f420
--- /dev/null
+++ b/test/app-pending-remote-reinject.test.js
@@ -0,0 +1,68 @@
+'use strict';
+
+// loadProjects re-injects a session that has no transcript yet. A launched
+// remote session must go back under its own host's project, never under a
+// local project that happens to have the same path.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { setupSidebarDom } = require('./dom-setup');
+const { loadAppFunctions } = require('./app-source');
+
+const ID = '3f2a9c10-7b1d-4e55-9a60-0123456789ab';
+
+function run(projects, pendingSession, pendingFolder) {
+  const ctx = setupSidebarDom();
+  try {
+    const { window } = ctx;
+    window.loadingStatus = window.document.createElement('div');
+    window.reportActivityFocus = () => {};
+    window.reportActivityTitles = () => {};
+    window.pollActiveSessions = async () => {};
+    window.refreshSidebar = () => {};
+    window.renderDefaultStatus = () => {};
+    window.encodeProjectPath = (p) => p.replace(/\//g, '-');
+    window.api = {
+      getProjects: async () => JSON.parse(JSON.stringify(projects)),
+      getActiveTerminals: async () => [],
+    };
+    window.cachedProjects = [];
+    window.cachedAllProjects = [];
+    window.pendingSessions.set(ID, { session: pendingSession, projectPath: pendingSession.projectPath, folder: pendingFolder });
+    const fns = loadAppFunctions(ctx.context, { functions: ['dedup', 'loadProjects'] });
+    return fns.loadProjects().then(() => JSON.parse(JSON.stringify({
+      cached: window.cachedProjects,
+      all: window.cachedAllProjects,
+    })));
+  } finally {
+    ctx.destroy();
+  }
+}
+
+const LOCAL = { folder: '-srv-app', projectPath: '/srv/app', sessions: [] };
+const REMOTE = { folder: 'box::-srv-app', projectPath: '/srv/app', remoteAlias: 'box', sessions: [] };
+const remoteSession = { sessionId: ID, projectPath: '/srv/app', remoteAlias: 'box', summary: 'New session' };
+
+test('a pending remote session is re-injected under the remote project, not the local one with the same path', async () => {
+  const { cached, all } = await run([LOCAL, REMOTE], remoteSession, 'box::-srv-app');
+  for (const list of [cached, all]) {
+    assert.deepEqual(list.find(p => !p.remoteAlias).sessions, []);
+    assert.deepEqual(list.find(p => p.remoteAlias === 'box').sessions.map(s => s.sessionId), [ID]);
+  }
+});
+
+test('with only a local project at that path, the pending remote session gets its own remote entry', async () => {
+  const { cached } = await run([LOCAL], remoteSession, 'box::-srv-app');
+  assert.deepEqual(cached.find(p => !p.remoteAlias).sessions, []);
+  const created = cached.find(p => p.remoteAlias === 'box');
+  assert.equal(created.folder, 'box::-srv-app');
+  assert.deepEqual(created.sessions.map(s => s.sessionId), [ID]);
+});
+
+test('a pending local session still lands under the local project', async () => {
+  const local = { sessionId: ID, projectPath: '/srv/app', summary: 'New session' };
+  const { cached } = await run([LOCAL, REMOTE], local, '-srv-app');
+  assert.deepEqual(cached.find(p => !p.remoteAlias).sessions.map(s => s.sessionId), [ID]);
+  assert.deepEqual(cached.find(p => p.remoteAlias === 'box').sessions, []);
+});
diff --git a/test/dom-remote-launch.test.js b/test/dom-remote-launch.test.js
new file mode 100644
index 00000000..8261f26e
--- /dev/null
+++ b/test/dom-remote-launch.test.js
@@ -0,0 +1,179 @@
+'use strict';
+
+// Issue #218 / #222: the remote New session dialog (public/dialogs.js) and
+// the renderer flow that follows it (launchRemoteSession in public/app.js,
+// extracted from the shipped source). Only the outside edges are stubbed.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+const { setupSidebarDom } = require('./dom-setup');
+const { loadAppFunctions } = require('./app-source');
+
+const plain = (value) => JSON.parse(JSON.stringify(value));
+const DIALOGS_PATH = path.join(__dirname, '..', 'public', 'dialogs.js');
+
+function remoteProject(alias, projectPath) {
+  return { folder: `${alias}::${projectPath.replace(/\//g, '-')}`, projectPath, remoteAlias: alias, sessions: [] };
+}
+
+function harness() {
+  const ctx = setupSidebarDom();
+  const { window } = ctx;
+  const launched = [];
+  window.launchRemoteSession = (project, request) => { launched.push({ project, request }); };
+  window.cachedProjects = [
+    remoteProject('box', '/srv/app'),
+    remoteProject('box', '/srv/api'),
+    remoteProject('box', '/srv/app'),
+    remoteProject('other', '/srv/elsewhere'),
+    { folder: '-home-dev-local', projectPath: '/home/dev/local', sessions: [] },
+  ];
+  vm.runInContext(fs.readFileSync(DIALOGS_PATH, 'utf8'), ctx.context, { filename: DIALOGS_PATH });
+  return { ctx, window, document: window.document, launched };
+}
+
+test('the dialog lists the known paths of that host only, once each, and pre-fills the project path', () => {
+  const { ctx, window, document } = harness();
+  try {
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    const options = [...document.querySelectorAll('#rld-paths option')].map(o => o.value);
+    assert.deepEqual(options, ['/srv/api', '/srv/app']);
+    assert.equal(document.querySelector('#rld-path').value, '/srv/app');
+    assert.match(document.querySelector('.new-session-dialog h3').textContent, /box/);
+  } finally { ctx.destroy(); }
+});
+
+test('Start launches with the typed path and the default options', () => {
+  const { ctx, window, document, launched } = harness();
+  try {
+    const project = remoteProject('box', '/srv/app');
+    window.showRemoteLaunchDialog(project);
+    document.querySelector('#rld-path').value = '  /srv/brand/new  ';
+    document.querySelector('.new-session-start-btn').click();
+    assert.equal(launched.length, 1);
+    assert.equal(launched[0].project, project);
+    assert.deepEqual(plain(launched[0].request), { cwd: '/srv/brand/new', options: {} });
+    assert.equal(document.querySelector('.new-session-overlay'), null, 'the dialog closes');
+  } finally { ctx.destroy(); }
+});
+
+test('a chosen permission mode and Dangerous Skip map to the launch options', () => {
+  const { ctx, window, document, launched } = harness();
+  try {
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    document.querySelector('#rld-mode-grid [data-mode="plan"]').click();
+    document.querySelector('.new-session-start-btn').click();
+    assert.deepEqual(plain(launched[0].request.options), { permissionMode: 'plan' });
+
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    document.querySelector('#rld-mode-grid [data-mode="plan"]').click();
+    document.querySelector('#rld-mode-grid [data-mode="dangerous-skip"]').click();
+    document.querySelector('.new-session-start-btn').click();
+    assert.deepEqual(plain(launched[1].request.options), { dangerouslySkipPermissions: true });
+  } finally { ctx.destroy(); }
+});
+
+test('an empty or relative path is refused in the dialog and nothing launches', () => {
+  const { ctx, window, document, launched } = harness();
+  try {
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    for (const bad of ['', '   ', 'relative/dir', '/srv/$(id)']) {
+      document.querySelector('#rld-path').value = bad;
+      document.querySelector('.new-session-start-btn').click();
+      assert.equal(launched.length, 0, JSON.stringify(bad));
+      assert.ok(document.querySelector('.new-session-overlay'), 'the dialog stays open');
+      assert.notEqual(document.querySelector('#rld-error').textContent, '');
+    }
+  } finally { ctx.destroy(); }
+});
+
+test('Cancel and Escape close the dialog without launching', () => {
+  const { ctx, window, document, launched } = harness();
+  try {
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    document.querySelector('.new-session-cancel-btn').click();
+    assert.equal(document.querySelector('.new-session-overlay'), null);
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    document.dispatchEvent(new window.KeyboardEvent('keydown', { key: 'Escape' }));
+    assert.equal(document.querySelector('.new-session-overlay'), null);
+    assert.equal(launched.length, 0);
+  } finally { ctx.destroy(); }
+});
+
+test('Enter in the path field starts, a click on the backdrop cancels, and choosing Default clears a mode', () => {
+  const { ctx, window, document, launched } = harness();
+  try {
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    document.querySelector('#rld-mode-grid [data-mode="plan"]').click();
+    document.querySelector('#rld-mode-grid [data-mode="null"]').click();
+    document.querySelector('#rld-path').dispatchEvent(new window.KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+    assert.equal(launched.length, 1);
+    assert.deepEqual(plain(launched[0].request.options), {});
+
+    window.showRemoteLaunchDialog(remoteProject('box', '/srv/app'));
+    document.querySelector('.new-session-overlay').click();
+    assert.equal(document.querySelector('.new-session-overlay'), null);
+    assert.equal(launched.length, 1);
+  } finally { ctx.destroy(); }
+});
+
+function flowHarness({ launchResult }) {
+  const ctx = setupSidebarDom();
+  const { window } = ctx;
+  const calls = { ipc: [], written: [], shown: [], synced: 0, polled: 0, persisted: 0, refreshed: 0 };
+  const entry = { initialSize: { cols: 90, rows: 25 }, closed: false, terminal: { write: (t) => calls.written.push(t) } };
+  window.encodeProjectPath = (p) => p.replace(/\//g, '-');
+  window.createTerminalEntry = () => entry;
+  window.syncPtySizeAfterOpen = () => { calls.synced++; };
+  window.showSession = (id) => calls.shown.push(id);
+  window.schedulePersistWorkingSet = () => { calls.persisted++; };
+  window.pollActiveSessions = () => { calls.polled++; };
+  window.refreshSidebar = () => { calls.refreshed++; };
+  window.api = { remoteLaunchSession: async (req) => { calls.ipc.push(req); return launchResult; } };
+  window.cachedProjects = [];
+  window.cachedAllProjects = [];
+  const { launchRemoteSession } = loadAppFunctions(ctx.context, { functions: ['launchRemoteSession'] });
+  return { ctx, window, calls, entry, launchRemoteSession };
+}
+
+test('launchRemoteSession adds a pending row under the host, launches over IPC and shows the session', async () => {
+  const { ctx, window, calls, launchRemoteSession } = flowHarness({ launchResult: { ok: true, remote: true } });
+  try {
+    await launchRemoteSession({ remoteAlias: 'box', projectPath: '/srv/app' }, { cwd: '/srv/api', options: { permissionMode: 'plan' } });
+    assert.equal(calls.ipc.length, 1);
+    const sessionId = calls.ipc[0].sessionId;
+    assert.match(sessionId, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+    assert.deepEqual(plain(calls.ipc[0]), {
+      alias: 'box',
+      sessionId,
+      cwd: '/srv/api',
+      options: { permissionMode: 'plan' },
+      initialSize: { cols: 90, rows: 25 },
+    });
+    const proj = window.cachedProjects[0];
+    assert.equal(proj.remoteAlias, 'box');
+    assert.equal(proj.projectPath, '/srv/api');
+    assert.equal(proj.folder, 'box::-srv-api');
+    assert.equal(proj.sessions[0].remoteAlias, 'box');
+    assert.equal(proj.sessions[0].sessionId, sessionId);
+    assert.equal(window.pendingSessions.has(sessionId), true);
+    assert.deepEqual(calls.shown, [sessionId]);
+    assert.equal(calls.synced, 1);
+    assert.equal(calls.polled, 1);
+  } finally { ctx.destroy(); }
+});
+
+test('launchRemoteSession writes the refusal into the terminal and closes the entry when the host refuses', async () => {
+  const { ctx, calls, entry, launchRemoteSession } = flowHarness({ launchResult: { ok: false, error: 'directory /srv/api does not exist on box' } });
+  try {
+    await launchRemoteSession({ remoteAlias: 'box', projectPath: '/srv/app' }, { cwd: '/srv/api', options: {} });
+    assert.match(calls.written.join(''), /directory \/srv\/api does not exist on box/);
+    assert.equal(entry.closed, true);
+    assert.equal(calls.synced, 0);
+    assert.equal(calls.polled, 0);
+  } finally { ctx.destroy(); }
+});
diff --git a/test/dom-setup.js b/test/dom-setup.js
index 1d97f9a1..b9b8f804 100644
--- a/test/dom-setup.js
+++ b/test/dom-setup.js
@@ -104,6 +104,7 @@ function setupSidebarDom() {
     confirmAndStopSession: () => {},
     pollActiveSessions: () => {},
     showNewSessionPopover: () => {},
+    showRemoteLaunchDialog: () => {},
     openSettingsViewer: () => {},
     showResumeSessionDialog: () => {},
     showJsonlViewer: () => {},
diff --git a/test/dom-sidebar-remote-tier-gates.test.js b/test/dom-sidebar-remote-tier-gates.test.js
index d5234660..4b714905 100644
--- a/test/dom-sidebar-remote-tier-gates.test.js
+++ b/test/dom-sidebar-remote-tier-gates.test.js
@@ -53,7 +53,40 @@ test('the new-session button is disabled and its title gives the launch tier rea
     const btn = header.querySelector('.project-new-btn');
     assert.equal(btn.disabled, true);
     assert.match(btn.title, /planificator/);
-    assert.ok(btn.title.includes('new sessions cannot be started from here; they must be started on the host'), btn.title);
+    assert.match(btn.title, /needs tmux on the host/);
+  } finally { ctx.destroy(); }
+});
+
+test('with tmux on the host the new-session button is enabled and opens the remote launch dialog, not the local popover', () => {
+  const ctx = setupSidebarDom();
+  try {
+    const profile = computeHostProfile({ at: AT, error: null, descriptors: [], tools: { tmux: true, inotifywait: true } });
+    const { header } = render(ctx, profile, session());
+    const btn = header.querySelector('.project-new-btn');
+    assert.equal(btn.disabled, false);
+    assert.equal(btn.title, 'New session on planificator');
+    const dialogs = [];
+    const popovers = [];
+    ctx.window.showRemoteLaunchDialog = (p) => dialogs.push(p.remoteAlias + ':' + p.projectPath);
+    ctx.window.showNewSessionPopover = (p) => popovers.push(p.projectPath);
+    btn.click();
+    assert.deepEqual(dialogs, ['planificator:/srv/supervision']);
+    assert.deepEqual(popovers, []);
+  } finally { ctx.destroy(); }
+});
+
+test('a host without tmux keeps the button disabled and a click opens nothing', () => {
+  const ctx = setupSidebarDom();
+  try {
+    const profile = computeHostProfile({ at: AT, error: null, descriptors: [], tools: { tmux: false, inotifywait: true } });
+    const { header } = render(ctx, profile, session());
+    const btn = header.querySelector('.project-new-btn');
+    assert.equal(btn.disabled, true);
+    assert.match(btn.title, /needs tmux on the host/);
+    const dialogs = [];
+    ctx.window.showRemoteLaunchDialog = (p) => dialogs.push(p.projectPath);
+    btn.onclick({ stopPropagation: () => {} });
+    assert.deepEqual(dialogs, []);
   } finally { ctx.destroy(); }
 });
 
diff --git a/test/main-remote-launch-wiring.test.js b/test/main-remote-launch-wiring.test.js
new file mode 100644
index 00000000..90fa89b4
--- /dev/null
+++ b/test/main-remote-launch-wiring.test.js
@@ -0,0 +1,49 @@
+'use strict';
+
+// Reads main.js as text: the remote-launch-session IPC and the shared
+// registration are glue that no test can load. Behaviour lives in
+// test/remote-launch.test.js.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const mainSrc = fs.readFileSync(path.join(__dirname, '..', 'main.js'), 'utf8').replace(/\r\n/g, '\n');
+
+function handlerBody(anchor, end) {
+  const at = mainSrc.indexOf(anchor);
+  assert.notEqual(at, -1, `main.js should still contain ${anchor}`);
+  const stop = mainSrc.indexOf(end, at);
+  assert.notEqual(stop, -1, `${end} should follow ${anchor}`);
+  return mainSrc.slice(at, stop);
+}
+
+const launch = handlerBody("ipcMain.handle('remote-launch-session'", '// --- IPC: remote-send-prompt');
+
+test('remote-launch-session passes the tier gate, the declared-host check, the adapter and attach to handleLaunchRequest', () => {
+  assert.match(launch, /handleLaunchRequest\(payload, \{/);
+  assert.match(launch, /launchBlockReason: \(alias\) => launchBlockReason\(remoteIndexer\.getRemoteHostProfile\(alias\)\)/);
+  assert.match(launch, /hasHost: \(alias\) => enabledHosts\(/);
+  assert.match(launch, /adapter: remoteLaunchAdapter/);
+  assert.match(launch, /attach: \(alias, descriptor, size\) => remoteAttachAdapter\.attach\(alias, descriptor, size\)/);
+});
+
+test('remote-launch-session lowercases the id before the activeSessions guard', () => {
+  const lower = launch.indexOf('rawId.toLowerCase()');
+  const guard = launch.indexOf('activeSessions.has(sessionId)');
+  assert.ok(lower !== -1 && guard !== -1 && lower < guard);
+});
+
+test('remote-launch-session registers the pty under the launched session id, the payload alias and the descriptor cwd', () => {
+  assert.match(launch, /registerRemoteAttachSession\(result\.descriptor\.sessionId, \{\s*alias: payload\.alias, projectPath: result\.descriptor\.cwd, cwd: result\.descriptor\.cwd, ptyProcess: result\.attachResult\.ptyProcess,\s*\}\)/);
+  assert.match(launch, /refreshHostNow\(payload\.alias, \{ force: true \}\)/);
+});
+
+test('registerRemoteAttachSession records a remote-attach session on its host and wires the pty; open-terminal uses it', () => {
+  const reg = handlerBody('function registerRemoteAttachSession(', "ipcMain.handle('open-terminal'");
+  assert.match(reg, /host: alias, kind: 'remote-attach'/);
+  assert.match(reg, /activeSessions\.set\(sessionId, remoteSession\);/);
+  assert.match(reg, /wireSessionPty\(remoteSession, sessionId, ptyProcess\);/);
+  assert.match(mainSrc, /registerRemoteAttachSession\(sessionId, \{\s*alias, projectPath, cwd: remoteCwd, ptyProcess: attachResult\.ptyProcess,\s*\}\)/);
+});
diff --git a/test/remote-host-profile.test.js b/test/remote-host-profile.test.js
index edf8ba19..3e1f23ac 100644
--- a/test/remote-host-profile.test.js
+++ b/test/remote-host-profile.test.js
@@ -2,7 +2,7 @@
 
 const test = require('node:test');
 const assert = require('node:assert/strict');
-const { computeHostProfile, attachBlockReason, sendBlockReason, ATTACH_BLOCK_AFTER_FAILURES, TIERS } = require('../remote-host-profile');
+const { computeHostProfile, attachBlockReason, sendBlockReason, launchBlockReason, ATTACH_BLOCK_AFTER_FAILURES, TIERS } = require('../remote-host-profile');
 
 const AT = Date.parse('2026-10-01T10:00:00Z');
 const tmuxDescriptor = { pid: 101, sessionId: 'a', tmux: 'main:@0.%0' };
@@ -24,10 +24,10 @@ test('a host never synced has no tier and every tier says it was not synced', ()
   assert.match(reasonFor(profile, 'observe'), /not yet synced/);
 });
 
-test('a host whose last cycle failed has no tier and the ssh error is the reason of every tier', () => {
+test('a host whose last cycle failed reads nothing and the ssh error is the reason of every tier but launch', () => {
   const profile = computeHostProfile({ at: AT, error: 'connect timed out', descriptors: [tmuxDescriptor] });
-  assert.equal(profile.tier, 'none');
-  for (const tier of TIERS) assert.match(reasonFor(profile, tier), /connect timed out/);
+  assert.equal(profile.tier, 'launch');
+  for (const tier of TIERS.filter(t => t !== 'launch')) assert.match(profile.tiers.find(x => x.tier === tier).reason, /connect timed out/);
 });
 
 test('a synced host with no live descriptor stops at observe and says why liveness is missing', () => {
@@ -57,15 +57,15 @@ test('a messagingSocketPath that is not a POSIX absolute path does not count', (
   }
 });
 
-test('a descriptor naming a tmux pane makes attach available even without a socket', () => {
+test('a descriptor naming a tmux pane makes attach and launch available even without a socket', () => {
   const profile = computeHostProfile({ at: AT, error: null, descriptors: [tmuxDescriptor] });
-  assert.equal(profile.tier, 'attach');
-  assert.deepEqual(profile.missing.map(m => m.tier), ['launch']);
+  assert.equal(profile.tier, 'launch');
+  assert.deepEqual(profile.missing, []);
 });
 
 test('the highest tier wins when several sessions bring different capabilities', () => {
   const profile = computeHostProfile({ at: AT, error: null, descriptors: [socketDescriptor, tmuxDescriptor] });
-  assert.equal(profile.tier, 'attach');
+  assert.equal(profile.tier, 'launch');
   assert.equal(profile.tiers.find(t => t.tier === 'inject').available, true);
 });
 
@@ -74,9 +74,26 @@ test('a tmux descriptor with an invalid pid does not count', () => {
   assert.equal(profile.tier, 'liveness');
 });
 
-test('launch is never available in this build and says to start the session on the host', () => {
-  const profile = computeHostProfile({ at: AT, error: null, descriptors: [tmuxDescriptor, socketDescriptor] });
-  assert.match(reasonFor(profile, 'launch'), /started on the host/);
+test('launch is available when the probe found tmux, with no live session at all', () => {
+  const profile = computeHostProfile({ at: AT, error: null, descriptors: [], tools: { tmux: true, inotifywait: false } });
+  assert.equal(profile.tiers.find(t => t.tier === 'launch').available, true);
+  assert.equal(profile.tier, 'launch');
+});
+
+test('launch is unavailable without tmux and says the host needs it', () => {
+  const missing = computeHostProfile({ at: AT, error: null, descriptors: [tmuxDescriptor], tools: { tmux: false, inotifywait: true } });
+  assert.equal(missing.tiers.find(t => t.tier === 'launch').available, false);
+  assert.match(reasonFor(missing, 'launch'), /needs tmux on the host.*not installed/);
+  const unknown = computeHostProfile({ at: AT, error: null, descriptors: [socketDescriptor] });
+  assert.equal(unknown.tiers.find(t => t.tier === 'launch').available, false);
+  assert.match(reasonFor(unknown, 'launch'), /needs tmux on the host/);
+});
+
+test('launchBlockReason refuses a host with no profile, a blocked one and one without tmux', () => {
+  assert.match(launchBlockReason(null), /not yet synced/);
+  assert.match(launchBlockReason(computeHostProfile({ at: null, error: null, descriptors: [] })), /not yet synced/);
+  assert.match(launchBlockReason(computeHostProfile({ at: AT, error: null, descriptors: [], tools: { tmux: false } })), /needs tmux/);
+  assert.equal(launchBlockReason(computeHostProfile({ at: AT, error: null, descriptors: [], tools: { tmux: true } })), null);
 });
 
 test('garbage input never throws and yields no tier', () => {
@@ -109,7 +126,7 @@ test('an idle synced host with tmux installed offers attach and no longer lists
   const profile = computeHostProfile({ at: AT, error: null, descriptors: [], tools: { tmux: true, inotifywait: true } });
   assert.equal(profile.tiers.find(t => t.tier === 'attach').available, true);
   assert.equal(reasonFor(profile, 'attach'), undefined);
-  assert.equal(profile.tier, 'attach');
+  assert.equal(profile.tier, 'launch');
 });
 
 test('an idle host with tmux installed still says liveness needs a live descriptor', () => {
@@ -169,3 +186,19 @@ test('send is never withheld by a failed or unsynced host: it runs its own ssh',
   assert.equal(sendBlockReason(computeHostProfile({ at: null, error: null, descriptors: [] })), null);
   assert.equal(sendBlockReason(undefined), null);
 });
+
+test('a failed last refresh does not disable launch: it runs its own ssh, like send', () => {
+  const failed = { at: AT, error: 'connect timed out', descriptors: [] };
+  const withTmux = computeHostProfile({ ...failed, tools: { tmux: true, inotifywait: true } });
+  assert.equal(withTmux.tiers.find(t => t.tier === 'launch').available, true);
+  assert.equal(launchBlockReason(withTmux), null);
+  assert.match(withTmux.tiers.find(t => t.tier === 'observe').reason, /connect timed out/);
+  assert.equal(computeHostProfile({ ...failed, descriptors: [tmuxDescriptor] }).tiers.find(t => t.tier === 'launch').available, true);
+  assert.match(launchBlockReason(computeHostProfile({ ...failed, tools: { tmux: false } })), /needs tmux/);
+  assert.match(launchBlockReason(computeHostProfile(failed)), /needs tmux/);
+});
+
+test('a host never synced still refuses launch with the not-synced reason', () => {
+  const profile = computeHostProfile({ at: null, error: null, descriptors: [], tools: { tmux: true } });
+  assert.match(launchBlockReason(profile), /not yet synced/);
+});
diff --git a/test/remote-index.test.js b/test/remote-index.test.js
index da22a80a..b3321f37 100644
--- a/test/remote-index.test.js
+++ b/test/remote-index.test.js
@@ -911,12 +911,12 @@ test('getRemoteHostProfile follows the last cycle: never synced, then live tmux
 
     assert.equal(indexer.getRemoteHostProfile('box').tier, 'none', 'never synced');
     await indexer.refreshNow();
-    assert.equal(indexer.getRemoteHostProfile('box').tier, 'attach');
+    assert.equal(indexer.getRemoteHostProfile('box').tier, 'launch');
     outcome = 'fail';
     await indexer.refreshNow({ force: true });
     const failed = indexer.getRemoteHostProfile('box');
-    assert.equal(failed.tier, 'none');
-    assert.match(failed.missing[0].reason, /connect timed out/);
+    assert.equal(failed.tier, 'launch');
+    assert.match(failed.tiers.find(t => t.tier === 'observe').reason, /connect timed out/);
   } finally { fs.rmSync(dataDir, { recursive: true, force: true }); }
 });
 
diff --git a/test/remote-launch.test.js b/test/remote-launch.test.js
new file mode 100644
index 00000000..7e5bd996
--- /dev/null
+++ b/test/remote-launch.test.js
@@ -0,0 +1,307 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  validateLaunchCwd,
+  validateSessionId,
+  buildClaudeArgs,
+  buildLaunchScript,
+  buildLaunchCommand,
+  parseLaunchOutput,
+  tmuxSessionName,
+  createRemoteLaunchAdapter,
+  handleLaunchRequest,
+  NO_DIR_EXIT_CODE,
+  NO_TMUX_EXIT_CODE,
+  NO_CLAUDE_EXIT_CODE,
+} = require('../remote-launch');
+const { buildStopCommand } = require('../remote-stop');
+const { shellSingleQuote, parseTmuxField } = require('../remote-attach');
+
+const UUID = '3f2a9c10-7b1d-4e55-9a60-0123456789ab';
+const silentLog = { info() {}, warn() {}, error() {} };
+
+test('the script is an exact string: directory check, tmux and claude checks, detached tmux session running claude', () => {
+  const script = buildLaunchScript({ sessionId: UUID, cwd: '/srv/app', options: {} });
+  assert.equal(script,
+    `cwd='/srv/app'; [ -d "$cwd" ] || exit ${NO_DIR_EXIT_CODE}; ` +
+    `command -v tmux >/dev/null 2>&1 || exit ${NO_TMUX_EXIT_CODE}; ` +
+    `command -v claude >/dev/null 2>&1 || exit ${NO_CLAUDE_EXIT_CODE}; ` +
+    `exec tmux new-session -d -P -F '#{session_name}:#{window_id}.#{pane_id} #{pane_pid}' ` +
+    `-s switchboard-3f2a9c10 -c "$cwd" 'claude --session-id ${UUID}'`);
+});
+
+test('the command wraps the script in sh -c so a non-POSIX login shell never parses it', () => {
+  const script = buildLaunchScript({ sessionId: UUID, cwd: '/srv/app', options: {} });
+  assert.equal(buildLaunchCommand({ sessionId: UUID, cwd: '/srv/app', options: {} }), `sh -c ${shellSingleQuote(script)}`);
+});
+
+test('permission options map to CLI flags and nothing else reaches the command', () => {
+  assert.deepEqual(buildClaudeArgs({ permissionMode: 'plan' }), { ok: true, args: ['--permission-mode', 'plan'] });
+  assert.deepEqual(buildClaudeArgs({ dangerouslySkipPermissions: true, permissionMode: 'plan' }), { ok: true, args: ['--dangerously-skip-permissions'] });
+  assert.deepEqual(buildClaudeArgs({}), { ok: true, args: [] });
+  assert.deepEqual(buildClaudeArgs(null), { ok: true, args: [] });
+  assert.deepEqual(buildClaudeArgs({ permissionMode: null, addDirs: '/x; rm -rf /', preLaunchCmd: 'evil' }), { ok: true, args: [] });
+  const bad = buildClaudeArgs({ permissionMode: 'plan; rm -rf /' });
+  assert.equal(bad.ok, false);
+  assert.match(bad.error, /permission mode/);
+  const script = buildLaunchScript({ sessionId: UUID, cwd: '/srv/app', options: { permissionMode: 'acceptEdits' } });
+  assert.match(script, /'claude --session-id [0-9a-f-]+ --permission-mode acceptEdits'$/);
+});
+
+test('a hostile working directory is refused, naming the rule', () => {
+  const hostile = [
+    "/srv/it's", '/srv/$(id)', '/srv/`id`', '/srv/a\nb', '/srv/a;b', '/srv/a"b', '/srv/a\\b', '/srv/a|b', '/srv/a&b',
+    '/srv/a$HOME', '/srv/../etc', '-rf', '--help', 'relative/path', '', '/srv/a\0b', '/' + 'a'.repeat(4100), 42, null, undefined,
+  ];
+  for (const cwd of hostile) {
+    const verdict = validateLaunchCwd(cwd);
+    assert.equal(verdict.ok, false, JSON.stringify(cwd));
+    assert.equal(typeof verdict.error, 'string');
+    assert.throws(() => buildLaunchScript({ sessionId: UUID, cwd, options: {} }), undefined, JSON.stringify(cwd));
+  }
+  assert.match(validateLaunchCwd('/srv/a$b').error, /characters/);
+  assert.match(validateLaunchCwd('-rf').error, /absolute/);
+  assert.match(validateLaunchCwd('/srv/../etc').error, /\.\./);
+});
+
+test('an ordinary directory, spaces and punctuation included, is accepted and stays single-quoted', () => {
+  for (const cwd of ['/', '/srv/app', '/home/jb/My Project', '/srv/a.b_c-d+e@f:g,h=i', '/srv/app/']) {
+    assert.deepEqual(validateLaunchCwd(cwd), { ok: true }, cwd);
+  }
+  assert.match(buildLaunchScript({ sessionId: UUID, cwd: '/home/jb/My Project', options: {} }), /^cwd='\/home\/jb\/My Project'; /);
+});
+
+test('the session id must be a uuid', () => {
+  assert.deepEqual(validateSessionId(UUID), { ok: true });
+  for (const id of ['', 'abc', UUID + ' ', UUID + "'; id", UUID.toUpperCase() + 'x', null, 7, `${UUID}\n`]) {
+    assert.equal(validateSessionId(id).ok, false, JSON.stringify(id));
+    assert.throws(() => buildLaunchScript({ sessionId: id, cwd: '/srv/app', options: {} }), undefined, JSON.stringify(id));
+  }
+});
+
+test('the tmux session name is generated from the uuid and is a valid tmux field', () => {
+  assert.equal(tmuxSessionName(UUID), 'switchboard-3f2a9c10');
+  assert.ok(parseTmuxField(`${tmuxSessionName(UUID)}:@3.%5`));
+});
+
+test('the launch output yields the pane target and pid; anything else is refused', () => {
+  assert.deepEqual(parseLaunchOutput('switchboard-3f2a9c10:@3.%5 4242\n'), { tmux: 'switchboard-3f2a9c10:@3.%5', pid: 4242 });
+  for (const bad of ['', 'garbage', 'x:@3.%5 0', 'x:@3.%5 abc', 'x:@3 4242', "x:@3.%5 4242; id", 'a b:@3.%5 4242', null]) {
+    assert.equal(parseLaunchOutput(bad), null, JSON.stringify(bad));
+  }
+});
+
+test('the stop command for a session we launched kills the pane and never the session', () => {
+  const parsed = parseLaunchOutput('switchboard-3f2a9c10:@3.%5 4242\n');
+  const stop = buildStopCommand(4242, parseTmuxField(parsed.tmux).target);
+  assert.match(stop, /kill-pane -t switchboard-3f2a9c10:@3\.%5/);
+  assert.doesNotMatch(stop, /kill-session/);
+});
+
+function fakeRun(result) {
+  const calls = [];
+  const run = async (alias, command, opts) => { calls.push({ alias, command, opts }); return typeof result === 'function' ? result(command) : result; };
+  return { run, calls };
+}
+
+test('adapter: success returns a descriptor naming the created pane, over the same ssh runner', async () => {
+  const { run, calls } = fakeRun({ code: 0, stdout: 'switchboard-3f2a9c10:@3.%5 4242\n', stderr: '' });
+  const adapter = createRemoteLaunchAdapter({ runRemoteCommand: run, log: silentLog });
+  const result = await adapter.launch('box', { sessionId: UUID, cwd: '/srv/app', options: { permissionMode: 'plan' } });
+  assert.deepEqual(result, { ok: true, descriptor: { sessionId: UUID, pid: 4242, tmux: 'switchboard-3f2a9c10:@3.%5', cwd: '/srv/app' } });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].alias, 'box');
+  assert.equal(calls[0].command, buildLaunchCommand({ sessionId: UUID, cwd: '/srv/app', options: { permissionMode: 'plan' } }));
+  assert.ok(calls[0].opts.timeoutMs > 0);
+});
+
+test('adapter: a missing directory is reported and a hostile one never reaches ssh', async () => {
+  const missing = fakeRun({ code: NO_DIR_EXIT_CODE, stdout: '', stderr: '' });
+  let result = await createRemoteLaunchAdapter({ runRemoteCommand: missing.run, log: silentLog })
+    .launch('box', { sessionId: UUID, cwd: '/nope', options: {} });
+  assert.equal(result.ok, false);
+  assert.match(result.error, /directory \/nope does not exist on box/);
+
+  const never = fakeRun({ code: 0, stdout: '', stderr: '' });
+  result = await createRemoteLaunchAdapter({ runRemoteCommand: never.run, log: silentLog })
+    .launch('box', { sessionId: UUID, cwd: '/srv/$(id)', options: {} });
+  assert.equal(result.ok, false);
+  assert.equal(never.calls.length, 0);
+});
+
+test('adapter: no tmux, no claude, ssh failure, timeout and unreadable output each say what happened', async () => {
+  const launch = (res) => createRemoteLaunchAdapter({ runRemoteCommand: fakeRun(res).run, log: silentLog })
+    .launch('box', { sessionId: UUID, cwd: '/srv/app', options: {} });
+  assert.match((await launch({ code: NO_TMUX_EXIT_CODE, stdout: '', stderr: '' })).error, /tmux is not installed on box/);
+  assert.match((await launch({ code: NO_CLAUDE_EXIT_CODE, stdout: '', stderr: '' })).error, /claude was not found on the PATH of an ssh command on box/);
+  assert.match((await launch({ code: 255, stdout: '', stderr: 'Connection refused\n' })).error, /launch failed \(exit 255\): Connection refused/);
+  assert.match((await launch({ code: 1, stdout: '', stderr: '' })).error, /no stderr/);
+  assert.match((await launch({ code: -1, stdout: '', stderr: '', timedOut: true })).error, /timed out/);
+  assert.match((await launch({ code: 0, stdout: 'nonsense', stderr: '' })).error, /tmux target/);
+  assert.match((await launch(null)).error, /no response/);
+  const throwing = createRemoteLaunchAdapter({ runRemoteCommand: async () => { throw new Error('boom'); }, log: silentLog });
+  assert.match((await throwing.launch('box', { sessionId: UUID, cwd: '/srv/app', options: {} })).error, /launch failed: boom/);
+});
+
+function makeDeps(overrides = {}) {
+  const calls = { launch: [], attach: [] };
+  const deps = {
+    hasHost: (alias) => alias === 'box',
+    launchBlockReason: () => null,
+    adapter: {
+      launch: async (alias, req) => {
+        calls.launch.push({ alias, req });
+        return { ok: true, descriptor: { sessionId: req.sessionId, pid: 4242, tmux: 'switchboard-3f2a9c10:@3.%5', cwd: req.cwd } };
+      },
+    },
+    attach: async (alias, descriptor, size) => {
+      calls.attach.push({ alias, descriptor, size });
+      return { ok: true, ptyProcess: { id: 'pty' } };
+    },
+    ...overrides,
+  };
+  return { deps, calls };
+}
+
+const PAYLOAD = { alias: 'box', sessionId: UUID, cwd: '/srv/app', options: { permissionMode: 'plan' }, initialSize: { cols: 100, rows: 30 } };
+
+test('flow: on success attach is called with the created target and the local size', async () => {
+  const { deps, calls } = makeDeps();
+  const result = await handleLaunchRequest(PAYLOAD, deps);
+  assert.equal(result.ok, true);
+  assert.deepEqual(calls.attach, [{
+    alias: 'box',
+    descriptor: { sessionId: UUID, pid: 4242, tmux: 'switchboard-3f2a9c10:@3.%5', cwd: '/srv/app' },
+    size: { cols: 100, rows: 30 },
+  }]);
+  assert.deepEqual(result.attachResult, { ok: true, ptyProcess: { id: 'pty' } });
+});
+
+test('flow: a failed directory check is reported and attach is never called', async () => {
+  const { deps, calls } = makeDeps({ adapter: { launch: async () => ({ ok: false, error: 'directory /srv/app does not exist on box' }) } });
+  const result = await handleLaunchRequest(PAYLOAD, deps);
+  assert.deepEqual(result, { ok: false, error: 'directory /srv/app does not exist on box' });
+  assert.equal(calls.attach.length, 0);
+});
+
+test('flow: a host whose launch tier is blocked is refused before any ssh', async () => {
+  const { deps, calls } = makeDeps({ launchBlockReason: () => 'needs tmux on the host' });
+  const result = await handleLaunchRequest(PAYLOAD, deps);
+  assert.deepEqual(result, { ok: false, error: 'needs tmux on the host' });
+  assert.equal(calls.launch.length, 0);
+});
+
+test('flow: an undeclared host, a bad id or a malformed request is refused before any ssh', async () => {
+  const { deps, calls } = makeDeps();
+  for (const payload of [
+    null, {}, { ...PAYLOAD, alias: 'other' }, { ...PAYLOAD, alias: 7 }, { ...PAYLOAD, sessionId: 'nope' }, { ...PAYLOAD, cwd: '/a/$(id)' },
+  ]) {
+    const result = await handleLaunchRequest(payload, deps);
+    assert.equal(result.ok, false, JSON.stringify(payload));
+  }
+  assert.equal(calls.launch.length, 0);
+});
+
+test('flow: a failed attach after a successful launch says the session is running on the host', async () => {
+  const { deps } = makeDeps({ attach: async () => ({ ok: false, error: 'size probe failed' }) });
+  const result = await handleLaunchRequest(PAYLOAD, deps);
+  assert.equal(result.ok, false);
+  assert.match(result.error, /started on box as switchboard-3f2a9c10:@3\.%5/);
+  assert.match(result.error, /size probe failed/);
+});
+
+test('flow: a bogus initialSize is passed on as null rather than trusted', async () => {
+  const { deps, calls } = makeDeps();
+  await handleLaunchRequest({ ...PAYLOAD, initialSize: { cols: -1, rows: 'x' } }, deps);
+  assert.equal(calls.attach[0].size, null);
+});
+
+const sh = spawnSync('sh', ['-c', 'echo ok'], { encoding: 'utf8' });
+const HAVE_SH = sh.status === 0 && /ok/.test(sh.stdout || '');
+
+test('real sh: the script refuses a missing directory with its own exit code, runs nothing', { skip: !HAVE_SH }, () => {
+  const script = buildLaunchScript({ sessionId: UUID, cwd: '/definitely/not/a/dir', options: {} });
+  const res = spawnSync('sh', ['-c', script], { encoding: 'utf8' });
+  assert.equal(res.status, NO_DIR_EXIT_CODE);
+});
+
+function toPosix(p) {
+  return p.split(path.sep).join('/').replace(/^([A-Za-z]):/, (_m, d) => '/' + d.toLowerCase());
+}
+
+test('real sh: with tmux and claude stubbed on PATH the script runs the exact tmux argv', { skip: !HAVE_SH }, (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'launch-'));
+  try {
+    const bin = path.join(dir, 'bin');
+    fs.mkdirSync(bin);
+    const cwd = path.join(dir, 'work dir');
+    fs.mkdirSync(cwd);
+    const posixCwd = toPosix(cwd);
+    if (!validateLaunchCwd(posixCwd).ok) { t.skip('the temporary directory path is outside the accepted character set'); return; }
+    const argvFile = path.join(dir, 'argv.txt');
+    fs.writeFileSync(path.join(bin, 'claude'), '#!/bin/sh\nexit 0\n', { mode: 0o755 });
+    fs.writeFileSync(path.join(bin, 'tmux'),
+      `#!/bin/sh\nfor a in "$@"; do printf '%s\n' "$a"; done > '${toPosix(argvFile)}'\necho 'switchboard-3f2a9c10:@3.%5 4242'\n`, { mode: 0o755 });
+    const script = buildLaunchScript({ sessionId: UUID, cwd: posixCwd, options: { permissionMode: 'plan' } });
+    const res = spawnSync('sh', ['-c', `PATH='${toPosix(bin)}':"$PATH"; ${script}`], { encoding: 'utf8' });
+    assert.equal(res.status, 0, `${res.stderr} / ${res.stdout}`);
+    assert.deepEqual(parseLaunchOutput(res.stdout), { tmux: 'switchboard-3f2a9c10:@3.%5', pid: 4242 });
+    const argv = fs.readFileSync(argvFile, 'utf8').split('\n').slice(0, -1);
+    assert.deepEqual(argv, [
+      'new-session', '-d', '-P', '-F', '#{session_name}:#{window_id}.#{pane_id} #{pane_pid}',
+      '-s', 'switchboard-3f2a9c10', '-c', posixCwd, `claude --session-id ${UUID} --permission-mode plan`,
+    ]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('a directory of 4096 bytes is accepted and one of 4097 is refused', () => {
+  assert.deepEqual(validateLaunchCwd('/' + 'a'.repeat(4095)), { ok: true });
+  assert.equal(validateLaunchCwd('/' + 'a'.repeat(4096)).ok, false);
+});
+
+test('only a boolean true adds the skip-permissions flag', () => {
+  assert.deepEqual(buildClaudeArgs({ dangerouslySkipPermissions: true }), { ok: true, args: ['--dangerously-skip-permissions'] });
+  for (const value of ['true', 1, 'false', 0, null, {}]) {
+    assert.deepEqual(buildClaudeArgs({ dangerouslySkipPermissions: value }), { ok: true, args: [] }, JSON.stringify(value));
+  }
+});
+
+test('the launch output is read from its last non-empty line, so rc-file noise before it is ignored', () => {
+  const target = 'switchboard-3f2a9c10:@3.%5 4242';
+  assert.deepEqual(parseLaunchOutput(`Welcome to box\nmotd line\n${target}\n\n`), { tmux: 'switchboard-3f2a9c10:@3.%5', pid: 4242 });
+  assert.deepEqual(parseLaunchOutput(`${target}\r\n`), { tmux: 'switchboard-3f2a9c10:@3.%5', pid: 4242 });
+  assert.equal(parseLaunchOutput(`${target}\ntrailing noise\n`), null);
+});
+
+test('real sh: buildLaunchCommand itself, run through sh -c, executes the exact tmux argv', { skip: !HAVE_SH }, (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'launch-'));
+  try {
+    const bin = path.join(dir, 'bin');
+    fs.mkdirSync(bin);
+    const cwd = path.join(dir, 'work dir');
+    fs.mkdirSync(cwd);
+    const posixCwd = toPosix(cwd);
+    if (!validateLaunchCwd(posixCwd).ok) { t.skip('the temporary directory path is outside the accepted character set'); return; }
+    const argvFile = path.join(dir, 'argv.txt');
+    fs.writeFileSync(path.join(bin, 'claude'), '#!/bin/sh\nexit 0\n', { mode: 0o755 });
+    fs.writeFileSync(path.join(bin, 'tmux'),
+      `#!/bin/sh\nfor a in "$@"; do printf '%s\n' "$a"; done > '${toPosix(argvFile)}'\necho 'noise'\necho 'switchboard-3f2a9c10:@3.%5 4242'\n`, { mode: 0o755 });
+    const command = buildLaunchCommand({ sessionId: UUID, cwd: posixCwd, options: { dangerouslySkipPermissions: true } });
+    const res = spawnSync('sh', ['-c', `PATH='${toPosix(bin)}':"$PATH"; ${command}`], { encoding: 'utf8' });
+    assert.equal(res.status, 0, `${res.stderr} / ${res.stdout}`);
+    assert.deepEqual(parseLaunchOutput(res.stdout), { tmux: 'switchboard-3f2a9c10:@3.%5', pid: 4242 });
+    const argv = fs.readFileSync(argvFile, 'utf8').split('\n').slice(0, -1);
+    assert.deepEqual(argv.slice(-3), ['-c', posixCwd, `claude --session-id ${UUID} --dangerously-skip-permissions`]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});