fix(ci): bundle L6 — re-attestation timestamps, event-driven sideband wait, one-process test leaks

.github/scripts/pr-quality-state.test.cjs

@@ -795,6 +795,41 @@ describe("durable readiness re-attestation", () => {
     assert.equal(result.pending.checkpointAt, null);
   });
 
+  it("accepts a delayed author event when the live head and body remain unchanged", () => {
+    const pending = { version: 1, headSha: HEAD_A, baseRef: "dev", generation: 2, phase: "await-clear", checkpointAt: CHECKPOINT };
+    const result = advanceReattestation({
+      pending,
+      legacy: false,
+      current: true,
+      readiness: readiness(0),
+      live: live(body0, { updatedAt: "2026-09-22T09:00:01.000Z" }),
+      event: authorEdit(body0, body4),
+    });
+    assert.equal(result.pending.phase, "await-check");
+    assert.equal(result.pending.checkpointAt, null);
+  });
+
+  it("rejects future author events and missing or invalid live timestamps", () => {
+    const pending = { version: 1, headSha: HEAD_A, baseRef: "dev", generation: 2, phase: "await-clear", checkpointAt: CHECKPOINT };
+    for (const [name, liveUpdatedAt, eventUpdatedAt] of [
+      ["future author event", LIVE_TIME, "2026-09-22T01:00:02.000Z"],
+      ["missing live timestamp", undefined, LIVE_TIME],
+      ["invalid live timestamp", "not-a-time", LIVE_TIME],
+    ]) {
+      const result = advanceReattestation({
+        pending,
+        legacy: false,
+        current: true,
+        readiness: readiness(0),
+        live: live(body0, { updatedAt: liveUpdatedAt }),
+        event: authorEdit(body0, body4, { updatedAt: eventUpdatedAt }),
+      });
+      assert.equal(result.pending.phase, "await-clear", name);
+      assert.equal(result.changed, false, name);
+      assert.equal(result.canComplete, false, name);
+    }
+  });
+
   it("rejects equal timestamps, title-only edits, and stale or reordered payloads", () => {
     const pending = { version: 1, headSha: HEAD_A, baseRef: "dev", generation: 2, phase: "await-clear", checkpointAt: CHECKPOINT };
     const cases = [

.github/scripts/pr-readiness-reattest.cjs

@@ -115,6 +115,10 @@ function samePending(left, right) {
 function qualifyingAuthorBodyEdit({ live, event, checkpointAt }) {
   const checkpointMs = Date.parse(checkpointAt);
   const eventMs = Date.parse(event?.updatedAt ?? "");
+  // GitHub can advance the live PR timestamp after the author event arrives.
+  // Do not cap the lag: a delayed event still proves this author's post-checkpoint
+  // edit when the exact body and head are unchanged at the live read.
+  const liveMs = Date.parse(live?.updatedAt ?? "");
   return Boolean(
     event?.name === "pull_request_target" &&
     event.action === "edited" &&
@@ -123,9 +127,8 @@ function qualifyingAuthorBodyEdit({ live, event, checkpointAt }) {
     event.headSha === live.headSha &&
     typeof event.body === "string" && event.body === live.body &&
     typeof event.previousBody === "string" && event.previousBody !== event.body &&
-    event.updatedAt === live.updatedAt &&
-    Number.isFinite(checkpointMs) && Number.isFinite(eventMs) &&
-    eventMs > checkpointMs
+    Number.isFinite(checkpointMs) && Number.isFinite(eventMs) && Number.isFinite(liveMs) &&
+    eventMs > checkpointMs && eventMs <= liveMs
   );
 }
 

tests/ci-workflows/pr-readiness-reattest.test.ts

@@ -90,6 +90,19 @@ describe("author-applied policy migration with durable re-attestation", () => {
     expect(pending(saved(retick, T5))).toBeNull();
   });
 
+  test("clear edit survives a live PR timestamp eight hours later", async () => {
+    const first = await initialize();
+    const laterComment = "2026-09-22T08:00:08Z";
+    const result = await runEnforcePrTarget(script, {
+      pr: { body: body(CURRENT, 0), draft: true, head: { sha: HEAD }, updated_at: "2026-09-22T08:00:06Z" },
+      eventPayload: { body: body(CURRENT, 0), draft: true, head: { sha: HEAD }, updated_at: T3 },
+      eventAction: "edited", previousBody: body(OLD), comments: [first], commentUpdatedAt: laterComment,
+    });
+    expect(pending(saved(result, laterComment)).phase).toBe("await-check");
+    expect(promotions(result)).toEqual([]);
+    expect(bodyWrites(result)).toEqual([]);
+  });
+
   test("identical pending replay does not duplicate notices or mutate author content", async () => {
     const first = await initialize();
     const replay = await runEnforcePrTarget(script, {

tests/images/download-connect-deadline-default.test.ts

@@ -1,11 +1,22 @@
-import { describe, expect, mock, test } from "bun:test";
+import { afterAll, describe, expect, mock, test } from "bun:test";
 
 // The default downloader inside connectPublicHttps is the production path for
 // provider-returned image/video URLs (downloadImageToArtifact and
 // downloadVideoToArtifact both go through it), while pinnedHttpsGet has no
 // production callers. A connect deadline wired only into pinnedHttpsGet would
 // therefore never arm in production — this suite pins the default path.
 
+// `mock.module` outlives this file: Bun keeps both overrides below for every file that
+// runs after this one in the same process, including download-cap-default's own capture of
+// the "real" modules and tests/lib's pinned-http suites (#5439). Keep the real modules,
+// captured before anything here is mocked, and put them back.
+const realDns = { ...(await import("node:dns/promises")) };
+const realPinnedHttp = { ...(await import("../../src/lib/pinned-http")) };
+afterAll(() => {
+  mock.module("node:dns/promises", () => realDns);
+  mock.module("../../src/lib/pinned-http", () => realPinnedHttp);
+});
+
 const lookupMock = mock(async (): Promise<{ address: string; family: number }[]> => [
   { address: "93.184.216.34", family: 4 },
 ]);

tests/server/cancel-body-on-abort.test.ts

@@ -5,11 +5,17 @@ import { handleResponses } from "../../src/server/responses";
 import type { OcxConfig } from "../../src/types";
 import { acquireOwnedSpendHome } from "../helpers/owned-spend-home";
 
+// Captured once so a test that never finishes (Bun's per-test timeout) cannot leave the stubbed
+// fetch installed for every later file in the same process.
+const REAL_FETCH = globalThis.fetch;
+
 let releaseSpendHome: (() => void) | undefined;
 afterEach(() => {
   // Release the lease before later teardown can replace the preload sandbox home.
   releaseSpendHome?.();
   releaseSpendHome = undefined;
+  // Bun runs afterEach even when a test times out, so this is the restore that survives a hang.
+  globalThis.fetch = REAL_FETCH;
 });
 
 function bodyWithCancelSpy(): { body: ReadableStream<Uint8Array>; cancelled: () => boolean } {
@@ -79,8 +85,14 @@ describe("readBodyCapped settles the stream when a read throws", () => {
     const requestAbort = new AbortController();
     const events: string[] = [];
     let rejectRead!: (reason: unknown) => void;
+    let readReached = false;
     let markReadStarted!: () => void;
-    const readStarted = new Promise<void>(resolve => { markReadStarted = resolve; });
+    const readStarted = new Promise<void>(resolve => {
+      markReadStarted = () => {
+        readReached = true;
+        resolve();
+      };
+    });
 
     const reader = {
       read(): Promise<ReadableStreamReadResult<Uint8Array>> {
@@ -139,7 +151,23 @@ describe("readBodyCapped settles the stream when a read throws", () => {
         body: "offer",
         signal: requestAbort.signal,
       }), config, { model: "", provider: "" });
-      await readStarted;
+      // Race the start signal against the handler settling: a handler that returns an error
+      // response without ever fetching would otherwise hang here until the harness kills the test.
+      await Promise.race([
+        readStarted,
+        pending.then(
+          async settled => {
+            if (readReached) return;
+            throw new Error(
+              `handleLive settled before reaching fetch: status ${settled.status} ${(await settled.text()).slice(0, 300)}`,
+            );
+          },
+          (reason: unknown) => {
+            if (readReached) return;
+            throw new Error(`handleLive settled before reaching fetch: ${reason instanceof Error ? reason.message : String(reason)}`);
+          },
+        ),
+      ]);
       requestAbort.abort(new DOMException("client closed request", "AbortError"));
 
       expect((await pending).status).toBe(499);

tests/server/companion-settings.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, mock, test } from "bun:test";
+import { afterAll, describe, expect, mock, test } from "bun:test";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -10,12 +10,18 @@ import {
 } from "../../src/companion/settings";
 import type { OcxConfig } from "../../src/types";
 
+// `mock.module` outlives this file: Bun keeps the override below for every file that runs after
+// this one in the same process. This is a spread snapshot of the real module, taken before it.
+const realOpenUrl = { ...(await import("../../src/lib/open-url")) };
 const opened: string[] = [];
 mock.module("../../src/lib/open-url", () => ({
   openUrl: (url: string) => {
     opened.push(url);
   },
 }));
+afterAll(() => {  // Put the real module back for every later file in the same process.
+  mock.module("../../src/lib/open-url", () => realOpenUrl);
+});
 const { resetCompanionPresenceForTests } = await import("../../src/server/management/companion-routes");
 const { handleManagementAPI } = await import("../../src/server/management-api");
 

tests/server/context-history.test.ts

@@ -1,4 +1,3 @@
-// mock.module replacements require file isolation (bun test --isolate).
 import { describe, test, expect, mock, beforeEach, afterAll } from "bun:test";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -33,6 +32,15 @@ let outgoingAccount = "test-only";
 let accountMode = "pool";
 let validated=0;
 let probe=false;let released=0;let directError=false;let duringSelection:(()=>void)|undefined;
+// `mock.module` outlives this file: Bun keeps all six overrides below for every file that runs
+// after this one in the same process. Keep the real modules, captured before anything here is
+// mocked, and put them back.
+const realAuthContext = { ...(await import("../../src/codex/auth-context")) };
+const realRouting = { ...(await import("../../src/codex/routing")) };
+const realSidecar = { ...(await import("../../src/providers/openai-sidecar")) };
+const realAuthCors = { ...(await import("../../src/server/auth-cors")) };
+const realResponses = { ...(await import("../../src/server/responses")) };
+const realLifecycle = { ...(await import("../../src/server/lifecycle")) };
 const errors = {
   CodexAccountCooldownError: class extends Error {},
   CodexMainSubstitutionUnavailableError: class extends Error {},
@@ -61,7 +69,6 @@ mock.module("../../src/codex/auth-context",()=>({
   cooldownErrorResponse:()=>new Response("cooldown",{status:429}),
   codexMainProfileDrainingResponse:()=>new Response("draining",{status:503}),
 }));
-const realRouting = await import("../../src/codex/routing");
 mock.module("../../src/codex/routing",()=>({...realRouting, formatCodexProviderForLog:()=>"openai-test"}));
 mock.module("../../src/providers/openai-sidecar",()=>({listOpenAiForwardSidecarCandidates:()=>[{providerName:"openai",provider:{baseUrl:"https://chatgpt.com/backend-api/codex"},accountMode}]}));
 class ForwardAdmissionCredentialError extends Error {}
@@ -92,7 +99,14 @@ const originalFetch=globalThis.fetch;
 function setFetch(handler: (input: string | URL | Request, init?: RequestInit) => Promise<Response>): void {
   globalThis.fetch = Object.assign(handler, { preconnect: originalFetch.preconnect });
 }
-afterAll(()=>{if(previousCodexHome===undefined)delete process.env.CODEX_HOME;else process.env.CODEX_HOME=previousCodexHome;resetContextRelayActivationForTests();clearContextSessionOwnersForTests();globalThis.fetch=originalFetch;mock.restore();});
+afterAll(()=>{try{if(previousCodexHome===undefined)delete process.env.CODEX_HOME;else process.env.CODEX_HOME=previousCodexHome;resetContextRelayActivationForTests();clearContextSessionOwnersForTests();globalThis.fetch=originalFetch;mock.restore();}finally{
+  mock.module("../../src/codex/auth-context",()=>realAuthContext);
+  mock.module("../../src/codex/routing",()=>realRouting);
+  mock.module("../../src/providers/openai-sidecar",()=>realSidecar);
+  mock.module("../../src/server/auth-cors",()=>realAuthCors);
+  mock.module("../../src/server/responses",()=>realResponses);
+  mock.module("../../src/server/lifecycle",()=>realLifecycle);
+}});
 beforeEach(()=>{clearContextSessionOwnersForTests();for (const id of ["root", "root-test", "s"]) seedOwner(id);outgoingAccount="test-only";globalThis.fetch=originalFetch;materialized=undefined;materializationError=undefined;selection=undefined;validated=0;materializationOptions=undefined;outgoingBearer="test-only";accountMode="pool";probe=false;released=0;directError=false;duringSelection=undefined;setContextFeature(true);});
 
 describe("context relay contract",()=>{

tests/server/management-api-logs-metrics.test.ts

@@ -46,6 +46,9 @@ let testDir = "";
 let previousHome: string | undefined;
 
 beforeEach(() => {
+  // The request log is process-wide: start empty so the first case does not read a row an
+  // earlier file left behind (a one-process tests/server run handed it a Kiro entry).
+  clearRequestLogsForTests();
   // addRequestLog persists to usage.jsonl; without a scratch OPENCODEX_HOME a bare
   // `bun test <file>` run from outside the repo (no bunfig preload) writes these
   // fixture rows into the real ~/.opencodex log and poisons the GUI Usage page.

tests/server/server-combo-failover-e2e.test.ts

@@ -4,7 +4,7 @@ import { comboProviderFactory } from "../helpers/combo-provider";
 import { registerComboContextOverflowCases } from "../helpers/combo-context-overflow-cases";
 import { registerComboContextHeadroomCases } from "../helpers/combo-context-headroom-cases";
 import { sessionLaneIdFromRequest } from "../../src/server/request-log-conversation";
-import { afterEach, beforeEach, describe, expect, mock, setDefaultTimeout, test } from "bun:test";
+import { afterAll, afterEach, beforeEach, describe, expect, mock, setDefaultTimeout, test } from "bun:test";
 import { logsFromApiBody } from "../helpers/logs-api";
 import { managementFetch as fetch, ManagementRequest as Request } from "../helpers/management-auth";
 import { mkdtempSync } from "node:fs";
@@ -58,9 +58,11 @@ import { captureConfigGeneration } from "../../src/lib/state-store-sweeper";
 // default 5s per-test budget (same flake class as 810fa115 / claude-management-api).
 setDefaultTimeout(30_000);
 
-const actualResolver = await import("../../src/server/adapter-resolve");
+// `mock.module` outlives this file: Bun keeps both overrides below for every file that runs after
+// this one in the same process. These are spread snapshots of the real modules, taken before them.
+const actualResolver = { ...(await import("../../src/server/adapter-resolve")) };
 const actualResolveAdapter = actualResolver.resolveAdapter;
-const actualRetry = await import("../../src/lib/upstream-retry");
+const actualRetry = { ...(await import("../../src/lib/upstream-retry")) };
 const actualFetchWithTransientRetry = actualRetry.fetchWithTransientRetry;
 const { createCursorAdapter } = await import("../../src/adapters/cursor");
 import type { CursorTransportFactory } from "../../src/adapters/cursor/transport";
@@ -130,6 +132,11 @@ mock.module("../../src/lib/upstream-retry", () => ({
   },
 }));
 
+afterAll(() => {  // Put the real modules back for every later file in the same process.
+  mock.module("../../src/server/adapter-resolve", () => actualResolver);
+  mock.module("../../src/lib/upstream-retry", () => actualRetry);
+});
+
 const { handleResponses } = await import("../../src/server/responses");
 const { handleResponsesCompact } = await import("../../src/server/responses/compact");
 type HandleOptions = NonNullable<Parameters<typeof handleResponses>[3]>;

tests/server/server-combo-zero-output-failover.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, setDefaultTimeout, test } from "bun:test";
+import { afterAll, afterEach, beforeEach, describe, expect, mock, setDefaultTimeout, test } from "bun:test";
 import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -20,7 +20,9 @@ import {
 import type { ProviderAdapter } from "../../src/adapters/base";
 import type { AdapterEvent, OcxConfig, OcxProviderConfig } from "../../src/types";
 
-const actualResolver = await import("../../src/server/adapter-resolve");
+// `mock.module` outlives this file: Bun keeps the override below for every file that runs after
+// this one in the same process. This is a spread snapshot of the real module, taken before it.
+const actualResolver = { ...(await import("../../src/server/adapter-resolve")) };
 const actualResolveAdapter = actualResolver.resolveAdapter;
 let customRunTurn: NonNullable<ProviderAdapter["runTurn"]> | undefined;
 
@@ -44,6 +46,10 @@ mock.module("../../src/server/adapter-resolve", () => ({
   },
 }));
 
+afterAll(() => {  // Put the real module back for every later file in the same process.
+  mock.module("../../src/server/adapter-resolve", () => actualResolver);
+});
+
 const { handleResponses } = await import("../../src/server/responses");
 
 /**