@@ -0,0 +1,41 @@
+/**
+ * The live console's "No terminal available" fallback must say what actually
+ * went wrong. A KNOWN transport ('pty', 'acp') arriving without a connection
+ * URL is a missing connection, not a transport this view cannot render; only
+ * an unrecognised transport gets the "cannot render" sentence.
+ *
+ * Found live: after `studyloop web` was restarted, a session whose server had
+ * stopped was adopted with transport "pty" and no URL, and the learner read
+ * 'This session reports transport "pty", which this view cannot render' —
+ * about the one transport the view renders with xterm. The "did not return a
+ * connection" sentence the troubleshooting guide describes for exactly this
+ * case was unreachable, because every caller passes a transport.
+ */
+// Run with:  node --test 'packages/studyloop/tests/js/**/*.test.js'
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { liveAgentConsole } from
+  '../../src/studyloop/web/static/js/components/live-agent-console.js';
+
+for (const transport of ['pty', 'acp']) {
+  test(`a known transport (${transport}) with no URL is reported as a missing connection`, () => {
+    const view = liveAgentConsole('study');
+
+    view.start({ transport, wsUrl: null, topic: 'Decorators', studySessionId: 's-1' });
+
+    assert.equal(view.terminalMode, 'unavailable');
+    assert.doesNotMatch(view.statusMessage, /cannot render/);
+    assert.match(view.statusMessage, /did not return a connection/);
+  });
+}
+
+test('an unrecognised transport still names the transport it cannot render', () => {
+  const view = liveAgentConsole('study');
+
+  view.start({ transport: 'carrier-pigeon', wsUrl: '/api/session/ws?study_session_id=s-1' });
+
+  assert.equal(view.terminalMode, 'unavailable');
+  assert.match(view.statusMessage, /transport "carrier-pigeon", which this view cannot render/);
+});
@@ -28,6 +28,7 @@
 from __future__ import annotations
 
 import asyncio
+import os
 import sys
 from pathlib import Path
 
@@ -559,3 +560,81 @@ async def test_an_existing_session_state_is_still_marked_ended(self) -> None:
         _signal_dashboard_ended()
 
         assert session_state.read_session_state()["mode"] == "ended"
+
+
+# ---------------------------------------------------------------------------
+# Defect 4 — a web session whose server stopped is offered for reattach
+# ---------------------------------------------------------------------------
+
+_DEAD_PID = 999_999_999  # beyond any pid the kernel hands out
+
+
+class TestAWebSessionWhoseServerStoppedIsNotLive:
+    """A PTY/ACP session lives inside the server process that started it.
+
+    When that server stops without ending the session, the state file still
+    says ``mode=focus`` and names the dead server's ``pid``. ``/session/start``
+    already treats that claim as stale (``claim_blocks_web_start``), but this
+    endpoint reported it as live with no ``reattach_url``. After a restart of
+    ``studyloop web`` the console adopted it and told the learner it "cannot
+    render" transport pty, the one transport it renders with xterm.
+    """
+
+    def _write_orphan(self, **overrides: object) -> None:
+        session_state.write_session_state(
+            {
+                "study_session_id": "orphan-1",
+                "topic": "Decorators",
+                "mode": "focus",
+                "transport": "pty",
+                "origin": "study",
+                "pid": _DEAD_PID,
+                **overrides,
+            }
+        )
+
+    def test_state_reports_it_ended(self, client: TestClient) -> None:
+        self._write_orphan()
+
+        state = client.get("/api/session/state").json()
+
+        assert state.get("mode") == "ended", "a session whose server is gone was offered as live"
+        assert "reattach_url" not in state
+
+    def test_an_acp_orphan_is_reported_ended_too(self, client: TestClient) -> None:
+        self._write_orphan(transport="acp")
+
+        assert client.get("/api/session/state").json().get("mode") == "ended"
+
+    def test_nothing_is_deleted(self, client: TestClient) -> None:
+        """A session that never ended never flushed its parking lot; those are
+        the learner's notes, so reporting it ended must not destroy them."""
+        self._write_orphan()
+        session_state.PARKING_FILE.write_text("- a parked question\n")
+
+        client.get("/api/session/state")
+
+        assert session_state.STATE_FILE.exists()
+        assert session_state.PARKING_FILE.read_text() == "- a parked question\n"
+
+    def test_a_live_foreign_server_s_session_is_left_alone(self, client: TestClient) -> None:
+        # pid 1 always exists and is foreign to the test process.
+        self._write_orphan(pid=1)
+
+        assert client.get("/api/session/state").json().get("mode") == "focus"
+
+    def test_this_process_s_own_claim_is_left_alone(self, client: TestClient) -> None:
+        """A start in flight writes its reservation with this process's pid
+        before the slot is acquired; that is not an orphan."""
+        self._write_orphan(pid=os.getpid(), mode="starting")
+
+        assert client.get("/api/session/state").json().get("mode") == "starting"
+
+    def test_a_cli_session_is_left_alone(self, client: TestClient) -> None:
+        """A CLI session's pid is the CLI process, which can exit while its
+        multiplexer session lives on; the zombie rule judges CLI sessions."""
+        session_state.write_session_state(
+            {"study_session_id": "cli-1", "topic": "tmux", "mode": "focus", "pid": _DEAD_PID}
+        )
+
+        assert client.get("/api/session/state").json().get("mode") == "focus"