Propagate record-video trace mode into network settle diagnostics

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

currentState.md

@@ -149,6 +149,7 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
 - Hardened `waitForSettledDOM` option reads for frame filtering with trap-safe accessors, so malformed/trap-prone option objects no longer break settle flow or frame-manager configuration.
 - Hardened wait-listener lifecycle cleanup against trap-prone session listener-method getters, preserving settle completion while emitting sanitized detach diagnostics.
 - Expanded settle-flow listener regressions to cover trap-prone `session.on` getters, ensuring timeout-based fallback remains deterministic under unreadable listener APIs.
+- Aligned settle network-tracing behavior so recording-video sessions now propagate trace mode into network-idle diagnostics (including stalled-request warnings) even when debug flags are off.
 - Hardened constructor LLM validation to reject malformed non-provider/non-client `llm` payloads instead of accepting invalid runtime objects, while preserving trap-safe config reads.
 - Added explicit constructor regression coverage for malformed partial `llm` objects to lock in fail-fast configuration behavior.
 - Hardened prompt final-goal rendering against malformed/trap-prone task inputs by normalizing non-string goals into bounded readable diagnostics instead of throwing.

src/utils/waitForSettledDOM.test.ts

@@ -252,6 +252,59 @@ describe("waitForSettledDOM diagnostics", () => {
     expect(setFrameFilteringEnabled).toHaveBeenCalledWith(false);
   });
 
+  it("enables network trace diagnostics when context is recording video", async () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const { session, emit } = createSessionWithEvents();
+    const cdpClient: CDPClient = {
+      rootSession: session,
+      createSession: async () => session,
+      acquireSession: async () => session,
+      dispose: async () => undefined,
+    };
+    getCDPClient.mockResolvedValue(cdpClient);
+    getOrCreateFrameContextManager.mockReturnValue({
+      setDebug: jest.fn(),
+    });
+    getDebugOptions.mockReturnValue({
+      enabled: false,
+      traceWait: false,
+    });
+
+    const page = {
+      context: () => ({
+        _options: {
+          recordVideo: {},
+        },
+      }),
+    } as never;
+
+    try {
+      const waitPromise = waitForSettledDOM(page, 5_000);
+      await Promise.resolve();
+      await Promise.resolve();
+
+      emit("Network.requestWillBeSent", {
+        requestId: "req-1",
+        type: "Document",
+        request: { url: "https://example.com/video" },
+      });
+
+      await jest.advanceTimersByTimeAsync(3_100);
+      await waitPromise;
+
+      const traceMessages = warnSpy.mock.calls
+        .map((call) => String(call[0] ?? ""))
+        .filter((message) => message.includes("[waitForSettledDOM]"));
+      expect(
+        traceMessages.some((message) =>
+          message.includes("Forcing completion of stalled request")
+        )
+      ).toBe(true);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
   it("continues when frame-filter configuration throws", async () => {
     const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
     const { session } = createSessionWithEvents();

src/utils/waitForSettledDOM.ts

@@ -265,7 +265,7 @@ export async function waitForSettledDOM(
   const networkStart = performance.now();
   const stats = await waitForNetworkIdle(lifecycleSession, {
     timeoutMs: normalizedTimeoutMs,
-    trace: traceWaitFlag,
+    trace: traceWait,
   });
   const networkDuration = performance.now() - networkStart;