diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 2abd5c41c1c..d44100d9db9 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -540,16 +540,24 @@ jobs:
           VITEST_MIN_THREADS: "${{ startsWith(runner.name, 'ecs-qwen-') && '1' || '' }}"
           VITEST_MAX_FORKS: "${{ startsWith(runner.name, 'ecs-qwen-') && (vars.QWEN_CI_VITEST_MAX_WORKERS || '4') || '' }}"
           VITEST_MIN_FORKS: "${{ startsWith(runner.name, 'ecs-qwen-') && '1' || '' }}"
-          # Nightly and preview releases may absorb a transient timing
-          # failure. Stable releases add no retry of their own and stay on
-          # whatever each workspace's Vitest config asks for; the flag is
-          # omitted rather than set to 0, because a command-line --retry=0
-          # outranks the config and would disable a workspace's deliberate
-          # retry (packages/sdk-typescript) on the release lane alone.
-          VITEST_RETRY: "${{ (needs.prepare.outputs.is_nightly == 'true' || needs.prepare.outputs.is_preview == 'true') && '2' || '' }}"
+          # Every release schedule absorbs a transient timing failure, not
+          # just nightly and preview. A stable release used to run with no
+          # retry at all, so any one flaky test out of ~30k reddened it
+          # outright: six consecutive stable runs failed on a single test
+          # each while every other gate stayed green, and the same test
+          # passed on the next attempt. Retrying hides nothing — a real
+          # break fails all three attempts — it only stops a contended
+          # runner from deciding whether a release ships. Operators can
+          # retune this without a PR via the repository variable, or set it
+          # to 'off' to omit the flag entirely. 'off' rather than '0': a
+          # command-line --retry=0 outranks the config and would disable a
+          # workspace's deliberate retry (packages/sdk-typescript) on the
+          # release lane alone, and an empty variable just falls back to the
+          # default.
+          VITEST_RETRY: "${{ vars.QWEN_RELEASE_VITEST_RETRY || '2' }}"
         run: |-
           retry_arg=()
-          if [ -n "${VITEST_RETRY}" ]; then
+          if [ -n "${VITEST_RETRY}" ] && [ "${VITEST_RETRY}" != 'off' ]; then
             retry_arg=("--retry=${VITEST_RETRY}")
           fi
           npm run test:release:workspaces -- --shard=${{ matrix.shard }}/3 --passWithNoTests "${retry_arg[@]}"
diff --git a/.github/workflows/sdk-java.yml b/.github/workflows/sdk-java.yml
index 9fb0e74a4c6..bca420fa8f4 100644
--- a/.github/workflows/sdk-java.yml
+++ b/.github/workflows/sdk-java.yml
@@ -98,17 +98,8 @@ jobs:
             exit 1
           fi
 
-      # Runner instances on one self-hosted machine share $HOME and therefore
-      # ~/.m2/toolchains.xml. setup-java merges its JDK entry into that file
-      # with a non-atomic read-modify-write, so two concurrent jobs can tear
-      # it — and once torn, every later job on the machine fails Set up Java
-      # with "Cannot insert a text node as a child of a document node". The
-      # build never reads toolchains.xml (no maven-toolchains-plugin), so
-      # dropping it is free and setup-java rewrites it from scratch.
-      - name: 'Drop shared Maven toolchains.xml (self-hosted)'
-        if: "${{ runner.environment == 'self-hosted' }}"
-        run: 'rm -f "${HOME}/.m2/toolchains.xml"'
-
+      # setup-java updates Maven files non-atomically. Keep them job-local
+      # because runner instances on one ECS host share HOME.
       - name: 'Set up Java'
         uses: 'actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654' # v5.2.0
         with:
@@ -116,6 +107,7 @@ jobs:
           java-version: '${{ matrix.java }}'
           cache: 'maven'
           cache-dependency-path: 'packages/sdk-java/qwencode/pom.xml'
+          settings-path: '${{ runner.temp }}/setup-java-m2'
 
       - name: 'Set up Maven (self-hosted)'
         if: "${{ runner.environment == 'self-hosted' }}"
@@ -129,6 +121,8 @@ jobs:
       - name: 'Run Java SDK tests (self-hosted)'
         if: "${{ runner.environment == 'self-hosted' }}"
         working-directory: 'packages/sdk-java/qwencode'
+        env:
+          MAVEN_ARGS: '--settings ${{ runner.temp }}/setup-java-m2/settings.xml --toolchains ${{ runner.temp }}/setup-java-m2/toolchains.xml'
         run: |-
           mkdir -p "${HOME}/.cache/qwen-code-ci"
           exec 9>"${HOME}/.cache/qwen-code-ci/sdk-java-tests.lock"
@@ -141,16 +135,22 @@ jobs:
       - name: 'Run Java SDK tests (hosted)'
         if: "${{ runner.environment == 'github-hosted' }}"
         working-directory: 'packages/sdk-java/qwencode'
+        env:
+          MAVEN_ARGS: '--settings ${{ runner.temp }}/setup-java-m2/settings.xml --toolchains ${{ runner.temp }}/setup-java-m2/toolchains.xml'
         run: 'mvn --batch-mode --no-transfer-progress clean test'
 
       - name: 'Run Java SDK Checkstyle'
         if: "${{ matrix.os == 'ubuntu-latest' && matrix.java == '11' }}"
         working-directory: 'packages/sdk-java/qwencode'
