From fd5b1096227365c8f3fe2a5974f2fa095ec8bb15 Mon Sep 17 00:00:00 2001
From: Crabbotix <artus.operator@gmail.com>
Date: Thu, 19 Feb 2026 08:41:55 +0100
Subject: [PATCH 1/7] Improve remote mobile QoL: add-project flow, refresh
 resilience, and busy indicators

---
 src/App.tsx                                   |   9 +-
 src/features/app/components/Sidebar.test.tsx  |  48 +++
 src/features/app/components/Sidebar.tsx       |   8 +
 src/features/app/components/WorkspaceCard.tsx |   9 +
 .../useRemoteThreadLiveConnection.test.tsx    | 331 ++++++++++++++++++
 .../hooks/useRemoteThreadLiveConnection.ts    |  91 ++++-
 .../hooks/useWorkspaceRefreshOnFocus.test.tsx | 184 ++++++++++
 .../hooks/useWorkspaceRefreshOnFocus.ts       | 103 ++++--
 .../workspaces/hooks/useWorkspaces.test.tsx   |  45 +++
 .../workspaces/hooks/useWorkspaces.ts         |  31 +-
 src/styles/sidebar.css                        |  14 +
 11 files changed, 844 insertions(+), 29 deletions(-)
 create mode 100644 src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
 create mode 100644 src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.test.tsx

diff --git a/src/App.tsx b/src/App.tsx
index 9a77f6d7e..aad769434 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -65,7 +65,10 @@ import { useWorkspaceFileListing } from "@app/hooks/useWorkspaceFileListing";
 import { useGitBranches } from "@/features/git/hooks/useGitBranches";
 import { useBranchSwitcher } from "@/features/git/hooks/useBranchSwitcher";
 import { useBranchSwitcherShortcut } from "@/features/git/hooks/useBranchSwitcherShortcut";
-import { useWorkspaceRefreshOnFocus } from "@/features/workspaces/hooks/useWorkspaceRefreshOnFocus";
+import {
+  REMOTE_WORKSPACE_REFRESH_INTERVAL_MS,
+  useWorkspaceRefreshOnFocus,
+} from "@/features/workspaces/hooks/useWorkspaceRefreshOnFocus";
 import { useWorkspaceRestore } from "@/features/workspaces/hooks/useWorkspaceRestore";
 import { useRenameWorktreePrompt } from "@/features/workspaces/hooks/useRenameWorktreePrompt";
 import { useLayoutController } from "@app/hooks/useLayoutController";
