fix: stabilize runtime reload hydration on slow runners

Author: pallyoung

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

@@ -69,6 +69,9 @@ const CONTROLLER_RECOVERY_INTERVAL_MS = 1_000;
 const HIDDEN_CONTROLLER_RECOVERY_INTERVAL_MS = 5_000;
 const TAKEOVER_POLL_INTERVAL_MS = 2_000;
 const HIDDEN_TAKEOVER_POLL_INTERVAL_MS = 5_000;
+// Reloads can briefly land on a stale bootstrap snapshot before runtime replay settles,
+// especially on slower CI runners. Reattaching ready tabs a few times closes that gap.
+const READY_TAB_RUNTIME_RECOVERY_DELAYS_MS = [0, 1_000, 3_000, 7_000] as const;
 
 type WorkbenchRuntimeCoordinatorProps = {
   appSettings: AppSettings;
@@ -465,18 +468,35 @@ export const WorkbenchRuntimeCoordinator = ({
   );
 
   useEffect(() => {
-    if (!attachedWorkspaceFingerprint) {
+    if (!attachedWorkspaceFingerprint || !isOnline) {
       return;
     }
 
-    const workspaceIds = state.tabs
-      .filter((tab) => tab.status === "ready")
-      .map((tab) => tab.id);
+    let cancelled = false;
+    const recoverReadyTabs = () => {
+      if (cancelled) {
+        return;
+      }
+      const workspaceIds = stateRef.current.tabs
+        .filter((tab) => tab.status === "ready")
+        .map((tab) => tab.id);
+      void Promise.all(workspaceIds.map(async (workspaceId) => {
+        await reattachWorkspaceRuntime(workspaceId);
+      }));
+    };
 
-    void Promise.all(workspaceIds.map(async (workspaceId) => {
-      await reattachWorkspaceRuntime(workspaceId);
-    }));
-  }, [attachedWorkspaceFingerprint, reattachWorkspaceRuntime]);
+    recoverReadyTabs();
+    const timers = READY_TAB_RUNTIME_RECOVERY_DELAYS_MS
+      .filter((delayMs) => delayMs > 0)
+      .map((delayMs) => window.setTimeout(recoverReadyTabs, delayMs));
+
+    return () => {
+      cancelled = true;
+      timers.forEach((timer) => {
+        window.clearTimeout(timer);
+      });
+    };
+  }, [attachedWorkspaceFingerprint, isOnline, reattachWorkspaceRuntime]);
 
   const controllerHeartbeatFingerprint = useMemo(
     () => state.tabs

tests/e2e/transport.spec.ts

@@ -938,15 +938,15 @@ test.describe('workspace transport baseline', () => {
       await expect(page.getByTestId('workspace-agent-recovery-action')).toHaveText('Resume agent');
       await page.getByTestId('workspace-agent-recovery-action').click();
 
-      await waitForWsEvent(
+      await waitForLifecycleReplayEntry(
         page,
-        'agent://lifecycle',
-        (payload) =>
-          payload.workspace_id === workspace.workspaceId
-          && payload.session_id === String(session.id)
-          && payload.kind === 'tool_started'
-          && typeof payload.data === 'string'
-          && payload.data.includes(resumeClaudeSessionId),
+        workspace.workspaceId,
+        ids,
+        (event) =>
+          event.session_id === String(session.id)
+          && event.kind === 'tool_started'
+          && typeof event.data === 'string'
+          && event.data.includes(resumeClaudeSessionId),
         TRANSPORT_EVENT_TIMEOUT_MS,
       );
 
@@ -1702,6 +1702,29 @@ async function waitForLifecycleReplayEvent(
     .toBe(true);
 }
 
+async function waitForLifecycleReplayEntry(
+  page: Page,
+  workspaceId: string,
+  ids: { deviceId: string; clientId: string },
+  predicate: (event: { session_id: string; kind: string; data?: string }) => boolean,
+  timeoutMs = 10000,
+) {
+  await expect
+    .poll(async () => {
+      const runtime = await invokeRpc<{
+        lifecycle_events?: Array<{ session_id: string; kind: string; data?: string }>;
+      }>(page, 'workspace_runtime_attach', {
+        workspaceId,
+        deviceId: ids.deviceId,
+        clientId: ids.clientId,
+      });
+      return runtime.lifecycle_events?.some(predicate) ?? false;
+    }, {
+      timeout: timeoutMs,
+    })
+    .toBe(true);
+}
+
 async function countWsEvents(
   page: Page,
   eventName: string,