diff --git a/.context/DECISIONS.md b/.context/DECISIONS.md
index 1a6db1f..318e4cb 100644
--- a/.context/DECISIONS.md
+++ b/.context/DECISIONS.md
@@ -3,6 +3,7 @@
 <!-- INDEX:START -->
 | Date | Decision |
 |------|--------|
+| 2026-02-15 | Track pane dimensions in paneSizes Map |
 | 2026-02-14 | Server-side output buffer in DO for reconnect replay |
 | 2026-02-14 | Render all tabs simultaneously with CSS visibility:hidden on inactive tabs |
 | 2026-02-14 | DO authoritative over layout with per-tab focus |
@@ -23,6 +24,20 @@ For lightweight decisions, a single statement suffices:
 
 For significant decisions:
 
+## [2026-02-15-180300] Track pane dimensions in paneSizes Map
+
+**Status**: Accepted
+
+**Context**: reconnectTerminal needed actual cols/rows but layout tree does not store them and handlePaneResize only forwards to terminal WS without persisting
+
+**Decision**: Track pane dimensions in paneSizes Map
+
+**Rationale**: In-memory Map is simplest — lost on hibernation but so are terminal WSes. Persisting to storage is unnecessary since reconnect already creates fresh PTYs. Alternative: send dimensions from frontend on reconnect — adds protocol complexity for no gain.
+
+**Consequences**: paneSizes must be updated at all 4 createTerminalWs call sites. Falls back to 80x24 for panes created before tracking or after hibernation.
+
+---
+
 ## [2026-02-14-233233] Server-side output buffer in DO for reconnect replay
 
 **Status**: Accepted
diff --git a/.context/LEARNINGS.md b/.context/LEARNINGS.md
index 400b032..7401c47 100644
--- a/.context/LEARNINGS.md
+++ b/.context/LEARNINGS.md
@@ -3,6 +3,7 @@
 <!-- INDEX:START -->
 | Date | Learning |
 |------|--------|
+| 2026-02-15 | paneSizes must be tracked at every terminal creation site |
 | 2026-02-14 | DO non-hibernation reconnect needs server-side replay |
 | 2026-02-14 | useMux() object identity churn breaks terminal lifecycle |
 | 2026-02-14 | ghostty-web container element must have no children |
@@ -12,6 +13,16 @@
 | 2026-02-14 | Zensical explicit nav is full override |
 <!-- INDEX:END -->
 
+## [2026-02-15-180258] paneSizes must be tracked at every terminal creation site
+
+**Context**: Code review caught that handleSessionCreate and handleTabCreate call createTerminalWs without saving to paneSizes, so reconnect falls back to 80x24
+
+**Lesson**: Any code path that calls createTerminalWs should also call paneSizes.set(ptyId, {cols, rows}). There are 4 sites: handleSessionCreate, handleTabCreate, handlePaneSplit, and reconnectTerminal (which looks up existing size).
+
+**Application**: When adding new terminal creation paths, always pair with paneSizes.set. Grep for createTerminalWs to find all call sites.
+
+---
+
 ## [2026-02-14-233231] DO non-hibernation reconnect needs server-side replay
 
 **Context**: Page reload doesn't hibernate the DO. reconnectAllTerminals() checks this.terminals.has() and skips. Frontend gets blank terminals because no ring buffer replay happens from CF Sandbox.
diff --git a/.context/TASKS.md b/.context/TASKS.md
index d572277..1da6135 100644
--- a/.context/TASKS.md
+++ b/.context/TASKS.md
@@ -22,7 +22,9 @@ STRUCTURE RULES (see CONSTITUTION.md):
 ### Phase 1: [Name] `#priority:high`
 - [ ] Clean up @kampus/wormhole package (old, no longer imported by live code) #added:2026-02-14-222749
 
-- [ ] Handle stale sessions on reconnect — detect dead terminal WSes and show session expired state instead of blank pane #added:2026-02-14-222749
+- [ ] Add reconnect retry limit — track per-ptyId attempt count, fail permanently after N attempts to prevent unbounded reconnect loops when sandbox is permanently dead #priority:medium #added:2026-02-15
+
+- [x] Handle stale sessions on reconnect — detect dead terminal WSes and show session expired state instead of blank pane #added:2026-02-14-222749 #done:2026-02-15
 
 - [x] Implement tab + focus wrapper on top of @usirin/layout-tree #priority:medium #added:2026-02-14-200550 #done:2026-02-14
 
diff --git a/.gitignore b/.gitignore
index 5898ea5..a5d8295 100644
--- a/.gitignore
+++ b/.gitignore
@@ -202,3 +202,6 @@ ralph*.sh
 
 # Zensical build output
 site/
+
+# Git worktrees
+.worktrees/
diff --git a/apps/kamp-us/src/wormhole/PaneLayout.tsx b/apps/kamp-us/src/wormhole/PaneLayout.tsx
index 2ee701c..aa76b9b 100644
--- a/apps/kamp-us/src/wormhole/PaneLayout.tsx
+++ b/apps/kamp-us/src/wormhole/PaneLayout.tsx
@@ -27,7 +27,7 @@ export function PaneLayout() {
 						}}
 					>
 						<Group orientation={tree.root.orientation}>
-							{renderChildren(tree.root, [], tab.focus, state.channels)}
+							{renderChildren(tree.root, [], tab.focus, state.channels, state.paneConnected)}
 						</Group>
 					</div>
 				);
