@@ -287,9 +287,11 @@ own front-end settings are separate; see [Configuration](#configuration).
 - **Cost tracking** — when odek has token prices configured, the header shows
   the running session spend, each turn footer its estimated cost, and
   `/stats` adds the `max_cost_usd` cap when set; hidden entirely otherwise.
-- **Live server snapshot** — a 25s heartbeat measures WebSocket round-trip
+- **Live server snapshot** — a 20s heartbeat measures WebSocket round-trip
   latency and refreshes server uptime, connection count, and streaming state
   (the ⚡ badge beside the model); `/server` opens the full cockpit card.
+  odek ≥ v2.1.0 also pushes `keepalive` so a thinking turn silent for
+  minutes does not lose the socket to an idle proxy.
 
 ### Accessibility & plain mode
 
 
@@ -60,11 +60,12 @@ These workflows have no server endpoint; bodek cannot offer them:
 |---------|-----------|--------|----|
 | `prompt` (content/model/thinking/attachments) | → | `SendPrompt` | composer ⏎ |
 | `approval_response` | → | `SendApproval` | approval queue (`A`/`D`/`T`, friction typing) |
-| `ping` | → | `Ping` | 25s heartbeat |
+| `ping` | → | `Ping` | 20s heartbeat |
 | `cancel` | → | `SendCancel` | `esc` (REST fallback) |
 | `session_switch` | → | `SessionSwitch` | session resume, reconnect re-adopt |
 | `skill_prompt_response` | → | `SendSkillPromptResponse` | suggestion card (`alt+s`/`alt+x`) |
 | `server_info` / `pong` | ← | — | cockpit, stream badge, RTT |
+| `keepalive` | ← | — | ignored (odek ≥ v2.1.0 idle traffic; must not drain the queue) |
 | `session` | ← | — | session/token capture, model sync |
 | `token` / `token_delta` | ← | — | transcript answer (coalesced) |
 | `thinking` / `thinking_delta` | ← | — | reasoning accordions |
 
@@ -134,6 +134,15 @@ func TestDecodeEvents(t *testing.T) {
 				}
 			},
 		},
+		{
+			name:  "keepalive",
+			frame: `{"type":"keepalive","t":1755768000000}`,
+			check: func(t *testing.T, e Event) {
+				if e.Type != "keepalive" || e.T == 0 {
+					t.Fatalf("bad keepalive decode: %+v", e)
+				}
+			},
+		},
 		{
 			name:  "memory_event",
 			frame: `{"type":"memory_event","event":"merge","target":"user","count":3}`,
 
@@ -4,14 +4,16 @@ import "strings"
 
 // ── provider-failure classification ─────────────────────────────────────────
 //
-// Turn failures arrive as raw provider-client text ("iteration 17: llm:
-// stream idle for over 2m0s without an event"). Under parallel-agent load
-// the dominant failure is a stalled stream — the provider accepted the
-// prompt and then went silent until the watchdog aborted — not an HTTP
-// error; raw 429s are absorbed by the client's retry budget and only
-// surface when it is exhausted. The classifier sorts the wire strings into
-// the handful of classes a user can act on, so the turn card explains what
-// happened and how to recover instead of echoing an LLM-internal line.
+// Turn failures arrive as raw provider-client text ("llm: stream idle
+// timeout", or the older "iteration 17: llm: stream idle for over 5m0s
+// without an event"). Under parallel-agent load the dominant failure is
+// a stalled stream — the provider accepted the prompt and then went
+// silent until the watchdog aborted — not an HTTP error; raw 429s are
+// absorbed by the client's retry budget and only surface when it is
+// exhausted. The classifier sorts the wire strings into the handful of
+// classes a user can act on, so the turn card explains what happened
+// and how to recover instead of echoing an LLM-internal line. odek
+// ≥ v2.1.0 defaults the idle/request budgets to 300s.
 
 type errClass uint8
 
@@ -55,13 +57,13 @@ func (m *Model) errorCard(raw string) string {
 	}
 	switch classifyErr(raw) {
 	case errStall:
-		return "**⚠ Provider stream stalled.** The provider accepted the prompt, then sent nothing for over 2m — usually throttling under parallel agent load" + hint + "."
+		return "**⚠ Provider stream stalled.** The provider accepted the prompt, then went silent past the idle timeout — raise `llm.stream_idle_timeout_seconds` (odek default 300s) if the model is still thinking" + hint + "."
 	case errRateLimit:
 		return "**⚠ Provider rate-limited (HTTP 429).** Concurrent agents exhausted the provider's stream budget" + hint + "."
 	case errConnDrop:
 		return "**⚠ Provider connection dropped** mid-stream" + hint + "."
 	case errTimeout:
-		return "**⚠ Provider request timed out.**" + hint
+		return "**⚠ Provider request timed out.** Raise `llm.request_timeout_seconds` (odek default 300s) if the model is still thinking" + hint
 	default:
 		return "**Error:** " + sanitize(raw)
 	}
 
@@ -25,6 +25,8 @@ func TestClassifyErr(t *testing.T) {
 	}{
 		{"iteration 17: llm: stream idle for over 2m0s without an event", errStall},
 		{"llm: stream idle for over 2m0s without an event", errStall},
+		{"llm: stream idle timeout", errStall},
+		{"iteration 4: llm: stream idle for over 5m0s without an event", errStall},
 		{"llm: provider rate limit (status 429) after 8 attempts", errRateLimit},
 		{"iteration 3: llm: read stream: read tcp 1.2.3.4:443->5.6.7.8:55: read: connection reset by peer", errConnDrop},
 		{"context deadline exceeded", errTimeout},
@@ -154,3 +156,26 @@ func TestFooterRetryHintOnError(t *testing.T) {
 		t.Errorf("retry hint must hide while a draft exists: %q", foot)
 	}
 }
+
+// TestErrorCardStallDoesNotHardcodeTwoMinutes pins the odek v2.1.0 budgets:
+// the stall card must not claim a 2-minute silence, and the timeout card
+// must point at request_timeout_seconds (default 300s).
+func TestErrorCardStallDoesNotHardcodeTwoMinutes(t *testing.T) {
+	m := errorTurn(t, "llm: stream idle timeout")
+	card := m.msgs[len(m.msgs)-1].content
+	if strings.Contains(card, "2m") {
+		t.Errorf("stall card still hardcodes the old 120s budget: %q", card)
+	}
+	if !strings.Contains(card, "idle timeout") {
+		t.Errorf("stall card missing idle-timeout wording: %q", card)
+	}
+	if !strings.Contains(card, "stream_idle_timeout_seconds") {
+		t.Errorf("stall card missing the config knob: %q", card)
+	}
+
+	to := errorTurn(t, "context deadline exceeded")
+	got := to.msgs[len(to.msgs)-1].content
+	if !strings.Contains(got, "request_timeout_seconds") {
+		t.Errorf("timeout card missing the config knob: %q", got)
+	}
+}
@@ -238,6 +238,13 @@ func (m *Model) handleEvent(ev client.Event) (tea.Model, tea.Cmd) {
 		}
 		stream = true
 
+	case "keepalive":
+		// odek ≥ v2.1.0 pushes idle traffic every 20s so proxies do not
+		// drop a socket waiting on a thinking model. Not a ping reply —
+		// ignore without refresh so the cadence cannot drain the queue
+		// or flicker the transcript.
+		return m, listen(m.events)
+
 	case "server_info", "pong":
 		// The connect hello and every heartbeat reply carry the same server
 		// snapshot. Only the pong closes a round trip.
 
@@ -397,10 +397,12 @@ func (m *Model) Init() tea.Cmd {
 		m.armHeartbeat())
 }
 