+        env:
+          MAVEN_ARGS: '--settings ${{ runner.temp }}/setup-java-m2/settings.xml --toolchains ${{ runner.temp }}/setup-java-m2/toolchains.xml'
         run: 'mvn --batch-mode --no-transfer-progress checkstyle:check'
 
       - name: 'Build release artifacts'
         if: "${{ matrix.os == 'ubuntu-latest' && matrix.java == '11' }}"
         working-directory: 'packages/sdk-java/qwencode'
+        env:
+          MAVEN_ARGS: '--settings ${{ runner.temp }}/setup-java-m2/settings.xml --toolchains ${{ runner.temp }}/setup-java-m2/toolchains.xml'
         run: 'mvn --batch-mode --no-transfer-progress -DskipTests -Dgpg.skip=true package'
 
   daemon-e2e:
@@ -205,12 +205,6 @@ jobs:
             echo "::warning::Expected Node 22.x but found $(node -v); daemon E2E will run against the runner's Node."
           fi
 
-      # Same shared-$HOME hazard as the unit job above: drop the torn-prone
-      # toolchains.xml so a corrupt leftover cannot fail Set up Java.
-      - name: 'Drop shared Maven toolchains.xml (self-hosted)'
-        if: "${{ runner.environment == 'self-hosted' }}"
-        run: 'rm -f "${HOME}/.m2/toolchains.xml"'
-
       - name: 'Set up Java'
         uses: 'actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654' # v5.2.0
         with:
@@ -218,6 +212,7 @@ jobs:
           java-version: '11'
           cache: 'maven'
           cache-dependency-path: 'packages/sdk-java/qwencode/pom.xml'
+          settings-path: '${{ runner.temp }}/setup-java-m2'
 
       - name: 'Set up Maven (self-hosted)'
         if: "${{ runner.environment == 'self-hosted' }}"
@@ -238,4 +233,6 @@ jobs:
         run: 'npm run bundle'
 
       - name: 'Run Java daemon E2E'
+        env:
+          MAVEN_ARGS: '--settings ${{ runner.temp }}/setup-java-m2/settings.xml --toolchains ${{ runner.temp }}/setup-java-m2/toolchains.xml'
         run: 'npx tsx scripts/run-java-daemon-sdk-e2e.ts'
diff --git a/package-lock.json b/package-lock.json
index 70ad14ab8a9..7253fd9d26f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23765,12 +23765,13 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.15.2",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.2.tgz",
-      "integrity": "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==",
+      "version": "6.16.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.16.0.tgz",
+      "integrity": "sha512-h6fhOIaRrID2CbEY2fqs+7t+UXZo+MLAnU5gRIq85uFtdiUPCdsApMlHhXogKVM4HM2DVbIjGNTTYH2OcmP1vA==",
       "license": "BSD-3-Clause",
       "dependencies": {
-        "side-channel": "^1.1.0"
+        "es-define-property": "^1.0.1",
+        "side-channel": "^1.1.1"
       },
       "engines": {
         "node": ">=0.6"
@@ -25547,14 +25548,14 @@
       }
     },
     "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
         "side-channel-map": "^1.0.1",
         "side-channel-weakmap": "^1.0.2"
       },
@@ -25566,13 +25567,13 @@
       }
     },
     "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
+        "object-inspect": "^1.13.4"
       },
       "engines": {
         "node": ">= 0.4"
diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts
index 74f5a3ac6b6..851c239d9b7 100644
--- a/packages/cli/src/acp-integration/session/Session.test.ts
+++ b/packages/cli/src/acp-integration/session/Session.test.ts
@@ -18320,6 +18320,100 @@ describe('Session', () => {
         ).toHaveBeenCalledWith([midTurnPart], 'please also check tests');
       }, 20_000);
 