@@ -41,22 +41,25 @@ function renderChildren(
 	path: LT.StackPath,
 	focus: number[],
 	channels: Record<string, number>,
+	paneConnected: Record<string, boolean>,
 ) {
 	return stack.children.map((child, i) => {
 		const childPath = [...path, i];
 		return (
 			<Fragment key={child.id}>
 				{i > 0 && (
-				<Separator
-					className={stack.orientation === "horizontal" ? styles.resizeHandleH : styles.resizeHandleV}
-				/>
-			)}
+					<Separator
+						className={
+							stack.orientation === "horizontal" ? styles.resizeHandleH : styles.resizeHandleV
+						}
+					/>
+				)}
 				<Panel>
 					{child.tag === "window" ? (
-						renderWindow(child as LT.Window, childPath, focus, channels)
+						renderWindow(child as LT.Window, childPath, focus, channels, paneConnected)
 					) : (
 						<Group orientation={(child as LT.Stack).orientation}>
-							{renderChildren(child as LT.Stack, childPath, focus, channels)}
+							{renderChildren(child as LT.Stack, childPath, focus, channels, paneConnected)}
 						</Group>
 					)}
 				</Panel>
@@ -70,17 +73,20 @@ function renderWindow(
 	path: LT.StackPath,
 	focus: number[],
 	channels: Record<string, number>,
+	paneConnected: Record<string, boolean>,
 ) {
 	const channel = channels[window.key];
 	if (channel === undefined) return <div>Loading...</div>;
 
 	const isFocused = JSON.stringify(path) === JSON.stringify(focus);
+	const isConnected = paneConnected[window.key] ?? true;
 
 	return (
 		<TerminalPane
 			channel={channel}
 			sessionId={window.key}
 			focused={isFocused}
+			connected={isConnected}
 			onFocus={() => {
 				/* focus is managed by DO */
 			}}
diff --git a/apps/kamp-us/src/wormhole/TerminalPane.tsx b/apps/kamp-us/src/wormhole/TerminalPane.tsx
index 3c4d205..d2127ce 100644
--- a/apps/kamp-us/src/wormhole/TerminalPane.tsx
+++ b/apps/kamp-us/src/wormhole/TerminalPane.tsx
@@ -1,17 +1,25 @@
 import type {ITheme} from "ghostty-web";
-import {useChannelTerminal} from "./use-channel-terminal.ts";
 import {useMux} from "./MuxClient.tsx";
+import {useChannelTerminal} from "./use-channel-terminal.ts";
 import styles from "./WormholeLayout.module.css";
 
 interface TerminalPaneProps {
 	channel: number;
 	sessionId: string;
 	focused: boolean;
+	connected: boolean;
 	onFocus: () => void;
 	theme?: ITheme;
 }
 
-export function TerminalPane({channel, sessionId, focused, onFocus, theme}: TerminalPaneProps) {
+export function TerminalPane({
+	channel,
+	sessionId,
+	focused,
+	connected,
+	onFocus,
+	theme,
+}: TerminalPaneProps) {
 	const {ref} = useChannelTerminal({channel, sessionId, theme});
 	const {splitPane, closePane} = useMux();
 
@@ -20,6 +28,11 @@ export function TerminalPane({channel, sessionId, focused, onFocus, theme}: Term
 		// biome-ignore lint/a11y/noStaticElementInteractions: terminal container, not a button
 		<div className={styles.pane} data-focused={focused || undefined} onClick={onFocus}>
 			<div ref={ref} style={{flex: 1, minHeight: 0}} />
+			{!connected && (
+				<div className={styles.disconnectedOverlay}>
+					<span>Disconnected — press any key to reconnect</span>
+				</div>
+			)}
 			<div className={styles.paneControls}>
 				<button
 					type="button"
diff --git a/apps/kamp-us/src/wormhole/WormholeLayout.module.css b/apps/kamp-us/src/wormhole/WormholeLayout.module.css
index 4d3bec7..9c001a3 100644
--- a/apps/kamp-us/src/wormhole/WormholeLayout.module.css
+++ b/apps/kamp-us/src/wormhole/WormholeLayout.module.css
@@ -69,3 +69,19 @@
 .resizeHandleV {
 	height: 2px;
 }
+
+.disconnectedOverlay {
+	position: absolute;
+	inset: 0;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	background: rgba(0, 0, 0, 0.6);
+	z-index: 5;
+}
+
+.disconnectedOverlay span {
+	color: #888;
+	font-size: 13px;
+	font-family: monospace;
+}
diff --git a/apps/kamp-us/src/wormhole/use-wormhole-client.ts b/apps/kamp-us/src/wormhole/use-wormhole-client.ts
index 5f2ef4b..5abc8c3 100644
--- a/apps/kamp-us/src/wormhole/use-wormhole-client.ts
+++ b/apps/kamp-us/src/wormhole/use-wormhole-client.ts
@@ -1,12 +1,13 @@
 // apps/kamp-us/src/wormhole/use-wormhole-client.ts
-import {useCallback, useEffect, useRef, useState} from "react";
+
 import {
+	type ClientMessage,
 	CONTROL_CHANNEL,
-	parseBinaryFrame,
 	encodeBinaryFrame,
+	parseBinaryFrame,
 	type ServerMessage,
-	type ClientMessage,
 } from "@kampus/sandbox/Protocol";
+import {useCallback, useEffect, useRef, useState} from "react";
 
 interface SessionRecord {
 	id: string;
@@ -28,6 +29,7 @@ interface WormholeClientState {
 	tabs: TabRecord[];
 	activeTab: string | null;
 	channels: Record<string, number>;
+	paneConnected: Record<string, boolean>;
 	connected: boolean;
 }
 
@@ -41,7 +43,12 @@ interface WormholeClient {
 	closeTab: (tabId: string) => void;
 	switchTab: (tabId: string) => void;
 	renameTab: (tabId: string, name: string) => void;
-	splitPane: (paneId: string, orientation: "horizontal" | "vertical", cols: number, rows: number) => void;
+	splitPane: (
+		paneId: string,
+		orientation: "horizontal" | "vertical",
+		cols: number,
+		rows: number,
+	) => void;
 	closePane: (paneId: string) => void;
 	resizePane: (paneId: string, cols: number, rows: number) => void;
 	moveFocus: (direction: "left" | "right" | "up" | "down") => void;
@@ -60,6 +67,7 @@ export function useWormholeClient(
 		tabs: [],
 		activeTab: null,
 		channels: {},
+		paneConnected: {},
 		connected: false,
 	});
 
@@ -114,8 +122,8 @@ export function useWormholeClient(
 		return () => {
 			ws.close();
 		};
-	// sendControl is stable (empty deps). viewport intentionally excluded: send initial dimensions on connect, not reconnect on resize.
-	// eslint-disable-next-line react-hooks/exhaustive-deps
+		// sendControl is stable (empty deps). viewport intentionally excluded: send initial dimensions on connect, not reconnect on resize.
+		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [url]);
 
 	function handleServerMessage(msg: ServerMessage) {
@@ -127,6 +135,7 @@ export function useWormholeClient(
 					tabs: msg.tabs as TabRecord[],
 					activeTab: msg.activeTab,
 					channels: msg.channels as Record<string, number>,
+					paneConnected: msg.connected as Record<string, boolean>,
 				}));
 				break;
 			case "layout_update":
@@ -135,36 +144,32 @@ export function useWormholeClient(
 					tabs: msg.tabs as TabRecord[],
 					activeTab: msg.activeTab,
 					channels: msg.channels as Record<string, number>,
+					paneConnected: msg.connected as Record<string, boolean>,
 				}));
 				break;
-			case "session_exit":
-				break;
 			case "sessions_reset":
 				break;
 		}
 	}
 
-	const onTerminalData = useCallback(
-		(channel: number, callback: (data: Uint8Array) => void) => {
-			if (!terminalListeners.current.has(channel)) {
-				terminalListeners.current.set(channel, new Set());
-			}
-			// biome-ignore lint/style/noNonNullAssertion: has() check above guarantees entry
-			terminalListeners.current.get(channel)!.add(callback);
-
-			// Flush any data that arrived before this listener mounted
-			const buffered = terminalBuffers.current.get(channel);
-			if (buffered) {
-				for (const data of buffered) callback(data);
-				terminalBuffers.current.delete(channel);
-			}
+	const onTerminalData = useCallback((channel: number, callback: (data: Uint8Array) => void) => {
+		if (!terminalListeners.current.has(channel)) {
+			terminalListeners.current.set(channel, new Set());
+		}
+		// biome-ignore lint/style/noNonNullAssertion: has() check above guarantees entry
+		terminalListeners.current.get(channel)!.add(callback);
+
+		// Flush any data that arrived before this listener mounted
+		const buffered = terminalBuffers.current.get(channel);
+		if (buffered) {
+			for (const data of buffered) callback(data);
+			terminalBuffers.current.delete(channel);
+		}
 
-			return () => {
-				terminalListeners.current.get(channel)?.delete(callback);
-			};
-		},
-		[],
-	);
+		return () => {
+			terminalListeners.current.get(channel)?.delete(callback);
+		};
+	}, []);
 
 	return {
 		state,
diff --git a/apps/worker/src/features/sandbox/WormholeServer.ts b/apps/worker/src/features/sandbox/WormholeServer.ts
index f6258a5..d15f22a 100644
--- a/apps/worker/src/features/sandbox/WormholeServer.ts
+++ b/apps/worker/src/features/sandbox/WormholeServer.ts
@@ -1,7 +1,7 @@
 import {DurableObject} from "cloudflare:workers";
 import {ChannelMap} from "@kampus/sandbox/ChannelMap";
-import * as TL from "@kampus/sandbox/TabbedLayout";
 import * as Protocol from "@kampus/sandbox/Protocol";
+import * as TL from "@kampus/sandbox/TabbedLayout";
 import * as LT from "@usirin/layout-tree";
 
 interface SessionRecord {
@@ -28,6 +28,8 @@ export class WormholeServer extends DurableObject {
 	private terminals = new Map<string, WebSocket>();
 	private tabToSession = new Map<string, string>();
 	private outputBuffers = new Map<string, Uint8Array[]>();
+	private reconnecting = new Set<string>();
+	private paneSizes = new Map<string, {cols: number; rows: number}>();
 
 	constructor(state: DurableObjectState, env: Env) {
 		super(state, env);
@@ -98,7 +100,12 @@ export class WormholeServer extends DurableObject {
 		const ptyId = this.channelMap.getPtyId(channel);
 		if (ptyId) {
 			const termWs = this.terminals.get(ptyId);
-			if (termWs) termWs.send(payload);
+			if (termWs) {
+				termWs.send(payload);
+			} else if (!this.reconnecting.has(ptyId)) {
+				// Terminal disconnected — lazy reconnect
+				await this.reconnectTerminal(ptyId, payload);
+			}
 		}
 	}
 
@@ -162,6 +169,7 @@ export class WormholeServer extends DurableObject {
 
 		// Create first terminal
 		const ptyId = crypto.randomUUID();
+		this.paneSizes.set(ptyId, {cols: 80, rows: 24});
 		await this.createTerminalWs(sandboxId, ptyId, 80, 24);
 
 		// Create layout with one tab + one pane
@@ -236,6 +244,7 @@ export class WormholeServer extends DurableObject {
 		if (!session) return;
 
 		const ptyId = crypto.randomUUID();
+		this.paneSizes.set(ptyId, {cols: 80, rows: 24});
 		await this.createTerminalWs(session.sandboxId, ptyId, 80, 24);
 
 		this.layout = TL.createTab(this.layout, msg.name, ptyId);
@@ -309,6 +318,7 @@ export class WormholeServer extends DurableObject {
 		if (!session) return;
 
 		const ptyId = crypto.randomUUID();
+		this.paneSizes.set(ptyId, {cols: msg.cols, rows: msg.rows});
 		await this.createTerminalWs(session.sandboxId, ptyId, msg.cols, msg.rows);
 
 		const result = TL.splitPane(this.layout, msg.paneId, msg.orientation, ptyId);
@@ -352,6 +362,7 @@ export class WormholeServer extends DurableObject {
 	}
 
 	private async handlePaneResize(msg: Protocol.PaneResizeMessage): Promise<void> {
+		this.paneSizes.set(msg.paneId, {cols: msg.cols, rows: msg.rows});
 		const termWs = this.terminals.get(msg.paneId);
 		if (!termWs) return;
 		termWs.send(JSON.stringify({type: "resize", cols: msg.cols, rows: msg.rows}));
@@ -366,6 +377,15 @@ export class WormholeServer extends DurableObject {
 
 	// --- Broadcast helpers ---
 
+	private buildConnectedRecord(): Record<string, boolean> {
+		const channels = this.channelMap.toRecord();
+		const connected: Record<string, boolean> = {};
+		for (const ptyId of Object.keys(channels)) {
+			connected[ptyId] = this.terminals.has(ptyId);
+		}
+		return connected;
+	}
+
 	private buildStateMessage(): Protocol.StateMessage {
 		return new Protocol.StateMessage({
 			type: "state",
@@ -380,6 +400,7 @@ export class WormholeServer extends DurableObject {
 				})) ?? [],
 			activeTab: this.layout?.tabs[this.layout.activeTab]?.id ?? null,
 			channels: this.channelMap.toRecord(),
+			connected: this.buildConnectedRecord(),
 		});
 	}
 
@@ -404,6 +425,7 @@ export class WormholeServer extends DurableObject {
 				})) ?? [],
 			activeTab: this.layout?.tabs[this.layout.activeTab]?.id ?? null,
 			channels: this.channelMap.toRecord(),
+			connected: this.buildConnectedRecord(),
 		});
 		const encoded = Protocol.encodeControlMessage(msg);
 		for (const ws of this.clients) {
@@ -440,7 +462,12 @@ export class WormholeServer extends DurableObject {
 		return keys;
 	}
 
-	private async createTerminalWs(sandboxId: string, ptyId: string, cols: number, rows: number): Promise<void> {
+	private async createTerminalWs(
+		sandboxId: string,
+		ptyId: string,
+		cols: number,
+		rows: number,
+	): Promise<void> {
 		const id = this.env.SANDBOX.idFromName(sandboxId);
 		const stub = this.env.SANDBOX.get(id);
 
@@ -486,24 +513,16 @@ export class WormholeServer extends DurableObject {
 
 		ws.addEventListener("close", () => {
 			this.terminals.delete(ptyId);
-			this.outputBuffers.delete(ptyId);
-			const exitMsg = new Protocol.SessionExitMessage({
-				type: "session_exit",
-				sessionId: this.getSessionForPty(ptyId),
-				ptyId,
-				channel,
-				exitCode: 0,
-			});
-			const encoded = Protocol.encodeControlMessage(exitMsg);
-			for (const client of this.clients) {
-				client.send(encoded);
-			}
+			// Keep outputBuffers — pane retains last visible output
+			// Keep channel assigned — frontend can still send data to trigger reconnect
+			// Broadcast layout update so clients see connected: false
+			this.broadcastLayoutUpdate();
 		});
 
 		ws.addEventListener("error", () => {
 			this.terminals.delete(ptyId);
-			this.outputBuffers.delete(ptyId);
-			this.channelMap.release(channel);
+			// Keep buffers and channel, same as close
+			this.broadcastLayoutUpdate();
 		});
 	}
 
@@ -532,6 +551,32 @@ export class WormholeServer extends DurableObject {
 		}
 	}
 
+	private async reconnectTerminal(ptyId: string, bufferedInput?: Uint8Array): Promise<void> {
+		if (this.reconnecting.has(ptyId)) return;
+		this.reconnecting.add(ptyId);
+		try {
+			const sessionId = this.getSessionForPty(ptyId);
+			if (!sessionId) return;
+			const session = this.sessions.find((s) => s.id === sessionId);
+			if (!session) return;
+
+			const size = this.paneSizes.get(ptyId) ?? {cols: 80, rows: 24};
+			await this.createTerminalWs(session.sandboxId, ptyId, size.cols, size.rows);
+
+			if (bufferedInput) {
+				const termWs = this.terminals.get(ptyId);
+				if (termWs) termWs.send(bufferedInput);
+			}
+
+			this.broadcastLayoutUpdate();
+		} catch (err) {
+			console.error("[WormholeServer] reconnectTerminal failed", {ptyId, err});
+			this.broadcastLayoutUpdate();
+		} finally {
+			this.reconnecting.delete(ptyId);
+		}
+	}
+
 	private async reconnectAllTerminals(): Promise<void> {
 		if (!this.layout) return;
 
@@ -545,7 +590,8 @@ export class WormholeServer extends DurableObject {
 				const keys = this.windowKeysForTab(tab);
 				for (const ptyId of keys) {
 					if (!this.terminals.has(ptyId)) {
-						await this.createTerminalWs(session.sandboxId, ptyId, 80, 24);
+						const size = this.paneSizes.get(ptyId) ?? {cols: 80, rows: 24};
+						await this.createTerminalWs(session.sandboxId, ptyId, size.cols, size.rows);
 					}
 				}
 			}
diff --git a/docs/plans/2026-02-15-stale-session-design.md b/docs/plans/2026-02-15-stale-session-design.md
new file mode 100644
index 0000000..4322e01
--- /dev/null
+++ b/docs/plans/2026-02-15-stale-session-design.md
@@ -0,0 +1,98 @@
+# Stale Session Detection & Lazy Reconnect
+
+## Problem
+
+Sandbox container sleeps after ~10min inactivity. Terminal WSes (DO -> Sandbox) close.
+The `close` handler fires: cleans `this.terminals`, deletes output buffers, sends
+`session_exit`. But the layout is untouched — panes become zombies. Frontend receives
+`session_exit` but ignores it (`break;` no-op). User sees panes that look alive but
+silently drop all input.
+
+## Design
+
+### Core Idea
+
+`this.terminals.has(ptyId)` already IS the connection state. Derive it, broadcast it,
+and reconnect lazily on interaction.
+
+### Backend (WormholeServer.ts)
+
+**Terminal WS close handler** — change from current behavior:
+- Keep output buffers (pane retains last visible output)
+- Don't send `session_exit` (replaced by connection status in layout state)
+- Broadcast layout update (client sees `connected: false` immediately)
+- Keep channel assigned (frontend can still send data to trigger reconnect)
+
+**State messages** — add `connected` field:
+- `StateMessage` and `LayoutUpdateMessage` get `connected: Record<string, boolean>`
+- Derived from `this.terminals`: `connected[ptyId] = this.terminals.has(ptyId)`
+- Sent alongside existing `channels` field
+
+**Input to disconnected pane** — lazy reconnect:
+- `webSocketMessage` receives input for a ptyId where `this.terminals.get(ptyId)` is undefined
+- Look up sandboxId via `getSessionForPty(ptyId)`
+- Call `createTerminalWs(sandboxId, ptyId, cols, rows)` to reconnect
+- On success: new channel assigned, broadcast layout update, pane goes `connected: true`
+- Buffer the triggering keystroke and send after reconnect
+
+### Protocol (Protocol.ts)
+
+- Add `connected: S.Record({key: S.String, value: S.Boolean})` to `StateMessage` and
+  `LayoutUpdateMessage`
+- Remove `SessionExitMessage` — no longer needed, connection status is in layout state
+- Remove `session_exit` from `ServerMessage` union
+
+### Frontend
+
+**use-wormhole-client.ts:**
+- Add `connected: Record<string, boolean>` to client state
+- Handle `connected` field from `state` and `layout_update` messages
+- Remove dead `session_exit` case
+
+**PaneLayout.tsx:**
+- Pass `connected[paneId]` to `TerminalPane`
+
+**TerminalPane.tsx:**
+- Accept `connected` prop
+- When `connected === false`: render overlay on top of terminal (absolute positioned sibling)
+- Overlay: dimmed background + "Disconnected — press any key to reconnect" text
+- Terminal still visible underneath (last output preserved)
+- Keystrokes still flow through to server (server handles reconnect)
+
+## Data Flow
+
+```
+Sandbox sleeps
+  -> terminal WS closes
+  -> close handler: keep buffers, keep channel, broadcast layout update
+  -> client receives layout_update with connected[ptyId] = false
+  -> TerminalPane renders "Disconnected" overlay
+
+User presses key
+  -> useChannelTerminal sends data on existing channel
+  -> server: channelMap.getPtyId(channel) succeeds, terminals.get(ptyId) = undefined
+  -> server triggers reconnectTerminal(ptyId, payload)
+  -> sandbox wakes, new PTY created, same channel kept
+  -> broadcast layout_update with connected[ptyId] = true
+  -> client updates: overlay disappears, terminal resumes
+```
+
+## Edge Cases
+
+- **Reconnect fails** (sandbox permanently dead): pane stays disconnected. Future:
+  add retry limit + "Session expired" state.
+- **Fresh shell after sandbox sleep**: old output still displayed, new prompt appears
+  at bottom. Cosmetic mismatch — acceptable for v1.
+- **Keystroke that triggers reconnect**: buffered and sent after WS established.
+  If buffer fails, lost — acceptable for v1.
+
+## Files Changed
+
+| File | Change |
+|------|--------|
+| `packages/sandbox/src/Protocol.ts` | Add `connected` to state messages, remove `SessionExitMessage` |
+| `apps/worker/src/features/sandbox/WormholeServer.ts` | Close handler, state builder, input reconnect |
+| `apps/kamp-us/src/wormhole/use-wormhole-client.ts` | Track `connected` state, remove session_exit |
+| `apps/kamp-us/src/wormhole/PaneLayout.tsx` | Pass connected status to panes |
+| `apps/kamp-us/src/wormhole/TerminalPane.tsx` | Disconnected overlay |
+| `apps/kamp-us/src/wormhole/WormholeLayout.module.css` | Overlay styles |
diff --git a/docs/plans/2026-02-15-stale-session-impl.md b/docs/plans/2026-02-15-stale-session-impl.md
new file mode 100644
index 0000000..e67698f
--- /dev/null
+++ b/docs/plans/2026-02-15-stale-session-impl.md
@@ -0,0 +1,621 @@
+# Stale Session Detection & Lazy Reconnect — Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Detect disconnected terminal panes and show a "Disconnected" overlay; reconnect lazily when the user types into a dead pane.
+
+**Architecture:** Derive per-pane connection status from `this.terminals.has(ptyId)` on the DO. Broadcast it in state/layout messages. Frontend renders overlay. Server handles reconnect on input to disconnected pane. Channels stay assigned across disconnect/reconnect.
+
+**Tech Stack:** Effect Schema, Cloudflare Durable Objects, React, CSS Modules
+
+**Design doc:** `docs/plans/2026-02-15-stale-session-design.md`
+
+---
+
+### Task 1: Protocol — add `connected`, remove `SessionExitMessage`
+
+**Files:**
+- Modify: `packages/sandbox/src/Protocol.ts`
+
+**Step 1: Add `connected` field to `StateMessage`**
+
+In `StateMessage` (line 155), add after `channels`:
+
+```typescript
+export class StateMessage extends S.Class<StateMessage>("StateMessage")({
+	type: S.Literal("state"),
+	sessions: S.Array(SessionRecord),
+	tabs: S.Array(TabRecord),
+	activeTab: S.NullOr(S.String),
+	channels: S.Record({key: S.String, value: S.Number}),
+	connected: S.Record({key: S.String, value: S.Boolean}),
+}) {}
+```
+
+**Step 2: Add `connected` field to `LayoutUpdateMessage`**
+
+In `LayoutUpdateMessage` (line 164), add after `channels`:
+
+```typescript
+export class LayoutUpdateMessage extends S.Class<LayoutUpdateMessage>("LayoutUpdateMessage")({
+	type: S.Literal("layout_update"),
+	tabs: S.Array(TabRecord),
+	activeTab: S.NullOr(S.String),
+	channels: S.Record({key: S.String, value: S.Number}),
+	connected: S.Record({key: S.String, value: S.Boolean}),
+}) {}
+```
+
+**Step 3: Remove `SessionExitMessage`**
+
+Delete the `SessionExitMessage` class (lines 172-178).
+
+**Step 4: Remove from `ServerMessage` union**
+
+Update `ServerMessage` union (line 187) to remove `SessionExitMessage`:
+
+```typescript
+export const ServerMessage = S.Union(
+	StateMessage,
+	LayoutUpdateMessage,
+	SessionsResetMessage,
+);
+```
+
+**Step 5: Typecheck**
+
+Run: `turbo run typecheck --filter=@kampus/sandbox`
+
+Expected: FAIL — `WormholeServer.ts` and `use-wormhole-client.ts` reference the removed/changed types. That's fine, we fix them in subsequent tasks.
+
+**Step 6: Commit**
+
+```
+feat(sandbox): add connected field to protocol, remove SessionExitMessage
+```
+
+---
+
+### Task 2: Backend — state builder includes `connected`
+
+**Files:**
+- Modify: `apps/worker/src/features/sandbox/WormholeServer.ts`
+
+**Step 1: Update `buildStateMessage` to include `connected`**
+
+In `buildStateMessage()` (line 369), add `connected` field derived from `this.terminals`:
+
+```typescript
+private buildStateMessage(): Protocol.StateMessage {
+	const channels = this.channelMap.toRecord();
+	const connected: Record<string, boolean> = {};
+	for (const ptyId of Object.keys(channels)) {
+		connected[ptyId] = this.terminals.has(ptyId);
+	}
+	return new Protocol.StateMessage({
+		type: "state",
+		sessions: this.sessions,
+		tabs:
+			this.layout?.tabs.map((t) => ({
+				id: t.id,
+				sessionId: this.getSessionIdForTab(t.id),
+				name: t.name,
+				layout: t.tree,
+				focus: t.focus,
+			})) ?? [],
+		activeTab: this.layout?.tabs[this.layout.activeTab]?.id ?? null,
+		channels,
+		connected,
+	});
+}
+```
+
+**Step 2: Update `broadcastLayoutUpdate` to include `connected`**
+
+In `broadcastLayoutUpdate()` (line 394), same pattern:
+
+```typescript
+private broadcastLayoutUpdate(): void {
+	const channels = this.channelMap.toRecord();
+	const connected: Record<string, boolean> = {};
+	for (const ptyId of Object.keys(channels)) {
+		connected[ptyId] = this.terminals.has(ptyId);
+	}
+	const msg = new Protocol.LayoutUpdateMessage({
+		type: "layout_update",
+		tabs:
+			this.layout?.tabs.map((t) => ({
+				id: t.id,
+				sessionId: this.getSessionIdForTab(t.id),
+				name: t.name,
+				layout: t.tree,
+				focus: t.focus,
+			})) ?? [],
+		activeTab: this.layout?.tabs[this.layout.activeTab]?.id ?? null,
+		channels,
+		connected,
+	});
+	const encoded = Protocol.encodeControlMessage(msg);
+	for (const ws of this.clients) {
+		ws.send(encoded);
+	}
+}
+```
+
+**Step 3: Extract shared `buildConnectedRecord` helper**
+
+Both methods build `connected` the same way. Extract to reduce duplication:
+
+```typescript
+private buildConnectedRecord(): Record<string, boolean> {
+	const channels = this.channelMap.toRecord();
+	const connected: Record<string, boolean> = {};
+	for (const ptyId of Object.keys(channels)) {
+		connected[ptyId] = this.terminals.has(ptyId);
+	}
+	return connected;
+}
+```
+
+Use in both `buildStateMessage` and `broadcastLayoutUpdate`.
+
+**Step 4: Typecheck**
+
+Run: `turbo run typecheck --filter=worker`
+
+Expected: Should pass for the worker package. Frontend still broken (next tasks).
+
+**Step 5: Commit**
+
+```
+feat(sandbox): include connected status in state messages
+```
+
+---
+
+### Task 3: Backend — terminal WS close handler
+
+**Files:**
+- Modify: `apps/worker/src/features/sandbox/WormholeServer.ts`
+
+**Step 1: Rewrite close handler in `createTerminalWs`**
+
+Replace the close handler (lines 492-506):
+
+```typescript
+ws.addEventListener("close", () => {
+	this.terminals.delete(ptyId);
+	// Keep outputBuffers — pane retains last visible output
+	// Keep channel assigned — frontend can still send data to trigger reconnect
+	// Broadcast layout update so clients see connected: false
+	this.broadcastLayoutUpdate();
+});
+```
+
+Key changes from before:
+- **Remove** `this.outputBuffers.delete(ptyId)` — keep buffers
+- **Remove** `SessionExitMessage` construction and broadcast
+- **Remove** `this.channelMap.release(channel)` — keep channel
+- **Add** `this.broadcastLayoutUpdate()` — notify clients of disconnection
+
+**Step 2: Simplify error handler**
+
+Update the error handler (lines 508-512) similarly:
+
+```typescript
+ws.addEventListener("error", () => {
+	this.terminals.delete(ptyId);
+	// Keep buffers and channel, same as close
+	this.broadcastLayoutUpdate();
+});
+```
+
+**Step 3: Typecheck**
+
+Run: `turbo run typecheck --filter=worker`
+
+Expected: PASS — no more reference to `SessionExitMessage`.
+
+**Step 4: Commit**
+
+```
+fix(sandbox): keep buffers and channels on terminal disconnect
+```
+
+---
+
+### Task 4: Backend — lazy reconnect on input
+
+**Files:**
+- Modify: `apps/worker/src/features/sandbox/WormholeServer.ts`
+
+**Step 1: Add reconnect logic in `webSocketMessage`**
+
+Replace the terminal input routing section (lines 97-103):
+
+```typescript
+// Route terminal input to CF terminal WS
+const ptyId = this.channelMap.getPtyId(channel);
+if (ptyId) {
+	const termWs = this.terminals.get(ptyId);
+	if (termWs) {
+		termWs.send(payload);
+	} else {
+		// Terminal disconnected — lazy reconnect
+		await this.reconnectTerminal(ptyId, payload);
+	}
+}
+```
+
+**Step 2: Implement `reconnectTerminal` method**
+
+Add after `reconnectAllTerminals`:
+
+```typescript
+private async reconnectTerminal(ptyId: string, bufferedInput?: Uint8Array): Promise<void> {
+	const sessionId = this.getSessionForPty(ptyId);
+	if (!sessionId) return;
+	const session = this.sessions.find((s) => s.id === sessionId);
+	if (!session) return;
+
+	await this.createTerminalWs(session.sandboxId, ptyId, 80, 24);
+
+	// Send the keystroke that triggered the reconnect
+	if (bufferedInput) {
+		const termWs = this.terminals.get(ptyId);
+		if (termWs) termWs.send(bufferedInput);
+	}
+
+	this.broadcastLayoutUpdate();
+}
+```
+
+**Step 3: Typecheck**
+
+Run: `turbo run typecheck --filter=worker`
+
+Expected: PASS
+
+**Step 4: Commit**
+
+```
+feat(sandbox): lazy reconnect terminal on user input
+```
+
+---
+
+### Task 5: Frontend — track `connected` in state
+
+**Files:**
+- Modify: `apps/kamp-us/src/wormhole/use-wormhole-client.ts`
+
+**Step 1: Add `paneConnected` to `WormholeClientState`**
+
+Update the interface (line 26) — use `paneConnected` to avoid collision with the existing `connected` (WS connection status):
+
+```typescript
+interface WormholeClientState {
+	sessions: SessionRecord[];
+	tabs: TabRecord[];
+	activeTab: string | null;
+	channels: Record<string, number>;
+	paneConnected: Record<string, boolean>;
+	connected: boolean;
+}
+```
+
+**Step 2: Initialize in useState**
+
+Update initial state (line 58):
+
+```typescript
+const [state, setState] = useState<WormholeClientState>({
+	sessions: [],
+	tabs: [],
+	activeTab: null,
+	channels: {},
+	paneConnected: {},
+	connected: false,
+});
+```
+
+**Step 3: Handle in `handleServerMessage`**
+
+Update `state` case (line 123):
+
+```typescript
+case "state":
+	setState((s) => ({
+		...s,
+		sessions: msg.sessions as SessionRecord[],
+		tabs: msg.tabs as TabRecord[],
+		activeTab: msg.activeTab,
+		channels: msg.channels as Record<string, number>,
+		paneConnected: msg.connected as Record<string, boolean>,
+	}));
+	break;
+```
+
+Update `layout_update` case (line 132):
+
+```typescript
+case "layout_update":
+	setState((s) => ({
+		...s,
+		tabs: msg.tabs as TabRecord[],
+		activeTab: msg.activeTab,
+		channels: msg.channels as Record<string, number>,
+		paneConnected: msg.connected as Record<string, boolean>,
+	}));
+	break;
+```
+
+**Step 4: Remove `session_exit` case**
+
+Delete lines 140-141 (`case "session_exit": break;`). The `ServerMessage` union no longer includes it, so TypeScript will error if we leave it.
+
+Also remove `sessions_reset` case (lines 142-143) if it's also unused — check if `SessionsResetMessage` is still in the union. (It is — keep it.)
+
+Actually, `SessionsResetMessage` is still in the union, so keep that case. Just remove `session_exit`.
+
+**Step 5: Typecheck**
+
+Run: `turbo run typecheck --filter=kamp-us`
+
+Expected: PASS for this file. `PaneLayout.tsx` and `TerminalPane.tsx` still need updates (next tasks).
+
+**Step 6: Commit**
+
+```
+feat(sandbox): track pane connection status in frontend state
+```
+
+---
+
+### Task 6: Frontend — pass `connected` through PaneLayout
+
+**Files:**
+- Modify: `apps/kamp-us/src/wormhole/PaneLayout.tsx`
+
+**Step 1: Thread `paneConnected` through render functions**
+
+Update `PaneLayout` to pass `state.paneConnected`:
+
+```typescript
+export function PaneLayout() {
+	const {state} = useMux();
+
+	return (
+		<div style={{flex: 1, position: "relative"}}>
+			{state.tabs.map((tab) => {
+				const tree = tab.layout as LT.Tree;
+				if (!tree || !tree.root) return null;
+
+				const isActive = tab.id === state.activeTab;
+
+				return (
+					<div
+						key={tab.id}
+						style={{
+							position: "absolute",
+							inset: 0,
+							visibility: isActive ? "visible" : "hidden",
+						}}
+					>
+						<Group orientation={tree.root.orientation}>
+							{renderChildren(tree.root, [], tab.focus, state.channels, state.paneConnected)}
+						</Group>
+					</div>
+				);
+			})}
+		</div>
+	);
+}
+```
+
+**Step 2: Update `renderChildren` signature**
+
+```typescript
+function renderChildren(
+	stack: LT.Stack,
+	path: LT.StackPath,
+	focus: number[],
+	channels: Record<string, number>,
+	paneConnected: Record<string, boolean>,
+) {
+	return stack.children.map((child, i) => {
+		const childPath = [...path, i];
+		return (
+			<Fragment key={child.id}>
+				{i > 0 && (
+					<Separator
+						className={stack.orientation === "horizontal" ? styles.resizeHandleH : styles.resizeHandleV}
+					/>
+				)}
+				<Panel>
+					{child.tag === "window" ? (
+						renderWindow(child as LT.Window, childPath, focus, channels, paneConnected)
+					) : (
+						<Group orientation={(child as LT.Stack).orientation}>
+							{renderChildren(child as LT.Stack, childPath, focus, channels, paneConnected)}
+						</Group>
+					)}
+				</Panel>
+			</Fragment>
+		);
+	});
+}
+```
+
+**Step 3: Update `renderWindow` to pass connected**
+
+```typescript
+function renderWindow(
+	window: LT.Window,
+	path: LT.StackPath,
+	focus: number[],
+	channels: Record<string, number>,
+	paneConnected: Record<string, boolean>,
+) {
+	const channel = channels[window.key];
+	if (channel === undefined) return <div>Loading...</div>;
+
+	const isFocused = JSON.stringify(path) === JSON.stringify(focus);
+	const isConnected = paneConnected[window.key] ?? false;
+
+	return (
+		<TerminalPane
+			channel={channel}
+			sessionId={window.key}
+			focused={isFocused}
+			connected={isConnected}
+			onFocus={() => {
+				/* focus is managed by DO */
+			}}
+		/>
+	);
+}
+```
+
+**Step 4: Typecheck**
+
+Run: `turbo run typecheck --filter=kamp-us`
+
+Expected: FAIL — `TerminalPane` doesn't accept `connected` prop yet. Fixed in Task 7.
+
+**Step 5: Commit**
+
+```
+feat(sandbox): thread pane connection status through layout
+```
+
+---
+
+### Task 7: Frontend — disconnected overlay in TerminalPane
+
+**Files:**
+- Modify: `apps/kamp-us/src/wormhole/TerminalPane.tsx`
+- Modify: `apps/kamp-us/src/wormhole/WormholeLayout.module.css`
+
+**Step 1: Add `connected` prop and overlay to TerminalPane**
+
+```typescript
+interface TerminalPaneProps {
+	channel: number;
+	sessionId: string;
+	focused: boolean;
+	connected: boolean;
+	onFocus: () => void;
+	theme?: ITheme;
+}
+
+export function TerminalPane({channel, sessionId, focused, connected, onFocus, theme}: TerminalPaneProps) {
+	const {ref} = useChannelTerminal({channel, sessionId, theme});
+	const {splitPane, closePane} = useMux();
+
+	return (
+		// biome-ignore lint/a11y/useKeyWithClickEvents: terminal handles keyboard events via ghostty-web
+		// biome-ignore lint/a11y/noStaticElementInteractions: terminal container, not a button
+		<div className={styles.pane} data-focused={focused || undefined} onClick={onFocus}>
+			<div ref={ref} style={{flex: 1, minHeight: 0}} />
+			{!connected && (
+				<div className={styles.disconnectedOverlay}>
+					<span>Disconnected — press any key to reconnect</span>
+				</div>
+			)}
+			<div className={styles.paneControls}>
+				<button
+					type="button"
+					onClick={(e) => {
+						e.stopPropagation();
+						splitPane(sessionId, "vertical", 80, 24);
+					}}
+					title="Split right"
+				>
+					|
+				</button>
+				<button
+					type="button"
+					onClick={(e) => {
+						e.stopPropagation();
+						splitPane(sessionId, "horizontal", 80, 24);
+					}}
+					title="Split down"
+				>
+					&mdash;
+				</button>
+				<button
+					type="button"
+					onClick={(e) => {
+						e.stopPropagation();
+						closePane(sessionId);
+					}}
+					title="Close pane"
+				>
+					&times;
+				</button>
+			</div>
+		</div>
+	);
+}
+```
+
+**Step 2: Add overlay CSS**
+
+Append to `WormholeLayout.module.css`:
+
+```css
+.disconnectedOverlay {
+	position: absolute;
+	inset: 0;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	background: rgba(0, 0, 0, 0.6);
+	z-index: 5;
+}
+
+.disconnectedOverlay span {
+	color: #888;
+	font-size: 13px;
+	font-family: monospace;
+}
+```
+
+**Step 3: Typecheck all**
+
+Run: `turbo run typecheck`
+
+Expected: PASS across all packages.
+
+**Step 4: Commit**
+
+```
+feat(sandbox): show disconnected overlay on stale terminal panes
+```
+
+---
+
+### Task 8: Final verification
+
+**Step 1: Full typecheck**
+
+Run: `turbo run typecheck`
+
+Expected: PASS
+
+**Step 2: Biome lint**
+
+Run: `biome check --write apps/worker/src/features/sandbox/WormholeServer.ts apps/kamp-us/src/wormhole/use-wormhole-client.ts apps/kamp-us/src/wormhole/PaneLayout.tsx apps/kamp-us/src/wormhole/TerminalPane.tsx apps/kamp-us/src/wormhole/WormholeLayout.module.css packages/sandbox/src/Protocol.ts`
+
+Expected: PASS or auto-fix
+
+**Step 3: Update design doc**
+
+Update `docs/plans/2026-02-15-stale-session-design.md` to reflect final decision: channels are NOT released on disconnect (design doc currently says "Release the channel"). Fix the Data Flow section too.
+
+**Step 4: Commit**
+
+```
+docs: update stale session design to match implementation
+```
diff --git a/packages/sandbox/src/Protocol.ts b/packages/sandbox/src/Protocol.ts
index aee589b..91f31e0 100644
--- a/packages/sandbox/src/Protocol.ts
+++ b/packages/sandbox/src/Protocol.ts
@@ -158,6 +158,7 @@ export class StateMessage extends S.Class<StateMessage>("StateMessage")({
 	tabs: S.Array(TabRecord),
 	activeTab: S.NullOr(S.String),
 	channels: S.Record({key: S.String, value: S.Number}),
+	connected: S.Record({key: S.String, value: S.Boolean}),
 }) {}
 
 /** @since 0.1.0 @category models */
@@ -166,15 +167,7 @@ export class LayoutUpdateMessage extends S.Class<LayoutUpdateMessage>("LayoutUpd
 	tabs: S.Array(TabRecord),
 	activeTab: S.NullOr(S.String),
 	channels: S.Record({key: S.String, value: S.Number}),
-}) {}
-
-/** @since 0.1.0 @category models */
-export class SessionExitMessage extends S.Class<SessionExitMessage>("SessionExitMessage")({
-	type: S.Literal("session_exit"),
-	sessionId: S.String,
-	ptyId: S.String,
-	channel: S.Number,
-	exitCode: S.Number,
+	connected: S.Record({key: S.String, value: S.Boolean}),
 }) {}
 
 /** @since 0.1.0 @category models */
@@ -184,12 +177,7 @@ export class SessionsResetMessage extends S.Class<SessionsResetMessage>("Session
 }) {}
 
 /** @since 0.1.0 @category models */
-export const ServerMessage = S.Union(
-	StateMessage,
-	LayoutUpdateMessage,
-	SessionExitMessage,
-	SessionsResetMessage,
-);
+export const ServerMessage = S.Union(StateMessage, LayoutUpdateMessage, SessionsResetMessage);
 
 /** @since 0.1.0 @category models */
 export type ServerMessage = S.Schema.Type<typeof ServerMessage>;