-// pingEvery is the application-level heartbeat cadence (spec: 25s). The
-// server answers inline — even mid-run — so the ping doubles as a liveness
-// probe and the pong refreshes the server snapshot (RTT, uptime, conns).
-const pingEvery = 25 * time.Second
+// pingEvery is the application-level heartbeat cadence (20s). Matches the
+// odek ≥ v2.1.0 server keepalive and stays under typical 30–60s proxy idle
+// timeouts so a thinking turn that is silent for minutes does not drop the
+// socket. The server answers inline — even mid-run — so the ping doubles
+// as a liveness probe and the pong refreshes the server snapshot.
+const pingEvery = 20 * time.Second
 
 // heartbeatMsg re-arms the heartbeat loop.
 type heartbeatMsg struct{}
 
@@ -95,6 +95,38 @@ func TestServerInfoAndPong(t *testing.T) {
 	}
 }
 
+func TestKeepaliveIsSilent(t *testing.T) {
+	m := newTestModel()
+	m.busy = true
+	m.status = "thinking"
+	m.queue = []string{"queued follow-up"}
+	n := len(m.msgs)
+	notices := len(m.notices)
+
+	_, cmd := m.handleEvent(client.Event{Type: "keepalive", T: time.Now().UnixMilli()})
+	if cmd == nil {
+		t.Error("keepalive must keep the event listener armed")
+	}
+	if len(m.queue) != 1 {
+		t.Fatal("keepalive must not drain the prompt queue")
+	}
+	if !m.busy || m.status != "thinking" {
+		t.Errorf("keepalive mutated turn state: busy=%v status=%q", m.busy, m.status)
+	}
+	if len(m.msgs) != n {
+		t.Error("keepalive must not append transcript")
+	}
+	if len(m.notices) != notices {
+		t.Errorf("keepalive posted a notice: %v", m.notices)
+	}
+}
+
+func TestPingEveryMatchesOdekKeepalive(t *testing.T) {
+	if pingEvery != 20*time.Second {
+		t.Errorf("pingEvery = %v, want 20s (under proxy idle; matches odek serve keepalive)", pingEvery)
+	}
+}
+
 func TestCancelledTurnClosesCleanly(t *testing.T) {
 	m := newTestModel()
 	streamingTurn(m)