🤖 Improve integration test diagnostics for flaky tool policy tests (#46)

## Problem

The tool policy integration tests are flaky in CI, timing out waiting
for `stream-end` events with no useful diagnostic information. When they
fail, we only see:

```
Expected: true
Received: false
  at assertStreamSuccess (tests/ipcMain/helpers.ts:191:36)
```

This tells us nothing about what actually went wrong.

## Solution

This PR makes **general improvements to test helpers** that benefit all
integration tests:

### 1. Enhanced `waitForEvent` helper
- Automatically logs stream-error details when timing out
- Shows error message and error type for debugging
- Makes all integration tests more debuggable

### 2. Enhanced `assertStreamSuccess` helper  
- Replaced generic expect() calls with descriptive Error messages
- Shows all collected events when any assertion fails
- Distinguishes between different failure modes:
  - Stream didn't complete (no stream-end)
  - Stream errored (has stream-error)
  - Stream completed but missing final message
- Includes the actual error message in the failure output

### 3. Fixed tool policy tests to wait for completion
- Now wait for either `stream-end` OR `stream-error` (prevents timeout)
- Rely on improved helpers for diagnostics
- Much simpler and more maintainable

## Impact

These changes benefit **all integration tests**, not just tool policy
tests. Any test using `waitForEvent` or `assertStreamSuccess` will now
provide much better error messages when failing.

## Next Steps

Once this PR is merged and we see the tests fail in CI, we'll get
detailed error logs that will help us:
- Identify if the AI is trying to use disabled tools
- See the actual API errors if any
- Understand the sequence of events leading to failure
- Fix the root cause instead of masking it with timeouts

_Generated with `cmux`_

Author: ammario

tests/ipcMain/helpers.ts

@@ -142,6 +142,15 @@ export class EventCollector {
       `waitForEvent timeout: Expected "${eventType}" but got events: [${eventTypes.join(", ")}]`
     );
 
+    // If there was a stream-error, log the error details
+    const errorEvent = this.events.find((e) => "type" in e && e.type === "stream-error");
+    if (errorEvent && "error" in errorEvent) {
+      console.error("Stream error details:", errorEvent.error);
+      if ("errorType" in errorEvent) {
+        console.error("Stream error type:", errorEvent.errorType);
+      }
+    }
+
     return null;
   }
 
@@ -186,12 +195,43 @@ export function createEventCollector(
 
 /**
  * Assert that a stream completed successfully
+ * Provides helpful error messages when assertions fail
  */
 export function assertStreamSuccess(collector: EventCollector): void {
-  expect(collector.hasStreamEnd()).toBe(true);
-  expect(collector.hasError()).toBe(false);
+  const allEvents = collector.getEvents();
+  const eventTypes = allEvents.filter((e) => "type" in e).map((e) => (e as { type: string }).type);
+
+  // Check for stream-end
+  if (!collector.hasStreamEnd()) {
+    const errorEvent = allEvents.find((e) => "type" in e && e.type === "stream-error");
+    if (errorEvent && "error" in errorEvent) {
+      throw new Error(
+        `Stream did not complete successfully. Got stream-error: ${errorEvent.error}\n` +
+          `All events: [${eventTypes.join(", ")}]`
+      );
+    }
+    throw new Error(
+      `Stream did not emit stream-end event.\n` + `All events: [${eventTypes.join(", ")}]`
+    );
+  }
+
+  // Check for errors
+  if (collector.hasError()) {
+    const errorEvent = allEvents.find((e) => "type" in e && e.type === "stream-error");
+    const errorMsg = errorEvent && "error" in errorEvent ? errorEvent.error : "unknown";
+    throw new Error(
+      `Stream completed but also has error event: ${errorMsg}\n` +
+        `All events: [${eventTypes.join(", ")}]`
+    );
+  }
+
+  // Check for final message
   const finalMessage = collector.getFinalMessage();
-  expect(finalMessage).toBeDefined();
+  if (!finalMessage) {
+    throw new Error(
+      `Stream completed but final message is missing.\n` + `All events: [${eventTypes.join(", ")}]`
+    );
+  }
 }
 
 /**

tests/ipcMain/sendMessage.test.ts

@@ -833,7 +833,15 @@ describeIntegration("IpcMain sendMessage integration tests", () => {
 
           // Wait for stream to complete (longer timeout for tool policy tests)
           const collector = createEventCollector(env.sentEvents, workspaceId);
-          await collector.waitForEvent("stream-end", 30000);
+          
+          // Wait for either stream-end or stream-error
+          // (helpers will log diagnostic info on failure)
+          await Promise.race([
+            collector.waitForEvent("stream-end", 30000),
+            collector.waitForEvent("stream-error", 30000),
+          ]);
+
+          // This will throw with detailed error info if stream didn't complete successfully
           assertStreamSuccess(collector);
 
           // Verify file still exists (bash tool was disabled, so deletion shouldn't have happened)
@@ -884,7 +892,15 @@ describeIntegration("IpcMain sendMessage integration tests", () => {
 
           // Wait for stream to complete (longer timeout for tool policy tests)
           const collector = createEventCollector(env.sentEvents, workspaceId);
-          await collector.waitForEvent("stream-end", 30000);
+          
+          // Wait for either stream-end or stream-error
+          // (helpers will log diagnostic info on failure)
+          await Promise.race([
+            collector.waitForEvent("stream-end", 30000),
+            collector.waitForEvent("stream-error", 30000),
+          ]);
+
+          // This will throw with detailed error info if stream didn't complete successfully
           assertStreamSuccess(collector);
 
           // Verify file content unchanged (file_edit tools and bash were disabled)