diff --git a/AGENTS.md b/AGENTS.md
index 3a8b08cc9..1cd5c66e4 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -15,6 +15,14 @@
 - Prefer composable primitives (signals, hooks, utilities) over deep inheritance or implicit global state.
 - When adding platform integrations (SSE, IPC, SDK), isolate them in thin adapters that surface typed events/actions.
 
+## PR Review Principles
+- **Check for regressions first.** Before approving any change, verify the existing behavior still works — run the test suite, test manually on both mobile and desktop, and confirm no unintended side effects in related subsystems.
+- **Look for better possible implementations.** Don't settle for the first working approach. Ask: is there a simpler way? Does the codebase already have a pattern for this? Would a different abstraction reduce future maintenance cost?
+- **Be the PR gatekeeper.** Every line merged becomes technical debt someone else will read. If it's unclear, fragile, or lacks tests, push back. The reviewer's job is to protect the codebase, not to be nice.
+- **Be ruthless about code quality.** Surface-level "LGTM" is negligence. Inspect: naming, error handling, edge cases, type safety, logging (is it useful or just noise?), performance (any unnecessary allocations or re-renders?), and whether the change respects existing architectural boundaries.
+- **Test before responding to review comments.** Never reply "works for me" or "this fixes it" without deploying the exact commit and verifying the behavior. Untested responses waste reviewer time and erode trust.
+- **UI and server must be built from the same version.** Version mismatches between UI and server cause subtle bugs (e.g., sessions disappearing). Always build both from the same commit before testing.
+
 ## Multi-Language Support (i18n)
 
 The UI uses a small custom i18n layer (no ICU/messageformat). When building features, never hardcode user-visible strings.
