fix(machine): a workspace owns a pane grid — selecting one switches the whole middle view

apps/realtime/src/terminal/__tests__/terminal-session-map.test.ts

@@ -11,6 +11,8 @@ function fakeSession(sessionKey = 'key1', sandboxId = 'sbx1'): TerminalSession {
     closedFn: vi.fn(),
     scrollback: [],
     scrollbackBytes: 0,
+    hasOutput: false,
+    resumedAtCreate: false,
     reAuthInterval: undefined,
     idleTimer: undefined,
   };
@@ -224,3 +226,33 @@ describe('appendScrollback', () => {
     expect(session.scrollbackBytes).toBe(4);
   });
 });
+
+describe('appendScrollback — hasOutput', () => {
+  it('given a chunk BIGGER than the whole scrollback cap, should still record that the PTY has spoken', () => {
+    const session = fakeSession();
+
+    // The chunk is pushed, then trimmed straight back off: the buffer ends up
+    // EMPTY for a session that has just produced 64KB+ of output.
+    appendScrollback(session, 'x'.repeat(MAX_SCROLLBACK_BYTES + 1));
+
+    expect({
+      given: 'one output chunk larger than MAX_SCROLLBACK_BYTES',
+      should:
+        'leave hasOutput true even though the trim emptied the buffer — a client that reads an empty scrollback as "still booting, safe to type" would otherwise type a starting prompt into an agent that has been screaming output',
+      actual: { scrollback: session.scrollback.length, hasOutput: session.hasOutput },
+      expected: { scrollback: 0, hasOutput: true },
+    }).toEqual({
+      given: 'one output chunk larger than MAX_SCROLLBACK_BYTES',
+      should:
+        'leave hasOutput true even though the trim emptied the buffer — a client that reads an empty scrollback as "still booting, safe to type" would otherwise type a starting prompt into an agent that has been screaming output',
+      actual: { scrollback: 0, hasOutput: true },
+      expected: { scrollback: 0, hasOutput: true },
+    });
+  });
+
+  it('given no output at all, should report hasOutput false', () => {
+    const session = fakeSession();
+
+    expect(session.hasOutput).toBe(false);
+  });
+});

apps/realtime/src/terminal/terminal-session-map.ts