@@ -1591,7 +1594,9 @@ function MainApp() {
   useWorkspaceRefreshOnFocus({
     workspaces,
     refreshWorkspaces,
-    listThreadsForWorkspace
+    listThreadsForWorkspace,
+    backendMode: appSettings.backendMode,
+    pollIntervalMs: REMOTE_WORKSPACE_REFRESH_INTERVAL_MS,
   });
 
   useRemoteThreadRefreshOnFocus({
diff --git a/src/features/app/components/Sidebar.test.tsx b/src/features/app/components/Sidebar.test.tsx
index 436e019ad..48515331c 100644
--- a/src/features/app/components/Sidebar.test.tsx
+++ b/src/features/app/components/Sidebar.test.tsx
@@ -242,4 +242,52 @@ describe("Sidebar", () => {
     fireEvent.click(draftRow);
     expect(onSelectWorkspace).toHaveBeenCalledWith("ws-1");
   });
+
+  it("shows a workspace activity indicator when a thread is processing", () => {
+    render(
+      <Sidebar
+        {...baseProps}
+        workspaces={[
+          {
+            id: "ws-1",
+            name: "Workspace",
+            path: "/tmp/workspace",
+            connected: true,
+            settings: { sidebarCollapsed: false },
+          },
+        ]}
+        groupedWorkspaces={[
+          {
+            id: null,
+            name: "Workspaces",
+            workspaces: [
+              {
+                id: "ws-1",
+                name: "Workspace",
+                path: "/tmp/workspace",
+                connected: true,
+                settings: { sidebarCollapsed: false },
+              },
+            ],
+          },
+        ]}
+        threadsByWorkspace={{
+          "ws-1": [
+            {
+              id: "thread-1",
+              name: "Thread 1",
+              updated_at: new Date().toISOString(),
+            } as never,
+          ],
+        }}
+        threadStatusById={{
+          "thread-1": { isProcessing: true, hasUnread: false, isReviewing: false },
+        }}
+      />,
+    );
+
+    const indicator = screen.getByTitle("Streaming updates in progress");
+    expect(indicator.className).toContain("workspace-activity-indicator");
+    expect(indicator.className).toContain("is-processing");
+  });
 });
diff --git a/src/features/app/components/Sidebar.tsx b/src/features/app/components/Sidebar.tsx
index 0f7cb4465..f2aaa8a5e 100644
--- a/src/features/app/components/Sidebar.tsx
+++ b/src/features/app/components/Sidebar.tsx
@@ -553,6 +553,13 @@ export const Sidebar = memo(function Sidebar({
                     isLoadingThreads && threads.length === 0;
                   const isPaging = threadListPagingByWorkspace[entry.id] ?? false;
                   const worktrees = worktreesByParent.get(entry.id) ?? [];
+                  const workspaceIdsWithChildren = [entry.id, ...worktrees.map((child) => child.id)];
+                  const hasProcessingActivity = workspaceIdsWithChildren.some((workspaceId) => {
+                    const workspaceThreads = threadsByWorkspace[workspaceId] ?? [];
+                    return workspaceThreads.some(
+                      (thread) => threadStatusById[thread.id]?.isProcessing,
+                    );
+                  });
                   const addMenuOpen = addMenuAnchor?.workspaceId === entry.id;
                   const isDraftNewAgent = newAgentDraftWorkspaceId === entry.id;
                   const isDraftRowActive =
@@ -573,6 +580,7 @@ export const Sidebar = memo(function Sidebar({
                       isCollapsed={isCollapsed}
                       addMenuOpen={addMenuOpen}
                       addMenuWidth={ADD_MENU_WIDTH}
+                      hasProcessingActivity={hasProcessingActivity}
                       onSelectWorkspace={onSelectWorkspace}
                       onShowWorkspaceMenu={showWorkspaceMenu}
                       onToggleWorkspaceCollapse={onToggleWorkspaceCollapse}
diff --git a/src/features/app/components/WorkspaceCard.tsx b/src/features/app/components/WorkspaceCard.tsx
index 58eaa86b1..b319eee02 100644
--- a/src/features/app/components/WorkspaceCard.tsx
+++ b/src/features/app/components/WorkspaceCard.tsx
@@ -9,6 +9,7 @@ type WorkspaceCardProps = {
   isCollapsed: boolean;
   addMenuOpen: boolean;
   addMenuWidth: number;
+  hasProcessingActivity?: boolean;
   onSelectWorkspace: (id: string) => void;
   onShowWorkspaceMenu: (event: MouseEvent, workspaceId: string) => void;
   onToggleWorkspaceCollapse: (workspaceId: string, collapsed: boolean) => void;
@@ -29,6 +30,7 @@ export function WorkspaceCard({
   isCollapsed,
   addMenuOpen,
   addMenuWidth,
+  hasProcessingActivity = false,
   onSelectWorkspace,
   onShowWorkspaceMenu,
   onToggleWorkspaceCollapse,
@@ -57,6 +59,13 @@ export function WorkspaceCard({
           <div className="workspace-name-row">
             <div className="workspace-title">
               <span className="workspace-name">{workspaceName ?? workspace.name}</span>
+              {hasProcessingActivity && (
+                <span
+                  className="workspace-activity-indicator is-processing"
+                  aria-hidden
+                  title="Streaming updates in progress"
+                />
+              )}
               <button
                 className={`workspace-toggle ${isCollapsed ? "" : "expanded"}`}
                 onClick={(event) => {
diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
new file mode 100644
index 000000000..0a9eb0615
--- /dev/null
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
@@ -0,0 +1,331 @@
+// @vitest-environment jsdom
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useRemoteThreadLiveConnection } from "./useRemoteThreadLiveConnection";
+
+const appServerListeners = new Set<(event: any) => void>();
+const subscribeAppServerEventsMock = vi.fn((listener: (event: any) => void) => {
+  appServerListeners.add(listener);
+  return () => {
+    appServerListeners.delete(listener);
+  };
+});
+
+const threadLiveSubscribeMock = vi.fn().mockResolvedValue(undefined);
+const threadLiveUnsubscribeMock = vi.fn().mockResolvedValue(undefined);
+const pushErrorToastMock = vi.fn();
+
+vi.mock("@services/events", () => ({
+  subscribeAppServerEvents: (listener: (event: any) => void) =>
+    subscribeAppServerEventsMock(listener),
+}));
+
+vi.mock("@services/tauri", () => ({
+  threadLiveSubscribe: (...args: any[]) => threadLiveSubscribeMock(...args),
+  threadLiveUnsubscribe: (...args: any[]) => threadLiveUnsubscribeMock(...args),
+}));
+
+vi.mock("@services/toasts", () => ({
+  pushErrorToast: (...args: any[]) => pushErrorToastMock(...args),
+}));
+
+vi.mock("@utils/appServerEvents", () => ({
+  getAppServerRawMethod: (event: any) => event.method ?? null,
+  getAppServerParams: (event: any) => event.params ?? {},
+}));
+
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({
+    listen: vi.fn().mockResolvedValue(() => {}),
+  }),
+}));
+
+describe("useRemoteThreadLiveConnection", () => {
+  let visibilityState: DocumentVisibilityState;
+  let hasFocus: boolean;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-02-19T00:00:00.000Z"));
+    visibilityState = "visible";
+    hasFocus = true;
+    Object.defineProperty(document, "visibilityState", {
+      configurable: true,
+      get: () => visibilityState,
+    });
+    Object.defineProperty(document, "hasFocus", {
+      configurable: true,
+      value: () => hasFocus,
+    });
+    appServerListeners.clear();
+    subscribeAppServerEventsMock.mockClear();
+    threadLiveSubscribeMock.mockClear();
+    threadLiveUnsubscribeMock.mockClear();
+    pushErrorToastMock.mockClear();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("reconnects when live stream goes stale after daemon interruption", async () => {
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+
+    renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: {
+          id: "ws-1",
+          name: "Workspace",
+          path: "/tmp/ws-1",
+          connected: true,
+          settings: { sidebarCollapsed: false },
+        },
+        activeThreadId: "thread-1",
+        refreshThread,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+    expect(refreshThread).toHaveBeenCalledTimes(1);
+
+    const heartbeatEvent = {
+      workspace_id: "ws-1",
+      method: "thread/live_heartbeat",
+      params: { threadId: "thread-1" },
+    };
+    await act(async () => {
+      for (const listener of appServerListeners) {
+        listener(heartbeatEvent);
+      }
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      vi.advanceTimersByTime(25_000);
+      await Promise.resolve();
+    });
+
+    expect(threadLiveSubscribeMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+    expect(threadLiveUnsubscribeMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+    expect(refreshThread.mock.calls.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("reconnects when thread live stream detaches while visible", async () => {
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+
+    renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: {
+          id: "ws-1",
+          name: "Workspace",
+          path: "/tmp/ws-1",
+          connected: true,
+          settings: { sidebarCollapsed: false },
+        },
+        activeThreadId: "thread-1",
+        refreshThread,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      for (const listener of appServerListeners) {
+        listener({
+          workspace_id: "ws-1",
+          method: "thread/live_detached",
+          params: { threadId: "thread-1" },
+        });
+      }
+      await Promise.resolve();
+    });
+
+    expect(threadLiveSubscribeMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+    expect(refreshThread.mock.calls.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("does not reconnect detached stream when window is not focused", async () => {
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+
+    renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: {
+          id: "ws-1",
+          name: "Workspace",
+          path: "/tmp/ws-1",
+          connected: true,
+          settings: { sidebarCollapsed: false },
+        },
+        activeThreadId: "thread-1",
+        refreshThread,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+
+    hasFocus = false;
+    await act(async () => {
+      for (const listener of appServerListeners) {
+        listener({
+          workspace_id: "ws-1",
+          method: "thread/live_detached",
+          params: { threadId: "thread-1" },
+        });
+      }
+      await Promise.resolve();
+    });
+
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("cleans up stale reconnect subscribe when sequence advances", async () => {
+    let resolveFirstSubscribe: (() => void) | null = null;
+    const firstSubscribe = new Promise<void>((resolve) => {
+      resolveFirstSubscribe = resolve;
+    });
+    threadLiveSubscribeMock
+      .mockImplementationOnce(() => firstSubscribe)
+      .mockResolvedValue(undefined);
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+
+    const { result } = renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: {
+          id: "ws-1",
+          name: "Workspace",
+          path: "/tmp/ws-1",
+          connected: true,
+          settings: { sidebarCollapsed: false },
+        },
+        activeThreadId: null,
+        refreshThread,
+      }),
+    );
+
+    let firstReconnectPromise: Promise<boolean> = Promise.resolve(false);
+    await act(async () => {
+      firstReconnectPromise = result.current.reconnectLive("ws-1", "thread-1", {
+        runResume: false,
+      });
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      await result.current.reconnectLive("ws-1", "thread-2", { runResume: false });
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      resolveFirstSubscribe?.();
+      await firstReconnectPromise;
+      await Promise.resolve();
+    });
+
+    expect(threadLiveUnsubscribeMock).toHaveBeenCalledWith("ws-1", "thread-1");
+  });
+
+  it("does not unsubscribe active thread when stale reconnect resolves late", async () => {
+    let resolveFirstSubscribe: (() => void) | null = null;
+    const firstSubscribe = new Promise<void>((resolve) => {
+      resolveFirstSubscribe = resolve;
+    });
+    threadLiveSubscribeMock
+      .mockImplementationOnce(() => firstSubscribe)
+      .mockResolvedValue(undefined);
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+
+    const { result } = renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: {
+          id: "ws-1",
+          name: "Workspace",
+          path: "/tmp/ws-1",
+          connected: true,
+          settings: { sidebarCollapsed: false },
+        },
+        activeThreadId: null,
+        refreshThread,
+      }),
+    );
+
+    let firstReconnectPromise: Promise<boolean> = Promise.resolve(false);
+    await act(async () => {
+      firstReconnectPromise = result.current.reconnectLive("ws-1", "thread-1", {
+        runResume: false,
+      });
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      const secondReconnect = result.current.reconnectLive("ws-1", "thread-1", {
+        runResume: false,
+      });
+      await Promise.resolve();
+      await secondReconnect;
+    });
+
+    await act(async () => {
+      resolveFirstSubscribe?.();
+      await firstReconnectPromise;
+      await Promise.resolve();
+    });
+
+    expect(threadLiveUnsubscribeMock).not.toHaveBeenCalled();
+  });
+
+  it("cancels in-flight reconnect attempt when window blurs", async () => {
+    let resolveFirstSubscribe: (() => void) | null = null;
+    const firstSubscribe = new Promise<void>((resolve) => {
+      resolveFirstSubscribe = resolve;
+    });
+    threadLiveSubscribeMock.mockImplementationOnce(() => firstSubscribe);
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+
+    const { result } = renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: {
+          id: "ws-1",
+          name: "Workspace",
+          path: "/tmp/ws-1",
+          connected: true,
+          settings: { sidebarCollapsed: false },
+        },
+        activeThreadId: null,
+        refreshThread,
+      }),
+    );
+
+    await act(async () => {
+      result.current.reconnectLive("ws-1", "thread-1", { runResume: false });
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      window.dispatchEvent(new Event("blur"));
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      resolveFirstSubscribe?.();
+      await Promise.resolve();
+    });
+
+    expect(threadLiveUnsubscribeMock).toHaveBeenCalledWith("ws-1", "thread-1");
+  });
+});
diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.ts b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
index 70bde85ca..ea0b2bb38 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.ts
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { subscribeAppServerEvents } from "@services/events";
 import { threadLiveSubscribe, threadLiveUnsubscribe } from "@services/tauri";
+import { pushErrorToast } from "@services/toasts";
 import {
   getAppServerParams,
   getAppServerRawMethod,
@@ -10,6 +11,10 @@ import type { WorkspaceInfo } from "@/types";
 
 export type RemoteThreadConnectionState = "live" | "polling" | "disconnected";
 
+export const REMOTE_LIVE_STALE_TIMEOUT_MS = 20_000;
+export const REMOTE_LIVE_RECONNECT_INTERVAL_MS = 5_000;
+const REMOTE_RECOVERY_TOAST_COOLDOWN_MS = 30_000;
+
 type ReconnectOptions = {
   runResume?: boolean;
 };
@@ -63,6 +68,13 @@ function isDocumentVisible() {
   return typeof document === "undefined" ? true : document.visibilityState === "visible";
 }
 
+function isWindowFocused() {
+  if (typeof document === "undefined" || typeof document.hasFocus !== "function") {
+    return true;
+  }
+  return document.hasFocus();
+}
+
 export function useRemoteThreadLiveConnection({
   backendMode,
   activeWorkspace,
@@ -90,8 +102,10 @@ export function useRemoteThreadLiveConnection({
   const reconnectWorkspaceRef = useRef(reconnectWorkspace);
   const connectionStateRef = useRef(connectionState);
   const activeSubscriptionKeyRef = useRef<string | null>(null);
+  const desiredSubscriptionKeyRef = useRef<string | null>(null);
   const reconnectSequenceRef = useRef(0);
   const lastThreadEventAtRef = useRef<number>(0);
+  const lastRecoveryToastAtRef = useRef<number>(0);
 
   useEffect(() => {
     backendModeRef.current = backendMode;
@@ -168,6 +182,8 @@ export function useRemoteThreadLiveConnection({
       setState(activeWorkspaceRef.current.connected ? "polling" : "disconnected");
 
       try {
+        const targetKey = keyForThread(workspaceId, threadId);
+        desiredSubscriptionKeyRef.current = targetKey;
         if (
           !activeWorkspaceRef.current.connected &&
           reconnectWorkspaceRef.current &&
@@ -186,12 +202,23 @@ export function useRemoteThreadLiveConnection({
           return false;
         }
 
+        if (activeSubscriptionKeyRef.current === targetKey) {
+          await threadLiveUnsubscribe(workspaceId, threadId).catch(() => {
+            // Best-effort dedupe: ignore unsubscribe failures before reattach.
+          });
+          activeSubscriptionKeyRef.current = null;
+        }
         await threadLiveSubscribe(workspaceId, threadId);
         if (sequence !== reconnectSequenceRef.current) {
+          if (desiredSubscriptionKeyRef.current !== targetKey) {
+            await threadLiveUnsubscribe(workspaceId, threadId).catch(() => {
+              // Best-effort cleanup for stale reconnect attempts.
+            });
+          }
           return false;
         }
 
-        activeSubscriptionKeyRef.current = keyForThread(workspaceId, threadId);
+        activeSubscriptionKeyRef.current = targetKey;
         setState("polling");
         return true;
       } catch {
@@ -210,6 +237,7 @@ export function useRemoteThreadLiveConnection({
       backendMode === "remote" && workspace?.id && activeThreadId
         ? keyForThread(workspace.id, activeThreadId)
         : null;
+    desiredSubscriptionKeyRef.current = nextKey;
     const previousKey = activeSubscriptionKeyRef.current;
 
     if (previousKey && previousKey !== nextKey) {
@@ -276,6 +304,11 @@ export function useRemoteThreadLiveConnection({
         if (threadId === selectedThreadId) {
           activeSubscriptionKeyRef.current = null;
           reconcileDisconnectedState();
+          if (isDocumentVisible() && isWindowFocused()) {
+            void reconnectLive(activeWorkspaceId, selectedThreadId, {
+              runResume: true,
+            });
+          }
         }
         return;
       }
@@ -296,8 +329,9 @@ export function useRemoteThreadLiveConnection({
       if (threadId !== selectedThreadId) {
         return;
       }
-      lastThreadEventAtRef.current = Date.now();
-      setState("live");
+      if (connectionStateRef.current === "live") {
+        lastThreadEventAtRef.current = Date.now();
+      }
     });
 
     return () => {
@@ -305,6 +339,54 @@ export function useRemoteThreadLiveConnection({
     };
   }, [reconnectLive, reconcileDisconnectedState, setState]);
 
+  useEffect(() => {
+    if (backendMode !== "remote") {
+      return;
+    }
+    const timer = setInterval(() => {
+      if (!isDocumentVisible() || !isWindowFocused()) {
+        return;
+      }
+      const workspaceId = activeWorkspaceRef.current?.id ?? null;
+      const threadId = activeThreadIdRef.current;
+      if (!workspaceId || !threadId) {
+        return;
+      }
+      const now = Date.now();
+      const lastEventAt = lastThreadEventAtRef.current;
+      const staleLive =
+        connectionStateRef.current === "live" &&
+        lastEventAt > 0 &&
+        now - lastEventAt >= REMOTE_LIVE_STALE_TIMEOUT_MS;
+      if (!staleLive) {
+        return;
+      }
+      const toastNow = Date.now();
+      if (
+        toastNow - lastRecoveryToastAtRef.current >=
+        REMOTE_RECOVERY_TOAST_COOLDOWN_MS
+      ) {
+        lastRecoveryToastAtRef.current = toastNow;
+        pushErrorToast({
+          title: "Server connection interrupted",
+          message:
+            "Live updates paused (likely daemon restart). Reconnecting automatically.",
+          durationMs: 5000,
+        });
+      }
+      setState("polling");
+      void (async () => {
+        await reconnectLive(workspaceId, threadId, {
+          runResume: true,
+        });
+      })();
+    }, REMOTE_LIVE_RECONNECT_INTERVAL_MS);
+
+    return () => {
+      clearInterval(timer);
+    };
+  }, [backendMode, reconnectLive, setState]);
+
   useEffect(() => {
     let unlistenWindowFocus: (() => void) | null = null;
     let unlistenWindowBlur: (() => void) | null = null;
@@ -327,6 +409,8 @@ export function useRemoteThreadLiveConnection({
     };
 
     const handleBlur = () => {
+      reconnectSequenceRef.current += 1;
+      desiredSubscriptionKeyRef.current = null;
       const currentKey = activeSubscriptionKeyRef.current;
       if (!currentKey) {
         return;
@@ -389,6 +473,7 @@ export function useRemoteThreadLiveConnection({
       window.removeEventListener("focus", handleFocus);
       window.removeEventListener("blur", handleBlur);
       document.removeEventListener("visibilitychange", handleVisibilityChange);
+      desiredSubscriptionKeyRef.current = null;
       const currentKey = activeSubscriptionKeyRef.current;
       if (currentKey) {
         activeSubscriptionKeyRef.current = null;
diff --git a/src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.test.tsx b/src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.test.tsx
new file mode 100644
index 000000000..65df634e4
--- /dev/null
+++ b/src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.test.tsx
@@ -0,0 +1,184 @@
+// @vitest-environment jsdom
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useWorkspaceRefreshOnFocus } from "./useWorkspaceRefreshOnFocus";
+
+describe("useWorkspaceRefreshOnFocus", () => {
+  let visibilityState: DocumentVisibilityState;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    visibilityState = "visible";
+    Object.defineProperty(document, "visibilityState", {
+      configurable: true,
+      get: () => visibilityState,
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("refreshes workspaces and connected threads on focus", async () => {
+    const refreshWorkspaces = vi.fn().mockResolvedValue([
+      {
+        id: "ws-1",
+        name: "Workspace",
+        path: "/tmp/ws-1",
+        connected: true,
+        settings: { sidebarCollapsed: false },
+      },
+    ]);
+    const listThreadsForWorkspace = vi.fn().mockResolvedValue(undefined);
+
+    renderHook(() =>
+      useWorkspaceRefreshOnFocus({
+        workspaces: [],
+        refreshWorkspaces,
+        listThreadsForWorkspace,
+      }),
+    );
+
+    await act(async () => {
+      window.dispatchEvent(new Event("focus"));
+      vi.advanceTimersByTime(500);
+      await Promise.resolve();
+    });
+
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(1);
+    expect(listThreadsForWorkspace).toHaveBeenCalledTimes(1);
+    expect(listThreadsForWorkspace).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "ws-1" }),
+      { preserveState: true },
+    );
+  });
+
+  it("polls automatically in remote mode", async () => {
+    const refreshWorkspaces = vi.fn().mockResolvedValue([
+      {
+        id: "ws-1",
+        name: "Workspace",
+        path: "/tmp/ws-1",
+        connected: true,
+        settings: { sidebarCollapsed: false },
+      },
+    ]);
+    const listThreadsForWorkspace = vi.fn().mockResolvedValue(undefined);
+
+    renderHook(() =>
+      useWorkspaceRefreshOnFocus({
+        workspaces: [],
+        refreshWorkspaces,
+        listThreadsForWorkspace,
+        backendMode: "remote",
+        pollIntervalMs: 2000,
+      }),
+    );
+
+    await act(async () => {
+      vi.advanceTimersByTime(1999);
+      await Promise.resolve();
+    });
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(0);
+
+    await act(async () => {
+      vi.advanceTimersByTime(1);
+      await Promise.resolve();
+    });
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(1);
+    expect(listThreadsForWorkspace).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not poll when backend mode is local", async () => {
+    const refreshWorkspaces = vi.fn().mockResolvedValue([]);
+    const listThreadsForWorkspace = vi.fn().mockResolvedValue(undefined);
+
+    renderHook(() =>
+      useWorkspaceRefreshOnFocus({
+        workspaces: [],
+        refreshWorkspaces,
+        listThreadsForWorkspace,
+        backendMode: "local",
+        pollIntervalMs: 1000,
+      }),
+    );
+
+    await act(async () => {
+      vi.advanceTimersByTime(4000);
+      await Promise.resolve();
+    });
+
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(0);
+    expect(listThreadsForWorkspace).toHaveBeenCalledTimes(0);
+  });
+
+  it("starts polling when backend mode changes from local to remote", async () => {
+    const refreshWorkspaces = vi.fn().mockResolvedValue([]);
+    const listThreadsForWorkspace = vi.fn().mockResolvedValue(undefined);
+
+    const { rerender } = renderHook(
+      (props: { backendMode: string }) =>
+        useWorkspaceRefreshOnFocus({
+          workspaces: [],
+          refreshWorkspaces,
+          listThreadsForWorkspace,
+          backendMode: props.backendMode,
+          pollIntervalMs: 1000,
+        }),
+      {
+        initialProps: { backendMode: "local" },
+      },
+    );
+
+    await act(async () => {
+      vi.advanceTimersByTime(1500);
+      await Promise.resolve();
+    });
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(0);
+
+    rerender({ backendMode: "remote" });
+
+    await act(async () => {
+      vi.advanceTimersByTime(1000);
+      await Promise.resolve();
+    });
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(1);
+  });
+
+  it("stops polling while hidden and resumes when visible again", async () => {
+    const refreshWorkspaces = vi.fn().mockResolvedValue([]);
+    const listThreadsForWorkspace = vi.fn().mockResolvedValue(undefined);
+
+    renderHook(() =>
+      useWorkspaceRefreshOnFocus({
+        workspaces: [],
+        refreshWorkspaces,
+        listThreadsForWorkspace,
+        backendMode: "remote",
+        pollIntervalMs: 1000,
+      }),
+    );
+
+    await act(async () => {
+      vi.advanceTimersByTime(1000);
+      await Promise.resolve();
+    });
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      visibilityState = "hidden";
+      document.dispatchEvent(new Event("visibilitychange"));
+      vi.advanceTimersByTime(3000);
+      await Promise.resolve();
+    });
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      visibilityState = "visible";
+      document.dispatchEvent(new Event("visibilitychange"));
+      vi.advanceTimersByTime(1000);
+      await Promise.resolve();
+    });
+    expect(refreshWorkspaces).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.ts b/src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.ts
index b7fc03c1a..160469ec3 100644
--- a/src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.ts
+++ b/src/features/workspaces/hooks/useWorkspaceRefreshOnFocus.ts
@@ -1,6 +1,8 @@
 import { useEffect, useRef } from "react";
 import type { WorkspaceInfo } from "../../../types";
 
+export const REMOTE_WORKSPACE_REFRESH_INTERVAL_MS = 15_000;
+
 type WorkspaceRefreshOptions = {
   workspaces: WorkspaceInfo[];
   refreshWorkspaces: () => Promise<WorkspaceInfo[] | void>;
@@ -8,61 +10,116 @@ type WorkspaceRefreshOptions = {
     workspace: WorkspaceInfo,
     options?: { preserveState?: boolean },
   ) => Promise<void>;
+  backendMode?: string;
+  pollIntervalMs?: number;
 };
 
 export function useWorkspaceRefreshOnFocus({
   workspaces,
   refreshWorkspaces,
   listThreadsForWorkspace,
+  backendMode = "local",
+  pollIntervalMs = REMOTE_WORKSPACE_REFRESH_INTERVAL_MS,
 }: WorkspaceRefreshOptions) {
-  const optionsRef = useRef({ workspaces, refreshWorkspaces, listThreadsForWorkspace });
+  const optionsRef = useRef({
+    workspaces,
+    refreshWorkspaces,
+    listThreadsForWorkspace,
+    backendMode,
+    pollIntervalMs,
+  });
   useEffect(() => {
-    optionsRef.current = { workspaces, refreshWorkspaces, listThreadsForWorkspace };
+    optionsRef.current = {
+      workspaces,
+      refreshWorkspaces,
+      listThreadsForWorkspace,
+      backendMode,
+      pollIntervalMs,
+    };
   });
 
   useEffect(() => {
     let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+    let pollTimer: ReturnType<typeof setInterval> | null = null;
+    let refreshInFlight = false;
 
-    const handleFocus = () => {
+    const runRefreshCycle = () => {
+      if (refreshInFlight) {
+        return;
+      }
+      refreshInFlight = true;
+      const {
+        workspaces: ws,
+        refreshWorkspaces: refresh,
+        listThreadsForWorkspace: listThreads,
+      } = optionsRef.current;
+      void (async () => {
+        let latestWorkspaces = ws;
+        try {
+          const entries = await refresh();
+          if (entries) {
+            latestWorkspaces = entries;
+          }
+        } catch {
+          // Silent: refresh errors show in debug panel.
+        }
+        const connected = latestWorkspaces.filter((entry) => entry.connected);
+        await Promise.allSettled(
+          connected.map((workspace) => listThreads(workspace, { preserveState: true })),
+        );
+      })().finally(() => {
+        refreshInFlight = false;
+      });
+    };
+
+    const updatePolling = () => {
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+      const { backendMode: currentBackendMode, pollIntervalMs: intervalMs } =
+        optionsRef.current;
+      if (currentBackendMode !== "remote" || document.visibilityState !== "visible") {
+        return;
+      }
+      pollTimer = setInterval(() => {
+        runRefreshCycle();
+      }, intervalMs);
+    };
+
+    const scheduleRefresh = () => {
       if (debounceTimer) {
         clearTimeout(debounceTimer);
       }
       debounceTimer = setTimeout(() => {
-        const { workspaces: ws, refreshWorkspaces: refresh, listThreadsForWorkspace: listThreads } = optionsRef.current;
-        void (async () => {
-          let latestWorkspaces = ws;
-          try {
-            const entries = await refresh();
-            if (entries) {
-              latestWorkspaces = entries;
-            }
-          } catch {
-            // Silent: refresh errors show in debug panel.
-          }
-          const connected = latestWorkspaces.filter((entry) => entry.connected);
-          await Promise.allSettled(
-            connected.map((workspace) =>
-              listThreads(workspace, { preserveState: true }),
-            ),
-          );
-        })();
+        runRefreshCycle();
       }, 500);
     };
 
+    const handleFocus = () => {
+      scheduleRefresh();
+      updatePolling();
+    };
+
     const handleVisibilityChange = () => {
       if (document.visibilityState === "visible") {
-        handleFocus();
+        scheduleRefresh();
       }
+      updatePolling();
     };
 
     window.addEventListener("focus", handleFocus);
     document.addEventListener("visibilitychange", handleVisibilityChange);
+    updatePolling();
     return () => {
       window.removeEventListener("focus", handleFocus);
       document.removeEventListener("visibilitychange", handleVisibilityChange);
       if (debounceTimer) {
         clearTimeout(debounceTimer);
       }
+      if (pollTimer) {
+        clearInterval(pollTimer);
+      }
     };
-  }, []);
+  }, [backendMode, pollIntervalMs]);
 }
diff --git a/src/features/workspaces/hooks/useWorkspaces.test.tsx b/src/features/workspaces/hooks/useWorkspaces.test.tsx
index 561a35af5..a6a97b4f1 100644
--- a/src/features/workspaces/hooks/useWorkspaces.test.tsx
+++ b/src/features/workspaces/hooks/useWorkspaces.test.tsx
@@ -13,6 +13,7 @@ import {
   renameWorktreeUpstream,
   updateWorkspaceSettings,
 } from "../../../services/tauri";
+import { isMobilePlatform } from "../../../utils/platformPaths";
 import { useWorkspaces } from "./useWorkspaces";
 
 vi.mock("@tauri-apps/plugin-dialog", () => ({
@@ -36,8 +37,13 @@ vi.mock("../../../services/tauri", () => ({
   updateWorkspaceSettings: vi.fn(),
 }));
 
+vi.mock("../../../utils/platformPaths", () => ({
+  isMobilePlatform: vi.fn(() => false),
+}));
+
 beforeEach(() => {
   vi.clearAllMocks();
+  vi.mocked(isMobilePlatform).mockReturnValue(false);
 });
 
 const worktree: WorkspaceInfo = {
@@ -359,4 +365,43 @@ describe("useWorkspaces.addWorkspace (bulk)", () => {
       expect.objectContaining({ title: "Some workspaces were skipped", kind: "warning" }),
     );
   });
+
+  it("uses manual server paths on mobile remote mode", async () => {
+    const listWorkspacesMock = vi.mocked(listWorkspaces);
+    const pickWorkspacePathsMock = vi.mocked(pickWorkspacePaths);
+    const isWorkspacePathDirMock = vi.mocked(isWorkspacePathDir);
+    const addWorkspaceMock = vi.mocked(addWorkspace);
+    const promptSpy = vi
+      .spyOn(window, "prompt")
+      .mockReturnValue("/srv/repo-a\n/srv/repo-b");
+    vi.mocked(isMobilePlatform).mockReturnValue(true);
+
+    listWorkspacesMock.mockResolvedValue([]);
+    isWorkspacePathDirMock.mockResolvedValue(true);
+    addWorkspaceMock
+      .mockResolvedValueOnce({ ...workspaceOne, id: "added-1", path: "/srv/repo-a" })
+      .mockResolvedValueOnce({ ...workspaceTwo, id: "added-2", path: "/srv/repo-b" });
+
+    const { result } = renderHook(() =>
+      useWorkspaces({
+        appSettings: { backendMode: "remote" } as never,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      await result.current.addWorkspace();
+    });
+
+    expect(promptSpy).toHaveBeenCalledTimes(1);
+    expect(pickWorkspacePathsMock).not.toHaveBeenCalled();
+    expect(addWorkspaceMock).toHaveBeenCalledTimes(2);
+    expect(addWorkspaceMock).toHaveBeenNthCalledWith(1, "/srv/repo-a", null);
+    expect(addWorkspaceMock).toHaveBeenNthCalledWith(2, "/srv/repo-b", null);
+
+    promptSpy.mockRestore();
+  });
 });
diff --git a/src/features/workspaces/hooks/useWorkspaces.ts b/src/features/workspaces/hooks/useWorkspaces.ts
index 7eaf6ae0f..d431d70a9 100644
--- a/src/features/workspaces/hooks/useWorkspaces.ts
+++ b/src/features/workspaces/hooks/useWorkspaces.ts
@@ -8,6 +8,7 @@ import type {
   WorkspaceSettings,
 } from "../../../types";
 import { ask, message } from "@tauri-apps/plugin-dialog";
+import { isMobilePlatform } from "../../../utils/platformPaths";
 import {
   addClone as addCloneService,
   addWorkspace as addWorkspaceService,
@@ -78,6 +79,26 @@ function normalizeWorkspacePathKey(value: string) {
   return value.trim().replace(/\\/g, "/").replace(/\/+$/, "");
 }
 
+function parseWorkspacePathInput(value: string) {
+  return value
+    .split(/\r?\n|,|;/)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function promptWorkspacePathsForMobileRemote(): string[] {
+  if (typeof window === "undefined" || typeof window.prompt !== "function") {
+    return [];
+  }
+  const input = window.prompt(
+    "Enter one or more project paths on the connected server.\nUse one path per line (or comma-separated).",
+  );
+  if (!input) {
+    return [];
+  }
+  return parseWorkspacePathInput(input);
+}
+
 export function useWorkspaces(options: UseWorkspacesOptions = {}) {
   const [workspaces, setWorkspaces] = useState<WorkspaceInfo[]>([]);
   const [activeWorkspaceId, setActiveWorkspaceId] = useState<string | null>(null);
@@ -377,12 +398,20 @@ export function useWorkspaces(options: UseWorkspacesOptions = {}) {
   );
 
   const addWorkspace = useCallback(async () => {
+    if (isMobilePlatform() && appSettings?.backendMode === "remote") {
+      const manualPaths = promptWorkspacePathsForMobileRemote();
+      if (manualPaths.length === 0) {
+        return null;
+      }
+      return addWorkspacesFromPaths(manualPaths);
+    }
+
     const selection = await pickWorkspacePaths();
     if (selection.length === 0) {
       return null;
     }
     return addWorkspacesFromPaths(selection);
-  }, [addWorkspacesFromPaths]);
+  }, [addWorkspacesFromPaths, appSettings?.backendMode]);
 
   const filterWorkspacePaths = useCallback(async (paths: string[]) => {
     const trimmed = paths.map((path) => path.trim()).filter(Boolean);
diff --git a/src/styles/sidebar.css b/src/styles/sidebar.css
index a6372be5e..d07076462 100644
--- a/src/styles/sidebar.css
+++ b/src/styles/sidebar.css
@@ -739,6 +739,20 @@
   min-width: 0;
 }
 
+.workspace-activity-indicator {
+  width: 8px;
+  height: 8px;
+  border-radius: 999px;
+  display: inline-block;
+  flex-shrink: 0;
+}
+
+.workspace-activity-indicator.is-processing {
+  background: #ff9f43;
+  box-shadow: 0 0 10px rgba(255, 159, 67, 0.8);
+  animation: pulse 1.2s ease-in-out infinite;
+}
+
 .workspace-toggle {
   border: none;
   background: transparent;

From 2f35d4bff32901412b41a1c901deb1100118a3d8 Mon Sep 17 00:00:00 2001
From: Crabbotix <artus.operator@gmail.com>
Date: Thu, 19 Feb 2026 11:46:23 +0100
Subject: [PATCH 2/7] Mark remote stream live on activity events

---
 .../useRemoteThreadLiveConnection.test.tsx    | 44 +++++++++++++++++++
 .../hooks/useRemoteThreadLiveConnection.ts    |  5 +--
 2 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
index 0a9eb0615..dce5031d1 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
@@ -191,6 +191,50 @@ describe("useRemoteThreadLiveConnection", () => {
     expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
   });
 
+  it("promotes polling state to live on thread activity without heartbeat", async () => {
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+    const workspace = {
+      id: "ws-1",
+      name: "Workspace",
+      path: "/tmp/ws-1",
+      connected: true,
+      settings: { sidebarCollapsed: false },
+    };
+
+    const { result } = renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: workspace,
+        activeThreadId: "thread-1",
+        refreshThread,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(result.current.connectionState).toBe("polling");
+
+    await act(async () => {
+      for (const listener of appServerListeners) {
+        listener({
+          workspace_id: "ws-1",
+          method: "item/started",
+          params: { threadId: "thread-1" },
+        });
+      }
+      await Promise.resolve();
+    });
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(result.current.connectionState).toBe("live");
+  });
+
   it("cleans up stale reconnect subscribe when sequence advances", async () => {
     let resolveFirstSubscribe: (() => void) | null = null;
     const firstSubscribe = new Promise<void>((resolve) => {
diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.ts b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
index ea0b2bb38..18a96a9e5 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.ts
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
@@ -329,9 +329,8 @@ export function useRemoteThreadLiveConnection({
       if (threadId !== selectedThreadId) {
         return;
       }
-      if (connectionStateRef.current === "live") {
-        lastThreadEventAtRef.current = Date.now();
-      }
+      lastThreadEventAtRef.current = Date.now();
+      setState("live");
     });
 
     return () => {

From 274d092bc5e71ec3073970fe46a1e0db355efa44 Mon Sep 17 00:00:00 2001
From: Crabbotix <artus.operator@gmail.com>
Date: Thu, 19 Feb 2026 12:17:42 +0100
Subject: [PATCH 3/7] Stabilize remote reconnect trigger on workspace identity
 changes

---
 .../useRemoteThreadLiveConnection.test.tsx    | 48 +++++++++++++++++++
 .../hooks/useRemoteThreadLiveConnection.ts    | 17 +++++--
 2 files changed, 61 insertions(+), 4 deletions(-)

diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
index dce5031d1..1d4b2653e 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
@@ -372,4 +372,52 @@ describe("useRemoteThreadLiveConnection", () => {
 
     expect(threadLiveUnsubscribeMock).toHaveBeenCalledWith("ws-1", "thread-1");
   });
+
+  it("does not reconnect when workspace object identity changes but key is unchanged", async () => {
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+    const firstWorkspace = {
+      id: "ws-1",
+      name: "Workspace",
+      path: "/tmp/ws-1",
+      connected: true,
+      settings: { sidebarCollapsed: false },
+    };
+
+    const { rerender } = renderHook(
+      ({ workspace }) =>
+        useRemoteThreadLiveConnection({
+          backendMode: "remote",
+          activeWorkspace: workspace,
+          activeThreadId: "thread-1",
+          refreshThread,
+        }),
+      {
+        initialProps: { workspace: firstWorkspace },
+      },
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+    expect(refreshThread).toHaveBeenCalledTimes(1);
+
+    const secondWorkspace = {
+      id: "ws-1",
+      name: "Workspace (renamed)",
+      path: "/tmp/ws-1",
+      connected: true,
+      settings: { sidebarCollapsed: false },
+    };
+
+    await act(async () => {
+      rerender({ workspace: secondWorkspace });
+      await Promise.resolve();
+    });
+
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+    expect(threadLiveUnsubscribeMock).toHaveBeenCalledTimes(0);
+    expect(refreshThread).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.ts b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
index 18a96a9e5..b5a224b4b 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.ts
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
@@ -83,6 +83,8 @@ export function useRemoteThreadLiveConnection({
   refreshThread,
   reconnectWorkspace,
 }: UseRemoteThreadLiveConnectionOptions) {
+  const activeWorkspaceId = activeWorkspace?.id ?? null;
+  const activeWorkspaceConnected = activeWorkspace?.connected ?? false;
   const [connectionState, setConnectionState] =
     useState<RemoteThreadConnectionState>(() => {
       if (backendMode !== "remote") {
@@ -232,10 +234,9 @@ export function useRemoteThreadLiveConnection({
   );
 
   useEffect(() => {
-    const workspace = activeWorkspace;
     const nextKey =
-      backendMode === "remote" && workspace?.id && activeThreadId
-        ? keyForThread(workspace.id, activeThreadId)
+      backendMode === "remote" && activeWorkspaceId && activeThreadId
+        ? keyForThread(activeWorkspaceId, activeThreadId)
         : null;
     desiredSubscriptionKeyRef.current = nextKey;
     const previousKey = activeSubscriptionKeyRef.current;
@@ -258,10 +259,18 @@ export function useRemoteThreadLiveConnection({
       reconcileDisconnectedState();
       return;
     }
+    if (
+      activeSubscriptionKeyRef.current === nextKey &&
+      connectionStateRef.current !== "disconnected" &&
+      activeWorkspaceConnected
+    ) {
+      return;
+    }
     void reconnectLive(parsed.workspaceId, parsed.threadId, { runResume: true });
   }, [
     activeThreadId,
-    activeWorkspace,
+    activeWorkspaceConnected,
+    activeWorkspaceId,
     backendMode,
     reconcileDisconnectedState,
     reconnectLive,

From 16ee85758c69b5a3f66ccf27cb52a55e8e914bfc Mon Sep 17 00:00:00 2001
From: Crabbotix <artus.operator@gmail.com>
Date: Thu, 19 Feb 2026 23:27:21 +0100
Subject: [PATCH 4/7] Prevent self-detach reconnect loops and coalesce same-key
 reconnects

---
 .../useRemoteThreadLiveConnection.test.tsx    |  54 +++++++-
 .../hooks/useRemoteThreadLiveConnection.ts    | 120 ++++++++++++------
 2 files changed, 130 insertions(+), 44 deletions(-)

diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
index 1d4b2653e..fabfb3e30 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
@@ -282,7 +282,7 @@ describe("useRemoteThreadLiveConnection", () => {
     expect(threadLiveUnsubscribeMock).toHaveBeenCalledWith("ws-1", "thread-1");
   });
 
-  it("does not unsubscribe active thread when stale reconnect resolves late", async () => {
+  it("coalesces same-key reconnect while subscribe is in flight", async () => {
     let resolveFirstSubscribe: (() => void) | null = null;
     const firstSubscribe = new Promise<void>((resolve) => {
       resolveFirstSubscribe = resolve;
@@ -308,6 +308,7 @@ describe("useRemoteThreadLiveConnection", () => {
     );
 
     let firstReconnectPromise: Promise<boolean> = Promise.resolve(false);
+    let secondReconnectPromise: Promise<boolean> = Promise.resolve(false);
     await act(async () => {
       firstReconnectPromise = result.current.reconnectLive("ws-1", "thread-1", {
         runResume: false,
@@ -316,16 +317,17 @@ describe("useRemoteThreadLiveConnection", () => {
     });
 
     await act(async () => {
-      const secondReconnect = result.current.reconnectLive("ws-1", "thread-1", {
+      secondReconnectPromise = result.current.reconnectLive("ws-1", "thread-1", {
         runResume: false,
       });
       await Promise.resolve();
-      await secondReconnect;
     });
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
 
     await act(async () => {
       resolveFirstSubscribe?.();
       await firstReconnectPromise;
+      await secondReconnectPromise;
       await Promise.resolve();
     });
 
@@ -420,4 +422,50 @@ describe("useRemoteThreadLiveConnection", () => {
     expect(threadLiveUnsubscribeMock).toHaveBeenCalledTimes(0);
     expect(refreshThread).toHaveBeenCalledTimes(1);
   });
+
+  it("ignores self-triggered detached event during dedupe reconnect", async () => {
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+    const workspace = {
+      id: "ws-1",
+      name: "Workspace",
+      path: "/tmp/ws-1",
+      connected: true,
+      settings: { sidebarCollapsed: false },
+    };
+
+    const { result } = renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: workspace,
+        activeThreadId: "thread-1",
+        refreshThread,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+    expect(refreshThread).toHaveBeenCalledTimes(1);
+
+    threadLiveUnsubscribeMock.mockImplementationOnce(async (workspaceId, threadId) => {
+      for (const listener of appServerListeners) {
+        listener({
+          workspace_id: workspaceId,
+          method: "thread/live_detached",
+          params: { threadId },
+        });
+      }
+    });
+
+    await act(async () => {
+      await result.current.reconnectLive("ws-1", "thread-1", { runResume: false });
+      await Promise.resolve();
+    });
+
+    expect(threadLiveUnsubscribeMock).toHaveBeenCalledTimes(1);
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(2);
+    expect(refreshThread).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.ts b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
index b5a224b4b..beaf973ab 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.ts
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
@@ -14,6 +14,7 @@ export type RemoteThreadConnectionState = "live" | "polling" | "disconnected";
 export const REMOTE_LIVE_STALE_TIMEOUT_MS = 20_000;
 export const REMOTE_LIVE_RECONNECT_INTERVAL_MS = 5_000;
 const REMOTE_RECOVERY_TOAST_COOLDOWN_MS = 30_000;
+const SELF_DETACH_IGNORE_WINDOW_MS = 10_000;
 
 type ReconnectOptions = {
   runResume?: boolean;
@@ -105,6 +106,10 @@ export function useRemoteThreadLiveConnection({
   const connectionStateRef = useRef(connectionState);
   const activeSubscriptionKeyRef = useRef<string | null>(null);
   const desiredSubscriptionKeyRef = useRef<string | null>(null);
+  const ignoreDetachedEventsUntilRef = useRef<Map<string, number>>(new Map());
+  const inFlightReconnectRef = useRef<{ key: string; promise: Promise<boolean> } | null>(
+    null,
+  );
   const reconnectSequenceRef = useRef(0);
   const lastThreadEventAtRef = useRef<number>(0);
   const lastRecoveryToastAtRef = useRef<number>(0);
@@ -179,56 +184,78 @@ export function useRemoteThreadLiveConnection({
         return false;
       }
 
-      const sequence = reconnectSequenceRef.current + 1;
-      reconnectSequenceRef.current = sequence;
-      setState(activeWorkspaceRef.current.connected ? "polling" : "disconnected");
-
-      try {
-        const targetKey = keyForThread(workspaceId, threadId);
-        desiredSubscriptionKeyRef.current = targetKey;
-        if (
-          !activeWorkspaceRef.current.connected &&
-          reconnectWorkspaceRef.current &&
-          activeWorkspaceRef.current.id === workspaceId
-        ) {
-          await Promise.resolve(reconnectWorkspaceRef.current(activeWorkspaceRef.current));
-        }
-        if (sequence !== reconnectSequenceRef.current) {
-          return false;
-        }
+      const targetKey = keyForThread(workspaceId, threadId);
+      desiredSubscriptionKeyRef.current = targetKey;
+      if (inFlightReconnectRef.current?.key === targetKey) {
+        return inFlightReconnectRef.current.promise;
+      }
 
-        if (options?.runResume !== false) {
-          await Promise.resolve(refreshThreadRef.current(workspaceId, threadId));
-        }
-        if (sequence !== reconnectSequenceRef.current) {
-          return false;
-        }
+      const reconnectPromise = (async (): Promise<boolean> => {
+        const sequence = reconnectSequenceRef.current + 1;
+        reconnectSequenceRef.current = sequence;
+        const workspaceAtStart = activeWorkspaceRef.current;
+        setState(workspaceAtStart?.connected ? "polling" : "disconnected");
+
+        try {
+          desiredSubscriptionKeyRef.current = targetKey;
+          const workspaceEntry = activeWorkspaceRef.current;
+          if (
+            workspaceEntry &&
+            !workspaceEntry.connected &&
+            reconnectWorkspaceRef.current &&
+            workspaceEntry.id === workspaceId
+          ) {
+            await Promise.resolve(reconnectWorkspaceRef.current(workspaceEntry));
+          }
+          if (sequence !== reconnectSequenceRef.current) {
+            return false;
+          }
 
-        if (activeSubscriptionKeyRef.current === targetKey) {
-          await threadLiveUnsubscribe(workspaceId, threadId).catch(() => {
-            // Best-effort dedupe: ignore unsubscribe failures before reattach.
-          });
-          activeSubscriptionKeyRef.current = null;
-        }
-        await threadLiveSubscribe(workspaceId, threadId);
-        if (sequence !== reconnectSequenceRef.current) {
-          if (desiredSubscriptionKeyRef.current !== targetKey) {
+          if (options?.runResume !== false) {
+            await Promise.resolve(refreshThreadRef.current(workspaceId, threadId));
+          }
+          if (sequence !== reconnectSequenceRef.current) {
+            return false;
+          }
+
+          if (activeSubscriptionKeyRef.current === targetKey) {
+            ignoreDetachedEventsUntilRef.current.set(
+              targetKey,
+              Date.now() + SELF_DETACH_IGNORE_WINDOW_MS,
+            );
             await threadLiveUnsubscribe(workspaceId, threadId).catch(() => {
-              // Best-effort cleanup for stale reconnect attempts.
+              // Best-effort dedupe: ignore unsubscribe failures before reattach.
             });
+            activeSubscriptionKeyRef.current = null;
+          }
+          await threadLiveSubscribe(workspaceId, threadId);
+          if (sequence !== reconnectSequenceRef.current) {
+            if (desiredSubscriptionKeyRef.current !== targetKey) {
+              await threadLiveUnsubscribe(workspaceId, threadId).catch(() => {
+                // Best-effort cleanup for stale reconnect attempts.
+              });
+            }
+            return false;
+          }
+
+          activeSubscriptionKeyRef.current = targetKey;
+          setState("polling");
+          return true;
+        } catch {
+          if (sequence === reconnectSequenceRef.current) {
+            reconcileDisconnectedState();
           }
           return false;
         }
+      })();
 
-        activeSubscriptionKeyRef.current = targetKey;
-        setState("polling");
-        return true;
-      } catch {
-        if (sequence === reconnectSequenceRef.current) {
-          reconcileDisconnectedState();
+      inFlightReconnectRef.current = { key: targetKey, promise: reconnectPromise };
+      reconnectPromise.finally(() => {
+        if (inFlightReconnectRef.current?.promise === reconnectPromise) {
+          inFlightReconnectRef.current = null;
         }
-        return false;
-      }
+      });
+      return reconnectPromise;
     },
     [reconcileDisconnectedState, setState],
   );
@@ -311,6 +338,16 @@ export function useRemoteThreadLiveConnection({
       if (method === "thread/live_detached") {
         const threadId = extractThreadId(method, params);
         if (threadId === selectedThreadId) {
+          const threadKey = keyForThread(activeWorkspaceId, threadId);
+          const ignoreDetachedUntil =
+            ignoreDetachedEventsUntilRef.current.get(threadKey) ?? 0;
+          if (ignoreDetachedUntil > 0 && ignoreDetachedUntil >= Date.now()) {
+            ignoreDetachedEventsUntilRef.current.delete(threadKey);
+            return;
+          }
+          if (ignoreDetachedUntil > 0) {
+            ignoreDetachedEventsUntilRef.current.delete(threadKey);
+          }
           activeSubscriptionKeyRef.current = null;
           reconcileDisconnectedState();
           if (isDocumentVisible() && isWindowFocused()) {
@@ -482,6 +519,7 @@ export function useRemoteThreadLiveConnection({
       window.removeEventListener("blur", handleBlur);
       document.removeEventListener("visibilitychange", handleVisibilityChange);
       desiredSubscriptionKeyRef.current = null;
+      ignoreDetachedEventsUntilRef.current.clear();
       const currentKey = activeSubscriptionKeyRef.current;
       if (currentKey) {
         activeSubscriptionKeyRef.current = null;

From b3406334a85cf385c81f2df0755ac8302c185d32 Mon Sep 17 00:00:00 2001
From: Thomas Ricouard <ricouard77@gmail.com>
Date: Fri, 20 Feb 2026 09:41:42 +0100
Subject: [PATCH 5/7] fix(sidebar): remove workspace processing activity
 indicator

---
 src-tauri/gen/apple/codex-monitor_iOS/Info.plist |  2 +-
 src/features/app/components/Sidebar.test.tsx     |  7 +++----
 src/features/app/components/Sidebar.tsx          |  8 --------
 src/features/app/components/WorkspaceCard.tsx    |  9 ---------
 src/styles/sidebar.css                           | 14 --------------
 5 files changed, 4 insertions(+), 36 deletions(-)

diff --git a/src-tauri/gen/apple/codex-monitor_iOS/Info.plist b/src-tauri/gen/apple/codex-monitor_iOS/Info.plist
index 19fc573c5..f132f0d0a 100644
--- a/src-tauri/gen/apple/codex-monitor_iOS/Info.plist
+++ b/src-tauri/gen/apple/codex-monitor_iOS/Info.plist
@@ -49,4 +49,4 @@
 	<key>NSMicrophoneUsageDescription</key>
 	<string>Allow access to the microphone for dictation.</string>
 </dict>
-</plist>
+</plist>
\ No newline at end of file
diff --git a/src/features/app/components/Sidebar.test.tsx b/src/features/app/components/Sidebar.test.tsx
index 48515331c..ac41e4f47 100644
--- a/src/features/app/components/Sidebar.test.tsx
+++ b/src/features/app/components/Sidebar.test.tsx
@@ -243,7 +243,7 @@ describe("Sidebar", () => {
     expect(onSelectWorkspace).toHaveBeenCalledWith("ws-1");
   });
 
-  it("shows a workspace activity indicator when a thread is processing", () => {
+  it("does not show a workspace activity indicator when a thread is processing", () => {
     render(
       <Sidebar
         {...baseProps}
@@ -286,8 +286,7 @@ describe("Sidebar", () => {
       />,
     );
 
-    const indicator = screen.getByTitle("Streaming updates in progress");
-    expect(indicator.className).toContain("workspace-activity-indicator");
-    expect(indicator.className).toContain("is-processing");
+    const indicator = screen.queryByTitle("Streaming updates in progress");
+    expect(indicator).toBeNull();
   });
 });
diff --git a/src/features/app/components/Sidebar.tsx b/src/features/app/components/Sidebar.tsx
index 70fb7fe5a..e0813f826 100644
--- a/src/features/app/components/Sidebar.tsx
+++ b/src/features/app/components/Sidebar.tsx
@@ -556,13 +556,6 @@ export const Sidebar = memo(function Sidebar({
                     isLoadingThreads && threads.length === 0;
                   const isPaging = threadListPagingByWorkspace[entry.id] ?? false;
                   const worktrees = worktreesByParent.get(entry.id) ?? [];
-                  const workspaceIdsWithChildren = [entry.id, ...worktrees.map((child) => child.id)];
-                  const hasProcessingActivity = workspaceIdsWithChildren.some((workspaceId) => {
-                    const workspaceThreads = threadsByWorkspace[workspaceId] ?? [];
-                    return workspaceThreads.some(
-                      (thread) => threadStatusById[thread.id]?.isProcessing,
-                    );
-                  });
                   const addMenuOpen = addMenuAnchor?.workspaceId === entry.id;
                   const isDraftNewAgent = newAgentDraftWorkspaceId === entry.id;
                   const isDraftRowActive =
@@ -583,7 +576,6 @@ export const Sidebar = memo(function Sidebar({
                       isCollapsed={isCollapsed}
                       addMenuOpen={addMenuOpen}
                       addMenuWidth={ADD_MENU_WIDTH}
-                      hasProcessingActivity={hasProcessingActivity}
                       onSelectWorkspace={onSelectWorkspace}
                       onShowWorkspaceMenu={showWorkspaceMenu}
                       onToggleWorkspaceCollapse={onToggleWorkspaceCollapse}
diff --git a/src/features/app/components/WorkspaceCard.tsx b/src/features/app/components/WorkspaceCard.tsx
index b319eee02..58eaa86b1 100644
--- a/src/features/app/components/WorkspaceCard.tsx
+++ b/src/features/app/components/WorkspaceCard.tsx
@@ -9,7 +9,6 @@ type WorkspaceCardProps = {
   isCollapsed: boolean;
   addMenuOpen: boolean;
   addMenuWidth: number;
-  hasProcessingActivity?: boolean;
   onSelectWorkspace: (id: string) => void;
   onShowWorkspaceMenu: (event: MouseEvent, workspaceId: string) => void;
   onToggleWorkspaceCollapse: (workspaceId: string, collapsed: boolean) => void;
@@ -30,7 +29,6 @@ export function WorkspaceCard({
   isCollapsed,
   addMenuOpen,
   addMenuWidth,
-  hasProcessingActivity = false,
   onSelectWorkspace,
   onShowWorkspaceMenu,
   onToggleWorkspaceCollapse,
@@ -59,13 +57,6 @@ export function WorkspaceCard({
           <div className="workspace-name-row">
             <div className="workspace-title">
               <span className="workspace-name">{workspaceName ?? workspace.name}</span>
-              {hasProcessingActivity && (
-                <span
-                  className="workspace-activity-indicator is-processing"
-                  aria-hidden
-                  title="Streaming updates in progress"
-                />
-              )}
               <button
                 className={`workspace-toggle ${isCollapsed ? "" : "expanded"}`}
                 onClick={(event) => {
diff --git a/src/styles/sidebar.css b/src/styles/sidebar.css
index 1e2ce81e8..434dc11ba 100644
--- a/src/styles/sidebar.css
+++ b/src/styles/sidebar.css
@@ -739,20 +739,6 @@
   min-width: 0;
 }
 
-.workspace-activity-indicator {
-  width: 8px;
-  height: 8px;
-  border-radius: 999px;
-  display: inline-block;
-  flex-shrink: 0;
-}
-
-.workspace-activity-indicator.is-processing {
-  background: #ff9f43;
-  box-shadow: 0 0 10px rgba(255, 159, 67, 0.8);
-  animation: pulse 1.2s ease-in-out infinite;
-}
-
 .workspace-toggle {
   border: none;
   background: transparent;

From 67a145cac718fcd7d32bda4ed9ab50839e315f77 Mon Sep 17 00:00:00 2001
From: Thomas Ricouard <ricouard77@gmail.com>
Date: Fri, 20 Feb 2026 09:46:45 +0100
Subject: [PATCH 6/7] fix: invalidate stale remote reconnect when blur/focus
 changes

---
 .../useRemoteThreadLiveConnection.test.tsx    | 59 +++++++++++++++++++
 .../hooks/useRemoteThreadLiveConnection.ts    | 24 ++++++--
 2 files changed, 77 insertions(+), 6 deletions(-)

diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
index fabfb3e30..453e40b7b 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
@@ -375,6 +375,65 @@ describe("useRemoteThreadLiveConnection", () => {
     expect(threadLiveUnsubscribeMock).toHaveBeenCalledWith("ws-1", "thread-1");
   });
 
+  it("starts a fresh reconnect after blur cancels same-key in-flight attempt", async () => {
+    let resolveFirstSubscribe: (() => void) | null = null;
+    const firstSubscribe = new Promise<void>((resolve) => {
+      resolveFirstSubscribe = resolve;
+    });
+    threadLiveSubscribeMock
+      .mockImplementationOnce(() => firstSubscribe)
+      .mockResolvedValue(undefined);
+    const refreshThread = vi.fn().mockResolvedValue(undefined);
+
+    const { result } = renderHook(() =>
+      useRemoteThreadLiveConnection({
+        backendMode: "remote",
+        activeWorkspace: {
+          id: "ws-1",
+          name: "Workspace",
+          path: "/tmp/ws-1",
+          connected: true,
+          settings: { sidebarCollapsed: false },
+        },
+        activeThreadId: null,
+        refreshThread,
+      }),
+    );
+
+    let firstReconnectPromise: Promise<boolean> = Promise.resolve(false);
+    await act(async () => {
+      firstReconnectPromise = result.current.reconnectLive("ws-1", "thread-1", {
+        runResume: false,
+      });
+      await Promise.resolve();
+    });
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      window.dispatchEvent(new Event("blur"));
+      await Promise.resolve();
+    });
+
+    let secondReconnectPromise: Promise<boolean> = Promise.resolve(false);
+    await act(async () => {
+      secondReconnectPromise = result.current.reconnectLive("ws-1", "thread-1", {
+        runResume: false,
+      });
+      await Promise.resolve();
+    });
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(2);
+
+    await act(async () => {
+      await expect(secondReconnectPromise).resolves.toBe(true);
+    });
+
+    await act(async () => {
+      resolveFirstSubscribe?.();
+      await expect(firstReconnectPromise).resolves.toBe(false);
+      await Promise.resolve();
+    });
+  });
+
   it("does not reconnect when workspace object identity changes but key is unchanged", async () => {
     const refreshThread = vi.fn().mockResolvedValue(undefined);
     const firstWorkspace = {
diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.ts b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
index beaf973ab..224950160 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.ts
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
@@ -107,9 +107,11 @@ export function useRemoteThreadLiveConnection({
   const activeSubscriptionKeyRef = useRef<string | null>(null);
   const desiredSubscriptionKeyRef = useRef<string | null>(null);
   const ignoreDetachedEventsUntilRef = useRef<Map<string, number>>(new Map());
-  const inFlightReconnectRef = useRef<{ key: string; promise: Promise<boolean> } | null>(
-    null,
-  );
+  const inFlightReconnectRef = useRef<{
+    key: string;
+    sequence: number;
+    promise: Promise<boolean>;
+  } | null>(null);
   const reconnectSequenceRef = useRef(0);
   const lastThreadEventAtRef = useRef<number>(0);
   const lastRecoveryToastAtRef = useRef<number>(0);
@@ -186,8 +188,13 @@ export function useRemoteThreadLiveConnection({
 
       const targetKey = keyForThread(workspaceId, threadId);
       desiredSubscriptionKeyRef.current = targetKey;
-      if (inFlightReconnectRef.current?.key === targetKey) {
-        return inFlightReconnectRef.current.promise;
+      const inFlightReconnect = inFlightReconnectRef.current;
+      if (inFlightReconnect?.key === targetKey) {
+        if (inFlightReconnect.sequence === reconnectSequenceRef.current) {
+          return inFlightReconnect.promise;
+        }
+        // A newer sequence (blur/focus/key change) has invalidated this attempt.
+        inFlightReconnectRef.current = null;
       }
 
       const reconnectPromise = (async (): Promise<boolean> => {
@@ -249,7 +256,12 @@ export function useRemoteThreadLiveConnection({
         }
       })();
 
-      inFlightReconnectRef.current = { key: targetKey, promise: reconnectPromise };
+      const reconnectSequence = reconnectSequenceRef.current;
+      inFlightReconnectRef.current = {
+        key: targetKey,
+        sequence: reconnectSequence,
+        promise: reconnectPromise,
+      };
       reconnectPromise.finally(() => {
         if (inFlightReconnectRef.current?.promise === reconnectPromise) {
           inFlightReconnectRef.current = null;

From 8d99ef1a82060399ea97c0001c9104c58137b194 Mon Sep 17 00:00:00 2001
From: Thomas Ricouard <ricouard77@gmail.com>
Date: Fri, 20 Feb 2026 09:49:33 +0100
Subject: [PATCH 7/7] fix: stop idle-time stale reconnect from remote live
 subscriptions

---
 .../useRemoteThreadLiveConnection.test.tsx    |  9 +--
 .../hooks/useRemoteThreadLiveConnection.ts    | 56 -------------------
 2 files changed, 5 insertions(+), 60 deletions(-)

diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
index 453e40b7b..66ffb309e 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.test.tsx
@@ -68,7 +68,7 @@ describe("useRemoteThreadLiveConnection", () => {
     vi.useRealTimers();
   });
 
-  it("reconnects when live stream goes stale after daemon interruption", async () => {
+  it("does not reconnect during normal idle period without detach signal", async () => {
     const refreshThread = vi.fn().mockResolvedValue(undefined);
 
     renderHook(() =>
@@ -110,9 +110,10 @@ describe("useRemoteThreadLiveConnection", () => {
       await Promise.resolve();
     });
 
-    expect(threadLiveSubscribeMock.mock.calls.length).toBeGreaterThanOrEqual(2);
-    expect(threadLiveUnsubscribeMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-    expect(refreshThread.mock.calls.length).toBeGreaterThanOrEqual(2);
+    expect(threadLiveSubscribeMock).toHaveBeenCalledTimes(1);
+    expect(threadLiveUnsubscribeMock).toHaveBeenCalledTimes(0);
+    expect(refreshThread).toHaveBeenCalledTimes(1);
+    expect(pushErrorToastMock).not.toHaveBeenCalled();
   });
 
   it("reconnects when thread live stream detaches while visible", async () => {
diff --git a/src/features/app/hooks/useRemoteThreadLiveConnection.ts b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
index 224950160..68db37c88 100644
--- a/src/features/app/hooks/useRemoteThreadLiveConnection.ts
+++ b/src/features/app/hooks/useRemoteThreadLiveConnection.ts
@@ -2,7 +2,6 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { subscribeAppServerEvents } from "@services/events";
 import { threadLiveSubscribe, threadLiveUnsubscribe } from "@services/tauri";
-import { pushErrorToast } from "@services/toasts";
 import {
   getAppServerParams,
   getAppServerRawMethod,
@@ -11,9 +10,6 @@ import type { WorkspaceInfo } from "@/types";
 
 export type RemoteThreadConnectionState = "live" | "polling" | "disconnected";
 
-export const REMOTE_LIVE_STALE_TIMEOUT_MS = 20_000;
-export const REMOTE_LIVE_RECONNECT_INTERVAL_MS = 5_000;
-const REMOTE_RECOVERY_TOAST_COOLDOWN_MS = 30_000;
 const SELF_DETACH_IGNORE_WINDOW_MS = 10_000;
 
 type ReconnectOptions = {
@@ -113,8 +109,6 @@ export function useRemoteThreadLiveConnection({
     promise: Promise<boolean>;
   } | null>(null);
   const reconnectSequenceRef = useRef(0);
-  const lastThreadEventAtRef = useRef<number>(0);
-  const lastRecoveryToastAtRef = useRef<number>(0);
 
   useEffect(() => {
     backendModeRef.current = backendMode;
@@ -374,7 +368,6 @@ export function useRemoteThreadLiveConnection({
       if (method === "thread/live_heartbeat") {
         const threadId = extractThreadId(method, params);
         if (threadId === selectedThreadId) {
-          lastThreadEventAtRef.current = Date.now();
           setState("live");
         }
         return;
@@ -387,7 +380,6 @@ export function useRemoteThreadLiveConnection({
       if (threadId !== selectedThreadId) {
         return;
       }
-      lastThreadEventAtRef.current = Date.now();
       setState("live");
     });
 
@@ -396,54 +388,6 @@ export function useRemoteThreadLiveConnection({
     };
   }, [reconnectLive, reconcileDisconnectedState, setState]);
 
-  useEffect(() => {
-    if (backendMode !== "remote") {
-      return;
-    }
-    const timer = setInterval(() => {
-      if (!isDocumentVisible() || !isWindowFocused()) {
-        return;
-      }
-      const workspaceId = activeWorkspaceRef.current?.id ?? null;
-      const threadId = activeThreadIdRef.current;
-      if (!workspaceId || !threadId) {
-        return;
-      }
-      const now = Date.now();
-      const lastEventAt = lastThreadEventAtRef.current;
-      const staleLive =
-        connectionStateRef.current === "live" &&
-        lastEventAt > 0 &&
-        now - lastEventAt >= REMOTE_LIVE_STALE_TIMEOUT_MS;
-      if (!staleLive) {
-        return;
-      }
-      const toastNow = Date.now();
-      if (
-        toastNow - lastRecoveryToastAtRef.current >=
-        REMOTE_RECOVERY_TOAST_COOLDOWN_MS
-      ) {
-        lastRecoveryToastAtRef.current = toastNow;
-        pushErrorToast({
-          title: "Server connection interrupted",
-          message:
-            "Live updates paused (likely daemon restart). Reconnecting automatically.",
-          durationMs: 5000,
-        });
-      }
-      setState("polling");
-      void (async () => {
-        await reconnectLive(workspaceId, threadId, {
-          runResume: true,
-        });
-      })();
-    }, REMOTE_LIVE_RECONNECT_INTERVAL_MS);
-
-    return () => {
-      clearInterval(timer);
-    };
-  }, [backendMode, reconnectLive, setState]);
-
   useEffect(() => {
     let unlistenWindowFocus: (() => void) | null = null;
     let unlistenWindowBlur: (() => void) | null = null;