e2e: raise CI timeouts for the agent tool-approval tests and add failure traces

CI failed both agent-tool-approval tests on their Allow/Deny wait after
exactly 15s (the assertion timeout), with total run time close to that
figure rather than the full 60s per-test budget — consistent with a
slower/shared CI runner running past a locally-comfortable margin, not a
hang or a real bug (the other six tests, none of which chain an agent-
workspace pick + detectScripts + a full chat round trip, passed fine).

- expect() timeout is now CI-aware (20s vs. 10s locally) in the config.
- The two Allow/Deny waits specifically go to 30s, with the per-test
  timeout for this file raised to 90s to leave room around them.
- trace: retain-on-failure and screenshot: only-on-failure are now on, so
  a future failure comes with a trace/screenshot instead of just a log.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: voidstackloop

e2e/playwright.config.ts

@@ -18,8 +18,19 @@ export default defineConfig({
     fullyParallel: false,
     retries: process.env.CI ? 1 : 0,
     timeout: 60_000,
-    expect: { timeout: 10_000 },
+    // CI runners (shared, no GPU, xvfb overhead on top of Electron's own
+    // startup cost) are measurably slower than a local dev machine — a wait
+    // that's comfortably generous locally can still time out there. Give CI
+    // more headroom uniformly rather than chasing each timeout one at a time.
+    expect: { timeout: process.env.CI ? 20_000 : 10_000 },
     reporter: process.env.CI ? [["list"], ["html", { open: "never" }]] : "list",
+    use: {
+        // Only kept for a run that actually failed — cheap on disk, and the
+        // difference between "it broke somewhere" and "here's exactly what
+        // the page looked like and every action leading up to it."
+        trace: "retain-on-failure",
+        screenshot: "only-on-failure",
+    },
     webServer: {
         command: "npx vite preview --port 5173 --strictPort",
         cwd: path.resolve(__dirname, "../frontend"),

e2e/tests/agent-tool-approval.spec.ts

@@ -12,6 +12,11 @@ import { startFakeOllama, type FakeOllamaServer } from "../fixtures/fake-ollama"
 // through the real IPC bridge and a real (sandboxed, harmless) command
 // execution on Allow, not a mocked approval handler.
 
+// The Allow/Deny wait below alone can take 30s on a slow CI runner; the
+// config's default 60s per-test budget leaves too little room for the setup
+// and follow-up assertions around it.
+test.setTimeout(90_000);
+
 let fakeOllama: FakeOllamaServer;
 let instance: LaunchedApp;
 let workspaceDir: string;
@@ -48,7 +53,7 @@ async function enableAgentModeAndSendToolCallingMessage(instance_: LaunchedApp):
     const input = window.getByPlaceholder("Send a message...");
     await input.fill("run a command for me");
     const sendButton = window.getByRole("button", { name: "Send message" });
-    await expect(sendButton).toBeEnabled({ timeout: 15_000 });
+    await expect(sendButton).toBeEnabled({ timeout: 20_000 });
     await sendButton.click();
 }
 
@@ -59,13 +64,19 @@ test("Deny stops the tool from running and the card clears", async () => {
     // "run_command" appears twice once the card is up (the tool-call summary
     // line and the pending-call header) — anchor on the Allow/Deny buttons
     // themselves, which is what actually defines "the approval card showed".
-    await expect(window.getByRole("button", { name: "Allow" })).toBeVisible({ timeout: 15_000 });
+    // Generous on top of the config's own CI-aware expect timeout: this
+    // specific wait spans agent-workspace setup (a real IPC round trip plus
+    // agentTools.detectProjectScripts()) and a full chat request/response
+    // round trip through the fake Ollama server — the longest chain of
+    // async work in this suite, and the one most exposed to a slower/shared
+    // CI runner.
+    await expect(window.getByRole("button", { name: "Allow" })).toBeVisible({ timeout: 30_000 });
     await window.getByRole("button", { name: "Deny" }).click();
 
     await expect(window.getByRole("button", { name: "Deny" })).toBeHidden();
     // The agent loop still completes (with the model told it was denied) —
     // the whole turn doesn't hang after a denial.
-    await expect(window.getByText("Hello from the fake model.")).toBeVisible({ timeout: 15_000 });
+    await expect(window.getByText("Hello from the fake model.")).toBeVisible({ timeout: 20_000 });
 
     // Nothing the denied command would have produced actually happened.
     expect(fs.readdirSync(workspaceDir)).toEqual([]);
@@ -75,12 +86,18 @@ test("Allow runs the tool for real and the card clears", async () => {
     const { window } = instance;
     await enableAgentModeAndSendToolCallingMessage(instance);
 
-    await expect(window.getByRole("button", { name: "Allow" })).toBeVisible({ timeout: 15_000 });
+    // Generous on top of the config's own CI-aware expect timeout: this
+    // specific wait spans agent-workspace setup (a real IPC round trip plus
+    // agentTools.detectProjectScripts()) and a full chat request/response
+    // round trip through the fake Ollama server — the longest chain of
+    // async work in this suite, and the one most exposed to a slower/shared
+    // CI runner.
+    await expect(window.getByRole("button", { name: "Allow" })).toBeVisible({ timeout: 30_000 });
     await window.getByRole("button", { name: "Allow" }).click();
 
     await expect(window.getByRole("button", { name: "Allow" })).toBeHidden();
     // The tool result card (not the earlier pending-call summary line, which
     // also still mentions the command) — proof the command actually ran.
-    await expect(window.locator("pre", { hasText: "hello-from-agent" })).toBeVisible({ timeout: 15_000 });
-    await expect(window.getByText("Hello from the fake model.")).toBeVisible({ timeout: 15_000 });
+    await expect(window.locator("pre", { hasText: "hello-from-agent" })).toBeVisible({ timeout: 20_000 });
+    await expect(window.getByText("Hello from the fake model.")).toBeVisible({ timeout: 20_000 });
 });