@@ -25,6 +25,26 @@ export type TerminalSession = {
   closedFn: (exitCode: number) => void;
   scrollback: string[];
   scrollbackBytes: number;
+  /**
+   * Has this PTY ever produced a byte? NOT the same question as "is the
+   * scrollback non-empty": a single chunk larger than MAX_SCROLLBACK_BYTES is
+   * pushed and then trimmed straight back off, leaving an EMPTY scrollback for a
+   * session that has been screaming output. A client that types a starting prompt
+   * into a terminal reads "has produced nothing" as "still booting, safe to type"
+   * — so it has to be the truth, not an artefact of the trim.
+   */
+  hasOutput: boolean;
+  /**
+   * Was this PTY already running when the bridge picked it up? (`openShell`
+   * resumed a Sprite exec session rather than starting one.)
+   *
+   * Kept ALONGSIDE `hasOutput` because the two answer the same question at
+   * different moments and neither covers the other: a resumed agent that has not
+   * yet said anything has `hasOutput: false`, and a reattach in that window would
+   * otherwise be told the PTY is a fresh boot — and a client holding a starting
+   * prompt would type it into an agent that has been running for hours.
+   */
+  resumedAtCreate: boolean;
   /**
    * Terminal Epic 3 metering (optional — set only when a `billing` seam is
    * wired). `payerId` + `connectedAt` identify who pays for the window that
@@ -39,8 +59,12 @@ export type TerminalSession = {
   pageId?: string;
 };
 
-export function appendScrollback(session: Pick<TerminalSession, 'scrollback' | 'scrollbackBytes'>, data: string): void {
+export function appendScrollback(
+  session: Pick<TerminalSession, 'scrollback' | 'scrollbackBytes' | 'hasOutput'>,
+  data: string,
+): void {
   const bytes = Buffer.byteLength(data, 'utf8');
+  session.hasOutput = true;
   session.scrollback.push(data);
   session.scrollbackBytes += bytes;
   while (session.scrollbackBytes > MAX_SCROLLBACK_BYTES && session.scrollback.length > 0) {

apps/web/src/app/dashboard/[driveId]/development/__tests__/layout.test.tsx

@@ -35,7 +35,7 @@ vi.mock('@/components/layout/middle-content/MachineKeepAliveHost', () => ({
 
 import DevelopmentLayout from '../layout';
 import { usePendingSessionStore } from '@/stores/development/usePendingSessionStore';
-import { useMachineWorkspaceStore } from '@/stores/machine-workspace/useMachineWorkspaceStore';
+import { useMachineWorkspaceStore, selectActiveWorkspace, panesOf } from '@/stores/machine-workspace/useMachineWorkspaceStore';
 
 const machine = (id: string) => ({ id, title: id, updatedAt: '2026-07-12T00:00:00.000Z' });
 
@@ -50,7 +50,7 @@ beforeEach(() => {
   vi.clearAllMocks();
   hostRenders.length = 0;
   usePendingSessionStore.setState({ pending: null });
-  useMachineWorkspaceStore.setState({ workspaces: {} });
+  useMachineWorkspaceStore.setState({ machines: {} });
   mockUseAuth.mockReturnValue({ user: { role: 'admin' }, isLoading: false });
   mockUseDriveMachines.mockReturnValue(driveMachines());
 });
@@ -157,7 +157,7 @@ describe('DevelopmentLayout', () => {
 
     expect(hostRenders.at(-1)!.activePageId).toBeNull();
     // Held, not applied — it converges once the machine is displayed again.
-    expect(useMachineWorkspaceStore.getState().workspaces['machine-1']).toBeUndefined();
+    expect(useMachineWorkspaceStore.getState().machines['machine-1']).toBeUndefined();
   });
 
   test('holds a session intent while the list loads, then applies it once the machine is displayed', () => {
@@ -174,11 +174,12 @@ describe('DevelopmentLayout', () => {
 
     // The list arrives, and the machine's pane region has ensured a workspace.
     mockUseDriveMachines.mockReturnValue(driveMachines({ machines: [machine('machine-1')] }));
-    useMachineWorkspaceStore.getState().ensureWorkspace('machine-1');
+    useMachineWorkspaceStore.getState().ensureMachine('machine-1');
     rerender(<DevelopmentLayout>{null}</DevelopmentLayout>);
 
-    const workspace = useMachineWorkspaceStore.getState().workspaces['machine-1'];
-    const activePane = workspace.columns.flatMap((c) => c.panes).find((p) => p.id === workspace.activePaneId);
+    // The session opens in ITS OWN workspace, which becomes the one on screen.
+    const workspace = selectActiveWorkspace('machine-1')(useMachineWorkspaceStore.getState())!;
+    const activePane = panesOf(workspace).find((pane) => pane.id === workspace.activePaneId);
     expect(activePane?.scope).toMatchObject({ name: 'agent-1' });
   });
 

apps/web/src/app/dashboard/[driveId]/development/layout.tsx

@@ -6,7 +6,7 @@ import { Cpu } from 'lucide-react';
 import MachineKeepAliveHost from '@/components/layout/middle-content/MachineKeepAliveHost';
 import { useAuth } from '@/hooks/useAuth';
 import { useDriveMachines } from '@/hooks/useDriveMachines';
-import { useMachineWorkspaceStore } from '@/stores/machine-workspace/useMachineWorkspaceStore';
+import { useMachineWorkspaceStore, selectActiveWorkspace } from '@/stores/machine-workspace/useMachineWorkspaceStore';
 import { usePendingSessionStore } from '@/stores/development/usePendingSessionStore';
 import { parseSelectedMachineId } from '@/lib/development/development-route';
 import { resolvePendingSession } from '@/lib/development/pending-session';
@@ -196,10 +196,9 @@ function DetailNotice({ title, description }: { title: string; description?: str
  * to actually has a workspace to open it into.
  *
  * The decision is the pure `resolvePendingSession`; this is the plumbing. It
- * re-evaluates whenever the workspace changes, so an intent applied against a
- * workspace that is then torn down and rebuilt (a remount — StrictMode's
- * double-invoke does this on first mount) re-applies to the new one instead of
- * being silently lost.
+ * re-evaluates whenever the workspace on screen changes, so an intent that has
+ * not converged yet — the pane region has not mounted, or the user is en route —
+ * is re-applied as soon as it can be, instead of being silently lost.
  *
  * Leaving the surface drops any unconverged intent: the store is a module
  * singleton, so an intent left behind here would otherwise still be sitting
@@ -209,8 +208,12 @@ function useDrainPendingSession(displayedMachineId: string | null) {
   const pending = usePendingSessionStore((state) => state.pending);
   const clearPending = usePendingSessionStore((state) => state.clearPending);
   const openTerminal = useMachineWorkspaceStore((state) => state.openTerminal);
+  // The machine's ACTIVE workspace — the grid the middle view is actually
+  // showing. A machine now holds many workspaces (each sidebar item owns one),
+  // and the intent converges when the session it names is in the active pane of
+  // the workspace on screen.
   const workspace = useMachineWorkspaceStore((state) =>
-    pending ? state.workspaces[pending.machineId] : undefined,
+    pending ? selectActiveWorkspace(pending.machineId)(state) : undefined,
   );
 
   useEffect(() => {