fix: recover observer runtimes after reload

Author: pallyoung

apps/web/src/features/app/WorkbenchRuntimeCoordinator.tsx

@@ -48,6 +48,7 @@ import {
   collectControlledWorkspaceReleasePayloads,
   getOrCreateClientId as getWorkspaceClientId,
   getOrCreateDeviceId as getWorkspaceDeviceId,
+  shouldRecoverWorkspaceController,
 } from "../workspace/workspace-controller";
 import { attachWorkspaceRuntimeWithRetry } from "../workspace/runtime-attach";
 import { createWorkspaceSessionActions } from "../workspace/session-actions";
@@ -509,10 +510,7 @@ export const WorkbenchRuntimeCoordinator = ({
     () => state.tabs
       .filter((tab) =>
         tab.status === "ready"
-        && tab.controller.role === "observer"
-        && !tab.controller.controllerDeviceId
-        && !tab.controller.controllerClientId
-        && !tab.controller.takeoverPending,
+        && shouldRecoverWorkspaceController(tab.controller),
       )
       .map((tab) => tab.id)
       .join("|"),
@@ -527,14 +525,13 @@ export const WorkbenchRuntimeCoordinator = ({
     const recoverableWorkspaceIds = () => stateRef.current.tabs
       .filter((tab) =>
         tab.status === "ready"
-        && tab.controller.role === "observer"
-        && !tab.controller.controllerDeviceId
-        && !tab.controller.controllerClientId
-        && !tab.controller.takeoverPending,
+        && shouldRecoverWorkspaceController(tab.controller),
       )
       .map((tab) => tab.id);
 
     const recoverControllers = () => {
+      // Observer tabs can miss an initial runtime attach/controller event during reloads.
+      // Reattaching until the tab converges keeps recovery/replay flows stable across slower environments.
       void Promise.all(recoverableWorkspaceIds().map(async (workspaceId) => {
         await reattachWorkspaceRuntime(workspaceId);
       }));

apps/web/src/features/workspace/WorkspaceScreen.tsx

@@ -1700,8 +1700,33 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
   };
 
   const onRecoverActiveSession = async () => {
-    const currentTab = stateRef.current.tabs.find((tab) => tab.id === activeTab.id) ?? activeTab;
-    const session = currentTab.sessions.find((item) => item.id === activePaneSession.id) ?? activePaneSession;
+    let currentTab = stateRef.current.tabs.find((tab) => tab.id === activeTab.id) ?? activeTab;
+    let session = currentTab.sessions.find((item) => item.id === activePaneSession.id) ?? activePaneSession;
+    const runtimeSnapshot = await attachWorkspaceRuntimeWithRetry(
+      currentTab.id,
+      deviceId,
+      clientId,
+      withServiceFallback,
+    );
+    if (runtimeSnapshot) {
+      let nextTab: Tab | null = null;
+      updateState((current) => {
+        const next = applyWorkspaceRuntimeSnapshot(
+          current,
+          runtimeSnapshot,
+          locale,
+          appSettings,
+          deviceId,
+          clientId,
+        );
+        nextTab = next.tabs.find((tab) => tab.id === currentTab.id) ?? null;
+        return next;
+      });
+      if (nextTab) {
+        currentTab = nextTab;
+        session = nextTab.sessions.find((item) => item.id === session.id) ?? session;
+      }
+    }
     const recoveryAction = resolveAgentRecoveryAction(currentTab.controller, session);
     if (!recoveryAction) return;
     setAgentRecoveryBusy({

apps/web/src/features/workspace/workspace-controller.ts

@@ -163,3 +163,7 @@ export const canMutateWorkspace = (
   controller: WorkspaceControllerState | null | undefined,
   _action: WorkspaceMutationAction,
 ) => controller?.role === "controller";
+
+export const shouldRecoverWorkspaceController = (
+  controller: WorkspaceControllerState | null | undefined,
+) => controller?.role === "observer" && !controller.takeoverPending;

tests/workspace-runtime-controller.test.ts

@@ -7,6 +7,7 @@ import {
   createWorkspaceControllerRpcPayload,
   createWorkspaceControllerState,
   createWorkspaceControllerStateFromLease,
+  shouldRecoverWorkspaceController,
 } from "../apps/web/src/features/workspace/workspace-controller.ts";
 import {
   applyWorkspaceControllerEvent,
@@ -127,6 +128,20 @@ test("same device with a different client stays observer", () => {
   assert.equal(controller.role, "observer");
 });
 
+test("observer controllers remain recoverable while takeover is not pending", () => {
+  const controller = createWorkspaceControllerState({
+    role: "observer",
+    deviceId: "device-a",
+    clientId: "client-b",
+    controllerDeviceId: "device-a",
+    controllerClientId: "client-a",
+    fencingToken: 1,
+    takeoverPending: false,
+  });
+
+  assert.equal(shouldRecoverWorkspaceController(controller), true);
+});
+
 test("controller mutation payload carries device, client, and fencing token", () => {
   const controller = createWorkspaceControllerState({
     role: "controller",