@aiwg/cockpit 2026.7.9 → 2026.7.11

package/bridge/src/server.mjs

@@ -357,19 +357,23 @@ async function proxy(res, method, target) {
   return json(res, r.status, body);
 }
 
-async function fetchJsonFirst(candidates, { method = 'GET', headers, body: requestBodyOption } = {}) {
+async function fetchJsonFirst(candidates, { method = 'GET', headers, body: requestBodyOption, timeoutMs = 0 } = {}) {
   const failures = [];
   for (const candidate of candidates) {
     const target = typeof candidate === 'string' ? candidate : candidate.target;
     const requestMethod = typeof candidate === 'string' ? method : candidate.method ?? method;
     const requestHeaders = typeof candidate === 'string' ? headers : candidate.headers ?? headers;
     const requestBody = typeof candidate === 'string' ? requestBodyOption : candidate.body ?? requestBodyOption;
+    const controller = timeoutMs > 0 ? new AbortController() : null;
+    const timeout = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
     let r;
     try {
-      r = await fetch(target, { method: requestMethod, headers: requestHeaders, body: requestBody });
+      r = await fetch(target, { method: requestMethod, headers: requestHeaders, body: requestBody, ...(controller ? { signal: controller.signal } : {}) });
     } catch (err) {
       failures.push(`${target} -> ${String(err?.message ?? err)}`);
       continue;
+    } finally {
+      if (timeout) clearTimeout(timeout);
     }
     const responseBody = await r.json().catch(() => ({}));
     if (r.ok) return { target, status: r.status, body: responseBody };
@@ -687,7 +691,18 @@ function normalizeTransport(posture) {
 function normalizeSessionBackends(backends, runtimeKind, state = 'unknown', agentReady = false) {
   const list = Array.isArray(backends) ? backends : [];
   if (!list.length && runtimeKind === 'host') {
-    return [{ mode: 'managed', backend: 'tmux', observe: true, drive: true, replay: false, keyframe: false, available: true, reason: 'agentic-sandbox v1 host session API default' }];
+    return [{
+      mode: 'managed',
+      backend: 'tmux',
+      observe: true,
+      drive: true,
+      replay: false,
+      keyframe: false,
+      available: agentReady,
+      reason: agentReady
+        ? 'agentic-sandbox v1 host session API default'
+        : 'host runtime is provisioned but the host agent has not registered; PTY sessions are not ready',
+    }];
   }
   if (!list.length && ['docker', 'container', 'vm', 'qemu', 'kvm'].includes(runtimeKind) && String(state).toLowerCase() === 'running') {
     return [{
@@ -751,6 +766,28 @@ function normalizeInstance(executorUrl, i) {
   };
 }
 
+function defaultSessionLaunch(instance) {
+  const runtime = String(instance?.runtime_posture?.kind ?? instance?.runtime ?? '').toLowerCase();
+  if (runtime === 'host') {
+    return {
+      command: 'bash',
+      args: ['-l'],
+      working_dir: instance?.launch_context?.cwd,
+    };
+  }
+  if (runtime === 'container' || runtime === 'docker' || runtime === 'vm' || runtime === 'qemu' || runtime === 'kvm') {
+    return {
+      command: '/bin/bash',
+      args: ['-lc', 'cd "${HOME:-/root}" && exec /bin/bash -l'],
+      working_dir: '/root',
+    };
+  }
+  return {
+    command: 'bash',
+    args: ['-l'],
+  };
+}
+
 function runtimeExtensionFromCard(card) {
   const extensions = card?.capabilities?.extensions;
   if (!Array.isArray(extensions)) return null;
@@ -1284,6 +1321,10 @@ async function getSessions(executorUrl, instanceId) {
     `${executorUrl}/api/v1/agents/${encodeURIComponent(agentId)}/sessions`,
   ]));
   const sessions = asArrayFromEnvelope(body, ['sessions', 'items', 'data']);
+  return normalizeSessionRows({ sessions, executorUrl, instanceId, sessionAgentId });
+}
+
+export function normalizeSessionRows({ sessions, executorUrl, instanceId, sessionAgentId = instanceId }) {
   const wsBase = executorUrl.replace(/^http/i, 'ws');
   const normalizeAttachUrl = (s, sessionId) => {
     const explicit = s.attach_url ?? s.attachUrl;
@@ -1304,26 +1345,83 @@ async function getSessions(executorUrl, instanceId) {
     // agent name is only needed for the session-list FETCH, not the attach path.
     return `${wsBase}/agents/${encodeURIComponent(instanceId)}/sessions/${encodeURIComponent(sessionId)}/attach`;
   };
-  // Dedup by session id: the executor can register/return the same session more
-  // than once (e.g. a session registered twice in its registry), which surfaced
-  // as duplicate rows that are impossible to tell apart in the Sessions picker.
-  // Keep the first occurrence of each id (and drop id-less entries).
-  const seen = new Set();
-  const deduped = [];
+  const sessionAliases = (entry, sessionId) => {
+    const aliases = [`session:${sessionId}`];
+    const commandId = entry.command_id ?? entry.commandId;
+    if (commandId) aliases.push(`command:${commandId}`);
+    return aliases;
+  };
+  const fallbackScore = (entry) => {
+    const sessionId = String(entry.id ?? entry.session_id ?? entry.sessionId ?? '');
+    const commandId = String(entry.command_id ?? entry.commandId ?? '');
+    const id = String(entry.id ?? '');
+    const name = String(entry.session_name ?? entry.sessionName ?? '');
+    const command = String(entry.command ?? '').trim();
+    let score = 0;
+    if (id && commandId && id === commandId) score += 2;
+    if (name && (name === sessionId || name === commandId)) score += 2;
+    if (/^\/?bin\/bash\s+-l$/.test(command)) score += 1;
+    if (entry.has_screen === false || entry.hasScreen === false) score += 1;
+    return score;
+  };
+  const namedScore = (entry) => {
+    const name = String(entry.session_name ?? entry.sessionName ?? '');
+    let score = name ? 1 : 0;
+    if (/^terminal-[a-z0-9-]+$/i.test(name)) score += 2;
+    if (entry.has_screen === true || entry.hasScreen === true) score += 1;
+    return score;
+  };
+  const shouldReplace = (existing, candidate) => {
+    const existingFallback = fallbackScore(existing);
+    const candidateFallback = fallbackScore(candidate);
+    if (existingFallback !== candidateFallback) return candidateFallback < existingFallback;
+    const existingNamed = namedScore(existing);
+    const candidateNamed = namedScore(candidate);
+    if (existingNamed !== candidateNamed) return candidateNamed > existingNamed;
+    return false;
+  };
+  const mergeGroups = (target, source) => {
+    if (target === source) return target;
+    for (const alias of source.aliases) {
+      target.aliases.add(alias);
+      groupsByAlias.set(alias, target);
+    }
+    source.merged = true;
+    if (!target.value || (source.value && shouldReplace(target.value, source.value))) target.value = source.value;
+    return target;
+  };
+  // Dedup by every stable alias we see. Docker/host fallback rows can share a
+  // command id with the Cockpit-created session; QEMU fallback rows can instead
+  // share only the formal session id while carrying a different command id. Keep
+  // the named/screen-backed session row so the UI exposes the working attach URL.
+  const groups = [];
+  const groupsByAlias = new Map();
   for (const s of sessions) {
     const sessionId = s.id ?? s.session_id ?? s.sessionId;
-    if (!sessionId || seen.has(sessionId)) continue;
-    seen.add(sessionId);
-    deduped.push({
+    if (!sessionId) continue;
+    const normalized = {
       ...s,
       id: sessionId,
       instance_id: s.instance_id ?? s.instanceId ?? instanceId,
       agent_id: s.agent_id ?? s.agentId ?? sessionAgentId,
       role_policy: s.role_policy ?? s.rolePolicy ?? (s.default_role === 'observer' ? 'observe-default' : s.default_role) ?? 'observe-default',
       attach_url: normalizeAttachUrl(s, sessionId),
-    });
+    };
+    const aliases = sessionAliases(s, sessionId);
+    let group = aliases.map((alias) => groupsByAlias.get(alias)).find(Boolean);
+    if (!group) {
+      group = { aliases: new Set(), value: null, merged: false };
+      groups.push(group);
+    }
+    for (const alias of aliases) {
+      const other = groupsByAlias.get(alias);
+      if (other && other !== group) group = mergeGroups(group, other);
+      group.aliases.add(alias);
+      groupsByAlias.set(alias, group);
+    }
+    if (!group.value || shouldReplace(group.value, normalized)) group.value = normalized;
   }
-  return { instance_id: instanceId, sessions: deduped };
+  return { instance_id: instanceId, sessions: groups.filter((group) => !group.merged && group.value).map((group) => group.value) };
 }
 
 async function endSession(executorUrl, instanceId, sessionId) {
@@ -1566,6 +1664,14 @@ export function createBridge({ executorUrl = EXECUTOR_URL, allowMockExecutor = A
         if (backend) qs.set('backend', backend);
         if (loadout) qs.set('loadout', loadout);
         const sessionAgentId = await resolveSessionAgentId(upstreamUrl, id);
+        let sessionLaunch = defaultSessionLaunch();
+        try {
+          const inventory = await getInventory(upstreamUrl);
+          sessionLaunch = defaultSessionLaunch(inventory.instances.find((inst) => inst.id === id));
+        } catch {
+          // Session creation can still proceed without an explicit cwd; the
+          // executor/agent will fall back to its own process cwd.
+        }
         const candidates = unique([sessionAgentId, id]).flatMap((agentId) => [
           {
             target: `${upstreamUrl}/api/v1/agents/${encodeURIComponent(agentId)}/sessions`,
@@ -1574,8 +1680,9 @@ export function createBridge({ executorUrl = EXECUTOR_URL, allowMockExecutor = A
             body: JSON.stringify({
               session_backend: backend || 'tmux',
               session_class: mode || 'managed',
-              command: 'bash',
-              args: ['-l'],
+              command: sessionLaunch.command,
+              args: sessionLaunch.args,
+              ...(sessionLaunch.working_dir ? { working_dir: sessionLaunch.working_dir } : {}),
             }),
           },
           {
@@ -1585,7 +1692,7 @@ export function createBridge({ executorUrl = EXECUTOR_URL, allowMockExecutor = A
         ]);
         let sessionCreate;
         try {
-          sessionCreate = await fetchJsonFirst(candidates);
+          sessionCreate = await fetchJsonFirst(candidates, { timeoutMs: 8000 });
         } catch (err) {
           return json(res, 409, {
             error: 'agent_not_registered',

package/bridge/src/smoke.mjs

@@ -3,7 +3,7 @@
 import assert from 'node:assert/strict';
 import { fileURLToPath } from 'node:url';
 import { createExecutor } from '../../mock-executor/src/server.mjs';
-import { createBridge } from './server.mjs';
+import { createBridge, normalizeSessionRows } from './server.mjs';
 
 const mock = createExecutor();
 await new Promise((r) => mock.listen(0, '127.0.0.1', r));
@@ -56,6 +56,32 @@ try {
   assert.equal(demo.backend, 'native', 'demo session backend');
   assert.equal(demo.role_policy, 'observe-default', 'session role policy');
 
+  const qemuDedup = normalizeSessionRows({
+    executorUrl,
+    instanceId: 'vm-1',
+    sessionAgentId: 'vm-agent-name',
+    sessions: [
+      {
+        id: 'sess-formal',
+        session_id: 'sess-formal',
+        command_id: 'cmd-real',
+        session_name: 'terminal-qemu',
+        command: '/bin/bash',
+        has_screen: true,
+      },
+      {
+        id: 'sess-formal',
+        session_id: 'sess-formal',
+        command_id: 'sess-formal',
+        session_name: 'sess-formal',
+        command: '/bin/bash -l',
+        has_screen: false,
+      },
+    ],
+  });
+  assert.equal(qemuDedup.sessions.length, 1, 'QEMU formal session + fallback row dedupe to one session');
+  assert.equal(qemuDedup.sessions[0].session_name, 'terminal-qemu', 'dedupe keeps the named screen-backed session');
+
   // missing instance param is a 400
   assert.equal((await f("/api/sessions")).status, 400, 'sessions requires instance');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cockpit",
-  "version": "2026.7.9",
+  "version": "2026.7.11",
   "description": "AIWG Cockpit — UX-first control plane over AIWG + multi-stack agentic sessions. Opt-in, separately published; NOT shipped in the base aiwg npm package (guarded by test/smoke/cockpit-base-footprint.test.js).",
   "type": "module",
   "license": "MIT",

package/web/src/components/LaunchInstanceModal.test.tsx

@@ -139,6 +139,7 @@ describe('LaunchInstanceModal', () => {
       .find((call) => String(call[0]).includes('/api/instances') && call[1]?.method === 'POST');
     expect(JSON.parse(String(postCall?.[1]?.body))).toMatchObject({
       runtime: 'qemu',
+      agentshare: true,
       ssh_key: '~/.ssh/agentic_ed25519.pub',
     });
   });

package/web/src/components/LaunchInstanceModal.tsx

@@ -141,7 +141,10 @@ export function LaunchInstanceModal({
         body.image = image === '__custom__' ? customImage.trim() : image;
         body.agentshare = true;
       }
-      if (runtime === 'qemu' && sshKey.trim()) body.ssh_key = sshKey.trim();
+      if (runtime === 'qemu') {
+        body.agentshare = true;
+        if (sshKey.trim()) body.ssh_key = sshKey.trim();
+      }
       if (runtime === 'docker' && mounts.trim()) body.mounts = mounts.split('\n').map((m) => m.trim()).filter(Boolean);
       const op = await api<{ id?: string; instance_id?: string; instanceId?: string; operation?: { id?: string }; result?: { instance_id?: string; instanceId?: string } }>('/api/instances', {
         method: 'POST',

package/web/src/components/Sessions.test.tsx

@@ -121,7 +121,7 @@ describe('Sessions', () => {
     expect(await within(nav).findByTitle('sess-new')).toBeTruthy();
   });
 
-  it('auto-attaches in observe when a different session is selected (#1670)', async () => {
+  it('keeps controller posture when a different session is selected while driving (#1670)', async () => {
     const session = stubSession(); // currently attached to .../sessions/sess-1/attach as controller
     const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
       const url = String(input);
@@ -137,11 +137,12 @@ describe('Sessions', () => {
     const nav = screen.getByLabelText('Instances and sessions');
     const sessBtn = await within(nav).findByTitle('sess-2');
     fireEvent.click(sessBtn);
-    // Selecting a not-yet-attached session attaches it read-only; the operator clicks Drive to take over.
-    expect(session.attach).toHaveBeenCalledWith('ws://x/agents/inst-1/sessions/sess-2/attach', false, 'observer');
+    // Selecting a not-yet-attached session should not silently downgrade an
+    // operator who is already driving another session.
+    expect(session.attach).toHaveBeenCalledWith('ws://x/agents/inst-1/sessions/sess-2/attach', false, 'controller');
   });
 
-  it('does not re-attach (downgrade) when re-selecting the session already attached', async () => {
+  it('reattaches with replay instead of downgrading when re-selecting the session already attached', async () => {
     const session = stubSession(); // state.url === .../sessions/sess-1/attach, role controller
     const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
       const url = String(input);
@@ -156,8 +157,10 @@ describe('Sessions', () => {
 
     const nav = screen.getByLabelText('Instances and sessions');
     fireEvent.click(await within(nav).findByTitle('sess-1'));
-    // Clicking the session we already drive must not downgrade us back to observer.
+    // Clicking the session we already drive replays/reasserts controller; it
+    // must not downgrade us back to observer.
     expect(session.attach).not.toHaveBeenCalled();
+    expect(session.replay).toHaveBeenCalledWith('ws://x/agents/inst-1/sessions/sess-1/attach', 'controller');
   });
 
   it('distinguishes sessions by name + backend + viewer count in the nav (#1670)', async () => {

package/web/src/components/Sessions.tsx

@@ -53,6 +53,7 @@ export function Sessions({ session, composer, setComposer, onRequestStart, refre
       .then((d) => {
         const nextSessions = d.sessions ?? [];
         setSessions(nextSessions);
+        setSessionErr('');
         setAttachUrl((currentUrl) => {
           if (currentUrl && nextSessions.some((s) => s.attach_url === currentUrl)) return currentUrl;
           return nextSessions[0]?.attach_url ?? '';
@@ -147,13 +148,18 @@ export function Sessions({ session, composer, setComposer, onRequestStart, refre
                             <li key={s.id}>
                               <button
                                 className={`nav-session${selS ? ' selected' : ''}${live ? ' live' : ''}`}
-                                // Selecting a session auto-attaches in observe (read-only) so the
-                                // operator immediately sees it; they click Drive to take control.
-                                // Re-selecting the session already attached here is a no-op (don't
-                                // downgrade an active controller back to observer).
+                                // Selecting a session keeps the operator's current posture when
+                                // possible. If they are already driving, do not silently downgrade
+                                // to observe; if they click the attached row, reattach+replay so
+                                // Docker/tmux streams repaint and control is reasserted.
                                 onClick={() => {
+                                  const role = session.state.role === 'controller' && selectedBackend?.drive !== false ? 'controller' : 'observer';
                                   setAttachUrl(s.attach_url);
-                                  if (s.attach_url !== session.state.url) session.attach(s.attach_url, false, 'observer');
+                                  if (s.attach_url === session.state.url && attached) {
+                                    session.replay(s.attach_url, role);
+                                  } else {
+                                    session.attach(s.attach_url, false, role);
+                                  }
                                 }}
                                 title={s.id}
                               >

package/web/src/components/StartSessionModal.test.tsx

@@ -11,13 +11,13 @@ const INSTANCE = {
   launch_context: { loadout: 'agentic-dev' },
   session_backends: [{ mode: 'managed', backend: 'tmux', available: true, drive: true }],
 };
-function mockFetch(postImpl?: () => Response | Promise<Response>) {
+function mockFetch(postImpl?: (init?: RequestInit) => Response | Promise<Response>) {
   return vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
     const url = String(input);
     const ok = (body: unknown) => new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/json' } });
     if (url.includes('/api/inventory')) return ok({ instances: [INSTANCE] });
     if (url.includes('/sessions') && init?.method === 'POST') {
-      return postImpl ? postImpl() : ok({ id: 'sess-x', attach_url: 'ws://x/agents/i/sessions/sess-x/attach' });
+      return postImpl ? postImpl(init) : ok({ id: 'sess-x', attach_url: 'ws://x/agents/i/sessions/sess-x/attach' });
     }
     return new Response('{}', { status: 404 });
   }) as unknown as typeof fetch;
@@ -32,7 +32,7 @@ function stubSession(attached = false): SessionApi {
 }
 
 beforeEach(() => { (window as unknown as { __COCKPIT_TOKEN__: string }).__COCKPIT_TOKEN__ = 't'; });
-afterEach(() => { cleanup(); vi.restoreAllMocks(); });
+afterEach(() => { cleanup(); vi.useRealTimers(); vi.restoreAllMocks(); });
 
 describe('StartSessionModal (#1640/#1641)', () => {
   it('renders nothing when closed', () => {
@@ -83,4 +83,27 @@ describe('StartSessionModal (#1640/#1641)', () => {
     await waitFor(() => expect(screen.getByText(/→ 500/)).toBeTruthy());
     expect(alertSpy).not.toHaveBeenCalled();
   });
+
+  it('unlocks when session start times out', async () => {
+    globalThis.fetch = mockFetch((init) => new Promise<Response>((_, reject) => {
+      init?.signal?.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')));
+    }));
+    render(<StartSessionModal open onClose={() => {}} session={stubSession()} onStarted={() => {}} startTimeoutMs={5} />);
+    const startBtn = await screen.findByRole('button', { name: /start session/i });
+    await waitFor(() => expect((startBtn as HTMLButtonElement).disabled).toBe(false));
+    fireEvent.click(startBtn);
+    expect(await screen.findByRole('button', { name: /starting/i })).toBeTruthy();
+    await waitFor(() => expect(screen.getByText(/timed out/i)).toBeTruthy());
+    expect(screen.getByRole('button', { name: /start session/i })).toBeTruthy();
+  });
+
+  it('unlocks when the bridge returns no attach URL', async () => {
+    globalThis.fetch = mockFetch(() => new Response('{"id":"sess-x"}', { status: 200, headers: { 'content-type': 'application/json' } }));
+    render(<StartSessionModal open onClose={() => {}} session={stubSession()} onStarted={() => {}} />);
+    const startBtn = await screen.findByRole('button', { name: /start session/i });
+    await waitFor(() => expect((startBtn as HTMLButtonElement).disabled).toBe(false));
+    fireEvent.click(startBtn);
+    await waitFor(() => expect(screen.getByText(/no attach URL/i)).toBeTruthy());
+    expect(screen.getByRole('button', { name: /start session/i })).toBeTruthy();
+  });
 });

package/web/src/components/StartSessionModal.tsx

@@ -15,9 +15,12 @@ interface Props {
   session: SessionApi;
   onStarted: () => void;          // switch to the Sessions workspace after attach
   initialInstanceId?: string;     // pre-select when opened from a specific instance/board
+  startTimeoutMs?: number;
 }
 
-export function StartSessionModal({ open, onClose, session, onStarted, initialInstanceId }: Props) {
+const START_SESSION_TIMEOUT_MS = 15000;
+
+export function StartSessionModal({ open, onClose, session, onStarted, initialInstanceId, startTimeoutMs = START_SESSION_TIMEOUT_MS }: Props) {
   const [instances, setInstances] = useState<Instance[]>([]);
   const [instId, setInstId] = useState('');
   const [loadoutId, setLoadoutId] = useState('');
@@ -77,17 +80,26 @@ export function StartSessionModal({ open, onClose, session, onStarted, initialIn
   const start = async () => {
     if (!current || !selectedBackend) return;
     setBusy(true); setErr('');
+    const controller = new AbortController();
+    const timeout = window.setTimeout(() => controller.abort(), startTimeoutMs);
     try {
       const qs = new URLSearchParams({ mode: selectedBackend.mode, backend: selectedBackend.backend });
       const s = await api<{ id: string; attach_url: string }>(
-        `/api/instances/${encodeURIComponent(current.id)}/sessions?${qs}`, { method: 'POST' },
+        `/api/instances/${encodeURIComponent(current.id)}/sessions?${qs}`,
+        { method: 'POST', signal: controller.signal },
       );
+      if (!s.attach_url) throw new Error('Session started but no attach URL was returned.');
       session.attach(s.attach_url, false, posture);
       onStarted();
       onClose();
     } catch (e) {
-      setErr((e as Error).message);   // inline — the operator sees exactly why
+      const message = e instanceof DOMException && e.name === 'AbortError'
+        ? 'Starting the session timed out. The instance may still be preparing PTY support; refresh sessions and try again.'
+        : (e as Error).message;
+      setErr(message);   // inline — the operator sees exactly why
       setBusy(false);
+    } finally {
+      window.clearTimeout(timeout);
     }
   };
 

package/web/src/useSession.test.tsx

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { renderHook, act } from '@testing-library/react';
-import { useSession } from './useSession';
+import { stripTerminalAutoResponses, useSession } from './useSession';
 
 // Minimal WebSocket double: records every constructed socket and lets the test
 // drive open/close/message. Mirrors the readiness-race timing (#1669).
@@ -23,6 +23,17 @@ beforeEach(() => {
 });
 afterEach(() => { vi.useRealTimers(); vi.restoreAllMocks(); });
 
+describe('stripTerminalAutoResponses', () => {
+  it('drops OSC color query replies without dropping real input', () => {
+    const data = '\x1b]10;rgb:cdcd/d3d3/dede\x07ls\x1b]11;rgb:0a0a/0c0c/1010\x1b\\\r';
+    expect(stripTerminalAutoResponses(data)).toBe('ls\r');
+  });
+
+  it('drops terminal identity/status replies', () => {
+    expect(stripTerminalAutoResponses('\x1b[?1;2chello\x1b[0n\x1b[12;40R')).toBe('hello');
+  });
+});
+
 describe('useSession — retry through the PTY-readiness window (#1669)', () => {
   it('reconnects on an early empty close instead of giving up', () => {
     const { result } = renderHook(() => useSession());
@@ -77,4 +88,67 @@ describe('useSession — retry through the PTY-readiness window (#1669)', () =>
     // 1 initial + 6 retries = 7 sockets, then it stops.
     expect(MockWS.instances.length).toBeLessThanOrEqual(7);
   });
+
+  it('ignores stale socket messages after switching sessions', () => {
+    const { result } = renderHook(() => useSession());
+    act(() => { result.current.attach('ws://x/agents/i/sessions/old/attach', false, 'controller'); });
+    const old = MockWS.instances[0];
+    act(() => { result.current.attach('ws://x/agents/i/sessions/new/attach', false, 'observer'); });
+    const current = MockWS.instances[1];
+
+    act(() => {
+      old.emit('open');
+      old.emit('message', { data: JSON.stringify({ op: 'binding_hello' }) });
+      old.emit('message', { data: JSON.stringify({ op: 'role_assigned', payload: { role: 'controller' } }) });
+      old.emit('close');
+    });
+    expect(old.sent).toEqual([]);
+    expect(result.current.state.url).toBe('ws://x/agents/i/sessions/new/attach');
+    expect(result.current.state.role).toBeNull();
+
+    act(() => {
+      current.emit('open');
+      current.emit('message', { data: JSON.stringify({ op: 'binding_hello' }) });
+      current.emit('message', { data: JSON.stringify({ op: 'role_assigned', payload: { role: 'observer' } }) });
+    });
+    expect(JSON.parse(current.sent[0])).toEqual({ op: 'pty.join_session', payload: { role: 'observer' } });
+    expect(result.current.state.role).toBe('observer');
+  });
+
+  it('does not let a stale close clear the active controller role', () => {
+    const { result } = renderHook(() => useSession());
+    act(() => { result.current.attach('ws://x/old', false, 'observer'); });
+    const old = MockWS.instances[0];
+    act(() => { result.current.attach('ws://x/new', false, 'controller'); });
+    const current = MockWS.instances[1];
+
+    act(() => {
+      current.emit('open');
+      current.emit('message', { data: JSON.stringify({ op: 'role_assigned', payload: { role: 'controller' } }) });
+    });
+    expect(result.current.state.role).toBe('controller');
+
+    act(() => { old.emit('close'); });
+    expect(result.current.state.url).toBe('ws://x/new');
+    expect(result.current.state.attached).toBe(true);
+    expect(result.current.state.role).toBe('controller');
+  });
+
+  it('reattaches for replay immediately and asks the active socket for replay_from', () => {
+    const { result } = renderHook(() => useSession());
+    act(() => { result.current.attach('ws://x/session', false, 'controller'); });
+    const first = MockWS.instances[0];
+    act(() => {
+      first.emit('open');
+      first.emit('message', { data: JSON.stringify({ op: 'output', seq: 12, payload: { data: btoa('ready') } }) });
+    });
+
+    act(() => { result.current.replay('ws://x/session', 'controller'); });
+    expect(MockWS.instances).toHaveLength(2);
+    const replay = MockWS.instances[1];
+    expect(replay.url).toBe('ws://x/session?replay_from=12');
+
+    act(() => { replay.emit('message', { data: JSON.stringify({ op: 'binding_hello' }) }); });
+    expect(JSON.parse(replay.sent[0])).toEqual({ op: 'pty.join_session', payload: { role: 'controller', replay_from: 12 } });
+  });
 });

package/web/src/useSession.ts

@@ -51,6 +51,13 @@ const toB64 = (s: string): string => {
   return btoa(bin);
 };
 
+export function stripTerminalAutoResponses(data: string): string {
+  return data
+    .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b\[\?[0-9;]*[cnhl]/g, '')
+    .replace(/\x1b\[[0-9;]*[Rn]/g, '');
+}
+
 function stripAnsi(text: string): string {
   return text
     .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
@@ -82,6 +89,7 @@ export function useSession() {
   const roRef = useRef<ResizeObserver | null>(null);
   const roleRef = useRef<Role>(null); // current role, read by term.onData without re-subscribing
   const outputTailRef = useRef('');
+  const connectionIdRef = useRef(0);
   // Retry-through-readiness state (#1669): a freshly-launched VM/container can
   // accept the pty-ws attach, send 0 frames, and close within ~2s because the
   // agent's PTY/tmux isn't streamable yet. Rather than show a hard
@@ -111,7 +119,9 @@ export function useSession() {
     noteOutput(bytes);
     try { termRef.current?.write(bytes); } catch { /* term not open */ }
   };
-  const sendOp = (op: string, payload?: unknown) => { try { wsRef.current?.send(JSON.stringify(payload === undefined ? { op } : { op, payload })); } catch { /* socket closed */ } };
+  const encodeOp = (op: string, payload?: unknown) => JSON.stringify(payload === undefined ? { op } : { op, payload });
+  const sendOp = (op: string, payload?: unknown) => { try { wsRef.current?.send(encodeOp(op, payload)); } catch { /* socket closed */ } };
+  const sendOn = (ws: WebSocket, op: string, payload?: unknown) => { try { ws.send(encodeOp(op, payload)); } catch { /* socket closed */ } };
   const clearResponseNeeded = () => setResponseNeeded({ needed: false, prompt: '', since: null, source: 'pty' });
 
   // Mount the terminal into the host element (ref callback from the Sessions tab).
@@ -139,11 +149,14 @@ export function useSession() {
       // Forward keystrokes to the PTY only while driving.
       term.onData((data) => {
         if (roleRef.current !== 'controller') return;
+        const userData = stripTerminalAutoResponses(data);
+        if (!userData) return;
         clearResponseNeeded();
-        sendOp('pty.session_input', { data: toB64(data) });
+        sendOp('pty.session_input', { data: toB64(userData) });
       });
       // Keep tmux sized to the terminal so redraws don't wrap/overflow.
       term.onResize(({ cols, rows }) => {
+        if (roleRef.current !== 'controller') return;
         if (cols < RESIZE_FLOOR_COLS || rows < RESIZE_FLOOR_ROWS) return;
         sendOp('pty.session_resize', { cols, rows });
       });
@@ -172,11 +185,14 @@ export function useSession() {
     try { termRef.current?.dispose(); } catch { /* */ }
     closedByUserRef.current = true;
     if (retryTimerRef.current) { clearTimeout(retryTimerRef.current); retryTimerRef.current = null; }
+    connectionIdRef.current += 1;
     wsRef.current?.close();
   }, []);
 
   const attach = useCallback((url: string, replay = false, requestedRole: Exclude<Role, null> = 'observer') => {
     if (retryTimerRef.current) { clearTimeout(retryTimerRef.current); retryTimerRef.current = null; }
+    const connectionId = connectionIdRef.current + 1;
+    connectionIdRef.current = connectionId;
     closedByUserRef.current = false;
     retryRef.current = 0;
     gotFrameRef.current = false;
@@ -191,11 +207,16 @@ export function useSession() {
 
     // Open (or re-open, on a readiness retry) the data-plane socket.
     const connect = () => {
+      if (connectionIdRef.current !== connectionId || closedByUserRef.current) return;
       const ws = new WebSocket(replay ? `${url}?replay_from=${lastSeq.current}` : url);
       wsRef.current = ws;
       let gone = false; // a failing socket fires BOTH 'error' and 'close' — handle once
-      ws.addEventListener('open', () => setState((s) => ({ ...s, attached: true, url })));
+      ws.addEventListener('open', () => {
+        if (connectionIdRef.current !== connectionId || wsRef.current !== ws) return;
+        setState((s) => ({ ...s, attached: true, url }));
+      });
       const onGone = (kind: 'close' | 'error') => {
+        if (connectionIdRef.current !== connectionId || wsRef.current !== ws) return;
         if (gone) return;
         gone = true;
         roleRef.current = null;
@@ -216,14 +237,15 @@ export function useSession() {
       ws.addEventListener('close', () => onGone('close'));
       ws.addEventListener('error', () => onGone('error'));
       ws.addEventListener('message', (ev) => {
+        if (connectionIdRef.current !== connectionId || wsRef.current !== ws) return;
         let m: WsMsg;
         try { m = JSON.parse(ev.data as string); } catch { return; }
         switch (m.op) {
           case 'binding_hello': {
-            sendOp('pty.join_session', { role: requestedRole });
+            sendOn(ws, 'pty.join_session', { role: requestedRole, ...(replay ? { replay_from: lastSeq.current } : {}) });
             // Tell the PTY our current dimensions up front so the first tmux redraw fits.
             const t = termRef.current;
-            if (t && t.cols >= RESIZE_FLOOR_COLS && t.rows >= RESIZE_FLOOR_ROWS) sendOp('pty.session_resize', { cols: t.cols, rows: t.rows });
+            if (requestedRole === 'controller' && t && t.cols >= RESIZE_FLOOR_COLS && t.rows >= RESIZE_FLOOR_ROWS) sendOn(ws, 'pty.session_resize', { cols: t.cols, rows: t.rows });
             break;
           }
           case 'role_assigned': {
@@ -232,10 +254,9 @@ export function useSession() {
             setState((s) => ({ ...s, role }));
             // Only a controller may type into the terminal; observers are read-only.
             if (termRef.current) termRef.current.options.disableStdin = role !== 'controller';
-            // Re-attaching to an established session whose shell is idle gets no
-            // live output and the join replay carries no keyframe — request one so
-            // the current screen paints immediately instead of staying blank.
-            if (!gotFrameRef.current) sendOp('pty.request_keyframe');
+            // The gateway owns replay/keyframe delivery for joined sessions.
+            // Avoid probing here: on some backends keyframe requests are
+            // controller-gated and create noisy permission errors for observers.
             requestAnimationFrame(() => fit());
             break;
           }
@@ -259,6 +280,7 @@ export function useSession() {
 
   const detach = useCallback(() => {
     closedByUserRef.current = true;
+    connectionIdRef.current += 1;
     roleRef.current = null;
     if (termRef.current) termRef.current.options.disableStdin = true; // detached → read-only
     if (retryTimerRef.current) { clearTimeout(retryTimerRef.current); retryTimerRef.current = null; }
@@ -267,9 +289,8 @@ export function useSession() {
   }, []);
   const replay = useCallback((url: string, requestedRole?: Exclude<Role, null>) => {
     const role = requestedRole ?? roleRef.current ?? 'observer';
-    detach();
-    setTimeout(() => attach(url, true, role), 50);
-  }, [attach, detach]);
+    attach(url, true, role);
+  }, [attach]);
   const requestKeyframe = useCallback(() => sendOp('pty.request_keyframe'), []);
   // Composer line-input (the input row + Actions inject). Raw keystrokes go via term.onData.
   const sendInput = useCallback((text: string): boolean => {