fix(release): stop one flaky test from failing a stable release

packages/cli/src/serve/server/session-pr-refresh.test.ts

@@ -44,6 +44,19 @@ import {
   startSessionPrRefreshTimer,
 } from './session-pr-refresh.js';
 
+// dispose() stops the next tick but does not await the sweep already in
+// flight, so a sweep can still be writing under the temp tree while teardown
+// walks it — recursive rm then fails with ENOTEMPTY when a file lands between
+// its readdir and rmdir. Retry so cleanup waits the writer out instead of
+// failing a test that already passed.
+const removeTempTree = (dir: string) =>
+  fsp.rm(dir, {
+    recursive: true,
+    force: true,
+    maxRetries: 10,
+    retryDelay: 50,
+  });
+
 // Delegating spy: the Aone tests seed a real repository, so resolution must
 // really run — the spy only makes its per-sweep cost observable.
 const aoneMocks = vi.hoisted(() => ({
@@ -1927,7 +1940,7 @@ describe('startSessionPrRefreshTimer', () => {
     vi.useRealTimers();
     delete process.env['QWEN_RUNTIME_DIR'];
     for (const dir of [baseDir, trustedCwd, untrustedCwd]) {
-      await fsp.rm(dir, { recursive: true, force: true });
+      await removeTempTree(dir);
     }
   });
 

packages/core/src/hooks/hook-runner.process.test.ts

@@ -902,7 +902,13 @@ setInterval(() => {}, 1000);
           input,
         );
 
-        descendantPid = await readPid(descendantPidPath);
+        // The root's 300ms hook timeout can fire before the descendant node
+        // process has started far enough to write its pid file, so poll for
+        // the file instead of reading it once the hook returns.
+        await waitFor(async () => {
+          descendantPid = await readPid(descendantPidPath);
+          return descendantPid !== undefined;
+        }, 10_000);
         expect(descendantPid).toBeDefined();
         expect(result).toMatchObject({
           success: false,
@@ -919,7 +925,7 @@ setInterval(() => {}, 1000);
         }
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 10_000);
+    }, 30_000);
 
     it('delivers complete large input after the parent exits', async () => {
       const tempDir = await mkdtemp(join(tmpdir(), 'qwen-hook-input-'));

packages/web-shell/client/components/MessageList.dom.test.tsx

@@ -513,6 +513,19 @@ const nextFrame = () =>
     () =>
       new Promise<void>((resolve) => requestAnimationFrame(() => resolve())),
   );
+// A fixed frame budget expires early on a loaded CI host: the frames still
+// tick, but the effect they were meant to flush is queued behind everything
+// else on the box. Poll frames against a wall-clock deadline instead, so the
+// wait stretches with the machine rather than with a frame count. The bound
+// stays well inside the 60s per-test budget this config gives shared ECS
+// runners, so a wait that never resolves still fails as an assertion.
+const FLUSH_DEADLINE_MS = 10_000;
+const waitForFrames = async (predicate: () => boolean) => {
+  const deadline = Date.now() + FLUSH_DEADLINE_MS;
+  while (!predicate() && Date.now() < deadline) {
+    await nextFrame();
+  }
+};
 const mockMessageListWidth = (width: number) =>
   vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue({
     width,
@@ -1401,15 +1414,8 @@ describe('MessageList — turn collapse (DOM)', () => {
       hasOlderHistory: true,
       onLoadOlderHistory,
     });
-    const waitForLoadCount = async (count: number) => {
-      for (
-        let frame = 0;
-        frame < 32 && onLoadOlderHistory.mock.calls.length < count;
-        frame += 1
-      ) {
-        await nextFrame();
-      }
-    };
+    const waitForLoadCount = (count: number) =>
+      waitForFrames(() => onLoadOlderHistory.mock.calls.length >= count);
     const list = c.querySelector(
       '[data-web-shell-message-list]',
     ) as HTMLElement;
@@ -2536,7 +2542,7 @@ describe('MessageList — turn collapse (DOM)', () => {
         resolveLoad();
         await Promise.resolve();
       });
-      await nextFrame();
+      await waitForFrames(() => list.scrollTop === 600);
       // The keep-open re-expanded the turn, and the anchor restore followed
       // the re-keyed run to a visible row instead of dropping: the scroll
       // position moved with the prepended history.