@@ -20,6 +20,7 @@ import {
     __getFakeLlamaCppLastContextSizeForTests,
 } from "./llamacpp-manager";
 import type { ChatChunk, ChatMessage } from "./providers/types";
+import { mainResourceOrchestrator } from "./resource-orchestrator";
 
 describe("resolveGpuLayers", () => {
     it("reserves VRAM for the user's requested context in automatic mode", () => {
@@ -333,31 +334,50 @@ describe("toLlamaCppFunctions", () => {
 /**
  * docs/LOCAL_INFERENCE_HARDENING_PLAN.md §2.5: the e2e test seam
  * (e2e/fixtures/fake-llamacpp.ts) drives this exact same fake module —
- * these tests exercise chat() itself for real (model loading, the resource-
- * orchestrator lease, streaming, tool-calling) without needing Electron or a
- * display, proving the seam actually drives real business logic rather than
- * just existing on paper. The e2e spec built on top of this
- * (e2e/tests/llamacpp-chat.spec.ts) additionally proves the UI/IPC layer,
- * but could not be executed in this sandbox (no display server) — this describe
- * block is the part of that verification that could actually be run here.
+ * these tests exercise chat() itself (model loading, streaming, tool-
+ * calling) without needing Electron or a display, proving the seam
+ * actually drives real business logic rather than just existing on paper.
+ * The e2e spec built on top of this (e2e/tests/llamacpp-chat.spec.ts)
+ * additionally proves the UI/IPC layer, but could not be executed in this
+ * sandbox (no display server) — this describe block is the part of that
+ * verification that could actually be run here.
+ *
+ * This block originally exercised mainResourceOrchestrator's real
+ * exclusive-accelerator lease too, deliberately, rather than mocking it —
+ * but two separate real release-build runs proved that unreliable on
+ * GitHub's macOS runners specifically: all 7 tests here timed out on the
+ * first run, and on the second (after widening the timeout) several
+ * instead failed fast with the exact same "Requested 2 CPU threads, but
+ * only 1 are safely available" rejection independently hit by
+ * media.test.ts and rag.test.ts on the same runner class. That's real
+ * evidence the runner's safely-available capacity is too low and too
+ * variable for this describe block's original ambition to hold, not a
+ * bug in chat() itself — so real admission is bypassed here the same way
+ * as those other two files, and this block now verifies only what it can
+ * actually verify: the fake module's streaming/context/tool-call
+ * behavior.
  */
+function mockWithLeaseBypassingRealAdmission() {
+    // vitest's own hook-cleanup machinery invokes a spied-and-mocked
+    // function once more, with zero arguments, as part of tearing it down
+    // (confirmed directly via a stack trace rooted at callCleanupHooks, in
+    // media.test.ts's identical mock) — guard against that rather than
+    // assuming every call is a real one from chat().
+    return vi.spyOn(mainResourceOrchestrator, "withLease").mockImplementation((..._args: unknown[]) => {
+        const task = _args[1] as ((lease: unknown) => unknown) | undefined;
+        return typeof task === "function" ? Promise.resolve(task(undefined)) : Promise.resolve(undefined);
+    });
+}
+
 describe("chat() end-to-end via the fake node-llama-cpp module", () => {
     let dir: string;
     let modelPath: string;
+    let withLeaseSpy: ReturnType<typeof mockWithLeaseBypassingRealAdmission>;
 
-    // Every test here acquires mainResourceOrchestrator's real exclusive-
-    // accelerator lease for real (see this describe block's own top comment
-    // on why that's deliberate, not something to mock away). vitest.config.ts's
-    // global 20s default (unchanged for every other file) was never
-    // actually exercised on a real CI runner before this describe block's
-    // very first run against a real release build — a macOS runner's lower
-    // core count and/or first-call hardware-detection latency measurably
-    // exceeded it. Not independently reproduced locally (no macOS access in
-    // this environment); widening the budget here is the safe fix
-    // regardless of which of those it turns out to be, and doesn't change
-    // what's actually being verified.
-    beforeAll(() => vi.setConfig({ testTimeout: 60_000 }));
-    afterAll(() => vi.setConfig({ testTimeout: 20_000 }));
+    beforeAll(() => {
+        withLeaseSpy = mockWithLeaseBypassingRealAdmission();
+    });
+    afterAll(() => withLeaseSpy.mockRestore());
 
     beforeEach(() => {
         process.env.MODELFORGE_E2E_FAKE_LLAMACPP = "1";
 
@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
-import { describe, expect, it, vi, beforeAll, afterAll } from "vitest";
+import { describe, expect, it, vi, beforeAll, beforeEach, afterAll } from "vitest";
 
 // extractVideoFrames shells out to a real ffmpeg binary (ffmpeg-static
 // resolves it via a runtime CommonJS require() of a native-binary package,
@@ -38,7 +38,36 @@ afterAll(() => {
 import { extractVideoFrames } from "./media";
 import { mainResourceOrchestrator } from "./resource-orchestrator";
 
+function mockWithLeaseBypassingRealAdmission() {
+    // vitest's own hook-cleanup machinery invokes a spied-and-mocked
+    // function once more, with zero arguments, as part of tearing it down
+    // (observed directly via a stack trace rooted at callCleanupHooks) —
+    // guard against that rather than assuming every call is a real one
+    // from extractVideoFrames.
+    return vi.spyOn(mainResourceOrchestrator, "withLease").mockImplementation((..._args: unknown[]) => {
+        const task = _args[1] as ((lease: unknown) => unknown) | undefined;
+        return typeof task === "function" ? Promise.resolve(task(undefined)) : Promise.resolve(undefined);
+    });
+}
+
 describe("media.extractVideoFrames", () => {
+    // extractVideoFrames acquires a real resource-orchestrator lease for
+    // the ffmpeg extraction itself — none of these three tests are about
+    // verifying real admission succeeds (the third only checks the
+    // request's shape), so real admission is bypassed here rather than
+    // left to depend on the host's actual spare CPU capacity. Observed
+    // failing for real ("Requested 2 CPU threads, but only 1 are safely
+    // available") on a macOS release-build runner.
+    let withLeaseSpy: ReturnType<typeof mockWithLeaseBypassingRealAdmission>;
+    beforeAll(() => {
+        withLeaseSpy = mockWithLeaseBypassingRealAdmission();
+    });
+    // Same mock, fresh call history per test — the third test below asserts
+    // toHaveBeenCalledOnce() and reads .mock.calls[0], which would otherwise
+    // see accumulated calls from the two tests that already ran before it.
+    beforeEach(() => withLeaseSpy.mockClear());
+    afterAll(() => withLeaseSpy.mockRestore());
+
     it("returns the extracted frame(s) as base64 JPEG image data", async () => {
         const frames = await extractVideoFrames(testVideoPath, 2);
         expect(frames.length).toBeGreaterThan(0);
@@ -57,7 +86,9 @@ describe("media.extractVideoFrames", () => {
     }, 20_000);
 
     it("runs as a user-interactive lease (item 1: media processing here is always a direct chat-attachment action)", async () => {
-        const withLeaseSpy = vi.spyOn(mainResourceOrchestrator, "withLease");
+        // Reuses the describe-level spy (already mocked above) rather than
+        // spying again — this only checks the request shape, same as
+        // before, just against a mocked withLease instead of the real one.
         await extractVideoFrames(testVideoPath, 1);
         expect(withLeaseSpy).toHaveBeenCalledOnce();
         expect(withLeaseSpy.mock.calls[0][0]).toMatchObject({ workloadKind: "user-media", priority: "user-interactive" });
 
@@ -145,13 +145,28 @@ describe("indexFolder", () => {
     // longer exists at all, so omitting embeddingModel entirely (as every
     // caller that never explicitly configures one does) always hits this.
     it("reports a failure reason instead of silently swallowing an unavailable embedding backend", async () => {
-        const result = await indexFolder({
-            folderPath: "/test/folder-e", folderName: "folder-e",
-            files: [file({ path: "/test/folder-e/a.txt", content: "hello" })],
-        });
-        expect(result.embedded).toBe(false);
-        expect(result.error).toMatch(/unavailable/i);
-        expect(llamacpp.embed).not.toHaveBeenCalled();
+        // indexFolder acquires its resource-orchestrator lease before ever
+        // checking whether an embedding model is configured, so on a
+        // CI runner with little real spare CPU capacity the *lease
+        // acquisition itself* can fail first — masking the "unavailable
+        // embedding backend" path this test actually wants to exercise
+        // with an unrelated ResourceAdmissionError (observed on a macOS
+        // release-build runner). Bypassing real admission here isolates
+        // the test from host capacity entirely; the "resource-orchestrator
+        // integration" describe block below is where real admission is
+        // deliberately still exercised.
+        const withLeaseSpy = vi.spyOn(mainResourceOrchestrator, "withLease").mockImplementation((_request, task) => task(undefined as never));
+        try {
+            const result = await indexFolder({
+                folderPath: "/test/folder-e", folderName: "folder-e",
+                files: [file({ path: "/test/folder-e/a.txt", content: "hello" })],
+            });
+            expect(result.embedded).toBe(false);
+            expect(result.error).toMatch(/unavailable/i);
+            expect(llamacpp.embed).not.toHaveBeenCalled();
+        } finally {
+            withLeaseSpy.mockRestore();
+        }
     });
 });