diff --git a/MOBILE-SSE-FIX-IMPLEMENTATION-GUIDE.md b/MOBILE-SSE-FIX-IMPLEMENTATION-GUIDE.md
new file mode 100644
index 000000000..17d20e71c
--- /dev/null
+++ b/MOBILE-SSE-FIX-IMPLEMENTATION-GUIDE.md
@@ -0,0 +1,289 @@
+# Mobile SSE Resilience Fix - Implementation Guide
+
+**Reference:** See `MOBILE-SSE-RESILIENCE-ANALYSIS.md` for root cause details
+
+## Implementation: Option A (Pong Retry Logic)
+
+This guide provides step-by-step instructions for implementing retry logic on the pong HTTP POST.
+
+### Changes Required
+
+#### 1. Create Utility: Retry Helper with Exponential Backoff
+
+**File:** `packages/ui/src/lib/retry-utils.ts` (new)
+
+```typescript
+interface RetryOptions {
+  maxAttempts?: number
+  initialDelayMs?: number
+  maxDelayMs?: number
+  backoffMultiplier?: number
+}
+
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {},
+): Promise<T> {
+  const {
+    maxAttempts = 3,
+    initialDelayMs = 100,
+    maxDelayMs = 5000,
+    backoffMultiplier = 2,
+  } = options
+
+  let lastError: Error | null = null
+  let delayMs = initialDelayMs
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn()
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error))
+
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs))
+        delayMs = Math.min(delayMs * backoffMultiplier, maxDelayMs)
+      }
+    }
+  }
+
+  throw new Error(
+    `Failed after ${maxAttempts} attempts: ${lastError?.message || "Unknown error"}`,
+  )
+}
+```
+
+#### 2. Update Server Events Pong Handler
+
+**File:** `packages/ui/src/lib/server-events.ts`
+
+**Change at line 47-56:**
+
+```typescript
+// BEFORE
+(payload) => {
+  void serverApi
+    .sendClientConnectionPong({
+      ...getClientIdentity(),
+      pingTs: payload.ts,
+    })
+    .catch(() => {
+      debugWarn("sse", "Pong failed (connection already closed)")
+    })
+}
+
+// AFTER
+(payload) => {
+  const identity = getClientIdentity()
+  const pongPayload = { ...identity, pingTs: payload.ts }
+  
+  void retryWithBackoff(
+    () => serverApi.sendClientConnectionPong(pongPayload),
+    {
+      maxAttempts: 3,
+      initialDelayMs: 100,
+      maxDelayMs: 2000,
+    }
+  )
+    .catch((error) => {
+      debugWarn("sse", `Pong failed after retries: ${error.message}`)
+    })
+}
+```
+
+**Also add import at top:**
+```typescript
+import { retryWithBackoff } from "./retry-utils"
+```
+
+#### 3. Add Logging for Observability
+
+**File:** `packages/ui/src/lib/server-events.ts`
+
+Enhance the pong handler to log retry attempts:
+
+```typescript
+(payload) => {
+  const identity = getClientIdentity()
+  const pongPayload = { ...identity, pingTs: payload.ts }
+  let attemptCount = 0
+  
+  void retryWithBackoff(
+    async () => {
+      attemptCount++
+      if (attemptCount > 1) {
+        logSse(`Pong retry attempt ${attemptCount}`)
+      }
+      return serverApi.sendClientConnectionPong(pongPayload)
+    },
+    {
+      maxAttempts: 3,
+      initialDelayMs: 100,
+      maxDelayMs: 2000,
+    }
+  )
+    .catch((error) => {
+      debugWarn("sse", `Pong failed: ${error.message}`)
+      // Optionally trigger reconnect if pong fails completely
+      // scheduleReconnect()
+    })
+}
+```
+
+### Testing Checklist
+
+#### Unit Tests
+
+**File:** `packages/ui/src/lib/retry-utils.test.ts` (new)
+
+```typescript
+import { describe, it, expect, vi } from "vitest"
+import { retryWithBackoff } from "./retry-utils"
+
+describe("retryWithBackoff", () => {
+  it("succeeds on first attempt", async () => {
+    const fn = vi.fn().mockResolvedValue("success")
+    const result = await retryWithBackoff(fn)
+    expect(result).toBe("success")
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it("retries on failure and succeeds", async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("fail"))
+      .mockResolvedValue("success")
+    const result = await retryWithBackoff(fn)
+    expect(result).toBe("success")
+    expect(fn).toHaveBeenCalledTimes(2)
+  })
+
+  it("fails after max attempts", async () => {
+    const fn = vi.fn().mockRejectedValue(new Error("always fails"))
+    await expect(retryWithBackoff(fn, { maxAttempts: 2 })).rejects.toThrow()
+    expect(fn).toHaveBeenCalledTimes(2)
+  })
+
+  it("respects backoff delays", async () => {
+    const fn = vi.fn().mockRejectedValue(new Error("fail"))
+    const startTime = Date.now()
+    
+    await expect(
+      retryWithBackoff(fn, {
+        maxAttempts: 3,
+        initialDelayMs: 50,
+        backoffMultiplier: 2,
+      })
+    ).rejects.toThrow()
+
+    const elapsed = Date.now() - startTime
+    // 50ms + 100ms = 150ms minimum (plus jitter)
+    expect(elapsed).toBeGreaterThanOrEqual(150)
+  })
+})
+```
+
+#### Integration Tests
+
+**File:** `packages/ui/src/lib/server-events.test.ts` (update existing)
+
+Add test for pong retry on network failure:
+
+```typescript
+it("retries pong on transient network failure", async () => {
+  const mockApi = {
+    sendClientConnectionPong: vi
+      .fn()
+      .mockRejectedValueOnce(new Error("Network timeout"))
+      .mockResolvedValue(undefined),
+  }
+
+  // Trigger ping handler
+  const pingPayload = { ts: Date.now() }
+  await pingHandler(pingPayload) // Assuming handler is extracted
+
+  // Verify retry logic was invoked
+  await vi.advanceTimersByTimeAsync(100)
+  expect(mockApi.sendClientConnectionPong).toHaveBeenCalledTimes(2)
+})
+```
+
+#### Manual Testing
+
+1. **Throttle Network (DevTools → Network → 3G)**
+   - Send message
+   - Verify response arrives (no "Abort" button needed)
+   - Check console for `Pong retry attempt` logs
+
+2. **Intermittent Connectivity**
+   - Use network simulator
+   - Create 500ms packet loss window during pong
+   - Verify retry succeeds after loss ends
+
+3. **Multiple Messages**
+   - Send 5 messages rapidly
+   - Verify all receive responses (with retries in logs)
+   - No dropped messages
+
+### Metrics to Monitor
+
+Add to server logs for post-deployment monitoring:
+
+**File:** `packages/server/src/server/routes/events.ts`
+
+Track pong success/failure rate:
+
+```typescript
+interface PongStats {
+  totalPings: number
+  successfulPongs: number
+  failedPongs: number
+}
+
+const stats = new Map<string, PongStats>()
+
+app.post("/api/client-connections/pong", (request, reply) => {
+  const body = PongBodySchema.parse(request.body ?? {})
+  if (!deps.connectionManager.pong(body)) {
+    // Track failed pongs
+    stats.set(body.clientId, {
+      ...stats.get(body.clientId),
+      failedPongs: (stats.get(body.clientId)?.failedPongs ?? 0) + 1,
+    })
+    reply.code(404).send({ error: "Client connection not found" })
+    return
+  }
+  
+  // Track successful pongs
+  stats.set(body.clientId, {
+    ...stats.get(body.clientId),
+    successfulPongs: (stats.get(body.clientId)?.successfulPongs ?? 0) + 1,
+  })
+  reply.code(204).send()
+})
+```
+
+### Success Criteria
+
+- ✓ No console errors for pong failures on 3G network
+- ✓ Messages received responses within 5 seconds (including retry time)
+- ✓ No "Abort" button needed for messages sent on poor networks
+- ✓ Retry logs show 1-2 retries on slow connections
+- ✓ Unit tests pass (100% coverage of retry-utils)
+- ✓ Integration tests pass (pong retry scenarios)
+
+### Rollback Plan
+
+If issues appear post-deployment:
+1. Reduce `maxAttempts` from 3 to 2
+2. Increase `initialDelayMs` from 100ms to 200ms
+3. Revert to previous version if retry logic causes new issues
+
+### Next Steps After Option A
+
+If retry logic doesn't fully solve mobile issues:
+1. Monitor metrics for pong failure patterns
+2. Identify if failures are permanent or transient
+3. Consider escalating to Option B (SSE-based pong)
+
+See `MOBILE-SSE-RESILIENCE-ANALYSIS.md` for Option B details.
diff --git a/MOBILE-SSE-RESILIENCE-ANALYSIS.md b/MOBILE-SSE-RESILIENCE-ANALYSIS.md
new file mode 100644
index 000000000..d36775fc8
--- /dev/null
+++ b/MOBILE-SSE-RESILIENCE-ANALYSIS.md
@@ -0,0 +1,178 @@
+# Mobile SSE Connection Resilience - Root Cause Analysis
+
+**Date:** May 28, 2026  
+**Branch:** `fix/mobile-network-resilience`  
+**Status:** Root cause identified, fix pending implementation
+
+## Problem Statement
+
+On mobile networks with poor connectivity or high latency, users experience:
+
+1. Message sent but no response received
+2. "Abort" button pressed to cancel the waiting request
+3. Response only arrives after:
+   - User sends another message (triggers reconnection), OR
+   - Page is manually refreshed
+
+**Expected behavior:** Server processes message and sends response immediately
+
+## Detailed Analysis
+
+### Server-Side Flow (events.ts, connection-manager.ts)
+
+```
+Server → Client: ping (every 15 seconds, line 53 in events.ts)
+         heartbeat = setInterval(() => { reply.raw.write(...) }, 15000)
+
+Client → Server: pong (HTTP POST to /api/client-connections/pong)
+
+Server waiting: 45 second timeout without pong (STALE_CONNECTION_TIMEOUT_MS, line 3 in connection-manager.ts)
+         If no pong received → connection marked as stale
+         Sweep interval: 5 seconds (STALE_SWEEP_INTERVAL_MS)
+```
+
+### Client-Side Flow (server-events.ts)
+
+```typescript
+// Line 47-56: When ping received
+(payload) => {
+  void serverApi
+    .sendClientConnectionPong({
+      ...getClientIdentity(),
+      pingTs: payload.ts,
+    })
+    .catch(() => {
+      debugWarn("sse", "Pong failed (connection already closed)")
+    })
+}
+```
+
+The pong is sent via **separate HTTP POST** (api-client.ts:548-552):
+```typescript
+sendClientConnectionPong(payload): Promise<void> {
+  return request<void>("/api/client-connections/pong", {
+    method: "POST",
+    body: JSON.stringify(payload),
+  })
+}
+```
+
+## Root Cause
+
+**On mobile networks with poor connectivity:**
+
+1. **User sends message** → arrives at server OK, processing begins
+2. **Server sends ping** via established SSE connection ✓ (works fine)
+3. **Client receives ping**, attempts to respond with **HTTP POST pong**
+4. **POST fails** due to:
+   - Network timeout (mobile latency)
+   - Network switch (WiFi ↔ cellular)
+   - High packet loss
+   - Result: `Client connection not found` error
+
+5. **Server never receives pong** → assumes client is dead
+6. **Server closes SSE connection after 45s timeout**
+7. **Message responses get stuck in event queue** (unable to send on closed connection)
+8. **Client shows "Abort" error** to user
+
+**Why it works after sending another message:**
+- New message triggers reconnection
+- New SSE connection established
+- Queued events from previous message now deliverable
+- Both old and new responses arrive together
+
+**Evidence from logs:**
+```
+[20:53:14.814] ERROR actions: sendMessage failed: No network connection
+[20:53:43.500] ERROR api: Request failed: POST /api/client-connections/pong - Client connection not found
+[20:53:43.501] WARN sse: Pong failed (connection already closed)
+```
+
+Timeline:
+- Message sent (14.8s)
+- ~29 seconds later: Pong POST fails → server closes connection
+
+## Critical Path
+
+1. **events.ts:27-79** — SSE connection setup with heartbeat ping
+2. **connection-manager.ts:73-96** — Pong reception and timeout sweep
+3. **server-events.ts:47-56** — Client pong response (HTTP POST)
+4. **api-client.ts:548-552** — HTTP POST implementation (no retry logic)
+
+## Proposed Solutions
+
+### Option A: Add Retry Logic to Pong POST (Quick Win)
+- **File:** `packages/ui/src/lib/server-events.ts`
+- **Change:** Implement exponential backoff retry for pong
+- **Risk:** Low
+- **Benefit:** Improves reliability for transient failures
+- **Limitation:** Still uses separate HTTP request
+
+**Implementation:**
+```typescript
+// Retry up to 3 times with exponential backoff
+sendPongWithRetry(payload, maxRetries = 3, delayMs = 100)
+```
+
+### Option B: Send Pong via SSE Channel (Robust Solution)
+- **File:** `packages/server/src/server/routes/events.ts`
+- **Change:** Allow client to send messages through SSE (not just receive)
+- **Risk:** Medium (protocol change)
+- **Benefit:** No separate HTTP request, reuses working connection
+- **Limitation:** Requires client/server coordination
+
+**Implementation:**
+```
+Client → Server: Can send special "codenomad.client.pong" event through SSE
+         Uses existing EventSource connection (no new HTTP request)
+```
+
+## Recommendation
+
+**Start with Option A** (retry logic) because:
+1. ✓ Low risk, easy to verify
+2. ✓ Handles transient network issues
+3. ✓ Quick to implement and deploy
+4. ✗ Still has fundamental limitation (separate HTTP request)
+
+**If Option A insufficient, move to Option B** for comprehensive solution.
+
+## Test Scenarios
+
+To verify fix effectiveness:
+
+1. **Slow network (throttle to 3G):**
+   - Send message, verify response arrives
+   - No "Abort" button needed
+
+2. **Network switch (WiFi → mobile):**
+   - Send message on WiFi
+   - Switch to mobile mid-transmission
+   - Verify response still arrives (with delay if needed)
+
+3. **High packet loss:**
+   - Use network simulator
+   - 10-20% packet loss
+   - Verify pong retries succeed
+
+4. **Intermittent connectivity:**
+   - Brief disconnects between ping/pong
+   - Verify graceful recovery
+
+## Files Involved
+
+**Server:**
+- `packages/server/src/server/routes/events.ts` — SSE setup, ping interval
+- `packages/server/src/clients/connection-manager.ts` — Pong timeout logic
+
+**Client:**
+- `packages/ui/src/lib/server-events.ts` — Pong response handler
+- `packages/ui/src/lib/api-client.ts` — HTTP POST implementation
+- `packages/ui/src/lib/event-source-handlers.ts` — SSE event listeners
+
+## Next Steps
+
+1. Implement Option A (pong retry logic)
+2. Test on mobile networks with poor connectivity
+3. Monitor logs for retry patterns
+4. If needed, escalate to Option B (SSE-based pong)
diff --git a/packages/server/scripts/copy-ui-dist.mjs b/packages/server/scripts/copy-ui-dist.mjs
index fdbe4818b..8448382a2 100644
--- a/packages/server/scripts/copy-ui-dist.mjs
+++ b/packages/server/scripts/copy-ui-dist.mjs
@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { cpSync, existsSync, mkdirSync, rmSync } from "fs"
+import { cpSync, existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from "fs"
 import path from "path"
 import { fileURLToPath } from "url"
 
@@ -18,4 +18,16 @@ rmSync(targetDir, { recursive: true, force: true })
 mkdirSync(targetDir, { recursive: true })
 cpSync(uiDistDir, targetDir, { recursive: true })
 
+// Patch index.html to unregister any existing service worker
+const htmlPath = path.join(targetDir, "index.html")
+if (existsSync(htmlPath)) {
+  let html = readFileSync(htmlPath, "utf-8")
+  const script = '<script>if("serviceWorker" in navigator){navigator.serviceWorker.getRegistrations().then(r=>r.forEach(r=>r.unregister()))}</script>'
+  if (!html.includes(script)) {
+    html = html.replace("</head>", script + "</head>")
+    writeFileSync(htmlPath, html, "utf-8")
+    console.log("[copy-ui-dist] Injected SW unregister script")
+  }
+}
+
 console.log(`[copy-ui-dist] Copied UI bundle from ${uiDistDir} -> ${targetDir}`)
diff --git a/packages/server/src/server/http-server.ts b/packages/server/src/server/http-server.ts
index 71a325438..4b9851a42 100644
--- a/packages/server/src/server/http-server.ts
+++ b/packages/server/src/server/http-server.ts
@@ -35,6 +35,7 @@ import { InstanceStore } from "../storage/instance-store"
 import { BackgroundProcessManager } from "../background-processes/manager"
 import type { AuthManager } from "../auth/manager"
 import { registerAuthRoutes } from "./routes/auth"
+import { registerDebugLogRoutes } from "./routes/debug-log"
 import { sendUnauthorized, wantsHtml } from "../auth/http-auth"
 import type { SpeechService } from "../speech/service"
 import { ClientConnectionManager } from "../clients/connection-manager"
@@ -274,6 +275,7 @@ export function createHttpServer(deps: HttpServerDeps) {
   registerFilesystemRoutes(app, { fileSystemBrowser: deps.fileSystemBrowser })
   registerConfigFileRoutes(app)
   registerMetaRoutes(app, { serverMeta: deps.serverMeta })
+  registerDebugLogRoutes(app)
   registerEventRoutes(app, {
     eventBus: deps.eventBus,
     registerClient: registerSseClient,
diff --git a/packages/ui/src/App.tsx b/packages/ui/src/App.tsx
index 2aa430fcd..e979b9d65 100644
--- a/packages/ui/src/App.tsx
+++ b/packages/ui/src/App.tsx
@@ -1,5 +1,7 @@
 import { Component, For, Show, createMemo, createEffect, createSignal, onMount, onCleanup } from "solid-js"
 import { Dialog } from "@kobalte/core/dialog"
+import NetworkStatusBanner from "./components/network-status-banner"
+import DebugOverlay from "./components/debug-overlay"
 import { Toaster } from "solid-toast"
 import useMediaQuery from "@suid/material/useMediaQuery"
 import { Minimize2 } from "lucide-solid"
@@ -555,6 +557,7 @@ const App: Component = () => {
         </Dialog.Portal>
       </Dialog>
       <div class="h-screen w-screen flex flex-col" style={{ height: "100dvh", "padding-bottom": "var(--keyboard-offset, 0px)" }}>
+        <NetworkStatusBanner />
         <Show when={isPhoneLayout() && mobileFullscreenMode()}>
           <div class="mobile-fullscreen-exit-wrapper">
             <button
@@ -690,6 +693,7 @@ const App: Component = () => {
             className: "bg-transparent border-none shadow-none p-0",
           }}
         />
+        <DebugOverlay />
       </div>
     </>
   )
diff --git a/packages/ui/src/components/debug-overlay.tsx b/packages/ui/src/components/debug-overlay.tsx
new file mode 100644
index 000000000..aab9167af
--- /dev/null
+++ b/packages/ui/src/components/debug-overlay.tsx
@@ -0,0 +1,113 @@
+import { For, Show, createEffect, createSignal } from "solid-js"
+import { entries, paused, visible, clearLog, toggleVisibility, togglePause, exportLog } from "../stores/debug-log"
+import { serverEvents } from "../lib/server-events"
+import { CODENOMAD_API_BASE } from "../lib/api-client"
+
+export default function DebugOverlay() {
+  let listRef: HTMLDivElement | undefined
+  const [sending, setSending] = createSignal(false)
+  const [copied, setCopied] = createSignal(false)
+
+  createEffect(() => {
+    if (!paused() && listRef) {
+      queueMicrotask(() => {
+        listRef?.scrollTo({ top: listRef.scrollHeight, behavior: "smooth" })
+      })
+    }
+  })
+
+  async function copyLog() {
+    try {
+      const text = entries().map((e) => `[${e.ts}] ${e.level.toUpperCase()} ${e.source}: ${e.message}`).join("\n")
+      await navigator.clipboard.writeText(text)
+      setCopied(true)
+      setTimeout(() => setCopied(false), 2000)
+    } catch {
+      // fallback for insecure contexts
+    }
+  }
+
+  async function sendToServer() {
+    setSending(true)
+    try {
+      const data = entries()
+      await fetch(`${CODENOMAD_API_BASE || ""}/api/debug-log`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ logs: data }),
+      })
+    } catch {
+      // Silently fail — the user can use export instead
+    } finally {
+      setSending(false)
+    }
+  }
+
+  function downloadLog() {
+    const blob = new Blob([exportLog()], { type: "application/json" })
+    const url = URL.createObjectURL(blob)
+    const a = document.createElement("a")
+    a.href = url
+    a.download = `codenomad-debug-${Date.now()}.json`
+    a.click()
+    URL.revokeObjectURL(url)
+  }
+
+  return (
+    <>
+      <Show when={visible()}>
+        <div class="fixed bottom-14 right-3 z-[9999] w-[90vw] max-w-md h-96 bg-surface-secondary border border-base rounded-lg shadow-2xl flex flex-col overflow-hidden select-none">
+          <div class="flex items-center justify-between px-3 py-1.5 border-b border-base bg-surface-tertiary text-[11px]">
+            <span class="text-muted font-medium">Debug Log ({entries().length}){serverEvents.connected ? "" : " ⚠ disconnected"}</span>
+            <div class="flex items-center gap-2">
+              <label class="flex items-center gap-1 text-muted cursor-pointer">
+                <input type="checkbox" checked={paused()} onChange={togglePause} class="w-3 h-3" />
+                Pause
+              </label>
+              <button type="button" class="text-muted hover:text-primary" onClick={copyLog} title="Copy to clipboard">{copied() ? "Copied!" : "Copy"}</button>
+              <button type="button" class="text-muted hover:text-primary" onClick={downloadLog} title="Download as JSON">Export</button>
+              <button type="button" class="text-muted hover:text-primary" onClick={sendToServer} disabled={sending()}>
+                {sending() ? "..." : "Send"}
+              </button>
+              <button type="button" class="text-muted hover:text-primary" onClick={clearLog}>Clear</button>
+              <button type="button" class="text-muted hover:text-primary" onClick={toggleVisibility}>Close</button>
+            </div>
+          </div>
+          <div ref={listRef} class="flex-1 overflow-y-auto p-2 font-mono text-[10px] leading-relaxed space-y-0.5">
+            <For each={entries()}>
+              {(entry) => (
+                <div
+                  class={`truncate ${
+                    entry.level === "error"
+                      ? "text-red-400"
+                      : entry.level === "warn"
+                        ? "text-amber-400"
+                        : entry.level === "debug"
+                          ? "text-muted"
+                          : "text-secondary"
+                  }`}
+                >
+                  <span class="text-muted">[{entry.ts}]</span>
+                  {" "}
+                  <span class={
+                    entry.level === "error"
+                      ? "text-red-400"
+                      : entry.level === "warn"
+                        ? "text-amber-400"
+                        : "text-muted"
+                  }>
+                    {entry.level.toUpperCase()}
+                  </span>
+                  {" "}
+                  <span class="text-muted">{entry.source}:</span>
+                  {" "}
+                  <span>{entry.message}</span>
+                </div>
+              )}
+            </For>
+          </div>
+        </div>
+      </Show>
+    </>
+  )
+}
diff --git a/packages/ui/src/components/message-item.tsx b/packages/ui/src/components/message-item.tsx
index 00785441f..e8e8ac58d 100644
--- a/packages/ui/src/components/message-item.tsx
+++ b/packages/ui/src/components/message-item.tsx
@@ -8,7 +8,7 @@ import MessagePart from "./message-part"
 import { copyToClipboard } from "../lib/clipboard"
 import { useI18n } from "../lib/i18n"
 import { showAlertDialog } from "../stores/alerts"
