test: stabilize transport reload and resume assertions

Author: pallyoung

apps/server/src/services/workspace_runtime.rs

@@ -813,4 +813,80 @@ mod tests {
         assert_eq!(runtime.lifecycle_events[0].source_event, "PreToolUse");
         assert_eq!(runtime.lifecycle_events[0].seq, 1);
     }
+
+    #[test]
+    fn workspace_runtime_attach_keeps_created_session_view_and_claude_id() {
+        let app = test_app();
+        let workspace_id = launch_test_workspace(&app, "/tmp/ws-runtime-session-view-test");
+        let session = create_workspace_session(app.state(), &workspace_id, SessionMode::Branch)
+            .expect("session should be created");
+
+        patch_workspace_view_state(
+            app.state(),
+            &workspace_id,
+            WorkspaceViewPatch {
+                active_session_id: Some(session.id.to_string()),
+                active_pane_id: Some(format!("pane-{}", session.id)),
+                active_terminal_id: None,
+                pane_layout: Some(json!({
+                    "type": "leaf",
+                    "id": format!("pane-{}", session.id),
+                    "sessionId": session.id.to_string(),
+                })),
+                file_preview: None,
+            },
+        )
+        .expect("view state should be updated");
+        update_workspace_session(
+            app.state(),
+            &workspace_id,
+            session.id,
+            SessionPatch {
+                title: None,
+                status: Some(SessionStatus::Interrupted),
+                mode: None,
+                auto_feed: None,
+                queue: None,
+                messages: None,
+                stream: None,
+                unread: None,
+                last_active_at: None,
+                claude_session_id: Some("claude-runtime-attach".to_string()),
+            },
+        )
+        .expect("session should be updated");
+
+        let runtime = workspace_runtime_attach(
+            workspace_id,
+            "device-a".to_string(),
+            "client-a".to_string(),
+            app.clone(),
+            app.state(),
+        )
+        .expect("runtime attach should succeed");
+
+        let restored = runtime
+            .snapshot
+            .sessions
+            .iter()
+            .find(|candidate| candidate.id == session.id)
+            .expect("created session should be present");
+        assert_eq!(restored.status, SessionStatus::Interrupted);
+        assert_eq!(
+            restored.claude_session_id.as_deref(),
+            Some("claude-runtime-attach")
+        );
+        assert_eq!(
+            runtime.snapshot.view_state.active_session_id,
+            session.id.to_string()
+        );
+        assert_eq!(
+            runtime.snapshot.view_state.active_pane_id,
+            format!("pane-{}", session.id)
+        );
+        assert_eq!(
+            runtime.snapshot.view_state.pane_layout["sessionId"].as_str(),
+            Some(session.id.to_string().as_str())
+        );
+    }
 }

tests/e2e/transport.spec.ts

@@ -542,7 +542,6 @@ test.describe('workspace transport baseline', () => {
       await page.reload();
       await waitForWorkspaceTopbar(page);
       await waitForBackendSocket(page);
-      const sessionCard = page.locator(`.agent-pane-card[data-session-id="${session.id}"]`).first();
       const controllerAfterReload = await currentWorkspaceController(page, workspace.workspaceId, ids);
       await invokeRpc(page, 'agent_start', {
         ...controllerAfterReload,
@@ -562,18 +561,31 @@ test.describe('workspace transport baseline', () => {
       await waitForWorkspaceTopbar(page);
       await waitForBackendSocket(page);
       const runtimeAfterReload = await invokeRpc<{
+        snapshot: {
+          sessions: Array<{ id: number }>;
+          view_state: {
+            active_session_id: string;
+            active_pane_id: string;
+          };
+        };
         lifecycle_events?: Array<{ session_id: string; kind: string }>;
       }>(page, 'workspace_runtime_attach', {
         workspaceId: workspace.workspaceId,
         deviceId: ids.deviceId,
         clientId: ids.clientId,
       });
+      expect(runtimeAfterReload.snapshot.sessions.some((candidate) => candidate.id === session.id)).toBe(true);
+      expect(runtimeAfterReload.snapshot.view_state.active_session_id).toBe(String(session.id));
+      expect(runtimeAfterReload.snapshot.view_state.active_pane_id).toBe(`pane-${session.id}`);
       expect(runtimeAfterReload.lifecycle_events?.some((event) =>
         event.session_id === String(session.id) && event.kind === 'tool_started'
       )).toBe(true);
       let lastReloadStatus: string | null = null;
       await expect.poll(async () => {
-        lastReloadStatus = await sessionCard.getAttribute('data-session-status');
+        lastReloadStatus = await page
+          .locator(`.agent-pane-card[data-session-id="${session.id}"]`)
+          .first()
+          .getAttribute('data-session-status');
         return lastReloadStatus === 'running' || lastReloadStatus === 'background';
       }, {
         timeout: 20000,
@@ -923,25 +935,18 @@ test.describe('workspace transport baseline', () => {
       await expect(page.getByTestId('workspace-agent-recovery-banner')).toBeVisible({
         timeout: 10000,
       });
+      await expect(page.getByTestId('workspace-agent-recovery-action')).toHaveText('Resume agent');
       await page.getByTestId('workspace-agent-recovery-action').click();
 
-      await waitForWsEvent(
-        page,
-        'agent://event',
-        (payload) =>
-          payload.workspace_id === workspace.workspaceId
-          && payload.session_id === String(session.id)
-          && typeof payload.data === 'string'
-          && payload.data.includes(`--resume ${resumeClaudeSessionId}`),
-        TRANSPORT_EVENT_TIMEOUT_MS,
-      );
       await waitForWsEvent(
         page,
         'agent://lifecycle',
         (payload) =>
           payload.workspace_id === workspace.workspaceId
           && payload.session_id === String(session.id)
-          && payload.kind === 'tool_started',
+          && payload.kind === 'tool_started'
+          && typeof payload.data === 'string'
+          && payload.data.includes(resumeClaudeSessionId),
         TRANSPORT_EVENT_TIMEOUT_MS,
       );