+      it('keeps a logger failure inside late drain recovery from escaping', async () => {
+        // Regression for the timeout branch's `.catch(() => {})` guard: the
+        // recovery is best-effort by construction, and anything thrown after
+        // the drain race — the debug logger among them — would escape a bare
+        // `void` as an unhandled rejection and end the daemon process. Same
+        // shape as the recovery test above, but the module-graph logger mock
+        // faults exactly on the recovery's own debug line, and the run must
+        // surface zero escaped rejections (vitest fails a file on one).
+        const tool = {
+          name: 'read_file',
+          kind: core.Kind.Read,
+          build: vi.fn().mockReturnValue({
+            params: { path: '/tmp/test.txt' },
+            getDefaultPermission: vi.fn().mockResolvedValue('allow'),
+            getDescription: vi.fn().mockReturnValue('Read file'),
+            toolLocations: vi.fn().mockReturnValue([]),
+            execute: vi
+              .fn()
+              .mockResolvedValue({ llmContent: 'ok', returnDisplay: 'ok' }),
+          }),
+        };
+        mockToolRegistry.getTool.mockReturnValue(tool);
+        mockConfig.getApprovalMode = vi.fn().mockReturnValue(ApprovalMode.YOLO);
+
+        let resolveLate: (value: { messages: string[] }) => void = () => {};
+        const latePromise = new Promise<{ messages: string[] }>((res) => {
+          resolveLate = res;
+        });
+        let drainCalls = 0;
+        mockClient.extMethod = vi.fn((method: string) => {
+          if (method !== 'craft/drainMidTurnQueue') return Promise.resolve({});
+          drainCalls += 1;
+          return drainCalls === 1
+            ? latePromise
+            : Promise.resolve({ messages: [] });
+        });
+
+        mockChat.sendMessageStream = vi
+          .fn()
+          .mockResolvedValueOnce(
+            createStreamWithChunks([
+              {
+                type: core.StreamEventType.CHUNK,
+                value: {
+                  functionCalls: [
+                    {
+                      id: 'c',
+                      name: 'read_file',
+                      args: { path: '/tmp/test.txt' },
+                    },
+                  ],
+                },
+              },
+            ]),
+          )
+          .mockResolvedValue(createEmptyStream());
+
+        // Fault through the module graph (sessionIdContext.run in a real turn
+        // bypasses any process-wide logger session): the recovery's own debug
+        // line throws, everything else logs normally.
+        debugLoggerDebugSpy.mockImplementation((message: unknown) => {
+          if (
+            typeof message === 'string' &&
+            message.includes('timed-out drain')
+          ) {
+            throw new Error('debug logger unavailable');
+          }
+        });
+
+        const unhandled = vi.fn();
+        process.on('unhandledRejection', unhandled);
+        try {
+          await session.prompt({
+            sessionId: 'test-session-id',
+            prompt: [{ type: 'text' as const, text: 'read file' }],
+          });
+
+          // The daemon's late answer lands; flush so the recovery race
+          // settles and its throwing logger call runs inside this test.
+          resolveLate({ messages: ['late message'] });
+          await new Promise((r) => setTimeout(r, 0));
+          await new Promise((r) => setImmediate(r));
+
+          // The recovery did reach its debug line (the fault actually fired).
+          expect(debugLoggerDebugSpy).toHaveBeenCalledWith(
+            expect.stringContaining('timed-out drain'),
+          );
+          expect(unhandled).not.toHaveBeenCalled();
+        } finally {
+          process.off('unhandledRejection', unhandled);
+          debugLoggerDebugSpy.mockImplementation(() => {});
+        }
+      }, 20_000);
+
       it('keeps mid-turn drain enabled after a transient error', async () => {
         const tool = {
           name: 'read_file',
diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts
index 56773c97fe6..1e882863250 100644
--- a/packages/cli/src/acp-integration/session/Session.ts
+++ b/packages/cli/src/acp-integration/session/Session.ts
@@ -8301,8 +8301,15 @@ export class Session implements SessionContext {
         // for. Recover that late response and inject it on the next batch instead
         // of discarding it (which would lose the messages from both queues —
         // silent loss). `#recoverLateDrain` bounds the wait and swallows a late
-        // rejection.
-        if (drainPromise) void this.#recoverLateDrain(drainPromise);
+        // rejection, but only of the drain promise: anything that throws after
+        // that race — the debug logger among them — escapes a bare `void` as an
+        // unhandled rejection, which ends the process. This recovery is
+        // best-effort by construction, so nothing it does may take the session
+        // down with it. Swallow silently rather than log, since the logger is
+        // itself one of the things that can throw here.
+        if (drainPromise) {
+          void this.#recoverLateDrain(drainPromise).catch(() => {});
+        }
       }
       // Repeated timeouts are also permanent: a conforming client answers
       // (or rejects with -32601) immediately, so sustained silence means the
diff --git a/packages/cli/src/serve/acp-http/transport.test.ts b/packages/cli/src/serve/acp-http/transport.test.ts
index 11aa8f2bbe9..046b803e6ee 100644
--- a/packages/cli/src/serve/acp-http/transport.test.ts
+++ b/packages/cli/src/serve/acp-http/transport.test.ts
@@ -81,6 +81,10 @@ import {
   type WorkspaceRuntime,
 } from '../workspace-registry.js';
 import { SessionArchiveCoordinator } from '../server/session-archive.js';
+import {
+  PersistedSessionListCache,
+  type PersistedSessionListCacheStatus,
+} from '../server/persisted-session-list-cache.js';
 import { createRequestedSessionIdAdmission } from '../session-id-admission.js';
 import { CredentialStore } from '../local-control/credentials.js';
 import { tagListener } from '../local-control/listener-identity.js';
@@ -3693,6 +3697,27 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
         });
         return scan;
       });
+    // The scan is cancelled the moment its waiter count reaches zero, and a
+    // request only becomes a waiter once it reaches `lookup()`. Posting both
+    // requests and waiting for the loader proves only that the *first* one
+    // attached: on a loaded runner the second can still be resolving params
+    // when the DELETE below tears the first connection down, which drops the
+    // count to zero, aborts the shared scan, and leaves the second request
+    // answering from a rejected promise. Watch `lookup()` for the
+    // single-flight join so the DELETE never lands before the second waiter
+    // is attached.
+    const lookupStatuses: PersistedSessionListCacheStatus[] = [];
+    const originalLookup = PersistedSessionListCache.prototype.lookup;
+    const lookupSpy = vi
+      .spyOn(PersistedSessionListCache.prototype, 'lookup')
+      .mockImplementation(function (
+        this: PersistedSessionListCache,
+        ...args: Parameters<typeof originalLookup>
+      ) {
+        const lookup = originalLookup.apply(this, args);
+        lookupStatuses.push(lookup.status);
+        return lookup;
+      });
 
     try {
       const firstConnId = await initialize();
@@ -3715,6 +3740,12 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
       ]);
       await waitUntil(() => loadSignal !== undefined);
       expect(listSessionsSpy).toHaveBeenCalledTimes(1);