-import { deleteMessage } from "../stores/session-actions"
+import { deleteMessage, retrySendMessage } from "../stores/session-actions"
 import { isTauriHost } from "../lib/runtime-env"
 import type { DeleteHoverState } from "../types/delete-hover"
 import { useSpeech } from "../lib/hooks/use-speech"
@@ -46,6 +46,30 @@ export default function MessageItem(props: MessageItemProps) {
   const [copied, setCopied] = createSignal(false)
   const [deletingMessage, setDeletingMessage] = createSignal(false)
   const [deletingUpTo, setDeletingUpTo] = createSignal(false)
+  const [showSending, setShowSending] = createSignal(false)
+  const [showGenerating, setShowGenerating] = createSignal(false)
+
+  createEffect(() => {
+    if (props.record.status === "sending") {
+      setShowSending(true)
+    } else if (showSending()) {
+      const timer = setTimeout(() => setShowSending(false), 1500)
+      onCleanup(() => clearTimeout(timer))
+    } else if (!showSending() && isUser() && props.record.status !== "error" && Date.now() - props.record.createdAt < 1500) {
+      setShowSending(true)
+      const timer = setTimeout(() => setShowSending(false), 1500)
+      onCleanup(() => clearTimeout(timer))
+    }
+  })
+
+  createEffect(() => {
+    if (isGenerating()) {
+      setShowGenerating(true)
+    } else if (showGenerating()) {
+      const timer = setTimeout(() => setShowGenerating(false), 1500)
+      onCleanup(() => clearTimeout(timer))
+    }
+  })
 
   type ImagePreviewState = {
     url: string
@@ -664,7 +688,7 @@ export default function MessageItem(props: MessageItemProps) {
           <div class="message-error-block" dir="auto">⚠️ {errorMessage()}</div>
         </Show>
 
-        <Show when={isGenerating()}>
+        <Show when={showGenerating()}>
           <div class="message-generating">
             <span class="generating-spinner">⏳</span> {t("messageItem.status.generating")}
           </div>
@@ -763,14 +787,23 @@ export default function MessageItem(props: MessageItemProps) {
           }}
         </Show>
 
-        <Show when={props.record.status === "sending"}>
+        <Show when={showSending()}>
           <div class="message-sending">
             <span class="generating-spinner">●</span> {t("messageItem.status.sending")}
           </div>
         </Show>
 
         <Show when={props.record.status === "error"}>
-          <div class="message-error">⚠ {t("messageItem.status.failedToSend")}</div>
+          <div class="message-error">
+            <span>⚠ {t("messageItem.status.failedToSend")}</span>
+            <button
+              type="button"
+              class="message-retry-button"
+              onClick={() => retrySendMessage(props.instanceId, props.sessionId, props.record.id)}
+            >
+              {t("messageItem.status.retry")}
+            </button>
+          </div>
         </Show>
       </div>
     </div>
diff --git a/packages/ui/src/components/message-section.tsx b/packages/ui/src/components/message-section.tsx
index ea9fac707..2406677ff 100644
--- a/packages/ui/src/components/message-section.tsx
+++ b/packages/ui/src/components/message-section.tsx
@@ -15,6 +15,7 @@ import { copyToClipboard } from "../lib/clipboard"
 import { showToastNotification } from "../lib/notifications"
 import { showAlertDialog } from "../stores/alerts"
 import { deleteMessage, deleteMessagePart } from "../stores/session-actions"
+import { visible as debugVisible, toggleVisibility as toggleDebug } from "../stores/debug-log"
 import type { InstanceMessageStore } from "../stores/message-v2/instance-store"
 import type { DeleteHoverState } from "../types/delete-hover"
 import { partHasRenderableText } from "../types/message"
@@ -728,7 +729,9 @@ export default function MessageSection(props: MessageSectionProps) {
     const api = listApi()
     if (!api) return
     if (props.registerScrollToBottom) {
-      props.registerScrollToBottom(() => api.scrollToBottom({ immediate: true }))
+      props.registerScrollToBottom(() => {
+        api.scrollToBottom({ immediate: true })
+      })
     }
   })
 
@@ -1295,6 +1298,14 @@ export default function MessageSection(props: MessageSectionProps) {
           registerState={(state) => setListState(state)}
           renderControls={(state, api) => (
             <div class="message-scroll-button-wrapper">
+              <button
+                type="button"
+                class="message-scroll-button debug-toggle-button"
+                onClick={toggleDebug}
+                title={debugVisible() ? "Close debug log" : "Open debug log"}
+              >
+                {debugVisible() ? "✕" : "⚙"}
+              </button>
               <button
                 type="button"
                 class="message-scroll-button"
diff --git a/packages/ui/src/components/network-status-banner.tsx b/packages/ui/src/components/network-status-banner.tsx
new file mode 100644
index 000000000..1fe7026a4
--- /dev/null
+++ b/packages/ui/src/components/network-status-banner.tsx
@@ -0,0 +1,46 @@
+import { createEffect, createSignal, Show } from "solid-js"
+import { isOnlineSignal } from "../lib/network-status"
+import { useI18n } from "../lib/i18n"
+
+export default function NetworkStatusBanner() {
+  const { t } = useI18n()
+  const [showRestored, setShowRestored] = createSignal(false)
+
+  let restoredTimer: ReturnType<typeof setTimeout> | null = null
+  let previousOnline = isOnlineSignal()()
+
+  createEffect(() => {
+    const online = isOnlineSignal()()
+    if (online && !previousOnline) {
+      if (restoredTimer !== null) clearTimeout(restoredTimer)
+      setShowRestored(true)
+      restoredTimer = setTimeout(() => {
+        setShowRestored(false)
+        restoredTimer = null
+      }, 3000)
+    } else if (!online) {
+      if (restoredTimer !== null) {
+        clearTimeout(restoredTimer)
+        restoredTimer = null
+      }
+      setShowRestored(false)
+    }
+    previousOnline = online
+  })
+
+  return (
+    <Show when={!isOnlineSignal()() || showRestored()}>
+      <div
+        role="status"
+        aria-live="polite"
+        class={`transition-all duration-300 text-center text-xs font-semibold py-1.5 px-3 ${
+          isOnlineSignal()()
+            ? "bg-emerald-700 text-emerald-200"
+            : "bg-amber-600 text-white"
+        }`}
+      >
+        {isOnlineSignal()() ? t("networkStatus.backOnline") : t("networkStatus.offline")}
+      </div>
+    </Show>
+  )
+}
diff --git a/packages/ui/src/lib/api-client.ts b/packages/ui/src/lib/api-client.ts
index 2eed070ea..9d8c30bda 100644
--- a/packages/ui/src/lib/api-client.ts
+++ b/packages/ui/src/lib/api-client.ts
@@ -46,6 +46,7 @@ import type {
 import { getClientIdentity } from "./client-identity"
 import { getLogger } from "./logger"
 import { attachEventSourceHandlers } from "./event-source-handlers"
+import { debugInfo, debugWarn, debugError } from "../stores/debug-log"
 
 const RUNTIME_BASE = typeof window !== "undefined" ? window.location?.origin : undefined
 const DEFAULT_BASE = typeof window !== "undefined" ? window.__CODENOMAD_API_BASE__ ?? RUNTIME_BASE : undefined
@@ -86,6 +87,19 @@ function buildAbsoluteUrl(path: string): string {
 const httpLogger = getLogger("api")
 const sseLogger = getLogger("sse")
 
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000
+
+function fetchWithTimeout(url: string | URL, init?: RequestInit, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS): Promise<Response> {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs)
+
+  if (init?.signal) {
+    init.signal.addEventListener("abort", () => controller.abort(), { once: true })
+  }
+
+  return fetch(url, { ...init, signal: controller.signal }).finally(() => clearTimeout(timeoutId))
+}
+
 function normalizeHeaders(headers: HeadersInit | undefined): Record<string, string> {
   const output: Record<string, string> = {}
   if (!headers) return output
@@ -146,7 +160,7 @@ async function request<T>(path: string, init?: RequestInit): Promise<T> {
   logHttp(`${method} ${path}`)
 
   try {
-    const response = await fetch(url, { ...init, headers, credentials: init?.credentials ?? "include" })
+    const response = await fetchWithTimeout(url, { ...init, headers, credentials: init?.credentials ?? "include" })
     if (!response.ok) {
       const message = await readErrorMessage(response)
       logHttp(`${method} ${path} -> ${response.status}`, { durationMs: Date.now() - startedAt, error: message })
@@ -160,6 +174,11 @@ async function request<T>(path: string, init?: RequestInit): Promise<T> {
     return (await response.json()) as T
   } catch (error) {
     logHttp(`${method} ${path} failed`, { durationMs: Date.now() - startedAt, error })
+    if (error instanceof Error && error.name === "AbortError") {
+      debugWarn("api", `Request timed out: ${method} ${path}`)
+      throw new Error(`Request timed out after ${DEFAULT_REQUEST_TIMEOUT_MS / 1000}s`)
+    }
+    debugError("api", `Request failed: ${method} ${path} - ${error instanceof Error ? error.message : String(error)}`)
     throw error
   }
 }
@@ -175,7 +194,16 @@ async function requestRaw(path: string, init?: RequestInit): Promise<Response> {
   const startedAt = Date.now()
   logHttp(`${method} ${path}`)
 
-  const response = await fetch(url, { ...init, headers, credentials: init?.credentials ?? "include" })
+  let response: Response
+  try {
+    response = await fetchWithTimeout(url, { ...init, headers, credentials: init?.credentials ?? "include" })
+  } catch (error) {
+    logHttp(`${method} ${path} failed`, { durationMs: Date.now() - startedAt, error })
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timed out after ${DEFAULT_REQUEST_TIMEOUT_MS / 1000}s`)
+    }
+    throw error
+  }
   if (!response.ok) {
     const message = await readErrorMessage(response)
     logHttp(`${method} ${path} -> ${response.status}`, { durationMs: Date.now() - startedAt, error: message })
diff --git a/packages/ui/src/lib/i18n/messages/en/messaging.ts b/packages/ui/src/lib/i18n/messages/en/messaging.ts
index 31700b64d..c4dfc9f5b 100644
--- a/packages/ui/src/lib/i18n/messages/en/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/en/messaging.ts
@@ -122,6 +122,7 @@ export const messagingMessages = {
   "messageItem.status.generating": "Generating...",
   "messageItem.status.sending": "Sending...",
   "messageItem.status.failedToSend": "Message failed to send",
+  "messageItem.status.retry": "Retry",
   "messagePart.actions.delete": "Delete Part",
   "messagePart.actions.deleting": "Deleting...",
   "messagePart.actions.deleteTitle": "Delete this item",
diff --git a/packages/ui/src/lib/i18n/messages/en/session.ts b/packages/ui/src/lib/i18n/messages/en/session.ts
index 1f0ce5053..fbb05dcac 100644
--- a/packages/ui/src/lib/i18n/messages/en/session.ts
+++ b/packages/ui/src/lib/i18n/messages/en/session.ts
@@ -108,10 +108,15 @@ export const sessionMessages = {
   "browserFrame.viewport.mobileLandscape": "Mobile landscape (844 x 390)",
 
   "sessionEvents.sessionCompactedToast": "Session {label} was compacted",
+  "sessionEvents.compactionTimeout.title": "Compaction timed out",
+  "sessionEvents.compactionTimeout.message": "Session compaction did not complete. You can try compacting again.",
   "sessionEvents.sessionError.unknown": "Unknown error",
   "sessionEvents.sessionError.title": "Session error",
   "sessionEvents.sessionError.message": "Error: {message}",
 
+  "networkStatus.offline": "No connection",
+  "networkStatus.backOnline": "Connection restored",
+
   "sessionState.cleanup.deepConfirm.message": "This cleanup may be slow, and may delete sessions you didn't intend to delete. Are you sure?",
   "sessionState.cleanup.deepConfirm.title": "Deep Clean Sessions",
   "sessionState.cleanup.deepConfirm.detail": "Deep Clean Sessions will delete all sessions that have no messages, remove any finished sub-agent sessions, and clear out any unused forks of a session.",
diff --git a/packages/ui/src/lib/i18n/messages/es/messaging.ts b/packages/ui/src/lib/i18n/messages/es/messaging.ts
index a2e88568d..ccde58e66 100644
--- a/packages/ui/src/lib/i18n/messages/es/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/es/messaging.ts
@@ -124,6 +124,7 @@ export const messagingMessages = {
   "messageItem.status.generating": "Generando...",
   "messageItem.status.sending": "Enviando...",
   "messageItem.status.failedToSend": "No se pudo enviar el mensaje",
+  "messageItem.status.retry": "Reintentar",
   "messagePart.actions.delete": "Eliminar parte",
   "messagePart.actions.deleting": "Eliminando...",
   "messagePart.actions.deleteTitle": "Eliminar este elemento",
diff --git a/packages/ui/src/lib/i18n/messages/es/session.ts b/packages/ui/src/lib/i18n/messages/es/session.ts
index 7a81e81af..07a5aa0f8 100644
--- a/packages/ui/src/lib/i18n/messages/es/session.ts
+++ b/packages/ui/src/lib/i18n/messages/es/session.ts
@@ -108,10 +108,15 @@ export const sessionMessages = {
   "browserFrame.viewport.mobileLandscape": "Móvil horizontal (844 x 390)",
 
   "sessionEvents.sessionCompactedToast": "La sesión {label} fue compactada",
+  "sessionEvents.compactionTimeout.title": "Compactación agotada",
+  "sessionEvents.compactionTimeout.message": "La compactación de la sesión no se completó. Puedes intentar compactar de nuevo.",
   "sessionEvents.sessionError.unknown": "Error desconocido",
   "sessionEvents.sessionError.title": "Error de sesión",
   "sessionEvents.sessionError.message": "Error: {message}",
 
+  "networkStatus.offline": "Sin conexión",
+  "networkStatus.backOnline": "Conexión restaurada",
+
   "sessionState.cleanup.deepConfirm.message": "Esta limpieza puede ser lenta y puede eliminar sesiones que no pretendías eliminar. ¿Estás seguro?",
   "sessionState.cleanup.deepConfirm.title": "Limpieza profunda de sesiones",
   "sessionState.cleanup.deepConfirm.detail": "La limpieza profunda de sesiones eliminará todas las sesiones sin mensajes, quitará cualquier sesión de subagente finalizada y limpiará cualquier fork no usado de una sesión.",
diff --git a/packages/ui/src/lib/i18n/messages/fr/messaging.ts b/packages/ui/src/lib/i18n/messages/fr/messaging.ts
index c15477e24..5d73f8799 100644
--- a/packages/ui/src/lib/i18n/messages/fr/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/fr/messaging.ts
@@ -124,6 +124,7 @@ export const messagingMessages = {
   "messageItem.status.generating": "Génération...",
   "messageItem.status.sending": "Envoi...",
   "messageItem.status.failedToSend": "Échec de l'envoi du message",
+  "messageItem.status.retry": "Réessayer",
   "messagePart.actions.delete": "Supprimer la partie",
   "messagePart.actions.deleting": "Suppression...",
   "messagePart.actions.deleteTitle": "Supprimer cet élément",
diff --git a/packages/ui/src/lib/i18n/messages/fr/session.ts b/packages/ui/src/lib/i18n/messages/fr/session.ts
index 55dca9930..f00face0b 100644
--- a/packages/ui/src/lib/i18n/messages/fr/session.ts
+++ b/packages/ui/src/lib/i18n/messages/fr/session.ts
@@ -108,10 +108,15 @@ export const sessionMessages = {
   "browserFrame.viewport.mobileLandscape": "Mobile paysage (844 x 390)",
 
   "sessionEvents.sessionCompactedToast": "La session {label} a été compactée",
+  "sessionEvents.compactionTimeout.title": "Compaction expirée",
+  "sessionEvents.compactionTimeout.message": "La compaction de la session n'a pas abouti. Vous pouvez réessayer.",
   "sessionEvents.sessionError.unknown": "Erreur inconnue",
   "sessionEvents.sessionError.title": "Erreur de session",
   "sessionEvents.sessionError.message": "Erreur : {message}",
 
+  "networkStatus.offline": "Hors connexion",
+  "networkStatus.backOnline": "Connexion rétablie",
+
   "sessionState.cleanup.deepConfirm.message": "Ce nettoyage peut être lent et peut supprimer des sessions que vous ne vouliez pas supprimer. Confirmez-vous ?",
   "sessionState.cleanup.deepConfirm.title": "Nettoyage approfondi des sessions",
   "sessionState.cleanup.deepConfirm.detail": "Le nettoyage approfondi des sessions supprime toutes les sessions sans messages, retire les sessions de sous-agent terminées et efface les forks inutilisés d'une session.",
diff --git a/packages/ui/src/lib/i18n/messages/he/messaging.ts b/packages/ui/src/lib/i18n/messages/he/messaging.ts
index 537db2db2..46068e5aa 100644
--- a/packages/ui/src/lib/i18n/messages/he/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/he/messaging.ts
@@ -122,6 +122,7 @@ export const messagingMessages = {
   "messageItem.status.generating": "מייצר...",
   "messageItem.status.sending": "שולח...",
   "messageItem.status.failedToSend": "שליחת ההודעה נכשלה",
+  "messageItem.status.retry": "נסה שוב",
   "messagePart.actions.delete": "מחק חלק",
   "messagePart.actions.deleting": "מוחק...",
   "messagePart.actions.deleteTitle": "מחק פריט זה",
diff --git a/packages/ui/src/lib/i18n/messages/he/session.ts b/packages/ui/src/lib/i18n/messages/he/session.ts
index e467e1541..bd350d694 100644
--- a/packages/ui/src/lib/i18n/messages/he/session.ts
+++ b/packages/ui/src/lib/i18n/messages/he/session.ts
@@ -108,10 +108,15 @@ export const sessionMessages = {
   "browserFrame.viewport.mobileLandscape": "נייד לרוחב (844 x 390)",
 
   "sessionEvents.sessionCompactedToast": "הסשן {label} סוכם",
+  "sessionEvents.compactionTimeout.title": "פג זמן הסיכום",
+  "sessionEvents.compactionTimeout.message": "סיכום הסשן לא הושלם. ניתן לנסות שוב.",
   "sessionEvents.sessionError.unknown": "שגיאה לא ידועה",
   "sessionEvents.sessionError.title": "שגיאת סשן",
   "sessionEvents.sessionError.message": "שגיאה: {message}",
 
+  "networkStatus.offline": "אין חיבור",
+  "networkStatus.backOnline": "החיבור שוחזר",
+
   "sessionState.cleanup.deepConfirm.message": "ניקוי עמוק זה עשוי להיות איטי, ועלול למחוק סשנים שלא התכוונת למחוק. האם אתה בטוח?",
   "sessionState.cleanup.deepConfirm.title": "ניקוי עמוק של סשנים",
   "sessionState.cleanup.deepConfirm.detail": "ניקוי עמוק של סשנים ימחק את כל הסשנים ללא הודעות, יסיר סשני תת-סוכן שסיימו, וינקה פיצולים לא בשימוש של סשן.",
diff --git a/packages/ui/src/lib/i18n/messages/ja/messaging.ts b/packages/ui/src/lib/i18n/messages/ja/messaging.ts
index 013d9b60b..216630c5d 100644
--- a/packages/ui/src/lib/i18n/messages/ja/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/ja/messaging.ts
@@ -124,6 +124,7 @@ export const messagingMessages = {
   "messageItem.status.generating": "生成中...",
   "messageItem.status.sending": "送信中...",
   "messageItem.status.failedToSend": "メッセージの送信に失敗しました",
+  "messageItem.status.retry": "再試行",
   "messagePart.actions.delete": "パートを削除",
   "messagePart.actions.deleting": "削除中...",
   "messagePart.actions.deleteTitle": "この項目を削除",
diff --git a/packages/ui/src/lib/i18n/messages/ja/session.ts b/packages/ui/src/lib/i18n/messages/ja/session.ts
index 39c1ff3e1..5d1b1d803 100644
--- a/packages/ui/src/lib/i18n/messages/ja/session.ts
+++ b/packages/ui/src/lib/i18n/messages/ja/session.ts
@@ -108,10 +108,15 @@ export const sessionMessages = {
   "browserFrame.viewport.mobileLandscape": "モバイル横向き (844 x 390)",
 
   "sessionEvents.sessionCompactedToast": "セッション {label} をコンパクト化しました",
+  "sessionEvents.compactionTimeout.title": "コンパクト化がタイムアウト",
+  "sessionEvents.compactionTimeout.message": "セッションのコンパクト化が完了しませんでした。もう一度お試しください。",
   "sessionEvents.sessionError.unknown": "不明なエラー",
   "sessionEvents.sessionError.title": "セッションエラー",
   "sessionEvents.sessionError.message": "エラー: {message}",
 
+  "networkStatus.offline": "オフライン",
+  "networkStatus.backOnline": "接続が復旧しました",
+
   "sessionState.cleanup.deepConfirm.message": "このクリーンアップは時間がかかる場合があり、意図しないセッションを削除する可能性があります。続行しますか？",
   "sessionState.cleanup.deepConfirm.title": "セッションを徹底クリーン",
   "sessionState.cleanup.deepConfirm.detail": "徹底クリーンは、メッセージがないセッションをすべて削除し、完了したサブエージェントのセッションを取り除き、未使用のセッションフォークを整理します。",
diff --git a/packages/ui/src/lib/i18n/messages/ru/messaging.ts b/packages/ui/src/lib/i18n/messages/ru/messaging.ts
index a4ce41f2b..3c406ed85 100644
--- a/packages/ui/src/lib/i18n/messages/ru/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/ru/messaging.ts
@@ -124,6 +124,7 @@ export const messagingMessages = {
   "messageItem.status.generating": "Генерация…",
   "messageItem.status.sending": "Отправка…",
   "messageItem.status.failedToSend": "Не удалось отправить сообщение",
+  "messageItem.status.retry": "Повторить",
   "messagePart.actions.delete": "Удалить часть",
   "messagePart.actions.deleting": "Удаление...",
   "messagePart.actions.deleteTitle": "Удалить этот элемент",
diff --git a/packages/ui/src/lib/i18n/messages/ru/session.ts b/packages/ui/src/lib/i18n/messages/ru/session.ts
index 81a3c897b..a1e55ef64 100644
--- a/packages/ui/src/lib/i18n/messages/ru/session.ts
+++ b/packages/ui/src/lib/i18n/messages/ru/session.ts
@@ -108,10 +108,15 @@ export const sessionMessages = {
   "browserFrame.viewport.mobileLandscape": "Мобильный горизонтально (844 x 390)",
 
   "sessionEvents.sessionCompactedToast": "Сессия {label} была компактирована",
+  "sessionEvents.compactionTimeout.title": "Тайм-аут компактизации",
+  "sessionEvents.compactionTimeout.message": "Компактизация сессии не завершена. Попробуйте снова.",
   "sessionEvents.sessionError.unknown": "Неизвестная ошибка",
   "sessionEvents.sessionError.title": "Ошибка сессии",
   "sessionEvents.sessionError.message": "Ошибка: {message}",
 
+  "networkStatus.offline": "Нет соединения",
+  "networkStatus.backOnline": "Соединение восстановлено",
+
   "sessionState.cleanup.deepConfirm.message": "Эта очистка может быть медленной и может удалить сессии, которые вы не хотели удалять. Вы уверены?",
   "sessionState.cleanup.deepConfirm.title": "Глубокая очистка сессий",
   "sessionState.cleanup.deepConfirm.detail": "Глубокая очистка сессий удалит все сессии без сообщений, уберет завершенные сессии субагентов и очистит неиспользуемые форки сессий.",
diff --git a/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts b/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts
index b00f7e676..48860bf24 100644
--- a/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts
@@ -124,6 +124,7 @@ export const messagingMessages = {
   "messageItem.status.generating": "正在生成...",
   "messageItem.status.sending": "正在发送...",
   "messageItem.status.failedToSend": "消息发送失败",
+  "messageItem.status.retry": "重试",
   "messagePart.actions.delete": "删除部分",
   "messagePart.actions.deleting": "正在删除...",
   "messagePart.actions.deleteTitle": "删除此项",
diff --git a/packages/ui/src/lib/i18n/messages/zh-Hans/session.ts b/packages/ui/src/lib/i18n/messages/zh-Hans/session.ts
index 04cdf990d..1b91d5966 100644
--- a/packages/ui/src/lib/i18n/messages/zh-Hans/session.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-Hans/session.ts
@@ -108,10 +108,15 @@ export const sessionMessages = {
   "browserFrame.viewport.mobileLandscape": "移动横屏 (844 x 390)",
 
   "sessionEvents.sessionCompactedToast": "会话 {label} 已被压缩",
+  "sessionEvents.compactionTimeout.title": "压缩超时",
+  "sessionEvents.compactionTimeout.message": "会话压缩未完成。您可以重试压缩。",
   "sessionEvents.sessionError.unknown": "未知错误",
   "sessionEvents.sessionError.title": "会话错误",
   "sessionEvents.sessionError.message": "错误：{message}",
 
+  "networkStatus.offline": "无网络连接",
+  "networkStatus.backOnline": "网络连接已恢复",
+
   "sessionState.cleanup.deepConfirm.message": "此清理可能较慢，并且可能删除你并不想删除的会话。确定要继续吗？",
   "sessionState.cleanup.deepConfirm.title": "深度清理会话",
   "sessionState.cleanup.deepConfirm.detail": "深度清理会话将删除所有没有消息的会话、移除已完成的子智能体会话，并清除会话中未使用的分叉。",
diff --git a/packages/ui/src/lib/network-status.ts b/packages/ui/src/lib/network-status.ts
new file mode 100644
index 000000000..6cabfc419
--- /dev/null
+++ b/packages/ui/src/lib/network-status.ts
@@ -0,0 +1,41 @@
+import { createSignal } from "solid-js"
+import { serverEvents } from "./server-events"
+import { debugInfo } from "../stores/debug-log"
+
+const [isOnline, setIsOnline] = createSignal(typeof navigator !== "undefined" ? navigator.onLine : true)
+
+const restoreListeners: Array<() => void> = []
+
+function onOnline() {
+  debugInfo("network", "Browser came online")
+  setIsOnline(true)
+  serverEvents.resetRetry()
+  restoreListeners.forEach((fn) => fn())
+}
+
+function onOffline() {
+  debugInfo("network", "Browser went offline")
+  setIsOnline(false)
+}
+
+let initialized = false
+function initNetworkStatus() {
+  if (initialized || typeof window === "undefined") return
+  initialized = true
+  window.addEventListener("online", onOnline)
+  window.addEventListener("offline", onOffline)
+}
+
+initNetworkStatus()
+
+export function isOnlineSignal(): () => boolean {
+  return isOnline
+}
+
+export function onNetworkRestored(fn: () => void): () => void {
+  restoreListeners.push(fn)
+  return () => {
+    const idx = restoreListeners.indexOf(fn)
+    if (idx !== -1) restoreListeners.splice(idx, 1)
+  }
+}
diff --git a/packages/ui/src/lib/opencode-api.ts b/packages/ui/src/lib/opencode-api.ts
index 58c4f24a9..624313459 100644
--- a/packages/ui/src/lib/opencode-api.ts
+++ b/packages/ui/src/lib/opencode-api.ts
@@ -29,7 +29,9 @@ export async function requestData<T>(
     throw new OpencodeApiError(`${label} returned no result`)
   }
   if ((result as any).error) {
-    throw new OpencodeApiError(`${label} failed`, { cause: (result as any).error })
+    const cause = (result as any).error
+    const causeMsg = cause instanceof Error ? cause.message : typeof cause === "string" ? cause : JSON.stringify(cause)
+    throw new OpencodeApiError(`${label} failed: ${causeMsg}`, { cause })
   }
   return (result as any).data as T
 }
diff --git a/packages/ui/src/lib/server-events.ts b/packages/ui/src/lib/server-events.ts
index 833e6c2aa..94c5cbcfe 100644
--- a/packages/ui/src/lib/server-events.ts
+++ b/packages/ui/src/lib/server-events.ts
@@ -2,6 +2,7 @@ import type { WorkspaceEventPayload, WorkspaceEventType } from "../../../server/
 import { serverApi } from "./api-client"
 import { getClientIdentity } from "./client-identity"
 import { getLogger } from "./logger"
+import { debugInfo, debugWarn } from "../stores/debug-log"
 
 const RETRY_BASE_DELAY = 1000
 const RETRY_MAX_DELAY = 10000
@@ -18,9 +19,15 @@ function logSse(message: string, context?: Record<string, unknown>) {
 class ServerEvents {
   private handlers = new Map<WorkspaceEventType | "*", Set<(event: WorkspaceEventPayload) => void>>()
   private openHandlers = new Set<() => void>()
+  private disconnectHandlers = new Set<() => void>()
   private source: EventSource | null = null
   private retryDelay = RETRY_BASE_DELAY
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private _connected = false
+
+  get connected(): boolean {
+    return this._connected
+  }
 
   constructor() {
     this.connect()
@@ -44,14 +51,15 @@ class ServerEvents {
             ...getClientIdentity(),
             pingTs: payload.ts,
           })
-          .catch((error) => {
-            log.error("Failed to send client connection pong", error)
+          .catch(() => {
+            debugWarn("sse", "Pong failed (connection already closed)")
           })
       },
     )
     this.source.onopen = () => {
       logSse("Events stream connected")
       this.retryDelay = RETRY_BASE_DELAY
+      this._connected = true
       this.openHandlers.forEach((handler) => handler())
     }
   }
@@ -62,6 +70,8 @@ class ServerEvents {
     }
     const source = this.source
     this.source = null
+    this._connected = false
+    this.disconnectHandlers.forEach((handler) => handler())
     logSse("Events stream disconnected, scheduling reconnect", { delayMs: this.retryDelay })
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null
@@ -90,6 +100,19 @@ class ServerEvents {
     this.openHandlers.add(handler)
     return () => this.openHandlers.delete(handler)
   }
+
+  onDisconnect(handler: () => void): () => void {
+    this.disconnectHandlers.add(handler)
+    return () => this.disconnectHandlers.delete(handler)
+  }
+
+  resetRetry() {
+    debugInfo("sse", "Reset retry delay and reconnect")
+    this.retryDelay = RETRY_BASE_DELAY
+    if (!this.source && this.reconnectTimer === null) {
+      this.connect()
+    }
+  }
 }
 
 export const serverEvents = new ServerEvents()
diff --git a/packages/ui/src/lib/sse-manager.ts b/packages/ui/src/lib/sse-manager.ts
index e6354e2cd..f84c34dbe 100644
--- a/packages/ui/src/lib/sse-manager.ts
+++ b/packages/ui/src/lib/sse-manager.ts
@@ -1,4 +1,4 @@
-import { createSignal } from "solid-js"
+import { createSignal, createRoot, createEffect } from "solid-js"
 import {
   MessageUpdateEvent,
   MessageRemovedEvent,
@@ -17,6 +17,7 @@ import type {
   EventSessionStatus,
 } from "@opencode-ai/sdk"
 import { serverEvents } from "./server-events"
+import { isOnlineSignal } from "./network-status"
 import type {
   BackgroundProcess,
   InstanceStreamEvent,
@@ -24,6 +25,7 @@ import type {
   WorkspaceEventPayload,
 } from "../../../server/src/api-types"
 import { getLogger } from "./logger"
+import { debugInfo } from "../stores/debug-log"
 
 const log = getLogger("sse")
 
@@ -107,6 +109,50 @@ class SSEManager {
       this.updateConnectionStatus(payload.instanceId, "connected")
       this.handleEvent(payload.instanceId, payload.event as SSEEvent)
     })
+
+    serverEvents.onDisconnect(() => {
+      log.warn("SSE transport disconnected → setting all instances to 'connecting'")
+      debugInfo("sse", "SSE transport disconnected → setting all instances to 'connecting'")
+      setConnectionStatus((prev) => {
+        const next = new Map(prev)
+        for (const [id] of next) {
+          next.set(id, "connecting")
+        }
+        return next
+      })
+    })
+
+    serverEvents.onOpen(() => {
+      log.warn("SSE transport reconnected → clearing 'connecting' status")
+      debugInfo("sse", "SSE transport reconnected → clearing 'connecting' status")
+      setConnectionStatus((prev) => {
+        const next = new Map(prev)
+        for (const [id, status] of next) {
+          if (status === "connecting") {
+            next.set(id, "connected")
+          }
+        }
+        return next
+      })
+    })
+
+    createRoot(() => {
+      createEffect(() => {
+        if (!isOnlineSignal()()) {
+          log.warn("Browser offline → setting all instances to 'connecting'")
+          debugInfo("sse", "Browser offline → setting all instances to 'connecting'")
+          setConnectionStatus((prev) => {
+            const next = new Map(prev)
+            for (const [id] of next) {
+              next.set(id, "connecting")
+            }
+            return next
+          })
+        }
+      })
+    })
+
+    log.info("sseManager initialized: listening for SSE disconnect, reconnect, and browser offline")
   }
 
   seedStatus(instanceId: string, status: ConnectionStatus) {
@@ -190,6 +236,9 @@ class SSEManager {
   }
 
   private updateConnectionStatus(instanceId: string, status: ConnectionStatus): void {
+    const shortId = instanceId.slice(0, 8)
+    log.info(`connectionStatus ${shortId} → ${status}`)
+    debugInfo("sse", `connectionStatus ${shortId} → ${status}`)
     setConnectionStatus((prev) => {
       const next = new Map(prev)
       next.set(instanceId, status)
diff --git a/packages/ui/src/stores/debug-log.ts b/packages/ui/src/stores/debug-log.ts
new file mode 100644
index 000000000..ecebe2eea
--- /dev/null
+++ b/packages/ui/src/stores/debug-log.ts
@@ -0,0 +1,125 @@
+import { createSignal } from "solid-js"
+
+const STORAGE_KEY = "codenomad:debug-log"
+const MAX_ENTRIES = 300
+const PERSIST_DEBOUNCE_MS = 1000
+
+type LogLevel = "info" | "warn" | "error" | "debug"
+
+interface LogEntry {
+  id: number
+  ts: string
+  level: LogLevel
+  source: string
+  message: string
+}
+
+function loadPersisted(): LogEntry[] {
+  try {
+    const raw = typeof window !== "undefined" ? localStorage.getItem(STORAGE_KEY) : null
+    if (raw) {
+      const parsed = JSON.parse(raw) as LogEntry[]
+      return Array.isArray(parsed) ? parsed : []
+    }
+  } catch { /* ignore */ }
+  return []
+}
+
+let persistTimer: ReturnType<typeof setTimeout> | null = null
+let pendingEntries: LogEntry[] | null = null
+
+function schedulePersist(entries: LogEntry[]) {
+  pendingEntries = entries
+  if (persistTimer !== null) return
+  persistTimer = setTimeout(() => {
+    persistTimer = null
+    if (pendingEntries) {
+      try {
+        if (typeof window !== "undefined") {
+          const slice = pendingEntries.slice(-MAX_ENTRIES)
+          localStorage.setItem(STORAGE_KEY, JSON.stringify(slice))
+        }
+      } catch { /* ignore */ }
+      pendingEntries = null
+    }
+  }, PERSIST_DEBOUNCE_MS)
+}
+
+function persistNow(entries: LogEntry[]) {
+  if (persistTimer !== null) {
+    clearTimeout(persistTimer)
+    persistTimer = null
+  }
+  pendingEntries = null
+  try {
+    if (typeof window !== "undefined") {
+      const slice = entries.slice(-MAX_ENTRIES)
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(slice))
+    }
+  } catch { /* ignore */ }
+}
+
+let nextId = 1
+const initial = loadPersisted()
+if (initial.length > 0) {
+  nextId = Math.max(...initial.map((e) => e.id), 0) + 1
+}
+
+const [entries, setEntries] = createSignal<LogEntry[]>(initial)
+const [paused, setPaused] = createSignal(false)
+const [visible, setVisible] = createSignal(false)
+
+function addEntry(level: LogLevel, source: string, message: string) {
+  const now = new Date()
+  const ts = now.toLocaleTimeString("en-US", { hour12: false }) + "." + String(now.getMilliseconds()).padStart(3, "0")
+  const entry: LogEntry = { id: nextId++, ts, level, source, message }
+  setEntries((prev) => {
+    const next = [...prev, entry]
+    const trimmed = next.length > MAX_ENTRIES ? next.slice(next.length - MAX_ENTRIES) : next
+    schedulePersist(trimmed)
+    return trimmed
+  })
+}
+
+function clearLog() {
+  setEntries([])
+  persistNow([])
+}
+
+function toggleVisibility() {
+  setVisible((v) => !v)
+}
+
+function togglePause() {
+  setPaused((p) => !p)
+}
+
+function exportLog(): string {
+  return JSON.stringify(entries(), null, 2)
+}
+
+export function debugLog(source: string, message: string) {
+  addEntry("debug", source, message)
+}
+
+export function debugInfo(source: string, message: string) {
+  addEntry("info", source, message)
+}
+
+export function debugWarn(source: string, message: string) {
+  addEntry("warn", source, message)
+}
+
+export function debugError(source: string, message: string) {
+  addEntry("error", source, message)
+}
+
+export {
+  entries,
+  paused,
+  visible,
+  clearLog,
+  toggleVisibility,
+  togglePause,
+  exportLog,
+}
diff --git a/packages/ui/src/stores/session-actions.ts b/packages/ui/src/stores/session-actions.ts
index 3cdf03211..45cb684b9 100644
--- a/packages/ui/src/stores/session-actions.ts
+++ b/packages/ui/src/stores/session-actions.ts
@@ -11,6 +11,8 @@ import { removeMessagePartV2, removeMessageV2 } from "./message-v2/bridge"
 import { getLogger } from "../lib/logger"
 import { requestData } from "../lib/opencode-api"
 import { clearConversationPlaybackForSession } from "./conversation-speech"
+import { onNetworkRestored } from "../lib/network-status"
+import { debugInfo, debugWarn, debugError } from "./debug-log"
 
 const log = getLogger("actions")
 
@@ -80,6 +82,7 @@ async function sendMessage(
   prompt: string,
   attachments: any[] = [],
 ): Promise<void> {
+  debugInfo("actions", `sendMessage: session=${sessionId.slice(0, 8)} len=${prompt.length}`)
   const instance = instances().get(instanceId)
   if (!instance || !instance.client) {
     throw new Error("Instance not ready")
@@ -218,6 +221,23 @@ async function sendMessage(
     )
   } catch (error) {
     log.error("Failed to send prompt", error)
+    const rawMsg = error instanceof Error ? error.message : String(error)
+    const friendlyMsg =
+      rawMsg.includes("Failed to fetch") || rawMsg.includes("NetworkError") || rawMsg.includes("network")
+        ? "No network connection"
+        : rawMsg.includes("timed out")
+          ? "Request timed out"
+          : rawMsg
+    debugError("actions", `sendMessage failed: ${friendlyMsg}`)
+    store.upsertMessage({
+      id: messageId,
+      sessionId,
+      role: "user",
+      status: "error",
+      parts: optimisticParts,
+      createdAt,
+      isEphemeral: true,
+    })
     throw error
   }
 }
@@ -462,12 +482,89 @@ async function deleteMessage(instanceId: string, sessionId: string, messageId: s
   updateSessionInfo(instanceId, sessionId)
 }
 
+async function retrySendMessage(instanceId: string, sessionId: string, messageId: string): Promise<void> {
+  debugInfo("actions", `retrySendMessage: session=${sessionId.slice(0, 8)} msg=${messageId.slice(0, 8)}`)
+  const store = messageStoreBus.getOrCreate(instanceId)
+  const message = store.getMessage(messageId)
+  if (!message) {
+    log.error("retrySendMessage: message not found", { instanceId, sessionId, messageId })
+    throw new Error("Message not found")
+  }
+
+  const textParts: string[] = []
+  for (const partId of message.partIds) {
+    const part = message.parts[partId]
+    if (part?.data?.type === "text") {
+      textParts.push((part.data as { text: string }).text)
+    }
+  }
+
+  const prompt = textParts.join("\n")
+  if (!prompt) {
+    log.error("retrySendMessage: no text content in message", { instanceId, sessionId, messageId })
+    throw new Error("Message has no text content")
+  }
+
+  removeMessageV2(instanceId, messageId)
+
+  await sendMessage(instanceId, sessionId, prompt)
+}
+
+// Auto-retry failed user messages when the browser regains connectivity
+// and the message store indicates they are in error state.
+function autoRetryOnReconnect() {
+  onNetworkRestored(() => {
+    // Collect unique failed messages first (deduplicate by messageId)
+    const pending = new Map<string, { instId: string; sessId: string; msgId: string }>()
+    const ids = instances()
+    for (const instId of ids.keys()) {
+      const store = messageStoreBus.getOrCreate(instId)
+      if (!store) continue
+      const sessEntries = Object.entries(store.state.sessions)
+      for (const [sessId] of sessEntries) {
+        const msgIds = store.getSessionMessageIds(sessId)
+        for (const msgId of msgIds) {
+          const msg = store.getMessage(msgId)
+          if (msg && msg.status === "error" && msg.role === "user" && !pending.has(msgId)) {
+            pending.set(msgId, { instId, sessId, msgId })
+          }
+        }
+      }
+    }
+
+    if (pending.size === 0) return
+
+    const count = pending.size
+    log.info(`Auto-retrying ${count} failed message(s) after 3s delay`)
+    debugInfo("actions", `Auto-retrying ${count} message(s) on reconnect in 3s`)
+
+    // Delay to let SSE reconnect before retrying
+    setTimeout(async () => {
+      let success = 0
+      for (const { instId, sessId, msgId } of pending.values()) {
+        try {
+          await retrySendMessage(instId, sessId, msgId)
+          success++
+        } catch (e) {
+          log.error("Auto-retry failed", { instanceId: instId, sessionId: sessId, messageId: msgId, error: e })
+        }
+      }
+      debugInfo("actions", `Auto-retry done: ${success}/${count} succeeded`)
+    }, 3000)
+  })
+}
+
+if (typeof window !== "undefined") {
+  autoRetryOnReconnect()
+}
+
 export {
   abortSession,
   deleteMessage,
   deleteMessagePart,
   executeCustomCommand,
   renameSession,
+  retrySendMessage,
   runShellCommand,
   sendMessage,
   updateSessionAgent,
diff --git a/packages/ui/src/stores/session-api.ts b/packages/ui/src/stores/session-api.ts
index 36609380f..80fc8d07e 100644
--- a/packages/ui/src/stores/session-api.ts
+++ b/packages/ui/src/stores/session-api.ts
@@ -822,10 +822,14 @@ async function loadMessages(
     }
 
     if (!agentName && !providerID && !modelID) {
-      const defaultModel = await getDefaultModel(instanceId, session.agent)
-      agentName = session.agent
-      providerID = defaultModel.providerId
-      modelID = defaultModel.modelId
+      if (session.model?.providerId && session.model?.modelId) {
+        // Preserve existing session model when messages don't include model info
+      } else {
+        const defaultModel = await getDefaultModel(instanceId, session.agent)
+        agentName = session.agent
+        providerID = defaultModel.providerId
+        modelID = defaultModel.modelId
+      }
     }
 
     setSessions((prev) => {
diff --git a/packages/ui/src/stores/session-events.ts b/packages/ui/src/stores/session-events.ts
index fcb253bf9..e53988ea9 100644
--- a/packages/ui/src/stores/session-events.ts
+++ b/packages/ui/src/stores/session-events.ts
@@ -54,6 +54,7 @@ import { ensureSessionParentExpanded, sessions, setSessions, syncInstanceSession
 import { normalizeMessagePart } from "./message-v2/normalizers"
 import { updateSessionInfo } from "./message-v2/session-info"
 import { tGlobal } from "../lib/i18n"
+import { debugInfo, debugWarn, debugError } from "./debug-log"
 
 import { loadMessages } from "./session-api"
 import { getOrCreateWorktreeClient, getRootClient, getWorktreeSlugForDirectory, getWorktreeSlugForSession } from "./worktrees"
@@ -80,6 +81,44 @@ const log = getLogger("sse")
 const pendingSessionFetches = new Map<string, Promise<void>>()
 let activeRetryToast: ToastHandle | null = null
 
+const COMPACTION_TIMEOUT_MS = 180_000
+const compactionTimers = new Map<string, ReturnType<typeof setTimeout>>()
+
+function clearCompactionTimer(instanceId: string, sessionId: string) {
+  const key = `${instanceId}:${sessionId}`
+  const timer = compactionTimers.get(key)
+  if (timer) {
+    clearTimeout(timer)
+    compactionTimers.delete(key)
+    debugInfo("sse", `Compaction timer cleared for session ${sessionId.slice(0, 8)}`)
+  }
+}
+
+function setCompactionTimer(instanceId: string, sessionId: string) {
+  const key = `${instanceId}:${sessionId}`
+  clearCompactionTimer(instanceId, sessionId)
+  debugInfo("sse", `Compaction timer set (${COMPACTION_TIMEOUT_MS / 1000}s) for session ${sessionId.slice(0, 8)}`)
+  compactionTimers.set(
+    key,
+    setTimeout(() => {
+      compactionTimers.delete(key)
+      log.warn(`[SSE] Compaction timeout for session ${sessionId}, recovering to "idle"`)
+      debugWarn("sse", `Compaction timeout for session ${sessionId.slice(0, 8)}, resetting to idle`)
+      withSession(instanceId, sessionId, (session) => {
+        if (session.status === "compacting") {
+          session.status = "idle"
+          showToastNotification({
+            title: tGlobal("sessionEvents.compactionTimeout.title"),
+            message: tGlobal("sessionEvents.compactionTimeout.message"),
+            variant: "warning",
+            duration: 10000,
+          })
+        }
+      })
+    }, COMPACTION_TIMEOUT_MS),
+  )
+}
+
 function isSameRetryState(left: SessionRetryState | null | undefined, right: SessionRetryState | null | undefined): boolean {
   const a = left ?? null
   const b = right ?? null
@@ -337,7 +376,9 @@ function handleMessageUpdate(instanceId: string, event: MessageUpdateEvent | Mes
     const messageId = typeof part.messageID === "string" ? part.messageID : fallbackMessageId
     if (!sessionId || !messageId) return
     if (part.type === "compaction") {
+      debugInfo("sse", `Compaction started for session ${sessionId.slice(0, 8)}`)
       ensureSessionStatus(instanceId, sessionId, "compacting", (event as any)?.directory)
+      setCompactionTimer(instanceId, sessionId)
     }
 
     const store = messageStoreBus.getOrCreate(instanceId)
@@ -370,6 +411,12 @@ function handleMessageUpdate(instanceId: string, event: MessageUpdateEvent | Mes
       upsertMessageInfoV2(instanceId, messageInfo, { status: "streaming" })
     }
   
+    // Clear any pending deltas for this part before applying the full part update.
+    // The part update contains the complete state from the server, so accumulated
+    // deltas would be stale and cause duplication if flushed later.
+    if (part.id) {
+      clearPendingDeltasForPart(instanceId, messageId, part.id)
+    }
     applyPartUpdateV2(instanceId, { ...part, sessionID: sessionId, messageID: messageId })
     handleConversationAssistantPartUpdated(instanceId, { ...part, sessionID: sessionId, messageID: messageId }, messageInfo)
 
@@ -388,6 +435,14 @@ function handleMessageUpdate(instanceId: string, event: MessageUpdateEvent | Mes
     const messageId = typeof info.id === "string" ? info.id : undefined
     if (!sessionId || !messageId) return
 
+    // Flush any pending deltas for this message before applying the update.
+    // Deltas are buffered for up to 50ms; if message.updated arrives before
+    // the buffer flushes, the message could be marked complete/error with
+    // stale text mutations still pending. Flushing first preserves the
+    // server's event ordering: all delta content is applied, then the
+    // message status/metadata update runs on the complete content.
+    flushPendingDeltasForMessage(instanceId, messageId)
+
     const timeInfo = (info.time ?? {}) as { created?: number; updated?: number; end?: number }
     const nextUpdated =
       typeof timeInfo.end === "number" && timeInfo.end > 0
@@ -439,12 +494,67 @@ function handleMessageUpdate(instanceId: string, event: MessageUpdateEvent | Mes
   }
 }
 
+const DELTA_FLUSH_INTERVAL = 50
+
+const pendingDeltas = new Map<string, { instanceId: string; messageId: string; partId: string; field: string; delta: string }>()
+let deltaFlushTimer: ReturnType<typeof setTimeout> | null = null
+
+function enqueueDelta(instanceId: string, messageId: string, partId: string, field: string, delta: string) {
+  const key = `${instanceId}:${messageId}:${partId}:${field}`
+  const existing = pendingDeltas.get(key)
+  const accumulated = existing ? existing.delta + delta : delta
+  pendingDeltas.set(key, { instanceId, messageId, partId, field, delta: accumulated })
+  if (deltaFlushTimer === null) {
+    deltaFlushTimer = setTimeout(flushDeltas, DELTA_FLUSH_INTERVAL)
+  }
+}
+
+function clearPendingDeltasForPart(instanceId: string, messageId: string, partId: string) {
+  const keysToDelete: string[] = []
+  for (const key of pendingDeltas.keys()) {
+    if (key.startsWith(`${instanceId}:${messageId}:${partId}:`)) {
+      keysToDelete.push(key)
+    }
+  }
+  for (const key of keysToDelete) {
+    pendingDeltas.delete(key)
+  }
+}
+
+function flushPendingDeltasForMessage(instanceId: string, messageId: string): void {
+  const prefix = `${instanceId}:${messageId}:`
+  for (const key of pendingDeltas.keys()) {
+    if (key.startsWith(prefix)) {
+      const pending = pendingDeltas.get(key)
+      if (pending) {
+        applyPartDeltaV2(instanceId, {
+          messageId: pending.messageId,
+          partId: pending.partId,
+          field: pending.field,
+          delta: pending.delta,
+        })
+        pendingDeltas.delete(key)
+      }
+    }
+  }
+}
+
+function flushDeltas() {
+  deltaFlushTimer = null
+  if (pendingDeltas.size === 0) return
+  const batch = Array.from(pendingDeltas.values())
+  pendingDeltas.clear()
+  for (const { instanceId, messageId, partId, field, delta } of batch) {
+    applyPartDeltaV2(instanceId, { messageId, partId, field, delta })
+  }
+}
+
 function handleMessagePartDelta(instanceId: string, event: MessagePartDeltaEvent): void {
   const props = event.properties
   if (!props) return
   const { messageID, partID, field, delta } = props
   if (!messageID || !partID || !field || typeof delta !== "string") return
-  applyPartDeltaV2(instanceId, { messageId: messageID, partId: partID, field, delta })
+  enqueueDelta(instanceId, messageID, partID, field, delta)
 }
 
 function handleSessionUpdate(instanceId: string, event: EventSessionUpdated): void {
@@ -606,6 +716,8 @@ function handleSessionCompacted(instanceId: string, event: EventSessionCompacted
   if (!sessionID) return
 
   log.info(`[SSE] Session compacted: ${sessionID}`)
+  debugInfo("sse", `Session compacted: ${sessionID.slice(0, 8)}`)
+  clearCompactionTimer(instanceId, sessionID)
 
   const existing = sessions().get(instanceId)?.get(sessionID)
   if (existing) {
@@ -635,8 +747,9 @@ function handleSessionCompacted(instanceId: string, event: EventSessionCompacted
   })
 }
 
-function handleSessionError(_instanceId: string, event: EventSessionError): void {
+function handleSessionError(instanceId: string, event: EventSessionError): void {
   const error = event.properties?.error
+  const sessionID = event.properties?.sessionID
   log.error(`[SSE] Session error:`, error)
 
   let message = tGlobal("sessionEvents.sessionError.unknown")
@@ -649,6 +762,17 @@ function handleSessionError(_instanceId: string, event: EventSessionError): void
     }
   }
 
+  if (sessionID) {
+    withSession(instanceId, sessionID, (session) => {
+      if (session.status === "compacting") {
+        log.warn(`[SSE] Compaction failed for session ${sessionID}, resetting status to "idle"`)
+        debugWarn("sse", `Compaction failed for session ${sessionID.slice(0, 8)}, resetting to idle`)
+        clearCompactionTimer(instanceId, sessionID)
+        session.status = "idle"
+      }
+    })
+  }
+
   showAlertDialog(tGlobal("sessionEvents.sessionError.message", { message }), {
     title: tGlobal("sessionEvents.sessionError.title"),
     variant: "error",
diff --git a/packages/ui/src/styles/messaging.css b/packages/ui/src/styles/messaging.css
index 10d91f722..e24b3ae11 100644
--- a/packages/ui/src/styles/messaging.css
+++ b/packages/ui/src/styles/messaging.css
@@ -37,12 +37,12 @@
 /* Message state indicators */
 .message-generating {
   @apply text-sm italic py-2;
-  color: var(--text-muted);
+  color: var(--status-warning);
 }
 
 .message-sending {
   @apply text-xs italic mt-1;
-  color: var(--text-muted);
+  color: var(--status-warning);
 }
 
 .message-error {
@@ -52,7 +52,7 @@
 
 .generating-spinner {
   @apply inline-block;
-  animation: pulse 1.5s ease-in-out infinite;
+  animation: generating-bounce 1.2s ease-in-out infinite;
 }
 
 .message-text {
@@ -112,3 +112,8 @@
 .reasoning-label {
   font-weight: var(--font-weight-medium);
 }
+
+@keyframes generating-bounce {
+  0%, 100% { transform: translateY(0); }
+  50% { transform: translateY(-3px); }
+}
diff --git a/packages/ui/src/styles/messaging/message-base.css b/packages/ui/src/styles/messaging/message-base.css
index 92af35daa..591eae2e3 100644
--- a/packages/ui/src/styles/messaging/message-base.css
+++ b/packages/ui/src/styles/messaging/message-base.css
@@ -244,10 +244,24 @@
 }
 
 .message-error {
-  @apply text-xs mt-1;
+  @apply text-xs mt-1 flex items-center gap-2;
   color: var(--status-error);
 }
 
+.message-retry-button {
+  @apply text-xs font-medium underline underline-offset-2;
+  color: var(--status-error);
+  cursor: pointer;
+  background: none;
+  border: none;
+  padding: 0;
+}
+
+.message-retry-button:hover {
+  color: var(--status-error);
+  opacity: 0.8;
+}
+
 .generating-spinner {
   @apply inline-block;
   animation: pulse 1.5s ease-in-out infinite;
diff --git a/packages/ui/src/styles/messaging/message-section.css b/packages/ui/src/styles/messaging/message-section.css
index e7c895157..a730d250c 100644
--- a/packages/ui/src/styles/messaging/message-section.css
+++ b/packages/ui/src/styles/messaging/message-section.css
@@ -246,6 +246,23 @@
   color: var(--text-secondary);
 }
 
+.debug-toggle-button {
+  @apply inline-flex items-center justify-center;
+  width: 2rem;
+  height: 2rem;
+  border-radius: 9999px;
+  border: 1px solid var(--border-base);
+  background-color: transparent;
+  color: var(--text-muted);
+  font-size: 14px;
+  transition: background-color 0.2s ease, color 0.2s ease;
+}
+
+.debug-toggle-button:hover {
+  background-color: var(--surface-hover);
+  color: var(--text-primary);
+}
+
 .message-quote-popover {
   position: absolute;
   z-index: 5;
diff --git a/packages/ui/vite.config.ts b/packages/ui/vite.config.ts
index ae2e2537e..e5d826330 100644
--- a/packages/ui/vite.config.ts
+++ b/packages/ui/vite.config.ts
@@ -61,7 +61,8 @@ export default defineConfig({
     },
     VitePWA({
       registerType: "autoUpdate",
-      injectRegister: "auto",
+      injectRegister: null,
+      selfDestroying: true,
       pwaAssets: {
         preset: "minimal-2023",
         image: "public/logo.png",