🤖 fix: add timeout to workspace list post-compaction state fetching (#1250)

## Problem

When the `POST_COMPACTION_CONTEXT` experiment is enabled, the
`workspace.list()` API call blocks for up to **2 minutes per SSH
workspace** if SSH hosts are unreachable. This causes the app to hang on
"Loading workspaces..." forever.

**Root cause:** `getPostCompactionState()` calls `fileExists()` which
calls `runtime.stat()`, which for SSH runtimes waits on the connection
pool with a 2-minute default timeout. The existing `catch` block only
fires *after* the timeout expires.

## Solution

Add a 3-second timeout wrapper around each `getPostCompactionState()`
call in `list()`. If the timeout expires, the workspace is returned
without post-compaction state (matching existing error-case behavior).

This ensures app startup completes quickly even when SSH hosts are
unreachable - users can work with local workspaces while SSH workspaces
simply lack the post-compaction state indicator until connectivity is
restored.

## Changes

- `src/node/services/workspaceService.ts`: Wrap
`getPostCompactionState()` calls with `Promise.race()` timeout
- `src/node/services/workspaceService.test.ts`: Add test verifying
timeout behavior

---
_Generated with `mux` • Model: `anthropic:claude-opus-4-5` • Thinking:
`high`_

Author: ammar-agent

src/node/services/workspaceService.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { describe, expect, test, mock, beforeEach, jest } from "bun:test";
 import { WorkspaceService } from "./workspaceService";
 import type { Config } from "@/node/config";
 import type { HistoryService } from "./historyService";
@@ -232,3 +232,88 @@ describe("WorkspaceService post-compaction metadata refresh", () => {
     expect(enriched.postCompaction?.planPath).toBe(postCompactionState.planPath);
   });
 });
+
+describe("WorkspaceService.list post-compaction timeout", () => {
+  let workspaceService: WorkspaceService;
+  let mockConfig: Partial<Config>;
+
+  beforeEach(() => {
+    const mockAIService: AIService = {
+      isStreaming: mock(() => false),
+      getWorkspaceMetadata: mock(() =>
+        Promise.resolve({ success: false as const, error: "not found" })
+      ),
+      on(_eventName: string | symbol, _listener: (...args: unknown[]) => void) {
+        return this;
+      },
+      off(_eventName: string | symbol, _listener: (...args: unknown[]) => void) {
+        return this;
+      },
+    } as unknown as AIService;
+
+    const mockHistoryService: Partial<HistoryService> = {
+      getHistory: mock(() => Promise.resolve({ success: true as const, data: [] })),
+      appendToHistory: mock(() => Promise.resolve({ success: true as const, data: undefined })),
+    };
+
+    const fakeWorkspace: FrontendWorkspaceMetadata = {
+      id: "ssh-workspace",
+      name: "ws",
+      projectName: "proj",
+      projectPath: "/tmp/proj",
+      namedWorkspacePath: "/tmp/proj/ws",
+      runtimeConfig: { type: "ssh", host: "unreachable-host", srcBaseDir: "/home/user/proj" },
+    };
+
+    mockConfig = {
+      srcDir: "/tmp/test",
+      getSessionDir: mock(() => "/tmp/test/sessions"),
+      generateStableId: mock(() => "test-id"),
+      findWorkspace: mock(() => null),
+      getAllWorkspaceMetadata: mock(() => Promise.resolve([fakeWorkspace])),
+    };
+
+    const mockPartialService: Partial<PartialService> = {
+      commitToHistory: mock(() => Promise.resolve({ success: true as const, data: undefined })),
+    };
+
+    const mockInitStateManager: Partial<InitStateManager> = {};
+    const mockExtensionMetadataService: Partial<ExtensionMetadataService> = {};
+    const mockBackgroundProcessManager: Partial<BackgroundProcessManager> = {
+      cleanup: mock(() => Promise.resolve()),
+    };
+
+    workspaceService = new WorkspaceService(
+      mockConfig as Config,
+      mockHistoryService as HistoryService,
+      mockPartialService as PartialService,
+      mockAIService,
+      mockInitStateManager as InitStateManager,
+      mockExtensionMetadataService as ExtensionMetadataService,
+      mockBackgroundProcessManager as BackgroundProcessManager
+    );
+  });
+
+  test("list returns quickly even when getPostCompactionState would hang (times out after 3s)", async () => {
+    // Simulate a slow SSH connection that never resolves
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    const neverResolves = new Promise<never>(() => {});
+    const getPostCompactionStateSpy = jest.spyOn(
+      workspaceService as unknown as { getPostCompactionState: () => Promise<unknown> },
+      "getPostCompactionState"
+    );
+    getPostCompactionStateSpy.mockReturnValue(neverResolves);
+
+    const startTime = Date.now();
+    const result = await workspaceService.list({ includePostCompaction: true });
+    const elapsed = Date.now() - startTime;
+
+    // Should complete within ~3s timeout + buffer, not hang for 2 minutes
+    expect(elapsed).toBeLessThan(5000);
+
+    // Should return workspace without post-compaction state (timeout fallback)
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe("ssh-workspace");
+    expect(result[0].postCompaction).toBeUndefined();
+  });
+});

src/node/services/workspaceService.ts

@@ -747,12 +747,18 @@ export class WorkspaceService extends EventEmitter {
       }
 
       // Fetch post-compaction state for all workspaces in parallel
-      // Catch per-workspace errors to avoid failing the entire list if one workspace is unreachable
+      // Use a short timeout per workspace to avoid blocking app startup if SSH is unreachable
+      const POST_COMPACTION_TIMEOUT_MS = 3000;
       return Promise.all(
         metadata.map(async (ws) => {
           try {
-            const postCompaction = await this.getPostCompactionState(ws.id);
-            return { ...ws, postCompaction };
+            const postCompaction = await Promise.race([
+              this.getPostCompactionState(ws.id),
+              new Promise<null>((resolve) =>
+                setTimeout(() => resolve(null), POST_COMPACTION_TIMEOUT_MS)
+              ),
+            ]);
+            return postCompaction ? { ...ws, postCompaction } : ws;
           } catch {
             // Workspace runtime unavailable (e.g., SSH unreachable) - return without post-compaction state
             return ws;