+      await waitUntil(
+        () =>
+          lookupStatuses.filter((status) => status === 'single_flight')
+            .length === 1,
+        10_000,
+      );
 
       const deleted = await fetch(`${base}/acp`, {
         method: 'DELETE',
@@ -3732,6 +3763,7 @@ describe('ACP Streamable HTTP transport (over the wire)', () => {
       ]);
     } finally {
       resolveScan({ items: [], nextCursor: undefined, hasMore: false });
+      lookupSpy.mockRestore();
       listSessionsSpy.mockRestore();
     }
   });
diff --git a/packages/cli/src/serve/local-bind-addresses.test.ts b/packages/cli/src/serve/local-bind-addresses.test.ts
index bc02499f167..e1d9fe3ca5d 100644
--- a/packages/cli/src/serve/local-bind-addresses.test.ts
+++ b/packages/cli/src/serve/local-bind-addresses.test.ts
@@ -35,9 +35,30 @@ import {
  * IPv4-only host too.
  */
 describe('isOwnInterfaceAddress', () => {
-  const own = Object.values(networkInterfaces())
-    .flatMap((entries) => entries ?? [])
-    .map((entry) => entry.address);
+  const currentAddresses = () =>
+    Object.values(networkInterfaces())
+      .flatMap((entries) => entries ?? [])
+      .map((entry) => entry.address);
+
+  const own = currentAddresses();
+
+  /**
+   * A shared CI host adds and drops veth interfaces while a suite runs, and
+   * `isOwnInterfaceAddress` re-reads `networkInterfaces()` on every call — so
+   * an address captured at collection can be gone by the time a later case
+   * asserts on it, and the case then fails on a host that changed rather than
+   * on a lost normalisation. That is how a release lane went red on the two
+   * cases that run last here while the earlier ones passed. Intersect the
+   * collection snapshot with a fresh read per case, from `node:os` rather than
+   * from the function under test so no case can confirm itself, and keep the
+   * vacuity guard: the loopback never churns, so this never runs empty.
+   */
+  const stillOwn = () => {
+    const current = new Set(currentAddresses());
+    const stable = own.filter((address) => current.has(address));
+    expect(stable.length).toBeGreaterThan(0);
+    return stable;
+  };
 
   it('reports at least one own address to test against', () => {
     // Guards the loops below from passing vacuously on a host that somehow
@@ -46,7 +67,7 @@ describe('isOwnInterfaceAddress', () => {
   });
 
   it('accepts every own interface address in its bare form', () => {
-    for (const address of own) {
+    for (const address of stillOwn()) {
       expect(isOwnInterfaceAddress(address)).toBe(true);
     }
   });
@@ -55,7 +76,7 @@ describe('isOwnInterfaceAddress', () => {
     // The bracketed spelling is what `workerDialHost` hands back out of a
     // `https://[2001:db8::5]:8080` daemon URL, and what an operator passes to
     // `--hostname`. `os.networkInterfaces()` never reports the brackets.
-    for (const address of own) {
+    for (const address of stillOwn()) {
       expect(isOwnInterfaceAddress(`[${address}]`)).toBe(true);
     }
   });
@@ -65,7 +86,7 @@ describe('isOwnInterfaceAddress', () => {
     // is the only form an operator can pass for one — and `networkInterfaces()`
     // keeps the scope in `scopeid`, not in `address`. Both the percent-encoded
     // URL spelling and the bare one have to survive.
-    for (const address of own) {
+    for (const address of stillOwn()) {
       expect(isOwnInterfaceAddress(`${address}%eth0`)).toBe(true);
       expect(isOwnInterfaceAddress(`[${address}%25eth0]`)).toBe(true);
     }
@@ -74,7 +95,7 @@ describe('isOwnInterfaceAddress', () => {
   it('matches an own address case-insensitively', () => {
     // IPv6 literals are hex and an operator may type them uppercase, while
     // `networkInterfaces()` reports them lowercase.
-    for (const address of own) {
+    for (const address of stillOwn()) {
       expect(isOwnInterfaceAddress(address.toUpperCase())).toBe(true);
     }
   });
diff --git a/packages/cli/src/serve/server/session-pr-refresh.test.ts b/packages/cli/src/serve/server/session-pr-refresh.test.ts
index fc2628f12f1..82c4c939ebf 100644
--- a/packages/cli/src/serve/server/session-pr-refresh.test.ts
+++ b/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);
     }
   });
 
diff --git a/packages/core/src/hooks/hook-runner.process.test.ts b/packages/core/src/hooks/hook-runner.process.test.ts
index ba22b6a50cb..ffb88c5481a 100644
--- a/packages/core/src/hooks/hook-runner.process.test.ts
+++ b/packages/core/src/hooks/hook-runner.process.test.ts
@@ -14,6 +14,21 @@ import { HookRunner } from './hookRunner.js';
 import { HookEventName, HooksConfigSource, HookType } from './types.js';
 import type { HookInput } from './types.js';
 
+// The tests here spawn real processes — `node --import=tsx/esm` where the
+// fixture imports HookRunner's TypeScript source, plain node over `node:`
+// builtins otherwise — and then wait on a wall-clock deadline. Process
+// startup is not something a smarter wait can speed up, so on a shared
+// runner these deadlines are a coin flip rather than a signal: size them for
+// the busiest host, not the median one. The budgets below are sized for the
+// tsx path, which pays seconds of loader startup the plain-node fixtures do
+// not, so they are generous rather than tight for those.
+// A genuine hang still fails, just later. The per-test timeouts below are
+// widened to match; they stay numeric literals so the call shape, and the
+// diff, stay unchanged.
+const PROCESS_STARTUP_TIMEOUT_MS = 30_000;
+const PROCESS_REAP_TIMEOUT_MS = 15_000;
+const HOOK_GROUP_TIMEOUT_MS = 5000;
+
 const waitFor = async (
   predicate: () => boolean | Promise<boolean>,
   timeoutMs: number,
@@ -136,7 +151,7 @@ setInterval(() => {}, 1000);
             (await readFile(descendantReadyPath, 'utf8').catch(() => '')) ===
               'ready'
           );
-        }, 5000);
+        }, PROCESS_STARTUP_TIMEOUT_MS);
 
         controller.abort();
         const result = await resultPromise;
@@ -173,7 +188,7 @@ setInterval(() => {}, 1000);
         }
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 15_000);
+    }, 90_000);
 
     it.each([
       ['synchronous', 'process-exit', false],
@@ -291,7 +306,7 @@ setInterval(() => {}, 1000);
               (await readFile(driverReadyPath, 'utf8').catch(() => '')) ===
                 'ready'
             );
-          }, 5000);
+          }, PROCESS_STARTUP_TIMEOUT_MS);
           if (exitMode !== 'process-exit') {
             process.kill(driverPid as number, 'SIGTERM');
           }
@@ -313,7 +328,7 @@ setInterval(() => {}, 1000);
             () =>
               !isRunning(rootPid as number) &&
               !isRunning(descendantPid as number),
-            3000,
+            PROCESS_REAP_TIMEOUT_MS,
           );
         } finally {
           if (driverPid && isRunning(driverPid)) {
@@ -340,7 +355,7 @@ setInterval(() => {}, 1000);
           await rm(tempDir, { recursive: true, force: true });
         }
       },
-      15_000,
+      90_000,
     );
 
     it.each([
@@ -479,7 +494,7 @@ writeFileSync(process.argv[3], 'completed');
               hookPid !== undefined &&
               (await readFile(readyPath, 'utf8').catch(() => '')) === 'ready'
             );
-          }, 5000);
+          }, PROCESS_STARTUP_TIMEOUT_MS);
           const readyAt = Date.now();
           expect(await driverExit).toEqual({ code: 0, signal: null });
           expect(await readFile(completedPath, 'utf8').catch(() => '')).toBe(
@@ -513,7 +528,7 @@ writeFileSync(process.argv[3], 'completed');
           await rm(tempDir, { recursive: true, force: true });
         }
       },
-      10_000,
+      90_000,
     );
 
     it('enforces a surviving hook timeout after the parent exits', async () => {
@@ -533,7 +548,7 @@ const { HookRunner } = await import(process.argv[2]);
 const [tempDir, fixturePath, readyPath, pidPath] = process.argv.slice(3);
 const runner = new HookRunner();
 void runner.executeHook(
-  { type: 'command', command: \`exec \${JSON.stringify(process.execPath)} \${JSON.stringify(fixturePath)} \${JSON.stringify(readyPath)} \${JSON.stringify(pidPath)}\`, source: 'project', shell: 'bash', timeout: 300 },
+  { type: 'command', command: \`exec \${JSON.stringify(process.execPath)} \${JSON.stringify(fixturePath)} \${JSON.stringify(readyPath)} \${JSON.stringify(pidPath)}\`, source: 'project', shell: 'bash', timeout: ${HOOK_GROUP_TIMEOUT_MS} },
   'StopFailure',
   { session_id: 'surviving-timeout-test', transcript_path: \`\${tempDir}/transcript.jsonl\`, cwd: tempDir, hook_event_name: 'StopFailure', timestamp: new Date().toISOString() },
 );
@@ -585,7 +600,10 @@ setInterval(() => {}, 1000);
         hookPid = await readPid(pidPath);
         expect(hookPid).toBeDefined();
         expect(isRunning(hookPid as number)).toBe(true);
-        await waitFor(() => !isRunning(hookPid as number), 4000);
+        await waitFor(
+          () => !isRunning(hookPid as number),
+          PROCESS_REAP_TIMEOUT_MS,
+        );
       } finally {
         if (hookPid && isRunning(hookPid)) {
           try {
@@ -596,7 +614,7 @@ setInterval(() => {}, 1000);
         }
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 10_000);
+    }, 90_000);
 
     it('preserves a surviving hook exit code 124 before its deadline', async () => {
       const runner = new HookRunner();
@@ -620,7 +638,7 @@ setInterval(() => {}, 1000);
 
       expect(result).toMatchObject({ success: false, exitCode: 124 });
       expect(result.error).toBeUndefined();
-    }, 10_000);
+    }, 90_000);
 
     it('preserves a prompt exit 124 when the parent event loop is delayed past the deadline', async () => {
       const tempDir = await mkdtemp(join(tmpdir(), 'qwen-hook-exit-124-'));
@@ -664,7 +682,7 @@ setInterval(() => {}, 1000);
       } finally {
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 10_000);
+    }, 90_000);
 
     it('isolates the supervisor from hook NODE_OPTIONS', async () => {
       const tempDir = await mkdtemp(join(tmpdir(), 'qwen-hook-node-options-'));
@@ -699,7 +717,7 @@ setInterval(() => {}, 1000);
       } finally {
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 10_000);
+    }, 90_000);
 
     it('forwards abort through a surviving hook supervisor', async () => {
       const tempDir = await mkdtemp(join(tmpdir(), 'qwen-hook-abort-'));
@@ -747,14 +765,17 @@ setInterval(() => {}, 1000);
             hookPid !== undefined &&
             (await readFile(readyPath, 'utf8').catch(() => '')) === 'ready'
           );
-        }, 5000);
+        }, PROCESS_STARTUP_TIMEOUT_MS);
         controller.abort();
         const result = await resultPromise;
 
         expect(result.error?.message).toBe(
           'Hook execution cancelled (aborted)',
         );
-        await waitFor(() => !isRunning(hookPid as number), 3000);
+        await waitFor(
+          () => !isRunning(hookPid as number),
+          PROCESS_REAP_TIMEOUT_MS,
+        );
       } finally {
         controller.abort();
         if (hookPid && isRunning(hookPid)) {
@@ -766,7 +787,7 @@ setInterval(() => {}, 1000);
         }
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 10_000);
+    }, 90_000);
 
     it('reaps a surviving hook when its supervisor is stopped before abort', async () => {
       const tempDir = await mkdtemp(join(tmpdir(), 'qwen-hook-stopped-'));
@@ -818,7 +839,7 @@ setInterval(() => {}, 1000);
             supervisorPid !== undefined &&
             (await readFile(readyPath, 'utf8').catch(() => '')) === 'ready'
           );
-        }, 5000);
+        }, PROCESS_STARTUP_TIMEOUT_MS);
 
         process.kill(supervisorPid as number, 'SIGSTOP');
         controller.abort();
@@ -847,7 +868,7 @@ setInterval(() => {}, 1000);
         }
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 15_000);
+    }, 90_000);
 
     it('keeps supervising a surviving hook group after its root exits', async () => {
       const tempDir = await mkdtemp(join(tmpdir(), 'qwen-hook-descendant-'));
@@ -896,19 +917,32 @@ setInterval(() => {}, 1000);
             command,
             source: HooksConfigSource.Project,
             shell: 'bash',
-            timeout: 300,
+            // The root exits as soon as the descendant has written its pid;
+            // the supervisor then keeps the surviving descendant on the
+            // clock until this deadline and kills the group. That kill is
+            // what ends the test, so the deadline must outlast a node
+            // process starting on a loaded host — at 300ms the descendant
+            // could be killed before it ever wrote the pid, and no amount
+            // of waiting for the file afterwards could recover it.
+            timeout: HOOK_GROUP_TIMEOUT_MS,
           },
           HookEventName.SessionDelete,
           input,
         );
 
-        descendantPid = await readPid(descendantPidPath);
+        await waitFor(async () => {
+          descendantPid = await readPid(descendantPidPath);
+          return descendantPid !== undefined;
+        }, PROCESS_STARTUP_TIMEOUT_MS);
         expect(descendantPid).toBeDefined();
         expect(result).toMatchObject({
           success: false,
-          error: { message: 'Hook timed out after 300ms' },
+          error: { message: `Hook timed out after ${HOOK_GROUP_TIMEOUT_MS}ms` },
         });
-        await waitFor(() => !isRunning(descendantPid as number), 3000);
+        await waitFor(
+          () => !isRunning(descendantPid as number),
+          PROCESS_REAP_TIMEOUT_MS,
+        );
       } finally {
         if (descendantPid && isRunning(descendantPid)) {
           try {
@@ -919,7 +953,7 @@ setInterval(() => {}, 1000);
         }
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 10_000);
+    }, 90_000);
 
     it('delivers complete large input after the parent exits', async () => {
       const tempDir = await mkdtemp(join(tmpdir(), 'qwen-hook-input-'));
@@ -1028,6 +1062,6 @@ writeFileSync(process.argv[2], JSON.stringify({ bytes: Buffer.byteLength(input),
         }
         await rm(tempDir, { recursive: true, force: true });
       }
-    }, 10_000);
+    }, 90_000);
   },
 );
diff --git a/packages/core/src/memory/recall-scan-latency.test.ts b/packages/core/src/memory/recall-scan-latency.test.ts
index 7f3672f53fe..e114c9b2405 100644
--- a/packages/core/src/memory/recall-scan-latency.test.ts
+++ b/packages/core/src/memory/recall-scan-latency.test.ts
@@ -43,6 +43,20 @@ vi.mock('./relevanceSelector.js', () => ({
 const INITIAL_BUDGET_MS = 100;
 const TOPIC_COUNTS = [200, 500, 1000] as const;
 const REPEATS = 5;
+// A wall-clock median on a shared runner measures how busy the host is, not
+// how fast the scan is: three release shards land on one machine, so the
+// median inflates with the neighbours' load and the assertion stops being
+// about this code. Assert the fastest sample instead — the run least
+// contaminated by contention, and the closest thing to the intrinsic cost —
+// and be honest about what the shared lane can check: not the budget —
+// a host that busy cannot say whether 100ms is met — but an order of
+// magnitude. A scan that has blown up still reddens the release; one that
+// merely drifted is caught by the strict bound off shared runners, where
+// the property this test is named for is actually asserted.
+const SHARED_CI = process.env['RUNNER_NAME']?.startsWith('ecs-qwen-') === true;
+const FAST_RESULT_CEILING_MS = SHARED_CI
+  ? INITIAL_BUDGET_MS * 10
+  : INITIAL_BUDGET_MS / 2;
 
 let tempDir: string;
 const projectRootByCount = new Map<number, string>();
@@ -128,7 +142,7 @@ describe('auto-memory recall scan latency', () => {
   });
 
   it('publishes the fast result well inside the initial budget', async () => {
-    const rows: Array<[number, number, number]> = [];
+    const rows: Array<[number, number, number, number]> = [];
 
     for (const topicCount of TOPIC_COUNTS) {
       const projectRoot = projectRootByCount.get(topicCount)!;
@@ -141,18 +155,21 @@ describe('auto-memory recall scan latency', () => {
         samples.push(await measureTimeToFastResultMs(projectRoot));
       }
       samples.sort((a, b) => a - b);
+      const best = samples[0];
       const median = samples[Math.floor(samples.length / 2)];
       const worst = samples[samples.length - 1];
-      rows.push([topicCount, median, worst]);
+      rows.push([topicCount, best, median, worst]);
 
       expect(Number.isFinite(median)).toBe(true);
     }
 
     const [smallest] = rows;
-    // The ordinary case must leave the rest of the budget to spare. Loose
-    // because CI is shared; the table is what carries the detail.
+    // The ordinary case must leave the rest of the budget to spare. On
+    // shared runners only the best sample survives contention, so the loose
+    // bound checks it; off them the median faces the strict ceiling. The
+    // table is what carries the detail.
     expect(smallest[0]).toBe(TOPIC_COUNTS[0]);
-    expect(smallest[1]).toBeLessThan(INITIAL_BUDGET_MS / 2);
+    expect(smallest[SHARED_CI ? 1 : 2]).toBeLessThan(FAST_RESULT_CEILING_MS);
 
     console.log(
       [
@@ -160,11 +177,11 @@ describe('auto-memory recall scan latency', () => {
         'Scan gate — time from recall start to fast result (single project scope)',
         `initial budget: ${INITIAL_BUDGET_MS} ms`,
         '',
-        `| topics | median | worst of ${REPEATS} | share of budget | fast result inside budget? |`,
-        '| --- | --- | --- | --- | --- |',
+        `| topics | best of ${REPEATS} | median | worst of ${REPEATS} | share of budget | fast result inside budget? |`,
+        '| --- | --- | --- | --- | --- | --- |',
         ...rows.map(
-          ([topicCount, median, worst]) =>
-            `| ${topicCount} | ${median.toFixed(1)} ms | ${worst.toFixed(1)} ms | ${((median / INITIAL_BUDGET_MS) * 100).toFixed(1)}% | ${worst < INITIAL_BUDGET_MS ? 'yes' : 'no'} |`,
+          ([topicCount, best, median, worst]) =>
+            `| ${topicCount} | ${best.toFixed(1)} ms | ${median.toFixed(1)} ms | ${worst.toFixed(1)} ms | ${((median / INITIAL_BUDGET_MS) * 100).toFixed(1)}% | ${worst < INITIAL_BUDGET_MS ? 'yes' : 'no'} |`,
         ),
         '',
         'The fast result is only available once this scan completes, so this is',
diff --git a/packages/vscode-ide-companion/NOTICES.txt b/packages/vscode-ide-companion/NOTICES.txt
index c8f2154ae4f..43723cd4b70 100644
--- a/packages/vscode-ide-companion/NOTICES.txt
+++ b/packages/vscode-ide-companion/NOTICES.txt
@@ -5052,7 +5052,7 @@ THE SOFTWARE.
 
 
 ============================================================
-qs@6.15.2
+qs@6.16.0
 (https://github.com/ljharb/qs.git)
 
 BSD 3-Clause License
@@ -5087,7 +5087,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 ============================================================
-side-channel@1.1.0
+side-channel@1.1.1
 (git+https://github.com/ljharb/side-channel.git)
 
 MIT License
@@ -5141,7 +5141,7 @@ SOFTWARE.
 
 
 ============================================================
-side-channel-list@1.0.0
+side-channel-list@1.0.1
 (git+https://github.com/ljharb/side-channel-list.git)
 
 MIT License
diff --git a/packages/web-shell/client/components/MessageList.dom.test.tsx b/packages/web-shell/client/components/MessageList.dom.test.tsx
index 335167c4a4b..b854e4d412b 100644
--- a/packages/web-shell/client/components/MessageList.dom.test.tsx
+++ b/packages/web-shell/client/components/MessageList.dom.test.tsx
@@ -513,6 +513,22 @@ 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 lane's per-test budget (60s on shared ECS runners,
+// vitest's 5s default elsewhere), so a wait that never resolves still fails
+// as an assertion.
+const FLUSH_DEADLINE_MS = process.env['RUNNER_NAME']?.startsWith('ecs-qwen-')
+  ? 10_000
+  : 4_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 +1417,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 +2545,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.
diff --git a/scripts/tests/qwen-autofix-workflow.test.js b/scripts/tests/qwen-autofix-workflow.test.js
index 4189f244e43..f9dc89bae63 100644
--- a/scripts/tests/qwen-autofix-workflow.test.js
+++ b/scripts/tests/qwen-autofix-workflow.test.js
@@ -19,7 +19,7 @@ import {
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import { getWorkflowJob } from './workflow-helpers.js';
 
@@ -384,6 +384,15 @@ const IDLE_NOW =
   'idle-timeout (no output for 1200000ms — the sandbox likely hung at startup)';
 const IDLE_HEAD = `🤖 AutoFix ran out of time before finishing (${IDLE_NOW}) (attempt 2/100) — it will retry on the next scan.`;
 
+// The heaviest cases here scan the whole rendered workflow (~15k lines)
+// repeatedly: 'upserts deferred findings into a per-PR issue that survives
+// the merge' alone measures ~14s on an idle machine against the 30s suite
+// default, and it exhausted that budget on a contended release runner in
+// runs 33676423730 and 33683912557 — the only failure in a job where the
+// other 75 files passed. Same reasoning as install-script.test.js: give the
+// file headroom rather than let host contention decide a release.
+vi.setConfig({ testTimeout: 90_000 });
+
 describe('qwen-autofix workflow', () => {
   it('keeps ECS issue autofix limited to forced and ready-for-agent issues', () => {
     expect(workflow).toContain('autofixTier');
diff --git a/scripts/tests/release-workflow.test.js b/scripts/tests/release-workflow.test.js
index 3529dbfcbbe..37232e3e71f 100644
--- a/scripts/tests/release-workflow.test.js
+++ b/scripts/tests/release-workflow.test.js
@@ -540,8 +540,12 @@ describe('release workflow', () => {
     expect(testStep.run).toContain(
       'npm run test:release:workspaces -- --shard=${{ matrix.shard }}/3 --passWithNoTests "${retry_arg[@]}"',
     );
+    // Every release schedule retries, stable included: running the stable
+    // lane with no retry let one flaky test out of ~30k red a release whose
+    // other gates were all green. The default is pinned here so a silent
+    // drop back to a no-retry stable lane fails this test.
     expect(testStep.env.VITEST_RETRY).toBe(
-      "${{ (needs.prepare.outputs.is_nightly == 'true' || needs.prepare.outputs.is_preview == 'true') && '2' || '' }}",
+      "${{ vars.QWEN_RELEASE_VITEST_RETRY || '2' }}",
     );
 
     const workspacePackages = getTestCiWorkspaces();
@@ -559,11 +563,12 @@ describe('release workflow', () => {
     }
   });
 
-  it('passes --retry only when the release schedule asks for one', () => {
+  it('passes --retry unless the operator switched it off', () => {
     // The flag reaches every workspace's vitest, where a command line option
-    // outranks the config. Passing --retry=0 on stable releases would switch
-    // off a workspace's own retry (packages/sdk-typescript) on this lane
-    // alone, so the stable path must omit the flag rather than zero it.
+    // outranks the config. Every schedule now retries by default; the only
+    // way off is the operator sentinel, and it must omit the flag rather
+    // than zero it — --retry=0 would switch off a workspace's own retry
+    // (packages/sdk-typescript) on this lane alone.
     const testStep = releaseYaml.jobs.workspace_tests.steps.find(
       (step) => step.name === 'Run Workspace Tests',
     );
@@ -572,6 +577,9 @@ describe('release workflow', () => {
     for (const [retry, expected] of [
       ['2', '--retry=2'],
       ['', null],
+      // 'off' must omit the flag, not pass --retry=0: that would outrank a
+      // workspace's own config-level retry.
+      ['off', null],
     ]) {
       const dir = mkdtempSync(join(tmpdir(), 'release-retry-'));
       try {
diff --git a/scripts/tests/sdk-java-workflow.test.js b/scripts/tests/sdk-java-workflow.test.js
index f3109d5425f..e27ea6293b6 100644
--- a/scripts/tests/sdk-java-workflow.test.js
+++ b/scripts/tests/sdk-java-workflow.test.js
@@ -45,4 +45,21 @@ describe('SDK Java self-hosted workflow guards', () => {
       'if: "${{ runner.environment == \'github-hosted\' }}"',
     );
   });
+
+  it.each(['test', 'daemon-e2e'])(
+    'keeps setup-java Maven files job-local in the %s job',
+    (name) => {
+      const block = job(name);
+      expect(block).toContain(
+        "settings-path: '${{ runner.temp }}/setup-java-m2'",
+      );
+      expect(
+        block.match(
+          /MAVEN_ARGS: '--settings \$\{\{ runner\.temp \}\}\/setup-java-m2\/settings\.xml --toolchains \$\{\{ runner\.temp \}\}\/setup-java-m2\/toolchains\.xml'/g,
+        ),
+      ).toHaveLength(name === 'test' ? 4 : 1);
+      expect(block).not.toContain('Drop shared Maven toolchains.xml');
+      expect(block).not.toContain('rm -f "${HOME}/.m2/toolchains.xml"');
+    },
+  );
 });