diff --git a/.bun-version b/.bun-version
new file mode 100644
index 000000000..7962dcfdb
--- /dev/null
+++ b/.bun-version
@@ -0,0 +1 @@
+1.3.13
diff --git a/.github/workflows/pr-checks.yml b/.github/workflows/pr-checks.yml
index 5379fb865..92d831f06 100644
--- a/.github/workflows/pr-checks.yml
+++ b/.github/workflows/pr-checks.yml
@@ -15,22 +15,22 @@ jobs:
 
     steps:
       - name: Check out repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           fetch-depth: 0
 
       - name: Set up Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: 22
 
       - name: Set up Bun
-        uses: oven-sh/setup-bun@4bc047ad259df6fc24a6c9b0f9a0cb08cf17fbe5 # v2.0.1
+        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
         with:
-          bun-version: 1.3.11
+          bun-version-file: .bun-version
 
       - name: Set up Python
-        uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c # v5.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: "3.12"
           cache: "pip"
@@ -64,17 +64,17 @@ jobs:
 
     steps:
       - name: Check out repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: 22
 
       - name: Set up Bun
-        uses: oven-sh/setup-bun@4bc047ad259df6fc24a6c9b0f9a0cb08cf17fbe5 # v2.0.1
+        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
         with:
-          bun-version: 1.3.11
+          bun-version-file: .bun-version
 
       - name: Install web dependencies
         run: bun install --cwd web --frozen-lockfile
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index f831478ea..dbda3cb1d 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -24,7 +24,7 @@ jobs:
     steps:
       - name: Run release-please
         id: release
-        uses: googleapis/release-please-action@16a9c90856f42705d54a6fda1823352bdc62cf38
+        uses: googleapis/release-please-action@45996ed1f6d02564a971a2fa1b5860e934307cf7 # v5.0.0
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           release-type: node
@@ -40,21 +40,21 @@ jobs:
       id-token: write
     steps:
       - name: Checkout release tag
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ needs.release-please.outputs.tag_name }}
           fetch-depth: 0
 
       - name: Set up Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: 24
           registry-url: https://registry.npmjs.org
 
       - name: Set up Bun
-        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6
+        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
         with:
-          bun-version: 1.3.11
+          bun-version-file: .bun-version
 
       - name: Install dependencies
         run: bun install --frozen-lockfile
@@ -98,15 +98,15 @@ jobs:
       packages: write
     steps:
       - name: Checkout release tag
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ needs.release-please.outputs.tag_name }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3.10.0
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
 
       - name: Log in to GitHub Container Registry
-        uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -114,7 +114,7 @@ jobs:
 
       - name: Extract metadata
         id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
         with:
           images: ghcr.io/${{ github.repository }}
           tags: |
@@ -123,7 +123,7 @@ jobs:
             type=raw,value=latest
 
       - name: Build and load locally
-        uses: docker/build-push-action@14487ce63c7a62a4a324b0bfb37086795e31c6c1 # v6.16.0
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
         with:
           context: .
           load: true
@@ -134,7 +134,7 @@ jobs:
         run: docker run --rm openclaude:smoke --version
 
       - name: Build and push
-        uses: docker/build-push-action@14487ce63c7a62a4a324b0bfb37086795e31c6c1 # v6.16.0
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
         with:
           context: .
           push: true
diff --git a/ANDROID_INSTALL.md b/ANDROID_INSTALL.md
index 818205ca7..ca49175a1 100644
--- a/ANDROID_INSTALL.md
+++ b/ANDROID_INSTALL.md
@@ -62,7 +62,7 @@ This downloads ~200–400MB. Wait for it to complete.
 proot-distro login ubuntu
 curl -fsSL https://bun.sh/install | bash
 source ~/.bashrc
-bun --version  # should show 1.3.11+
+bun --version  # should show 1.3.13+
 ```
 
 ### Step 6 — Build OpenClaude
diff --git a/Dockerfile b/Dockerfile
index 950f33ae2..a1a868562 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,13 +1,16 @@
 # ---- build stage ----
 FROM node:22-slim AS build
 
-# Install Bun
-RUN npm install -g bun@1.3.11
-
 WORKDIR /app
 
 # Copy dependency manifests first for better layer caching
-COPY package.json bun.lock ./
+COPY package.json bun.lock .bun-version ./
+
+# Install the Bun version tracked by the repo
+RUN set -eu; \
+    BUN_VERSION="$(tr -d '\r\n' < .bun-version)"; \
+    printf '%s' "$BUN_VERSION" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+$'; \
+    npm install -g "bun@$BUN_VERSION"
 
 # Install all dependencies (including devDependencies for build)
 RUN bun install --frozen-lockfile
diff --git a/docs/advanced-setup.md b/docs/advanced-setup.md
index ad1b78c3f..7d8ab03bd 100644
--- a/docs/advanced-setup.md
+++ b/docs/advanced-setup.md
@@ -12,7 +12,7 @@ npm install -g @gitlawb/openclaude
 
 ### Option B: From source with Bun
 
-Use Bun `1.3.11` or newer for source builds on Windows. Older Bun versions can fail during `bun run build`.
+Use Bun `1.3.13` or newer for source builds on Windows. Older Bun versions can fail during `bun run build`.
 
 ```bash
 git clone https://github.com/Gitlawb/openclaude.git
diff --git a/src/integrations/discoveryCache.test.ts b/src/integrations/discoveryCache.test.ts
index 6df25bc40..a07a0b4cb 100644
--- a/src/integrations/discoveryCache.test.ts
+++ b/src/integrations/discoveryCache.test.ts
@@ -17,6 +17,10 @@ import {
   setFsImplementation,
   setOriginalFsImplementation,
 } from '../utils/fsOperations.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../test/sharedMutationLock.js'
 
 const originalConfigDir = process.env.CLAUDE_CONFIG_DIR
 
@@ -31,6 +35,7 @@ function createModel(id: string): ModelCatalogEntry {
 }
 
 beforeEach(async () => {
+  await acquireSharedMutationLock('discoveryCache.test.ts')
   tempDir = mkdtempSync(join(tmpdir(), 'openclaude-discovery-cache-test-'))
   process.env.CLAUDE_CONFIG_DIR = tempDir
   setOriginalFsImplementation()
@@ -38,13 +43,17 @@ beforeEach(async () => {
 })
 
 afterEach(() => {
-  setOriginalFsImplementation()
-  if (originalConfigDir === undefined) {
-    delete process.env.CLAUDE_CONFIG_DIR
-  } else {
-    process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+  try {
+    setOriginalFsImplementation()
+    if (originalConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+    }
+    rmSync(tempDir, { recursive: true, force: true })
+  } finally {
+    releaseSharedMutationLock()
   }
-  rmSync(tempDir, { recursive: true, force: true })
 })
 
 describe('parseDurationString', () => {
diff --git a/src/integrations/discoveryService.test.ts b/src/integrations/discoveryService.test.ts
index 386b6a81a..9c48c2041 100644
--- a/src/integrations/discoveryService.test.ts
+++ b/src/integrations/discoveryService.test.ts
@@ -3,6 +3,10 @@ import { mkdtempSync, rmSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import { registerGateway } from './index.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../test/sharedMutationLock.js'
 
 const originalFetch = globalThis.fetch
 const originalEnv = {
@@ -58,7 +62,8 @@ function clearProviderEnv(): void {
   delete process.env.CLAUDE_CODE_USE_FOUNDRY
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('discoveryService.test.ts')
   mock.restore()
   tempDir = mkdtempSync(join(tmpdir(), 'openclaude-discovery-service-test-'))
   process.env.CLAUDE_CONFIG_DIR = tempDir
@@ -68,22 +73,26 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  mock.restore()
-  globalThis.fetch = originalFetch
-  rmSync(tempDir, { recursive: true, force: true })
-  restoreEnvValue('CLAUDE_CONFIG_DIR')
-  restoreEnvValue('OPENROUTER_API_KEY')
-  restoreEnvValue('OPENAI_BASE_URL')
-  restoreEnvValue('OPENAI_API_BASE')
-  restoreEnvValue('OPENAI_MODEL')
-  restoreEnvValue('CLAUDE_CODE_USE_OPENAI')
-  restoreEnvValue('CLAUDE_CODE_USE_GEMINI')
-  restoreEnvValue('CLAUDE_CODE_USE_MISTRAL')
-  restoreEnvValue('CLAUDE_CODE_USE_GITHUB')
-  restoreEnvValue('CLAUDE_CODE_USE_BEDROCK')
-  restoreEnvValue('CLAUDE_CODE_USE_VERTEX')
-  restoreEnvValue('CLAUDE_CODE_USE_FOUNDRY')
-  restoreEnvValue('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC')
+  try {
+    mock.restore()
+    globalThis.fetch = originalFetch
+    rmSync(tempDir, { recursive: true, force: true })
+    restoreEnvValue('CLAUDE_CONFIG_DIR')
+    restoreEnvValue('OPENROUTER_API_KEY')
+    restoreEnvValue('OPENAI_BASE_URL')
+    restoreEnvValue('OPENAI_API_BASE')
+    restoreEnvValue('OPENAI_MODEL')
+    restoreEnvValue('CLAUDE_CODE_USE_OPENAI')
+    restoreEnvValue('CLAUDE_CODE_USE_GEMINI')
+    restoreEnvValue('CLAUDE_CODE_USE_MISTRAL')
+    restoreEnvValue('CLAUDE_CODE_USE_GITHUB')
+    restoreEnvValue('CLAUDE_CODE_USE_BEDROCK')
+    restoreEnvValue('CLAUDE_CODE_USE_VERTEX')
+    restoreEnvValue('CLAUDE_CODE_USE_FOUNDRY')
+    restoreEnvValue('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC')
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 describe('discoverModelsForRoute', () => {
diff --git a/src/services/api/client.test.ts b/src/services/api/client.test.ts
index 68394b673..e286db26c 100644
--- a/src/services/api/client.test.ts
+++ b/src/services/api/client.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 import { getAnthropicClient } from './client.js'
 
 type FetchType = typeof globalThis.fetch
@@ -49,7 +50,8 @@ function restoreEnv(key: string, value: string | undefined): void {
   }
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('client.test.ts')
   ;(globalThis as Record<string, unknown>).MACRO = { VERSION: 'test-version' }
   process.env.CLAUDE_CODE_USE_GEMINI = '1'
   process.env.GEMINI_API_KEY = 'gemini-test-key'
@@ -79,33 +81,40 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  ;(globalThis as Record<string, unknown>).MACRO = originalMacro
-  restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
-  restoreEnv('CLAUDE_CODE_USE_BEDROCK', originalEnv.CLAUDE_CODE_USE_BEDROCK)
-  restoreEnv('CLAUDE_CODE_SKIP_BEDROCK_AUTH', originalEnv.CLAUDE_CODE_SKIP_BEDROCK_AUTH)
-  restoreEnv('CLAUDE_CODE_USE_VERTEX', originalEnv.CLAUDE_CODE_USE_VERTEX)
-  restoreEnv('CLAUDE_CODE_USE_FOUNDRY', originalEnv.CLAUDE_CODE_USE_FOUNDRY)
-  restoreEnv('CLAUDE_CODE_USE_GEMINI', originalEnv.CLAUDE_CODE_USE_GEMINI)
-  restoreEnv('CLAUDE_CODE_USE_GITHUB', originalEnv.CLAUDE_CODE_USE_GITHUB)
-  restoreEnv('CLAUDE_CODE_USE_MISTRAL', originalEnv.CLAUDE_CODE_USE_MISTRAL)
-  restoreEnv('GEMINI_API_KEY', originalEnv.GEMINI_API_KEY)
-  restoreEnv('GEMINI_MODEL', originalEnv.GEMINI_MODEL)
-  restoreEnv('GEMINI_BASE_URL', originalEnv.GEMINI_BASE_URL)
-  restoreEnv('GEMINI_AUTH_MODE', originalEnv.GEMINI_AUTH_MODE)
-  restoreEnv('GOOGLE_API_KEY', originalEnv.GOOGLE_API_KEY)
-  restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
-  restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
-  restoreEnv('OPENAI_API_BASE', originalEnv.OPENAI_API_BASE)
-  restoreEnv('OPENAI_API_FORMAT', originalEnv.OPENAI_API_FORMAT)
-  restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
-  restoreEnv('MINIMAX_API_KEY', originalEnv.MINIMAX_API_KEY)
-  restoreEnv('XAI_API_KEY', originalEnv.XAI_API_KEY)
-  restoreEnv('NVIDIA_NIM', originalEnv.NVIDIA_NIM)
-  restoreEnv('ANTHROPIC_API_KEY', originalEnv.ANTHROPIC_API_KEY)
-  restoreEnv('ANTHROPIC_AUTH_TOKEN', originalEnv.ANTHROPIC_AUTH_TOKEN)
-  restoreEnv('ANTHROPIC_BASE_URL', originalEnv.ANTHROPIC_BASE_URL)
-  restoreEnv('ANTHROPIC_CUSTOM_HEADERS', originalEnv.ANTHROPIC_CUSTOM_HEADERS)
-  globalThis.fetch = originalFetch
+  try {
+    ;(globalThis as Record<string, unknown>).MACRO = originalMacro
+    restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
+    restoreEnv('CLAUDE_CODE_USE_BEDROCK', originalEnv.CLAUDE_CODE_USE_BEDROCK)
+    restoreEnv(
+      'CLAUDE_CODE_SKIP_BEDROCK_AUTH',
+      originalEnv.CLAUDE_CODE_SKIP_BEDROCK_AUTH,
+    )
+    restoreEnv('CLAUDE_CODE_USE_VERTEX', originalEnv.CLAUDE_CODE_USE_VERTEX)
+    restoreEnv('CLAUDE_CODE_USE_FOUNDRY', originalEnv.CLAUDE_CODE_USE_FOUNDRY)
+    restoreEnv('CLAUDE_CODE_USE_GEMINI', originalEnv.CLAUDE_CODE_USE_GEMINI)
+    restoreEnv('CLAUDE_CODE_USE_GITHUB', originalEnv.CLAUDE_CODE_USE_GITHUB)
+    restoreEnv('CLAUDE_CODE_USE_MISTRAL', originalEnv.CLAUDE_CODE_USE_MISTRAL)
+    restoreEnv('GEMINI_API_KEY', originalEnv.GEMINI_API_KEY)
+    restoreEnv('GEMINI_MODEL', originalEnv.GEMINI_MODEL)
+    restoreEnv('GEMINI_BASE_URL', originalEnv.GEMINI_BASE_URL)
+    restoreEnv('GEMINI_AUTH_MODE', originalEnv.GEMINI_AUTH_MODE)
+    restoreEnv('GOOGLE_API_KEY', originalEnv.GOOGLE_API_KEY)
+    restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
+    restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
+    restoreEnv('OPENAI_API_BASE', originalEnv.OPENAI_API_BASE)
+    restoreEnv('OPENAI_API_FORMAT', originalEnv.OPENAI_API_FORMAT)
+    restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
+    restoreEnv('MINIMAX_API_KEY', originalEnv.MINIMAX_API_KEY)
+    restoreEnv('XAI_API_KEY', originalEnv.XAI_API_KEY)
+    restoreEnv('NVIDIA_NIM', originalEnv.NVIDIA_NIM)
+    restoreEnv('ANTHROPIC_API_KEY', originalEnv.ANTHROPIC_API_KEY)
+    restoreEnv('ANTHROPIC_AUTH_TOKEN', originalEnv.ANTHROPIC_AUTH_TOKEN)
+    restoreEnv('ANTHROPIC_BASE_URL', originalEnv.ANTHROPIC_BASE_URL)
+    restoreEnv('ANTHROPIC_CUSTOM_HEADERS', originalEnv.ANTHROPIC_CUSTOM_HEADERS)
+    globalThis.fetch = originalFetch
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 test('first-party Anthropic requests execute the configured fetch wrapper without runtime symbol errors', async () => {
diff --git a/src/services/api/codexOAuth.test.ts b/src/services/api/codexOAuth.test.ts
index e98b57927..966083790 100644
--- a/src/services/api/codexOAuth.test.ts
+++ b/src/services/api/codexOAuth.test.ts
@@ -1,166 +1,311 @@
-import { createServer } from 'node:http'
-
 import { afterEach, expect, mock, test } from 'bun:test'
-
+import { acquireEnvMutex, releaseEnvMutex } from '../../entrypoints/sdk/shared.js'
 import { CodexOAuthService } from './codexOAuth.js'
 
-const originalFetch = globalThis.fetch
-const originalCallbackPort = process.env.CODEX_OAUTH_CALLBACK_PORT
-const originalClientId = process.env.CODEX_OAUTH_CLIENT_ID
+type CodexOAuthTestSnapshot = {
+  fetch: typeof globalThis.fetch
+  callbackPort: string | undefined
+  callbackHost: string | undefined
+  clientId: string | undefined
+}
+
+type FakeResponseCapture = {
+  body: string
+  headers: Record<string, string>
+  statusCode: number | null
+}
+
+type FakeServerResponse = {
+  destroyed: boolean
+  headersSent: boolean
+  writableEnded: boolean
+  writeHead: (statusCode: number, headers?: Record<string, string>) => void
+  end: (chunk?: string) => void
+}
+
+type FakeAuthCodeListenerInstance = {
+  callbackPath: string
+  capture: FakeResponseCapture | null
+  cancelCalls: Error[]
+  closeCalls: number
+  hasPendingResponse: () => boolean
+  start: (port?: number, host?: string) => Promise<number>
+  waitForAuthorization: (
+    state: string,
+    onReady: () => Promise<void>,
+  ) => Promise<string>
+  handleSuccessRedirect: (
+    scopes: string[],
+    customHandler?: (res: FakeServerResponse, scopes: string[]) => void,
+  ) => void
+  handleErrorRedirect: (customHandler?: (res: FakeServerResponse) => void) => void
+  cancelPendingAuthorization: (error?: Error) => void
+  close: () => void
+}
+
+let activeSnapshot: CodexOAuthTestSnapshot | null = null
+let fakeListenerInstance: FakeAuthCodeListenerInstance | null = null
+let nextFakePort = 41000
+
+function createFakeServerResponse(capture: FakeResponseCapture): FakeServerResponse {
+  return {
+    destroyed: false,
+    headersSent: false,
+    writableEnded: false,
+    writeHead(statusCode: number, headers?: Record<string, string>) {
+      capture.statusCode = statusCode
+      capture.headers = { ...(headers ?? {}) }
+      this.headersSent = true
+    },
+    end(chunk?: string) {
+      if (chunk) {
+        capture.body += chunk
+      }
+      this.writableEnded = true
+    },
+  }
+}
+
+function createFakeAuthCodeListener(callbackPath: string): FakeAuthCodeListenerInstance {
+  fakeListenerInstance = null
+  class FakeAuthCodeListener {
+    callbackPath: string
+    capture: FakeResponseCapture | null = null
+    cancelCalls: Error[] = []
+    closeCalls = 0
+    private pending = false
+    private boundPort = 0
+    private boundHost = 'localhost'
+
+    constructor(callbackPath: string = '/callback') {
+      this.callbackPath = callbackPath
+      fakeListenerInstance = this as unknown as FakeAuthCodeListenerInstance
+    }
+
+    hasPendingResponse(): boolean {
+      return this.pending
+    }
+
+    async start(port?: number, host: string = 'localhost'): Promise<number> {
+      this.boundHost = host
+      this.boundPort = port && port > 0 ? port : nextFakePort++
+      return this.boundPort
+    }
+
+    async waitForAuthorization(
+      state: string,
+      onReady: () => Promise<void>,
+    ): Promise<string> {
+      this.pending = true
+      this.capture = { body: '', headers: {}, statusCode: null }
+      await onReady()
+      void state
+      return 'auth-code'
+    }
+
+    handleSuccessRedirect(
+      scopes: string[],
+      customHandler?: (res: FakeServerResponse, scopes: string[]) => void,
+    ): void {
+      if (!this.pending || !this.capture) {
+        return
+      }
+
+      const res = createFakeServerResponse(this.capture)
+      customHandler?.(res, scopes)
+      if (!res.writableEnded) {
+        res.end()
+      }
+      this.pending = false
+    }
+
+    handleErrorRedirect(
+      customHandler?: (res: FakeServerResponse) => void,
+    ): void {
+      if (!this.pending || !this.capture) {
+        return
+      }
+
+      const res = createFakeServerResponse(this.capture)
+      customHandler?.(res)
+      if (!res.writableEnded) {
+        res.end()
+      }
+      this.pending = false
+    }
+
+    cancelPendingAuthorization(
+      error: Error = new Error('OAuth authorization was cancelled.'),
+    ): void {
+      this.cancelCalls.push(error)
+    }
+
+    close(): void {
+      this.closeCalls += 1
+      this.pending = false
+    }
+  }
+
+  return new FakeAuthCodeListener(callbackPath) as FakeAuthCodeListenerInstance
+}
+
+async function acquireCodexOAuthTestIsolation(): Promise<CodexOAuthTestSnapshot> {
+  const result = await acquireEnvMutex()
+  expect(result.acquired).toBe(true)
+
+  activeSnapshot = {
+    fetch: globalThis.fetch,
+    callbackPort: process.env.CODEX_OAUTH_CALLBACK_PORT,
+    callbackHost: process.env.CODEX_OAUTH_CALLBACK_HOST,
+    clientId: process.env.CODEX_OAUTH_CLIENT_ID,
+  }
+
+  return activeSnapshot
+}
+
+function restoreCodexOAuthTestIsolation(): void {
+  if (!activeSnapshot) {
+    return
+  }
+
+  const snapshot = activeSnapshot
+  activeSnapshot = null
+  fakeListenerInstance = null
+
+  globalThis.fetch = snapshot.fetch
+
+  if (snapshot.callbackPort === undefined) {
+    delete process.env.CODEX_OAUTH_CALLBACK_PORT
+  } else {
+    process.env.CODEX_OAUTH_CALLBACK_PORT = snapshot.callbackPort
+  }
+
+  if (snapshot.callbackHost === undefined) {
+    delete process.env.CODEX_OAUTH_CALLBACK_HOST
+  } else {
+    process.env.CODEX_OAUTH_CALLBACK_HOST = snapshot.callbackHost
+  }
+
+  if (snapshot.clientId === undefined) {
+    delete process.env.CODEX_OAUTH_CLIENT_ID
+  } else {
+    process.env.CODEX_OAUTH_CLIENT_ID = snapshot.clientId
+  }
+
+  releaseEnvMutex()
+}
 
 afterEach(() => {
   mock.restore()
-  globalThis.fetch = originalFetch
-
-  if (originalCallbackPort === undefined) {
-    delete process.env.CODEX_OAUTH_CALLBACK_PORT
-  } else {
-    process.env.CODEX_OAUTH_CALLBACK_PORT = originalCallbackPort
-  }
-
-  if (originalClientId === undefined) {
-    delete process.env.CODEX_OAUTH_CLIENT_ID
-  } else {
-    process.env.CODEX_OAUTH_CLIENT_ID = originalClientId
-  }
+  restoreCodexOAuthTestIsolation()
 })
 
-async function getFreePort(): Promise<number> {
-  return await new Promise((resolve, reject) => {
-    const server = createServer()
-
-    server.once('error', reject)
-    server.listen(0, '127.0.0.1', () => {
-      const address = server.address()
-      if (!address || typeof address === 'string') {
-        server.close(() => reject(new Error('Failed to allocate test port.')))
-        return
-      }
-
-      const { port } = address
-      server.close(error => {
-        if (error) {
-          reject(error)
-          return
-        }
-        resolve(port)
-      })
-    })
-  })
-}
-
-function buildCallbackRequest(authUrl: string): string {
-  const authorizeUrl = new URL(authUrl)
-  const redirectUri = authorizeUrl.searchParams.get('redirect_uri')
-  const state = authorizeUrl.searchParams.get('state')
-
-  if (!redirectUri || !state) {
-    throw new Error('Codex OAuth test did not receive a valid authorization URL.')
-  }
-
-  const callbackUrl = new URL(redirectUri)
-  callbackUrl.searchParams.set('code', 'auth-code')
-  callbackUrl.searchParams.set('state', state)
-  return callbackUrl.toString()
-}
-
 test('serves updated success copy after a successful Codex OAuth flow', async () => {
-  const callbackPort = await getFreePort()
-  process.env.CODEX_OAUTH_CALLBACK_PORT = String(callbackPort)
-  process.env.CODEX_OAUTH_CLIENT_ID = 'test-client-id'
+  await acquireCodexOAuthTestIsolation()
 
-  globalThis.fetch = mock(async (input, init) => {
-    const url = String(input)
-    if (url.startsWith('http://localhost:')) {
-      return originalFetch(input, init)
-    }
+  try {
+    process.env.CODEX_OAUTH_CLIENT_ID = 'test-client-id'
 
-    return new Response(
-      JSON.stringify({
-        access_token: 'access-token',
-        refresh_token: 'refresh-token',
-      }),
-      {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      },
+    globalThis.fetch = mock(async () => {
+      return new Response(
+        JSON.stringify({
+          access_token: 'access-token',
+          refresh_token: 'refresh-token',
+        }),
+        {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        },
+      )
+    }) as typeof fetch
+
+    const service = new CodexOAuthService({
+      callbackPort: 0,
+      callbackHost: '127.0.0.1',
+      createAuthCodeListener: createFakeAuthCodeListener,
+    })
+
+    let capturedAuthUrl = ''
+    const tokens = await service.startOAuthFlow(async authUrl => {
+      capturedAuthUrl = authUrl
+    })
+
+    expect(tokens.accessToken).toBe('access-token')
+    expect(tokens.refreshToken).toBe('refresh-token')
+    expect(capturedAuthUrl).toContain('client_id=test-client-id')
+    expect(capturedAuthUrl).toContain(
+      encodeURIComponent('http://127.0.0.1:41000/auth/callback'),
     )
-  }) as typeof fetch
-
-  const service = new CodexOAuthService()
-  let callbackResponsePromise!: Promise<Response>
-
-  const flowPromise = service.startOAuthFlow(async authUrl => {
-    callbackResponsePromise = originalFetch(buildCallbackRequest(authUrl))
-  })
-
-  const tokens = await flowPromise
-  const callbackResponse = await callbackResponsePromise
-  const html = await callbackResponse.text()
-
-  expect(tokens.accessToken).toBe('access-token')
-  expect(tokens.refreshToken).toBe('refresh-token')
-  expect(html).toContain('You can return to OpenClaude now.')
-  expect(html).toContain(
-    'OpenClaude will finish activating your new Codex OAuth login.',
-  )
-  expect(html).not.toContain('continue automatically')
+    expect(fakeListenerInstance?.capture?.statusCode).toBe(200)
+    expect(fakeListenerInstance?.capture?.body).toContain(
+      'You can return to OpenClaude now.',
+    )
+    expect(fakeListenerInstance?.capture?.body).toContain(
+      'OpenClaude will finish activating your new Codex OAuth login.',
+    )
+    expect(fakeListenerInstance?.capture?.body).not.toContain(
+      'continue automatically',
+    )
+  } finally {
+    restoreCodexOAuthTestIsolation()
+  }
 })
 
 test('cancellation during token exchange returns a cancelled page and rejects the flow', async () => {
-  const callbackPort = await getFreePort()
-  process.env.CODEX_OAUTH_CALLBACK_PORT = String(callbackPort)
-  process.env.CODEX_OAUTH_CLIENT_ID = 'test-client-id'
+  await acquireCodexOAuthTestIsolation()
 
-  let resolveFetchStart!: () => void
-  const fetchStarted = new Promise<void>(resolve => {
-    resolveFetchStart = resolve
-  })
+  try {
+    process.env.CODEX_OAUTH_CLIENT_ID = 'test-client-id'
 
-  globalThis.fetch = mock((input, init) => {
-    const url = String(input)
-    if (url.startsWith('http://localhost:')) {
-      return originalFetch(input, init)
-    }
-
-    return new Promise<Response>((_resolve, reject) => {
-      resolveFetchStart()
-
-      const signal = init?.signal
-      if (!signal) {
-        return
-      }
-
-      if (signal.aborted) {
-        reject(signal.reason)
-        return
-      }
-
-      signal.addEventListener(
-        'abort',
-        () => {
-          reject(signal.reason)
-        },
-        { once: true },
-      )
+    let resolveFetchStart!: () => void
+    const fetchStarted = new Promise<void>(resolve => {
+      resolveFetchStart = resolve
     })
-  }) as typeof fetch
 
-  const service = new CodexOAuthService()
-  let callbackResponsePromise!: Promise<Response>
+    globalThis.fetch = mock((_input, init) => {
+      return new Promise<Response>((_resolve, reject) => {
+        resolveFetchStart()
 
-  const flowPromise = service.startOAuthFlow(async authUrl => {
-    callbackResponsePromise = originalFetch(buildCallbackRequest(authUrl))
-  })
+        const signal = init?.signal
+        if (!signal) {
+          return
+        }
 
-  await fetchStarted
-  service.cleanup()
+        if (signal.aborted) {
+          reject(signal.reason)
+          return
+        }
 
-  await expect(flowPromise).rejects.toThrow('Codex OAuth flow was cancelled.')
+        signal.addEventListener(
+          'abort',
+          () => {
+            reject(signal.reason)
+          },
+          { once: true },
+        )
+      })
+    }) as typeof fetch
 
-  const callbackResponse = await callbackResponsePromise
-  const html = await callbackResponse.text()
+    const service = new CodexOAuthService({
+      callbackPort: 0,
+      callbackHost: '127.0.0.1',
+      createAuthCodeListener: createFakeAuthCodeListener,
+    })
 
-  expect(html).toContain('Codex login cancelled')
-  expect(html).toContain('retry in OpenClaude')
+    const flowPromise = service.startOAuthFlow(async () => {})
+
+    await fetchStarted
+    service.cleanup()
+
+    await expect(flowPromise).rejects.toThrow('Codex OAuth flow was cancelled.')
+    expect(fakeListenerInstance?.capture?.statusCode).toBe(200)
+    expect(fakeListenerInstance?.capture?.body).toContain(
+      'Codex login cancelled',
+    )
+    expect(fakeListenerInstance?.capture?.body).toContain(
+      'retry in OpenClaude',
+    )
+  } finally {
+    restoreCodexOAuthTestIsolation()
+  }
 })
diff --git a/src/services/api/codexOAuth.ts b/src/services/api/codexOAuth.ts
index fbeac022a..be2b99d24 100644
--- a/src/services/api/codexOAuth.ts
+++ b/src/services/api/codexOAuth.ts
@@ -10,6 +10,8 @@ import {
   CODEX_OAUTH_ORIGINATOR,
   CODEX_OAUTH_SCOPE,
   escapeHtml,
+  getCodexOAuthCallbackHost,
+  getCodexOAuthCallbackOrigin,
   exchangeCodexIdTokenForApiKey,
   getCodexOAuthCallbackPort,
   getCodexOAuthClientId,
@@ -33,10 +35,13 @@ export type CodexOAuthTokens = {
 
 function buildCodexAuthorizeUrl(options: {
   port: number
+  host: string
   codeChallenge: string
   state: string
 }): string {
-  const redirectUri = `http://localhost:${options.port}/auth/callback`
+  const redirectUri = `${getCodexOAuthCallbackOrigin(options.port, {
+    CODEX_OAUTH_CALLBACK_HOST: options.host,
+  } as NodeJS.ProcessEnv)}/auth/callback`
   const authUrl = new URL(`${CODEX_OAUTH_ISSUER}/oauth/authorize`)
 
   authUrl.searchParams.append('response_type', 'code')
@@ -117,9 +122,12 @@ async function exchangeAuthorizationCode(options: {
   authorizationCode: string
   codeVerifier: string
   port: number
+  host: string
   signal?: AbortSignal
 }): Promise<CodexOAuthTokens> {
-  const redirectUri = `http://localhost:${options.port}/auth/callback`
+  const redirectUri = `${getCodexOAuthCallbackOrigin(options.port, {
+    CODEX_OAUTH_CALLBACK_HOST: options.host,
+  } as NodeJS.ProcessEnv)}/auth/callback`
   const body = new URLSearchParams({
     grant_type: 'authorization_code',
     code: options.authorizationCode,
@@ -179,11 +187,29 @@ async function exchangeAuthorizationCode(options: {
   }
 }
 
+type CodexOAuthServiceOptions = {
+  callbackPort?: number
+  callbackHost?: string
+  createAuthCodeListener?: (callbackPath: string) => CodexOAuthListener
+}
+
+type CodexOAuthListener = Pick<
+  AuthCodeListener,
+  | 'start'
+  | 'hasPendingResponse'
+  | 'waitForAuthorization'
+  | 'handleSuccessRedirect'
+  | 'handleErrorRedirect'
+  | 'cancelPendingAuthorization'
+>
+
 export class CodexOAuthService {
-  private authCodeListener: AuthCodeListener | null = null
+  private authCodeListener: CodexOAuthListener | null = null
   private port: number | null = null
   private tokenExchangeAbortController: AbortController | null = null
 
+  constructor(private readonly options: CodexOAuthServiceOptions = {}) {}
+
   private buildCancellationError(): Error {
     return new Error('Codex OAuth flow was cancelled.')
   }
@@ -192,20 +218,26 @@ export class CodexOAuthService {
     authURLHandler: (authUrl: string) => Promise<void>,
   ): Promise<CodexOAuthTokens> {
     const codeVerifier = generateCodeVerifier()
-    const callbackPort = getCodexOAuthCallbackPort()
-    const authCodeListener = new AuthCodeListener('/auth/callback')
+    const callbackPort =
+      this.options.callbackPort ?? getCodexOAuthCallbackPort()
+    const callbackHost =
+      this.options.callbackHost ?? getCodexOAuthCallbackHost()
+    const authCodeListener =
+      this.options.createAuthCodeListener?.('/auth/callback') ??
+      new AuthCodeListener('/auth/callback')
 
     this.authCodeListener = authCodeListener
     this.port = null
 
     try {
-      const port = await authCodeListener.start(callbackPort)
+      const port = await authCodeListener.start(callbackPort, callbackHost)
       this.port = port
 
       const state = generateState()
       const codeChallenge = await generateCodeChallenge(codeVerifier)
       const authUrl = buildCodexAuthorizeUrl({
         port,
+        host: callbackHost,
         codeChallenge,
         state,
       })
@@ -227,6 +259,7 @@ export class CodexOAuthService {
             authorizationCode,
             codeVerifier,
             port,
+            host: callbackHost,
             signal: tokenExchangeAbortController.signal,
           })
         } finally {
@@ -286,7 +319,7 @@ export class CodexOAuthService {
         message.includes(String(callbackPort))
       ) {
         throw new Error(
-          `Codex OAuth needs localhost:${callbackPort} for its callback. Close any app already using that port and try again.`,
+          `Codex OAuth needs ${callbackHost}:${callbackPort} for its callback. Close any app already using that port and try again.`,
         )
       }
       throw error
diff --git a/src/services/api/codexOAuthShared.test.ts b/src/services/api/codexOAuthShared.test.ts
new file mode 100644
index 000000000..65ca60e07
--- /dev/null
+++ b/src/services/api/codexOAuthShared.test.ts
@@ -0,0 +1,38 @@
+import { expect, test } from 'bun:test'
+
+import {
+  DEFAULT_CODEX_OAUTH_CALLBACK_HOST,
+  DEFAULT_CODEX_OAUTH_CALLBACK_PORT,
+  getCodexOAuthCallbackHost,
+  getCodexOAuthCallbackPort,
+} from './codexOAuthShared.js'
+
+test('getCodexOAuthCallbackPort falls back for zero', () => {
+  expect(
+    getCodexOAuthCallbackPort({
+      CODEX_OAUTH_CALLBACK_PORT: '0',
+    } as NodeJS.ProcessEnv),
+  ).toBe(DEFAULT_CODEX_OAUTH_CALLBACK_PORT)
+})
+
+test('getCodexOAuthCallbackPort falls back for invalid values', () => {
+  expect(
+    getCodexOAuthCallbackPort({
+      CODEX_OAUTH_CALLBACK_PORT: '-1',
+    } as NodeJS.ProcessEnv),
+  ).toBe(DEFAULT_CODEX_OAUTH_CALLBACK_PORT)
+})
+
+test('getCodexOAuthCallbackHost only accepts loopback hosts', () => {
+  expect(
+    getCodexOAuthCallbackHost({
+      CODEX_OAUTH_CALLBACK_HOST: '127.0.0.1',
+    } as NodeJS.ProcessEnv),
+  ).toBe('127.0.0.1')
+
+  expect(
+    getCodexOAuthCallbackHost({
+      CODEX_OAUTH_CALLBACK_HOST: 'example.com',
+    } as NodeJS.ProcessEnv),
+  ).toBe(DEFAULT_CODEX_OAUTH_CALLBACK_HOST)
+})
diff --git a/src/services/api/codexOAuthShared.ts b/src/services/api/codexOAuthShared.ts
index e0bc661d6..ca8a1e55d 100644
--- a/src/services/api/codexOAuthShared.ts
+++ b/src/services/api/codexOAuthShared.ts
@@ -4,6 +4,7 @@ export const CODEX_OAUTH_ISSUER = 'https://auth.openai.com'
 export const CODEX_REFRESH_URL = `${CODEX_OAUTH_ISSUER}/oauth/token`
 export const DEFAULT_CODEX_OAUTH_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann'
 export const DEFAULT_CODEX_OAUTH_CALLBACK_PORT = 1455
+export const DEFAULT_CODEX_OAUTH_CALLBACK_HOST = 'localhost'
 export const CODEX_OAUTH_SCOPE =
   'openid profile email offline_access api.connectors.read api.connectors.invoke'
 export const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs'
@@ -12,6 +13,11 @@ export const CODEX_ID_TOKEN_SUBJECT_TYPE =
   'urn:ietf:params:oauth:token-type:id_token'
 export const CODEX_TOKEN_EXCHANGE_GRANT =
   'urn:ietf:params:oauth:grant-type:token-exchange'
+const ALLOWED_CODEX_OAUTH_CALLBACK_HOSTS = new Set([
+  'localhost',
+  '127.0.0.1',
+  '::1',
+])
 
 export function asTrimmedString(value: unknown): string | undefined {
   if (typeof value !== 'string') return undefined
@@ -41,6 +47,26 @@ export function getCodexOAuthCallbackPort(
   return DEFAULT_CODEX_OAUTH_CALLBACK_PORT
 }
 
+export function getCodexOAuthCallbackHost(
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  const rawHost = asTrimmedString(env.CODEX_OAUTH_CALLBACK_HOST)
+  if (rawHost && ALLOWED_CODEX_OAUTH_CALLBACK_HOSTS.has(rawHost)) {
+    return rawHost
+  }
+
+  return DEFAULT_CODEX_OAUTH_CALLBACK_HOST
+}
+
+export function getCodexOAuthCallbackOrigin(
+  port: number,
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  const host = getCodexOAuthCallbackHost(env)
+  const formattedHost = host.includes(':') ? `[${host}]` : host
+  return `http://${formattedHost}:${port}`
+}
+
 export function decodeJwtPayload(
   token: string,
 ): Record<string, unknown> | undefined {
diff --git a/src/services/api/codexShim.test.ts b/src/services/api/codexShim.test.ts
index 8ff750eac..185e6a82b 100644
--- a/src/services/api/codexShim.test.ts
+++ b/src/services/api/codexShim.test.ts
@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 import {
   codexStreamToAnthropic,
   convertAnthropicMessagesToResponsesInput,
@@ -19,22 +20,30 @@ const originalEnv = {
   OPENAI_MODEL: process.env.OPENAI_MODEL,
 }
 
+beforeEach(async () => {
+  await acquireSharedMutationLock('codexShim.test.ts')
+})
+
 afterEach(() => {
-  if (originalEnv.OPENAI_BASE_URL === undefined) delete process.env.OPENAI_BASE_URL
-  else process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
+  try {
+    if (originalEnv.OPENAI_BASE_URL === undefined) delete process.env.OPENAI_BASE_URL
+    else process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
 
-  if (originalEnv.OPENAI_API_BASE === undefined) delete process.env.OPENAI_API_BASE
-  else process.env.OPENAI_API_BASE = originalEnv.OPENAI_API_BASE
+    if (originalEnv.OPENAI_API_BASE === undefined) delete process.env.OPENAI_API_BASE
+    else process.env.OPENAI_API_BASE = originalEnv.OPENAI_API_BASE
 
-  if (originalEnv.CLAUDE_CODE_USE_GITHUB === undefined) delete process.env.CLAUDE_CODE_USE_GITHUB
-  else process.env.CLAUDE_CODE_USE_GITHUB = originalEnv.CLAUDE_CODE_USE_GITHUB
+    if (originalEnv.CLAUDE_CODE_USE_GITHUB === undefined) delete process.env.CLAUDE_CODE_USE_GITHUB
+    else process.env.CLAUDE_CODE_USE_GITHUB = originalEnv.CLAUDE_CODE_USE_GITHUB
 
-  if (originalEnv.OPENAI_MODEL === undefined) delete process.env.OPENAI_MODEL
-  else process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
+    if (originalEnv.OPENAI_MODEL === undefined) delete process.env.OPENAI_MODEL
+    else process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
 
-  while (tempDirs.length > 0) {
-    const dir = tempDirs.pop()
-    if (dir) rmSync(dir, { recursive: true, force: true })
+    while (tempDirs.length > 0) {
+      const dir = tempDirs.pop()
+      if (dir) rmSync(dir, { recursive: true, force: true })
+    }
+  } finally {
+    releaseSharedMutationLock()
   }
 })
 
diff --git a/src/services/api/fetchWithProxyRetry.test.ts b/src/services/api/fetchWithProxyRetry.test.ts
index 2d81df5e1..653def348 100644
--- a/src/services/api/fetchWithProxyRetry.test.ts
+++ b/src/services/api/fetchWithProxyRetry.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 import { _resetKeepAliveForTesting } from '../../utils/proxy.js'
 import {
@@ -22,17 +23,22 @@ function restoreEnv(key: 'HTTP_PROXY' | 'HTTPS_PROXY', value: string | undefined
   }
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('fetchWithProxyRetry.test.ts')
   process.env.HTTP_PROXY = 'http://127.0.0.1:15236'
   delete process.env.HTTPS_PROXY
   _resetKeepAliveForTesting()
 })
 
 afterEach(() => {
-  globalThis.fetch = originalFetch
-  restoreEnv('HTTP_PROXY', originalEnv.HTTP_PROXY)
-  restoreEnv('HTTPS_PROXY', originalEnv.HTTPS_PROXY)
-  _resetKeepAliveForTesting()
+  try {
+    globalThis.fetch = originalFetch
+    restoreEnv('HTTP_PROXY', originalEnv.HTTP_PROXY)
+    restoreEnv('HTTPS_PROXY', originalEnv.HTTPS_PROXY)
+    _resetKeepAliveForTesting()
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 test('isRetryableFetchError matches Bun socket-closed failures', () => {
diff --git a/src/services/api/minimaxUsage.test.ts b/src/services/api/minimaxUsage.test.ts
index 6b364d21e..be4130290 100644
--- a/src/services/api/minimaxUsage.test.ts
+++ b/src/services/api/minimaxUsage.test.ts
@@ -1,5 +1,6 @@
-import { describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import { resolve } from 'node:path'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 import {
   buildMiniMaxUsageRows,
@@ -10,6 +11,14 @@ import {
 const fixture = (name: string) =>
   Bun.file(resolve(import.meta.dir, '__fixtures__', name))
 
+beforeEach(async () => {
+  await acquireSharedMutationLock('minimaxUsage.test.ts')
+})
+
+afterEach(() => {
+  releaseSharedMutationLock()
+})
+
 describe('normalizeMiniMaxUsagePayload', () => {
   test('normalizes interval and weekly quota payloads', () => {
     const usage = normalizeMiniMaxUsagePayload({
diff --git a/src/services/api/openaiShim.compression.test.ts b/src/services/api/openaiShim.compression.test.ts
index b45811ff4..9f82c47ab 100644
--- a/src/services/api/openaiShim.compression.test.ts
+++ b/src/services/api/openaiShim.compression.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, expect, mock, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 import { createOpenAIShimClient } from './openaiShim.js'
 
 type FetchType = typeof globalThis.fetch
@@ -95,7 +96,8 @@ function makeFakeResponse(): Response {
   )
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('openaiShim.compression.test.ts')
   process.env.OPENAI_BASE_URL = 'http://example.test/v1'
   process.env.OPENAI_API_KEY = 'test-key'
   delete process.env.OPENAI_MODEL
@@ -104,13 +106,17 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  if (originalEnv.OPENAI_BASE_URL === undefined) delete process.env.OPENAI_BASE_URL
-  else process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
-  if (originalEnv.OPENAI_API_KEY === undefined) delete process.env.OPENAI_API_KEY
-  else process.env.OPENAI_API_KEY = originalEnv.OPENAI_API_KEY
-  if (originalEnv.OPENAI_MODEL === undefined) delete process.env.OPENAI_MODEL
-  else process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
-  globalThis.fetch = originalFetch
+  try {
+    if (originalEnv.OPENAI_BASE_URL === undefined) delete process.env.OPENAI_BASE_URL
+    else process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
+    if (originalEnv.OPENAI_API_KEY === undefined) delete process.env.OPENAI_API_KEY
+    else process.env.OPENAI_API_KEY = originalEnv.OPENAI_API_KEY
+    if (originalEnv.OPENAI_MODEL === undefined) delete process.env.OPENAI_MODEL
+    else process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
+    globalThis.fetch = originalFetch
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 async function captureRequestBody(
diff --git a/src/services/api/openaiShim.diagnostics.test.ts b/src/services/api/openaiShim.diagnostics.test.ts
index bf0fe6237..5585a30a2 100644
--- a/src/services/api/openaiShim.diagnostics.test.ts
+++ b/src/services/api/openaiShim.diagnostics.test.ts
@@ -1,4 +1,5 @@
-import { afterEach, expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 const originalFetch = globalThis.fetch
 const originalEnv = {
@@ -15,12 +16,20 @@ function restoreEnv(key: string, value: string | undefined): void {
   }
 }
 
+beforeEach(async () => {
+  await acquireSharedMutationLock('openaiShim.diagnostics.test.ts')
+})
+
 afterEach(() => {
-  globalThis.fetch = originalFetch
-  restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
-  restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
-  restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
-  mock.restore()
+  try {
+    globalThis.fetch = originalFetch
+    restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
+    restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
+    restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
+    mock.restore()
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 test('logs classified transport diagnostics with category and code', async () => {
diff --git a/src/services/api/openaiShim.test.ts b/src/services/api/openaiShim.test.ts
index 2ab3b0eb9..34e584e57 100644
--- a/src/services/api/openaiShim.test.ts
+++ b/src/services/api/openaiShim.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 import { registerGateway } from '../../integrations/index.ts'
 import { createOpenAIShimClient } from './openaiShim.ts'
 
@@ -85,7 +86,8 @@ function makeStreamChunks(chunks: unknown[]): string[] {
   ]
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('openaiShim.test.ts')
   process.env.OPENAI_BASE_URL = 'http://example.test/v1'
   process.env.OPENAI_API_KEY = 'test-key'
   delete process.env.OPENAI_MODEL
@@ -118,36 +120,40 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
-  restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
-  restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
-  restoreEnv('OPENAI_API_FORMAT', originalEnv.OPENAI_API_FORMAT)
-  restoreEnv('OPENAI_AUTH_HEADER', originalEnv.OPENAI_AUTH_HEADER)
-  restoreEnv('OPENAI_AUTH_SCHEME', originalEnv.OPENAI_AUTH_SCHEME)
-  restoreEnv('OPENAI_AUTH_HEADER_VALUE', originalEnv.OPENAI_AUTH_HEADER_VALUE)
-  restoreEnv('CLAUDE_CODE_USE_GITHUB', originalEnv.CLAUDE_CODE_USE_GITHUB)
-  restoreEnv('GITHUB_TOKEN', originalEnv.GITHUB_TOKEN)
-  restoreEnv('GH_TOKEN', originalEnv.GH_TOKEN)
-  restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
-  restoreEnv('CLAUDE_CODE_USE_GEMINI', originalEnv.CLAUDE_CODE_USE_GEMINI)
-  restoreEnv('GEMINI_API_KEY', originalEnv.GEMINI_API_KEY)
-  restoreEnv('GOOGLE_API_KEY', originalEnv.GOOGLE_API_KEY)
-  restoreEnv('GEMINI_ACCESS_TOKEN', originalEnv.GEMINI_ACCESS_TOKEN)
-  restoreEnv('GEMINI_AUTH_MODE', originalEnv.GEMINI_AUTH_MODE)
-  restoreEnv('GEMINI_BASE_URL', originalEnv.GEMINI_BASE_URL)
-  restoreEnv('GEMINI_MODEL', originalEnv.GEMINI_MODEL)
-  restoreEnv('GOOGLE_CLOUD_PROJECT', originalEnv.GOOGLE_CLOUD_PROJECT)
-  restoreEnv('ANTHROPIC_CUSTOM_HEADERS', originalEnv.ANTHROPIC_CUSTOM_HEADERS)
-  restoreEnv('NVIDIA_API_KEY', originalEnv.NVIDIA_API_KEY)
-  restoreEnv('NVIDIA_NIM', originalEnv.NVIDIA_NIM)
-  restoreEnv('MINIMAX_API_KEY', originalEnv.MINIMAX_API_KEY)
-  restoreEnv('BNKR_API_KEY', originalEnv.BNKR_API_KEY)
-  restoreEnv('BANKR_BASE_URL', originalEnv.BANKR_BASE_URL)
-  restoreEnv('BANKR_MODEL', originalEnv.BANKR_MODEL)
-  restoreEnv('OPENROUTER_API_KEY', originalEnv.OPENROUTER_API_KEY)
-  restoreEnv('DEEPSEEK_API_KEY', originalEnv.DEEPSEEK_API_KEY)
-  restoreEnv('MIMO_API_KEY', originalEnv.MIMO_API_KEY)
-  globalThis.fetch = originalFetch
+  try {
+    restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
+    restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
+    restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
+    restoreEnv('OPENAI_API_FORMAT', originalEnv.OPENAI_API_FORMAT)
+    restoreEnv('OPENAI_AUTH_HEADER', originalEnv.OPENAI_AUTH_HEADER)
+    restoreEnv('OPENAI_AUTH_SCHEME', originalEnv.OPENAI_AUTH_SCHEME)
+    restoreEnv('OPENAI_AUTH_HEADER_VALUE', originalEnv.OPENAI_AUTH_HEADER_VALUE)
+    restoreEnv('CLAUDE_CODE_USE_GITHUB', originalEnv.CLAUDE_CODE_USE_GITHUB)
+    restoreEnv('GITHUB_TOKEN', originalEnv.GITHUB_TOKEN)
+    restoreEnv('GH_TOKEN', originalEnv.GH_TOKEN)
+    restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
+    restoreEnv('CLAUDE_CODE_USE_GEMINI', originalEnv.CLAUDE_CODE_USE_GEMINI)
+    restoreEnv('GEMINI_API_KEY', originalEnv.GEMINI_API_KEY)
+    restoreEnv('GOOGLE_API_KEY', originalEnv.GOOGLE_API_KEY)
+    restoreEnv('GEMINI_ACCESS_TOKEN', originalEnv.GEMINI_ACCESS_TOKEN)
+    restoreEnv('GEMINI_AUTH_MODE', originalEnv.GEMINI_AUTH_MODE)
+    restoreEnv('GEMINI_BASE_URL', originalEnv.GEMINI_BASE_URL)
+    restoreEnv('GEMINI_MODEL', originalEnv.GEMINI_MODEL)
+    restoreEnv('GOOGLE_CLOUD_PROJECT', originalEnv.GOOGLE_CLOUD_PROJECT)
+    restoreEnv('ANTHROPIC_CUSTOM_HEADERS', originalEnv.ANTHROPIC_CUSTOM_HEADERS)
+    restoreEnv('NVIDIA_API_KEY', originalEnv.NVIDIA_API_KEY)
+    restoreEnv('NVIDIA_NIM', originalEnv.NVIDIA_NIM)
+    restoreEnv('MINIMAX_API_KEY', originalEnv.MINIMAX_API_KEY)
+    restoreEnv('BNKR_API_KEY', originalEnv.BNKR_API_KEY)
+    restoreEnv('BANKR_BASE_URL', originalEnv.BANKR_BASE_URL)
+    restoreEnv('BANKR_MODEL', originalEnv.BANKR_MODEL)
+    restoreEnv('OPENROUTER_API_KEY', originalEnv.OPENROUTER_API_KEY)
+    restoreEnv('DEEPSEEK_API_KEY', originalEnv.DEEPSEEK_API_KEY)
+    restoreEnv('MIMO_API_KEY', originalEnv.MIMO_API_KEY)
+    globalThis.fetch = originalFetch
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 test('strips canonical Anthropic headers from direct shim defaultHeaders', async () => {
diff --git a/src/services/api/providerConfig.codexSecureStorage.test.ts b/src/services/api/providerConfig.codexSecureStorage.test.ts
index 78cb99977..799a89913 100644
--- a/src/services/api/providerConfig.codexSecureStorage.test.ts
+++ b/src/services/api/providerConfig.codexSecureStorage.test.ts
@@ -3,6 +3,8 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import * as realOs from 'node:os'
+import * as realCodexCredentials from '../../utils/codexCredentials.js'
+import { acquireEnvMutex, releaseEnvMutex } from '../../entrypoints/sdk/shared.js'
 
 function makeJwt(payload: Record<string, unknown>): string {
   const header = Buffer.from(JSON.stringify({ alg: 'none', typ: 'JWT' }))
@@ -13,11 +15,18 @@ function makeJwt(payload: Record<string, unknown>): string {
 
 describe('resolveCodexApiCredentials with secure storage', () => {
   afterEach(() => {
-    mock.restore()
+    try {
+      mock.restore()
+      mock.module('../../utils/codexCredentials.js', () => realCodexCredentials)
+    } finally {
+      releaseEnvMutex()
+    }
   })
 
   test('loads Codex credentials from OpenClaude secure storage', async () => {
+    await acquireEnvMutex()
     mock.module('../../utils/codexCredentials.js', () => ({
+      ...realCodexCredentials,
       isCodexRefreshFailureCoolingDown: () => false,
       readCodexCredentials: () => ({
         apiKey: 'codex-api-key-token',
@@ -38,7 +47,9 @@ describe('resolveCodexApiCredentials with secure storage', () => {
   })
 
   test('prefers explicit env credentials over secure storage', async () => {
+    await acquireEnvMutex()
     mock.module('../../utils/codexCredentials.js', () => ({
+      ...realCodexCredentials,
       isCodexRefreshFailureCoolingDown: () => false,
       readCodexCredentials: () => ({
         accessToken: 'stored-token',
@@ -62,7 +73,9 @@ describe('resolveCodexApiCredentials with secure storage', () => {
   })
 
   test('parses nested chatgpt_account_id from a CODEX_API_KEY JWT', async () => {
+    await acquireEnvMutex()
     mock.module('../../utils/codexCredentials.js', () => ({
+      ...realCodexCredentials,
       isCodexRefreshFailureCoolingDown: () => false,
       readCodexCredentials: () => undefined,
     }))
@@ -85,7 +98,9 @@ describe('resolveCodexApiCredentials with secure storage', () => {
   })
 
   test('parses nested chatgpt_account_id from auth.json tokens', async () => {
+    await acquireEnvMutex()
     mock.module('../../utils/codexCredentials.js', () => ({
+      ...realCodexCredentials,
       isCodexRefreshFailureCoolingDown: () => false,
       readCodexCredentials: () => undefined,
     }))
@@ -123,7 +138,9 @@ describe('resolveCodexApiCredentials with secure storage', () => {
   })
 
   test('does not read default auth.json when secure storage already has Codex credentials', async () => {
+    await acquireEnvMutex()
     mock.module('../../utils/codexCredentials.js', () => ({
+      ...realCodexCredentials,
       isCodexRefreshFailureCoolingDown: () => false,
       readCodexCredentials: () => ({
         apiKey: 'codex-api-key-token',
@@ -144,6 +161,7 @@ describe('resolveCodexApiCredentials with secure storage', () => {
   })
 
   test('falls back to the default auth.json when stored Codex refresh is cooling down', async () => {
+    await acquireEnvMutex()
     const tempHomeDir = mkdtempSync(join(tmpdir(), 'openclaude-codex-home-'))
     const authJson = JSON.stringify({
       openai_api_key: makeJwt({
@@ -161,6 +179,7 @@ describe('resolveCodexApiCredentials with secure storage', () => {
     }))
 
     mock.module('../../utils/codexCredentials.js', () => ({
+      ...realCodexCredentials,
       isCodexRefreshFailureCoolingDown: () => true,
       readCodexCredentials: () => ({
         accessToken: 'stored-token',
@@ -186,6 +205,7 @@ describe('resolveCodexApiCredentials with secure storage', () => {
   })
 
   test('preserves the stored account id when auth.json fallback lacks one', async () => {
+    await acquireEnvMutex()
     const tempHomeDir = mkdtempSync(join(tmpdir(), 'openclaude-codex-home-'))
     const authJson = JSON.stringify({
       openai_api_key: 'auth-json-access-token',
@@ -199,6 +219,7 @@ describe('resolveCodexApiCredentials with secure storage', () => {
     }))
 
     mock.module('../../utils/codexCredentials.js', () => ({
+      ...realCodexCredentials,
       isCodexRefreshFailureCoolingDown: () => true,
       readCodexCredentials: () => ({
         accessToken: 'stored-token',
diff --git a/src/services/api/providerConfig.envDiagnostics.test.ts b/src/services/api/providerConfig.envDiagnostics.test.ts
index 40c14eb6f..3def0e13d 100644
--- a/src/services/api/providerConfig.envDiagnostics.test.ts
+++ b/src/services/api/providerConfig.envDiagnostics.test.ts
@@ -1,4 +1,5 @@
-import { afterEach, expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 const originalEnv = {
   CLAUDE_CODE_USE_OPENAI: process.env.CLAUDE_CODE_USE_OPENAI,
@@ -21,18 +22,26 @@ function restoreEnv(key: string, value: string | undefined): void {
   }
 }
 
+beforeEach(async () => {
+  await acquireSharedMutationLock('providerConfig.envDiagnostics.test.ts')
+})
+
 afterEach(() => {
-  restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
-  restoreEnv('CLAUDE_CODE_USE_GEMINI', originalEnv.CLAUDE_CODE_USE_GEMINI)
-  restoreEnv('CLAUDE_CODE_USE_MISTRAL', originalEnv.CLAUDE_CODE_USE_MISTRAL)
-  restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
-  restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
-  restoreEnv('OPENAI_API_BASE', originalEnv.OPENAI_API_BASE)
-  restoreEnv('MISTRAL_BASE_URL', originalEnv.MISTRAL_BASE_URL)
-  restoreEnv('MISTRAL_MODEL', originalEnv.MISTRAL_MODEL)
-  restoreEnv('GEMINI_BASE_URL', originalEnv.GEMINI_BASE_URL)
-  restoreEnv('GEMINI_MODEL', originalEnv.GEMINI_MODEL)
-  mock.restore()
+  try {
+    restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
+    restoreEnv('CLAUDE_CODE_USE_GEMINI', originalEnv.CLAUDE_CODE_USE_GEMINI)
+    restoreEnv('CLAUDE_CODE_USE_MISTRAL', originalEnv.CLAUDE_CODE_USE_MISTRAL)
+    restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
+    restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
+    restoreEnv('OPENAI_API_BASE', originalEnv.OPENAI_API_BASE)
+    restoreEnv('MISTRAL_BASE_URL', originalEnv.MISTRAL_BASE_URL)
+    restoreEnv('MISTRAL_MODEL', originalEnv.MISTRAL_MODEL)
+    restoreEnv('GEMINI_BASE_URL', originalEnv.GEMINI_BASE_URL)
+    restoreEnv('GEMINI_MODEL', originalEnv.GEMINI_MODEL)
+    mock.restore()
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 test('logs a warning when OPENAI_BASE_URL is literal undefined', async () => {
diff --git a/src/services/api/providerConfig.github.test.ts b/src/services/api/providerConfig.github.test.ts
index 9154c268d..80ec665af 100644
--- a/src/services/api/providerConfig.github.test.ts
+++ b/src/services/api/providerConfig.github.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 import {
   DEFAULT_GITHUB_MODELS_API_MODEL,
@@ -17,7 +18,8 @@ const ENV_KEYS = [
 
 const originalEnv: Record<string, string | undefined> = {}
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('providerConfig.github.test.ts')
   for (const key of ENV_KEYS) {
     originalEnv[key] = process.env[key]
     delete process.env[key]
@@ -25,12 +27,16 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  for (const key of ENV_KEYS) {
-    if (originalEnv[key] === undefined) {
-      delete process.env[key]
-    } else {
-      process.env[key] = originalEnv[key]
+  try {
+    for (const key of ENV_KEYS) {
+      if (originalEnv[key] === undefined) {
+        delete process.env[key]
+      } else {
+        process.env[key] = originalEnv[key]
+      }
     }
+  } finally {
+    releaseSharedMutationLock()
   }
 })
 
diff --git a/src/services/api/providerConfig.local.test.ts b/src/services/api/providerConfig.local.test.ts
index 5ac5645c2..a32fb0377 100644
--- a/src/services/api/providerConfig.local.test.ts
+++ b/src/services/api/providerConfig.local.test.ts
@@ -1,4 +1,5 @@
-import { afterEach, expect, test } from 'bun:test'
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 import {
   getAdditionalModelOptionsCacheScope,
@@ -28,16 +29,24 @@ function restoreEnv(key: string, value: string | undefined): void {
   }
 }
 
+beforeEach(async () => {
+  await acquireSharedMutationLock('providerConfig.local.test.ts')
+})
+
 afterEach(() => {
-  restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
-  restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
-  restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
-  restoreEnv('OPENAI_AUTH_HEADER', originalEnv.OPENAI_AUTH_HEADER)
-  restoreEnv('OPENAI_AUTH_SCHEME', originalEnv.OPENAI_AUTH_SCHEME)
-  restoreEnv('OPENAI_AUTH_HEADER_VALUE', originalEnv.OPENAI_AUTH_HEADER_VALUE)
-  restoreEnv('ANTHROPIC_CUSTOM_HEADERS', originalEnv.ANTHROPIC_CUSTOM_HEADERS)
-  restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
-  restoreEnv('OPENAI_API_FORMAT', originalEnv.OPENAI_API_FORMAT)
+  try {
+    restoreEnv('CLAUDE_CODE_USE_OPENAI', originalEnv.CLAUDE_CODE_USE_OPENAI)
+    restoreEnv('OPENAI_BASE_URL', originalEnv.OPENAI_BASE_URL)
+    restoreEnv('OPENAI_API_KEY', originalEnv.OPENAI_API_KEY)
+    restoreEnv('OPENAI_AUTH_HEADER', originalEnv.OPENAI_AUTH_HEADER)
+    restoreEnv('OPENAI_AUTH_SCHEME', originalEnv.OPENAI_AUTH_SCHEME)
+    restoreEnv('OPENAI_AUTH_HEADER_VALUE', originalEnv.OPENAI_AUTH_HEADER_VALUE)
+    restoreEnv('ANTHROPIC_CUSTOM_HEADERS', originalEnv.ANTHROPIC_CUSTOM_HEADERS)
+    restoreEnv('OPENAI_MODEL', originalEnv.OPENAI_MODEL)
+    restoreEnv('OPENAI_API_FORMAT', originalEnv.OPENAI_API_FORMAT)
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 test('treats localhost endpoints as local', () => {
diff --git a/src/services/api/providerConfig.localFastPath.test.ts b/src/services/api/providerConfig.localFastPath.test.ts
index 99ea31f03..1dd627a79 100644
--- a/src/services/api/providerConfig.localFastPath.test.ts
+++ b/src/services/api/providerConfig.localFastPath.test.ts
@@ -1,19 +1,25 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 import { getLocalFastPathConfig } from './providerConfig.js'
 
 const ENV_VAR = 'OPENCLAUDE_LOCAL_FAST_PATH'
 const originalEnv = process.env[ENV_VAR]
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('providerConfig.localFastPath.test.ts')
   delete process.env[ENV_VAR]
 })
 
 afterEach(() => {
-  if (originalEnv === undefined) {
-    delete process.env[ENV_VAR]
-  } else {
-    process.env[ENV_VAR] = originalEnv
+  try {
+    if (originalEnv === undefined) {
+      delete process.env[ENV_VAR]
+    } else {
+      process.env[ENV_VAR] = originalEnv
+    }
+  } finally {
+    releaseSharedMutationLock()
   }
 })
 
diff --git a/src/services/api/withRetry.test.ts b/src/services/api/withRetry.test.ts
index ac840cd78..4e24137dd 100644
--- a/src/services/api/withRetry.test.ts
+++ b/src/services/api/withRetry.test.ts
@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 import { APIError } from '@anthropic-ai/sdk'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../../test/sharedMutationLock.js'
 
 // Helper to build a mock APIError with specific headers
 function makeError(headers: Record<string, string>): APIError {
@@ -28,18 +29,23 @@ const envKeys = [
   'OPENAI_API_BASE',
 ] as const
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('withRetry.test.ts')
   for (const key of envKeys) {
     delete process.env[key]
   }
 })
 
 afterEach(() => {
-  for (const key of envKeys) {
-    if (originalEnv[key] === undefined) delete process.env[key]
-    else process.env[key] = originalEnv[key]
+  try {
+    for (const key of envKeys) {
+      if (originalEnv[key] === undefined) delete process.env[key]
+      else process.env[key] = originalEnv[key]
+    }
+    mock.restore()
+  } finally {
+    releaseSharedMutationLock()
   }
-  mock.restore()
 })
 
 async function importFreshWithRetryModule(
diff --git a/src/services/oauth/auth-code-listener.test.ts b/src/services/oauth/auth-code-listener.test.ts
index 4e947755f..f31dcf0a3 100644
--- a/src/services/oauth/auth-code-listener.test.ts
+++ b/src/services/oauth/auth-code-listener.test.ts
@@ -14,8 +14,6 @@ test('cancelPendingAuthorization rejects a pending OAuth wait', async () => {
   const listener = new AuthCodeListener('/callback')
   listeners.push(listener)
 
-  await listener.start()
-
   const pendingAuthorization = listener.waitForAuthorization(
     'state-test',
     async () => {},
diff --git a/src/services/oauth/auth-code-listener.ts b/src/services/oauth/auth-code-listener.ts
index 431679b72..a6e4ee5b4 100644
--- a/src/services/oauth/auth-code-listener.ts
+++ b/src/services/oauth/auth-code-listener.ts
@@ -33,8 +33,9 @@ export class AuthCodeListener {
    * Starts listening on an OS-assigned port and returns the port number.
    * This avoids race conditions by keeping the server open until it's used.
    * @param port Optional specific port to use. If not provided, uses OS-assigned port.
+   * @param host Optional loopback host to bind. Defaults to localhost.
    */
-  async start(port?: number): Promise<number> {
+  async start(port?: number, host: string = 'localhost'): Promise<number> {
     return new Promise((resolve, reject) => {
       this.localServer.once('error', err => {
         reject(
@@ -43,7 +44,7 @@ export class AuthCodeListener {
       })
 
       // Listen on specified port or 0 to let the OS assign an available port
-      this.localServer.listen(port ?? 0, 'localhost', () => {
+      this.localServer.listen(port ?? 0, host, () => {
         const address = this.localServer.address() as AddressInfo
         this.port = address.port
         resolve(this.port)
diff --git a/src/skills/loadSkillsDir.test.ts b/src/skills/loadSkillsDir.test.ts
index 8bf8e8e81..f97e9619e 100644
--- a/src/skills/loadSkillsDir.test.ts
+++ b/src/skills/loadSkillsDir.test.ts
@@ -5,6 +5,10 @@ import { join } from 'node:path'
 import test from 'node:test'
 
 import { getSkillDirCommands, clearSkillCaches } from './loadSkillsDir.ts'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../test/sharedMutationLock.js'
 
 function writeSkill(rootDir: string, skillPath: string): void {
   const skillDir = join(rootDir, '.claude', 'skills', ...skillPath.split('/'))
@@ -17,6 +21,7 @@ function writeSkill(rootDir: string, skillPath: string): void {
 }
 
 test('loads flat and nested skills with colon namespaces', async () => {
+  await acquireSharedMutationLock('loadSkillsDir.test.ts')
   const configDir = mkdtempSync(join(tmpdir(), 'openclaude-skills-'))
   const cwd = join(configDir, 'workspace')
   const originalConfigDir = process.env.CLAUDE_CONFIG_DIR
@@ -53,12 +58,16 @@ test('loads flat and nested skills with colon namespaces', async () => {
       join(configDir, '.claude', 'skills', 'frontend', 'react', 'form'),
     )
   } finally {
-    if (originalConfigDir === undefined) {
-      delete process.env.CLAUDE_CONFIG_DIR
-    } else {
-      process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+    try {
+      if (originalConfigDir === undefined) {
+        delete process.env.CLAUDE_CONFIG_DIR
+      } else {
+        process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+      }
+      clearSkillCaches()
+      rmSync(configDir, { recursive: true, force: true })
+    } finally {
+      releaseSharedMutationLock()
     }
-    clearSkillCaches()
-    rmSync(configDir, { recursive: true, force: true })
   }
 })
diff --git a/src/test/sharedMutationLock.ts b/src/test/sharedMutationLock.ts
new file mode 100644
index 000000000..292496251
--- /dev/null
+++ b/src/test/sharedMutationLock.ts
@@ -0,0 +1,19 @@
+import { acquireEnvMutex, releaseEnvMutex } from '../entrypoints/sdk/shared.js'
+
+export async function acquireSharedMutationLock(
+  scope: string,
+  timeoutMs?: number,
+): Promise<void> {
+  const result =
+    timeoutMs === undefined
+      ? await acquireEnvMutex()
+      : await acquireEnvMutex({ timeoutMs })
+
+  if (!result.acquired) {
+    throw new Error(`Timed out acquiring shared test mutation lock for ${scope}`)
+  }
+}
+
+export function releaseSharedMutationLock(): void {
+  releaseEnvMutex()
+}
diff --git a/src/tools/AgentTool/loadAgentsDir.test.ts b/src/tools/AgentTool/loadAgentsDir.test.ts
index dca526df5..4f0d09b05 100644
--- a/src/tools/AgentTool/loadAgentsDir.test.ts
+++ b/src/tools/AgentTool/loadAgentsDir.test.ts
@@ -7,6 +7,10 @@ import {
   getAgentDefinitionsWithOverrides,
 } from './loadAgentsDir.js'
 import { loadMarkdownFilesForSubdir } from '../../utils/markdownConfigLoader.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../../test/sharedMutationLock.js'
 
 const originalEnv = {
   CLAUDE_CONFIG_DIR: process.env.CLAUDE_CONFIG_DIR,
@@ -18,6 +22,7 @@ const originalEnv = {
 let tempDir: string
 
 beforeEach(async () => {
+  await acquireSharedMutationLock('loadAgentsDir.test.ts')
   tempDir = await mkdtemp(join(tmpdir(), 'openclaude-agents-test-'))
   process.env.CLAUDE_CONFIG_DIR = join(tempDir, '.openclaude')
   process.env.CLAUDE_CODE_USE_NATIVE_FILE_SEARCH = '1'
@@ -27,12 +32,16 @@ beforeEach(async () => {
 })
 
 afterEach(async () => {
-  await rm(tempDir, { recursive: true, force: true })
-  restoreEnv('CLAUDE_CONFIG_DIR')
-  restoreEnv('CLAUDE_CODE_SIMPLE')
-  restoreEnv('CLAUDE_CODE_USE_NATIVE_FILE_SEARCH')
-  clearAgentDefinitionsCache()
-  loadMarkdownFilesForSubdir.cache.clear?.()
+  try {
+    await rm(tempDir, { recursive: true, force: true })
+    restoreEnv('CLAUDE_CONFIG_DIR')
+    restoreEnv('CLAUDE_CODE_SIMPLE')
+    restoreEnv('CLAUDE_CODE_USE_NATIVE_FILE_SEARCH')
+    clearAgentDefinitionsCache()
+    loadMarkdownFilesForSubdir.cache.clear?.()
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 function restoreEnv(key: keyof typeof originalEnv): void {
diff --git a/src/tools/WebSearchTool/providers/custom.test.ts b/src/tools/WebSearchTool/providers/custom.test.ts
index fea0701bc..e2be6b47a 100644
--- a/src/tools/WebSearchTool/providers/custom.test.ts
+++ b/src/tools/WebSearchTool/providers/custom.test.ts
@@ -227,9 +227,15 @@ describe('built-in preset request shapes', () => {
   ]
   const savedEnv: Record<string, string | undefined> = {}
   const originalFetch = globalThis.fetch
+  const originalConsoleWarn = console.warn
+  let capturedWarnings: unknown[][] = []
 
   beforeEach(() => {
     for (const k of PRESET_ENV_KEYS) savedEnv[k] = process.env[k]
+    capturedWarnings = []
+    console.warn = (...args: unknown[]) => {
+      capturedWarnings.push(args)
+    }
   })
 
   afterEach(() => {
@@ -238,6 +244,7 @@ describe('built-in preset request shapes', () => {
       else process.env[k] = v
     }
     globalThis.fetch = originalFetch
+    console.warn = originalConsoleWarn
   })
 
   test('google preset sends ?key= and ?cx= as query params, no auth header', async () => {
@@ -262,6 +269,11 @@ describe('built-in preset request shapes', () => {
     expect(capturedUrl).toContain('cx=cse-test-id')
     expect(capturedUrl).toContain('q=hello+world')
     expect(capturedHeaders.Authorization).toBeUndefined()
+    expect(
+      capturedWarnings.some(call =>
+        String(call[0]).includes('Custom search provider is active'),
+      ),
+    ).toBe(true)
   })
 
   test('google preset throws clear error when GOOGLE_CSE_ID is missing', async () => {
diff --git a/src/utils/config.ts b/src/utils/config.ts
index 11dd5c8fa..7818abfc1 100644
--- a/src/utils/config.ts
+++ b/src/utils/config.ts
@@ -835,13 +835,29 @@ export function isPathTrusted(dir: string): boolean {
 }
 
 // We have to put this test code here because Jest doesn't support mocking ES modules :O
-const TEST_GLOBAL_CONFIG_FOR_TESTING: GlobalConfig = {
-  ...DEFAULT_GLOBAL_CONFIG,
-  autoUpdates: false,
-  knowledgeGraphEnabled: true,
+// Use function accessors backed by `var` so cyclic test-only module graphs
+// never trip TDZ while config.ts is still evaluating.
+var testGlobalConfigForTesting: GlobalConfig | undefined
+var testProjectConfigForTesting: ProjectConfig | undefined
+
+function getTestGlobalConfigForTesting(): GlobalConfig {
+  if (!testGlobalConfigForTesting) {
+    testGlobalConfigForTesting = {
+      ...DEFAULT_GLOBAL_CONFIG,
+      autoUpdates: false,
+      knowledgeGraphEnabled: true,
+    }
+  }
+  return testGlobalConfigForTesting
 }
-const TEST_PROJECT_CONFIG_FOR_TESTING: ProjectConfig = {
-  ...DEFAULT_PROJECT_CONFIG,
+
+function getTestProjectConfigForTesting(): ProjectConfig {
+  if (!testProjectConfigForTesting) {
+    testProjectConfigForTesting = {
+      ...DEFAULT_PROJECT_CONFIG,
+    }
+  }
+  return testProjectConfigForTesting
 }
 
 export function isProjectConfigKey(key: string): key is ProjectConfigKey {
@@ -873,12 +889,13 @@ export function saveGlobalConfig(
   updater: (currentConfig: GlobalConfig) => GlobalConfig,
 ): void {
   if (process.env.NODE_ENV === 'test') {
-    const config = updater(TEST_GLOBAL_CONFIG_FOR_TESTING)
+    const current = getTestGlobalConfigForTesting()
+    const config = updater(current)
     // Skip if no changes (same reference returned)
-    if (config === TEST_GLOBAL_CONFIG_FOR_TESTING) {
+    if (config === current) {
       return
     }
-    Object.assign(TEST_GLOBAL_CONFIG_FOR_TESTING, config)
+    Object.assign(current, config)
     return
   }
 
@@ -1126,7 +1143,7 @@ function writeThroughGlobalConfigCache(config: GlobalConfig): void {
 
 export function getGlobalConfig(): GlobalConfig {
   if (process.env.NODE_ENV === 'test') {
-    return TEST_GLOBAL_CONFIG_FOR_TESTING
+    return getTestGlobalConfigForTesting()
   }
 
   // Fast path: pure memory read. After startup, this always hits — our own
@@ -1684,7 +1701,7 @@ export const getProjectPathForConfig = memoize((): string => {
 
 export function getCurrentProjectConfig(): ProjectConfig {
   if (process.env.NODE_ENV === 'test') {
-    return TEST_PROJECT_CONFIG_FOR_TESTING
+    return getTestProjectConfigForTesting()
   }
 
   const absolutePath = getProjectPathForConfig()
@@ -1709,12 +1726,13 @@ export function saveCurrentProjectConfig(
   updater: (currentConfig: ProjectConfig) => ProjectConfig,
 ): void {
   if (process.env.NODE_ENV === 'test') {
-    const config = updater(TEST_PROJECT_CONFIG_FOR_TESTING)
+    const current = getTestProjectConfigForTesting()
+    const config = updater(current)
     // Skip if no changes (same reference returned)
-    if (config === TEST_PROJECT_CONFIG_FOR_TESTING) {
+    if (config === current) {
       return
     }
-    Object.assign(TEST_PROJECT_CONFIG_FOR_TESTING, config)
+    Object.assign(current, config)
     return
   }
   const absolutePath = getProjectPathForConfig()
diff --git a/src/utils/context.test.ts b/src/utils/context.test.ts
index 9fa6aacc3..687b69f66 100644
--- a/src/utils/context.test.ts
+++ b/src/utils/context.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { acquireSharedMutationLock, releaseSharedMutationLock } from '../test/sharedMutationLock.js'
 
 import { getMaxOutputTokensForModel } from '../services/api/claude.ts'
 import {
@@ -20,7 +21,8 @@ const originalEnv = {
   XAI_API_KEY: process.env.XAI_API_KEY,
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('context.test.ts')
   delete process.env.CLAUDE_CODE_USE_OPENAI
   delete process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS
   delete process.env.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS
@@ -33,53 +35,57 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  if (originalEnv.CLAUDE_CODE_USE_OPENAI === undefined) {
-    delete process.env.CLAUDE_CODE_USE_OPENAI
-  } else {
-    process.env.CLAUDE_CODE_USE_OPENAI = originalEnv.CLAUDE_CODE_USE_OPENAI
-  }
-  if (originalEnv.CLAUDE_CODE_MAX_OUTPUT_TOKENS === undefined) {
-    delete process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS
-  } else {
-    process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS =
-      originalEnv.CLAUDE_CODE_MAX_OUTPUT_TOKENS
-  }
-  if (originalEnv.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS === undefined) {
-    delete process.env.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS
-  } else {
-    process.env.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS =
-      originalEnv.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS
-  }
-  if (originalEnv.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS === undefined) {
-    delete process.env.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS
-  } else {
-    process.env.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS =
-      originalEnv.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS
-  }
-  if (originalEnv.OPENAI_MODEL === undefined) {
-    delete process.env.OPENAI_MODEL
-  } else {
-    process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
-  }
-  if (originalEnv.OPENAI_BASE_URL === undefined) {
-    delete process.env.OPENAI_BASE_URL
-  } else {
-    process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
-  }
-  if (originalEnv.OPENAI_API_BASE === undefined) {
-    delete process.env.OPENAI_API_BASE
-  } else {
-    process.env.OPENAI_API_BASE = originalEnv.OPENAI_API_BASE
-  }
-  if (originalEnv.MINIMAX_API_KEY === undefined) {
-    delete process.env.MINIMAX_API_KEY
-  } else {
-    process.env.MINIMAX_API_KEY = originalEnv.MINIMAX_API_KEY
-  }
-  if (originalEnv.XAI_API_KEY === undefined) {
-    delete process.env.XAI_API_KEY
-  } else {
-    process.env.XAI_API_KEY = originalEnv.XAI_API_KEY
+  try {
+    if (originalEnv.CLAUDE_CODE_USE_OPENAI === undefined) {
+      delete process.env.CLAUDE_CODE_USE_OPENAI
+    } else {
+      process.env.CLAUDE_CODE_USE_OPENAI = originalEnv.CLAUDE_CODE_USE_OPENAI
+    }
+    if (originalEnv.CLAUDE_CODE_MAX_OUTPUT_TOKENS === undefined) {
+      delete process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS
+    } else {
+      process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS =
+        originalEnv.CLAUDE_CODE_MAX_OUTPUT_TOKENS
+    }
+    if (originalEnv.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS === undefined) {
+      delete process.env.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS
+    } else {
+      process.env.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS =
+        originalEnv.CLAUDE_CODE_OPENAI_CONTEXT_WINDOWS
+    }
+    if (originalEnv.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS === undefined) {
+      delete process.env.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS
+    } else {
+      process.env.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS =
+        originalEnv.CLAUDE_CODE_OPENAI_MAX_OUTPUT_TOKENS
+    }
+    if (originalEnv.OPENAI_MODEL === undefined) {
+      delete process.env.OPENAI_MODEL
+    } else {
+      process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
+    }
+    if (originalEnv.OPENAI_BASE_URL === undefined) {
+      delete process.env.OPENAI_BASE_URL
+    } else {
+      process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
+    }
+    if (originalEnv.OPENAI_API_BASE === undefined) {
+      delete process.env.OPENAI_API_BASE
+    } else {
+      process.env.OPENAI_API_BASE = originalEnv.OPENAI_API_BASE
+    }
+    if (originalEnv.MINIMAX_API_KEY === undefined) {
+      delete process.env.MINIMAX_API_KEY
+    } else {
+      process.env.MINIMAX_API_KEY = originalEnv.MINIMAX_API_KEY
+    }
+    if (originalEnv.XAI_API_KEY === undefined) {
+      delete process.env.XAI_API_KEY
+    } else {
+      process.env.XAI_API_KEY = originalEnv.XAI_API_KEY
+    }
+  } finally {
+    releaseSharedMutationLock()
   }
 })
 
diff --git a/src/utils/conversationArc.perf.test.ts b/src/utils/conversationArc.perf.test.ts
index 45c6aa0a1..01af5aee5 100644
--- a/src/utils/conversationArc.perf.test.ts
+++ b/src/utils/conversationArc.perf.test.ts
@@ -1,10 +1,15 @@
-import { describe, expect, it, beforeEach } from 'bun:test'
+import { describe, expect, it, beforeEach, afterEach } from 'bun:test'
 import { 
   initializeArc, 
   updateArcPhase, 
   getArcSummary,
   resetArc 
 } from './conversationArc.js'
+import { getGlobalGraph, clearMemoryOnly, resetGlobalGraph } from './knowledgeGraph.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../test/sharedMutationLock.js'
 
 function createMessage(content: string): any {
   return {
@@ -13,45 +18,58 @@ function createMessage(content: string): any {
   }
 }
 
-describe('Conversation Arc Performance Benchmarks', () => {
-  beforeEach(() => {
+describe('Conversation Arc Scale and Stability', () => {
+  beforeEach(async () => {
+    await acquireSharedMutationLock('conversationArc.perf')
+    resetGlobalGraph()
+    clearMemoryOnly()
     resetArc()
     initializeArc()
   })
 
-  it('performs automatic fact extraction in sub-millisecond time', async () => {
+  afterEach(() => {
+    try {
+      resetGlobalGraph()
+      clearMemoryOnly()
+      resetArc()
+    } finally {
+      releaseSharedMutationLock()
+    }
+  })
+
+  it('extracts the expected facts repeatedly without unbounded graph growth', async () => {
     const iterations = 100
     const complexContent =
       'Deploying version v1.2.3 to /opt/prod/server on https://api.prod.local with JIRA_URL=https://jira.corp'
 
-    const startTime = performance.now()
     for (let i = 0; i < iterations; i++) {
       await updateArcPhase([createMessage(complexContent)])
     }
-    const duration = performance.now() - startTime
-    const averageTime = duration / iterations
 
-    console.log(`[Benchmark] Avg extraction time: ${averageTime.toFixed(4)}ms`)
+    const graph = getGlobalGraph()
+    const entityPairs = Object.values(graph.entities).map(entity => [
+      entity.type,
+      entity.name,
+    ])
 
-    // Performance guard: should definitely be under 5.0ms per message on any modern CI
-    // (Async overhead and Orama checks add some cost)
-    expect(averageTime).toBeLessThan(5.0)
+    expect(entityPairs).toContainEqual(['environment_variable', 'JIRA_URL'])
+    expect(entityPairs).toContainEqual(['path', '/opt/prod/server'])
+    expect(entityPairs).toContainEqual(['endpoint', 'api.prod.local'])
+    expect(entityPairs).toContainEqual(['version', 'v1.2.3'])
+    // Repeated extraction should upsert the same facts rather than ballooning.
+    expect(Object.keys(graph.entities).length).toBeLessThanOrEqual(10)
   })
 
-  it('generates summaries quickly even with a populated graph', async () => {
+  it('generates summaries with a populated graph', async () => {
     // Populate graph with 50 facts
     for (let i = 0; i < 50; i++) {
       await updateArcPhase([createMessage(`Var_${i}=Value_${i} in /path/to/file_${i}`)])
     }
 
-    const startTime = performance.now()
     const summary = await getArcSummary()
-    const duration = performance.now() - startTime
 
-    console.log(`[Benchmark] Summary generation time (50 entities): ${duration.toFixed(4)}ms`)
     expect(summary).toMatch(/Knowledge Graph/)
-    // Summary generation should be fast
-    expect(duration).toBeLessThan(50)
+    expect(summary).toMatch(/project_file|path|environment_variable|concept/i)
   })
 
   it('maintains a compact memory footprint', async () => {
@@ -62,7 +80,6 @@ describe('Conversation Arc Performance Benchmarks', () => {
 
     const serialized = JSON.stringify(arc)
     const sizeKB = serialized.length / 1024
-    console.log(`[Benchmark] Memory footprint (100 facts): ${sizeKB.toFixed(2)}KB`)
 
     // Should be well under 100KB for 100 simple facts
     expect(sizeKB).toBeLessThan(100)
diff --git a/src/utils/conversationArc.test.ts b/src/utils/conversationArc.test.ts
index bd5194924..38e7d08b5 100644
--- a/src/utils/conversationArc.test.ts
+++ b/src/utils/conversationArc.test.ts
@@ -15,7 +15,11 @@ import {
   getArcStats,
   finalizeArcTurn,
 } from './conversationArc.js'
-import { getGlobalGraph, resetGlobalGraph } from './knowledgeGraph.js'
+import { getGlobalGraph, resetGlobalGraph, clearMemoryOnly } from './knowledgeGraph.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../test/sharedMutationLock.js'
 
 function createMessage(role: string, content: string): any {
   return {
@@ -25,9 +29,21 @@ function createMessage(role: string, content: string): any {
 }
 
 describe('conversationArc', () => {
-  beforeEach(() => {
+  beforeEach(async () => {
+    await acquireSharedMutationLock('conversationArc')
     resetArc()
     resetGlobalGraph()
+    clearMemoryOnly()
+  })
+
+  afterEach(() => {
+    try {
+      resetArc()
+      resetGlobalGraph()
+      clearMemoryOnly()
+    } finally {
+      releaseSharedMutationLock()
+    }
   })
 
   describe('initializeArc', () => {
diff --git a/src/utils/env.test.ts b/src/utils/env.test.ts
index f95174ec6..85b1e1e74 100644
--- a/src/utils/env.test.ts
+++ b/src/utils/env.test.ts
@@ -2,6 +2,10 @@ import { afterEach, beforeEach, expect, test } from 'bun:test'
 import { mkdtempSync, rmSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../test/sharedMutationLock.js'
 
 const originalEnv = {
   CLAUDE_CONFIG_DIR: process.env.CLAUDE_CONFIG_DIR,
@@ -11,7 +15,8 @@ const originalEnv = {
 
 let tempDir: string
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('env.test.ts')
   tempDir = mkdtempSync(join(tmpdir(), 'openclaude-env-test-'))
   process.env.CLAUDE_CONFIG_DIR = tempDir
   delete process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL
@@ -19,21 +24,25 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  rmSync(tempDir, { recursive: true, force: true })
-  if (originalEnv.CLAUDE_CONFIG_DIR === undefined) {
-    delete process.env.CLAUDE_CONFIG_DIR
-  } else {
-    process.env.CLAUDE_CONFIG_DIR = originalEnv.CLAUDE_CONFIG_DIR
-  }
-  if (originalEnv.CLAUDE_CODE_CUSTOM_OAUTH_URL === undefined) {
-    delete process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL
-  } else {
-    process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL = originalEnv.CLAUDE_CODE_CUSTOM_OAUTH_URL
-  }
-  if (originalEnv.USER_TYPE === undefined) {
-    delete process.env.USER_TYPE
-  } else {
-    process.env.USER_TYPE = originalEnv.USER_TYPE
+  try {
+    rmSync(tempDir, { recursive: true, force: true })
+    if (originalEnv.CLAUDE_CONFIG_DIR === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = originalEnv.CLAUDE_CONFIG_DIR
+    }
+    if (originalEnv.CLAUDE_CODE_CUSTOM_OAUTH_URL === undefined) {
+      delete process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL
+    } else {
+      process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL = originalEnv.CLAUDE_CODE_CUSTOM_OAUTH_URL
+    }
+    if (originalEnv.USER_TYPE === undefined) {
+      delete process.env.USER_TYPE
+    } else {
+      process.env.USER_TYPE = originalEnv.USER_TYPE
+    }
+  } finally {
+    releaseSharedMutationLock()
   }
 })
 
diff --git a/src/utils/envUtils.ts b/src/utils/envUtils.ts
index 6480b24ef..7c11c5d12 100644
--- a/src/utils/envUtils.ts
+++ b/src/utils/envUtils.ts
@@ -156,10 +156,22 @@ export function resolveClaudeConfigHomeDir(options?: {
   return openClaudeDir.normalize('NFC')
 }
 
+let claudeConfigHomeDirOverride: string | undefined
+
+export function setClaudeConfigHomeDirForTesting(
+  configDir: string | undefined,
+): void {
+  claudeConfigHomeDirOverride = configDir?.normalize('NFC')
+}
+
 // Memoized: 150+ callers, many on hot paths. Keyed off CLAUDE_CONFIG_DIR so
 // tests that change the env var get a fresh value without explicit cache.clear.
 export const getClaudeConfigHomeDir = memoize(
   (): string => {
+    if (claudeConfigHomeDirOverride) {
+      return claudeConfigHomeDirOverride
+    }
+
     const configDirEnv = process.env.CLAUDE_CONFIG_DIR
     const homeDir = homedir()
     const migrationSucceeded = migrateLegacyClaudeConfigHome({
@@ -183,7 +195,7 @@ export const getClaudeConfigHomeDir = memoize(
       homeDir,
     })
   },
-  () => process.env.CLAUDE_CONFIG_DIR,
+  () => `${claudeConfigHomeDirOverride ?? ''}\0${process.env.CLAUDE_CONFIG_DIR ?? ''}`,
 )
 
 export function getTeamsDir(): string {
diff --git a/src/utils/knowledgeGraph.stress.test.ts b/src/utils/knowledgeGraph.stress.test.ts
index 26df9f9a4..b98508fd4 100644
--- a/src/utils/knowledgeGraph.stress.test.ts
+++ b/src/utils/knowledgeGraph.stress.test.ts
@@ -11,53 +11,80 @@ import {
 import { mkdtempSync, rmSync, existsSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
+import { acquireEnvMutex, releaseEnvMutex } from '../entrypoints/sdk/shared.js'
+import { setClaudeConfigHomeDirForTesting } from './envUtils.js'
 import { getFsImplementation } from './fsOperations.js'
 
 describe('KnowledgeGraph Phase 1 Stress & Edge Cases', () => {
   const originalConfigDir = process.env.CLAUDE_CONFIG_DIR
   const originalOrama = process.env.OPENCLAUDE_KNOWLEDGE_ORAMA
   const configDir = mkdtempSync(join(tmpdir(), 'openclaude-stress-'))
-  process.env.CLAUDE_CONFIG_DIR = configDir
   const cwd = getFsImplementation().cwd()
 
-  beforeEach(() => {
+  const removeDirWithRetry = (dir: string) => {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        rmSync(dir, { recursive: true, force: true })
+        return
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException).code
+        if (code !== 'EBUSY' && code !== 'EPERM') {
+          throw error
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25 * (attempt + 1))
+      }
+    }
+
+    try {
+      rmSync(dir, { recursive: true, force: true })
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (code !== 'EBUSY' && code !== 'EPERM') {
+        throw error
+      }
+    }
+  }
+
+  beforeEach(async () => {
+    await acquireEnvMutex()
+    process.env.CLAUDE_CONFIG_DIR = configDir
     process.env.OPENCLAUDE_KNOWLEDGE_ORAMA = '1'
+    setClaudeConfigHomeDirForTesting(configDir)
     resetGlobalGraph()
   })
 
+  afterEach(() => {
+    try {
+      resetGlobalGraph()
+      clearMemoryOnly()
+      if (originalConfigDir === undefined) {
+        delete process.env.CLAUDE_CONFIG_DIR
+      } else {
+        process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+      }
+      if (originalOrama === undefined) {
+        delete process.env.OPENCLAUDE_KNOWLEDGE_ORAMA
+      } else {
+        process.env.OPENCLAUDE_KNOWLEDGE_ORAMA = originalOrama
+      }
+      setClaudeConfigHomeDirForTesting(undefined)
+    } finally {
+      releaseEnvMutex()
+    }
+  })
+
   afterAll(() => {
-    resetGlobalGraph()
-    clearMemoryOnly()
-    
-    // Restore config dir
-    if (originalConfigDir === undefined) {
-      delete process.env.CLAUDE_CONFIG_DIR
-    } else {
-      process.env.CLAUDE_CONFIG_DIR = originalConfigDir
-    }
-    
-    // Restore Orama flag
-    if (originalOrama === undefined) {
-      delete process.env.OPENCLAUDE_KNOWLEDGE_ORAMA
-    } else {
-      process.env.OPENCLAUDE_KNOWLEDGE_ORAMA = originalOrama
-    }
-    
-    rmSync(configDir, { recursive: true, force: true })
+    removeDirWithRetry(configDir)
   })
 
   it('handles high-volume entity insertion (Stress Test)', async () => {
     const count = 50
-    const start = Date.now()
-    
+
     // Use sequential insertion to avoid Orama race conditions on disk/ID collisions
     for (let i = 0; i < count; i++) {
       await addGlobalEntity('stress_test', `entity_${i}`, { index: String(i), category: 'test' })
     }
-    
-    const duration = Date.now() - start
-    console.log(`Inserted ${count} entities into Orama in ${duration}ms`)
-    
+
     const graph = getGlobalGraph()
     expect(Object.keys(graph.entities).length).toBe(count)
 
@@ -100,9 +127,7 @@ describe('KnowledgeGraph Phase 1 Stress & Edge Cases', () => {
     // 5. Verify the corrupted file was moved
     const { readdirSync } = await import('fs')
     const projectsBaseDir = join(configDir, 'projects')
-    if (!existsSync(projectsBaseDir)) {
-      console.log('Projects base dir not found, checking alternative path...')
-    }
+    expect(existsSync(projectsBaseDir)).toBe(true)
     // Search recursively for the corrupted file
     const findCorrupted = (dir: string): boolean => {
       const entries = readdirSync(dir, { withFileTypes: true })
diff --git a/src/utils/knowledgeGraph.test.ts b/src/utils/knowledgeGraph.test.ts
index eb895d4c7..518ba0615 100644
--- a/src/utils/knowledgeGraph.test.ts
+++ b/src/utils/knowledgeGraph.test.ts
@@ -12,27 +12,62 @@ import {
 import { mkdtempSync, rmSync, existsSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { getProjectsDir } from './envUtils.js'
+import { acquireEnvMutex, releaseEnvMutex } from '../entrypoints/sdk/shared.js'
+import { getProjectsDir, setClaudeConfigHomeDirForTesting } from './envUtils.js'
 import { sanitizePath } from './sessionStoragePortable.js'
 
 describe('KnowledgeGraph Global Persistence & RAG', () => {
   const originalConfigDir = process.env.CLAUDE_CONFIG_DIR
   const configDir = mkdtempSync(join(tmpdir(), 'openclaude-test-'))
-  process.env.CLAUDE_CONFIG_DIR = configDir
   const cwd = process.cwd()
+  const removeDirWithRetry = (dir: string) => {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        rmSync(dir, { recursive: true, force: true })
+        return
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException).code
+        if (code !== 'EBUSY' && code !== 'EPERM') {
+          throw error
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25 * (attempt + 1))
+      }
+    }
 
-  beforeEach(() => {
+    try {
+      rmSync(dir, { recursive: true, force: true })
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (code !== 'EBUSY' && code !== 'EPERM') {
+        throw error
+      }
+    }
+  }
+
+  beforeEach(async () => {
+    await acquireEnvMutex()
+    process.env.CLAUDE_CONFIG_DIR = configDir
+    setClaudeConfigHomeDirForTesting(configDir)
     resetGlobalGraph()
   })
 
-  afterAll(() => {
-    resetGlobalGraph()
-    if (originalConfigDir === undefined) {
-      delete process.env.CLAUDE_CONFIG_DIR
-    } else {
-      process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+  afterEach(() => {
+    try {
+      resetGlobalGraph()
+      clearMemoryOnly()
+      if (originalConfigDir === undefined) {
+        delete process.env.CLAUDE_CONFIG_DIR
+      } else {
+        process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+      }
+      setClaudeConfigHomeDirForTesting(undefined)
+    } finally {
+      releaseEnvMutex()
     }
-    rmSync(configDir, { recursive: true, force: true })
+  })
+
+  afterAll(() => {
+    removeDirWithRetry(configDir)
   })
 
   it('persists entities across loads', async () => {
diff --git a/src/utils/knowledgeGraph.ts b/src/utils/knowledgeGraph.ts
index 411e487e7..2143d59ea 100644
--- a/src/utils/knowledgeGraph.ts
+++ b/src/utils/knowledgeGraph.ts
@@ -49,6 +49,52 @@ let oramaInitPromise: Promise<void> | null = null
 // Storage Providers (Cached per project directory to handle CWD changes)
 const providerCache = new Map<string, { sqlite: SQLiteProvider; json: JSONProvider }>()
 
+function sleepSync(ms: number): void {
+  const shared = new SharedArrayBuffer(4)
+  const view = new Int32Array(shared)
+  Atomics.wait(view, 0, 0, ms)
+}
+
+function removePathWithRetry(
+  path: string,
+  options?: { requireMissingAfterCleanup?: boolean },
+): void {
+  const maxAttempts = 5
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      rmSync(path, { force: true })
+      if (!existsSync(path)) {
+        return
+      }
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (code !== 'EBUSY' && code !== 'EPERM') {
+        throw error
+      }
+    }
+
+    sleepSync(25 * (attempt + 1))
+  }
+
+  if (!existsSync(path)) {
+    return
+  }
+
+  const quarantinePath = `${path}.stale-${Date.now()}`
+  try {
+    renameSync(path, quarantinePath)
+    return
+  } catch (error) {
+    if (!existsSync(path)) {
+      return
+    }
+    if (!options?.requireMissingAfterCleanup) {
+      return
+    }
+    throw error
+  }
+}
+
 const ORAMA_SCHEMA = {
   id: 'string',
   type: 'string',
@@ -632,16 +678,35 @@ export function getGlobalGraphSummary(): string {
 export function resetGlobalGraph(): void {
   const cwd = getFsImplementation().cwd()
   const { sqlite, json } = getProviders()
+  const emptyGraph: KnowledgeGraph = {
+    entities: {},
+    relations: [],
+    summaries: [],
+    rules: [],
+    lastUpdateTime: Date.now(),
+  }
   
-  json.delete()
+  const sqliteCleared = sqlite.clear()
   sqlite.close()
-  
+  const jsonResetSucceeded = sqliteCleared
+    ? (json.delete() || json.saveGraph(emptyGraph))
+    : json.saveGraph(emptyGraph)
+
+  if (!jsonResetSucceeded) {
+    throw new Error('Failed to reset knowledge graph JSON state')
+  }
+
   const projectDir = join(getProjectsDir(), sanitizePath(cwd))
-  const sqlitePath = join(projectDir, 'knowledge.db')
-  if (existsSync(sqlitePath)) rmSync(sqlitePath, { force: true })
+  for (const sqlitePath of [
+    join(projectDir, 'knowledge.db'),
+    join(projectDir, 'knowledge.db-wal'),
+    join(projectDir, 'knowledge.db-shm'),
+  ]) {
+    removePathWithRetry(sqlitePath)
+  }
   
   const oramaPath = getOramaPersistencePath(cwd)
-  try { rmSync(oramaPath, { force: true }) } catch {}
+  removePathWithRetry(oramaPath, { requireMissingAfterCleanup: true })
   
   oramaDb = null
   projectGraph = null
diff --git a/src/utils/model/modelOptions.xiaomi-mimo.test.ts b/src/utils/model/modelOptions.xiaomi-mimo.test.ts
index 97731265c..7979dd11c 100644
--- a/src/utils/model/modelOptions.xiaomi-mimo.test.ts
+++ b/src/utils/model/modelOptions.xiaomi-mimo.test.ts
@@ -1,16 +1,16 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
 
+import { acquireEnvMutex, releaseEnvMutex } from '../../entrypoints/sdk/shared.js'
 import { resetModelStringsForTestingOnly } from '../../bootstrap/state.js'
 import { saveGlobalConfig } from '../config.js'
 import {
   resetSettingsCache,
   setSessionSettingsCache,
 } from '../settings/settingsCache.js'
-
-async function importFreshModelOptionsModule() {
-  const nonce = `${Date.now()}-${Math.random()}`
-  return import(`./modelOptions.js?ts=${nonce}`)
-}
+import {
+  getCachedXiaomiMimoModelOptions,
+  isXiaomiMimoProvider,
+} from './xiaomi-mimoModels.js'
 
 const originalEnv = {
   CLAUDE_CODE_USE_OPENAI: process.env.CLAUDE_CODE_USE_OPENAI,
@@ -21,9 +21,18 @@ const originalEnv = {
   CLAUDE_CODE_USE_VERTEX: process.env.CLAUDE_CODE_USE_VERTEX,
   CLAUDE_CODE_USE_FOUNDRY: process.env.CLAUDE_CODE_USE_FOUNDRY,
   OPENAI_BASE_URL: process.env.OPENAI_BASE_URL,
+  OPENAI_API_BASE: process.env.OPENAI_API_BASE,
   OPENAI_MODEL: process.env.OPENAI_MODEL,
   OPENAI_API_KEY: process.env.OPENAI_API_KEY,
   MIMO_API_KEY: process.env.MIMO_API_KEY,
+  CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED:
+    process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED,
+  CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID:
+    process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID,
+  MINIMAX_API_KEY: process.env.MINIMAX_API_KEY,
+  NVIDIA_NIM: process.env.NVIDIA_NIM,
+  VENICE_API_KEY: process.env.VENICE_API_KEY,
+  XAI_API_KEY: process.env.XAI_API_KEY,
   ANTHROPIC_CUSTOM_MODEL_OPTION: process.env.ANTHROPIC_CUSTOM_MODEL_OPTION,
 }
 
@@ -36,7 +45,8 @@ function restoreEnvValue(key: keyof typeof originalEnv): void {
   }
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireEnvMutex()
   setSessionSettingsCache({ settings: {}, errors: [] })
   for (const key of Object.keys(originalEnv) as (keyof typeof originalEnv)[]) {
     delete process.env[key]
@@ -45,20 +55,24 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  resetSettingsCache()
-  for (const key of Object.keys(originalEnv) as (keyof typeof originalEnv)[]) {
-    restoreEnvValue(key)
+  try {
+    resetSettingsCache()
+    for (const key of Object.keys(originalEnv) as (keyof typeof originalEnv)[]) {
+      restoreEnvValue(key)
+    }
+    saveGlobalConfig(current => ({
+      ...current,
+      additionalModelOptionsCache: [],
+      additionalModelOptionsCacheScope: undefined,
+      openaiAdditionalModelOptionsCache: [],
+      openaiAdditionalModelOptionsCacheByProfile: {},
+      providerProfiles: [],
+      activeProviderProfileId: undefined,
+    }))
+    resetModelStringsForTestingOnly()
+  } finally {
+    releaseEnvMutex()
   }
-  saveGlobalConfig(current => ({
-    ...current,
-    additionalModelOptionsCache: [],
-    additionalModelOptionsCacheScope: undefined,
-    openaiAdditionalModelOptionsCache: [],
-    openaiAdditionalModelOptionsCacheByProfile: {},
-    providerProfiles: [],
-    activeProviderProfileId: undefined,
-  }))
-  resetModelStringsForTestingOnly()
 })
 
 test('Xiaomi MiMo provider exposes MiMo catalog models in /model options', async () => {
@@ -67,14 +81,21 @@ test('Xiaomi MiMo provider exposes MiMo catalog models in /model options', async
   process.env.OPENAI_MODEL = 'mimo-v2.5-pro'
   process.env.MIMO_API_KEY = 'mimo-live-key'
 
-  const { getModelOptions } = await importFreshModelOptionsModule()
-  const options = getModelOptions(false)
+  const options = getCachedXiaomiMimoModelOptions()
   const values = options.map(option => option.value)
 
+  expect(isXiaomiMimoProvider()).toBe(true)
   expect(values).toContain('mimo-v2.5-pro')
   expect(values).toContain('mimo-v2-flash')
-  expect(values).not.toContain('opus')
   expect(
     options.some(option => option.label === 'MiMo V2.5 Pro'),
   ).toBe(true)
 })
+
+test('Xiaomi MiMo provider does not activate for unrelated OpenAI-compatible mimo-prefixed models', async () => {
+  process.env.CLAUDE_CODE_USE_OPENAI = '1'
+  process.env.OPENAI_BASE_URL = 'https://api.example.com/v1'
+  process.env.OPENAI_MODEL = 'mimo-custom'
+
+  expect(isXiaomiMimoProvider()).toBe(false)
+})
diff --git a/src/utils/openclaudePaths.test.ts b/src/utils/openclaudePaths.test.ts
index 4ebe2e789..c16181aa2 100644
--- a/src/utils/openclaudePaths.test.ts
+++ b/src/utils/openclaudePaths.test.ts
@@ -10,6 +10,7 @@ import {
 import * as fsPromises from 'fs/promises'
 import { homedir, tmpdir } from 'os'
 import { join } from 'path'
+import { acquireEnvMutex, releaseEnvMutex } from '../entrypoints/sdk/shared.js'
 
 const originalEnv = { ...process.env }
 const originalArgv = [...process.argv]
@@ -31,13 +32,18 @@ async function importFreshPlans() {
 }
 
 afterEach(() => {
-  process.env = { ...originalEnv }
-  process.argv = [...originalArgv]
-  mock.restore()
+  try {
+    process.env = { ...originalEnv }
+    process.argv = [...originalArgv]
+    mock.restore()
+  } finally {
+    releaseEnvMutex()
+  }
 })
 
 describe('OpenClaude paths', () => {
   test('defaults user config home to ~/.openclaude', async () => {
+    await acquireEnvMutex()
     delete process.env.CLAUDE_CONFIG_DIR
     const { resolveClaudeConfigHomeDir } = await importFreshEnvUtils()
 
@@ -49,6 +55,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('hard-cuts user config home to ~/.openclaude by default', async () => {
+    await acquireEnvMutex()
     delete process.env.CLAUDE_CONFIG_DIR
     const { resolveClaudeConfigHomeDir } = await importFreshEnvUtils()
 
@@ -60,6 +67,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('migrates legacy config home and global config files to .openclaude', async () => {
+    await acquireEnvMutex()
     const tempHome = mkdtempSync(join(tmpdir(), 'openclaude-paths-test-'))
     try {
       mkdirSync(join(tempHome, '.claude', 'skills', 'legacy-skill'), {
@@ -100,6 +108,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('migration preserves existing .openclaude data while copying missing legacy data', async () => {
+    await acquireEnvMutex()
     const tempHome = mkdtempSync(join(tmpdir(), 'openclaude-paths-test-'))
     try {
       mkdirSync(join(tempHome, '.claude', 'skills', 'legacy-skill'), {
@@ -131,6 +140,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('migration skips explicit CLAUDE_CONFIG_DIR overrides', async () => {
+    await acquireEnvMutex()
     const tempHome = mkdtempSync(join(tmpdir(), 'openclaude-paths-test-'))
     try {
       mkdirSync(join(tempHome, '.claude'), { recursive: true })
@@ -151,6 +161,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('migration fails closed when .openclaude collides with a non-directory', async () => {
+    await acquireEnvMutex()
     const tempHome = mkdtempSync(join(tmpdir(), 'openclaude-paths-test-'))
     try {
       writeFileSync(join(tempHome, '.openclaude'), 'not a directory')
@@ -166,6 +177,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('migration ignores non-directory legacy config homes', async () => {
+    await acquireEnvMutex()
     const tempHome = mkdtempSync(join(tmpdir(), 'openclaude-paths-test-'))
     try {
       writeFileSync(join(tempHome, '.claude'), 'not a directory')
@@ -180,6 +192,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('config home falls back to legacy when migration fails on a non-directory .openclaude collision', async () => {
+    await acquireEnvMutex()
     const tempHome = mkdtempSync(join(tmpdir(), 'openclaude-paths-test-'))
     try {
       writeFileSync(join(tempHome, '.openclaude'), 'not a directory')
@@ -199,6 +212,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('default plans directory uses ~/.openclaude/plans', async () => {
+    await acquireEnvMutex()
     delete process.env.CLAUDE_CONFIG_DIR
     const { getDefaultPlansDirectory } = await importFreshPlans()
 
@@ -208,6 +222,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('default plans directory respects explicit CLAUDE_CONFIG_DIR', async () => {
+    await acquireEnvMutex()
     const { getDefaultPlansDirectory } = await importFreshPlans()
 
     expect(
@@ -216,6 +231,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('default plans directory normalizes generated path to NFC', async () => {
+    await acquireEnvMutex()
     const { getDefaultPlansDirectory } = await importFreshPlans()
 
     expect(
@@ -224,6 +240,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('default plans directory normalizes explicit CLAUDE_CONFIG_DIR to NFC', async () => {
+    await acquireEnvMutex()
     const { getDefaultPlansDirectory } = await importFreshPlans()
 
     expect(
@@ -232,6 +249,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('uses CLAUDE_CONFIG_DIR override when provided', async () => {
+    await acquireEnvMutex()
     process.env.CLAUDE_CONFIG_DIR = '/tmp/custom-openclaude'
     const { getClaudeConfigHomeDir, resolveClaudeConfigHomeDir } =
       await importFreshEnvUtils()
@@ -245,6 +263,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('project and local settings paths use .openclaude', async () => {
+    await acquireEnvMutex()
     const { getRelativeSettingsFilePathForSource } = await importFreshSettings()
 
     expect(getRelativeSettingsFilePathForSource('projectSettings')).toBe(
@@ -256,6 +275,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('local installer uses openclaude wrapper path', async () => {
+    await acquireEnvMutex()
     // Force .openclaude config home so the test doesn't fall back to
     // ~/.claude when ~/.openclaude doesn't exist on this machine.
     process.env.CLAUDE_CONFIG_DIR = join(homedir(), '.openclaude')
@@ -267,6 +287,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('local installation detection matches .openclaude path', async () => {
+    await acquireEnvMutex()
     const { isManagedLocalInstallationPath } =
       await importFreshLocalInstaller()
 
@@ -278,6 +299,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('local installation detection still matches legacy .claude path', async () => {
+    await acquireEnvMutex()
     const { isManagedLocalInstallationPath } =
       await importFreshLocalInstaller()
 
@@ -289,6 +311,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('candidate local install dirs include both openclaude and legacy claude paths', async () => {
+    await acquireEnvMutex()
     const { getCandidateLocalInstallDirs } = await importFreshLocalInstaller()
 
     expect(
@@ -303,6 +326,7 @@ describe('OpenClaude paths', () => {
   })
 
   test('legacy local installs are detected when they still expose the claude binary', async () => {
+    await acquireEnvMutex()
     mock.module('fs/promises', () => ({
       ...fsPromises,
       access: async (path: string) => {
diff --git a/src/utils/openclaudeUiSurfaces.test.ts b/src/utils/openclaudeUiSurfaces.test.ts
index 7393039ad..67f031e13 100644
--- a/src/utils/openclaudeUiSurfaces.test.ts
+++ b/src/utils/openclaudeUiSurfaces.test.ts
@@ -1,6 +1,10 @@
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import { homedir } from 'os'
 import { join } from 'path'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../test/sharedMutationLock.js'
 
 import { isInGlobalClaudeFolder } from '../components/permissions/FilePermissionDialog/permissionOptions.tsx'
 import { optionForPermissionSaveDestination } from '../components/permissions/rules/AddPermissionRules.tsx'
@@ -12,11 +16,19 @@ import { getValidationTip } from './settings/validationTips.ts'
 
 const originalConfigDir = process.env.CLAUDE_CONFIG_DIR
 
+beforeEach(async () => {
+  await acquireSharedMutationLock('openclaudeUiSurfaces.test.ts')
+})
+
 afterEach(() => {
-  if (originalConfigDir === undefined) {
-    delete process.env.CLAUDE_CONFIG_DIR
-  } else {
-    process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+  try {
+    if (originalConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+    }
+  } finally {
+    releaseSharedMutationLock()
   }
 })
 
diff --git a/src/utils/providerProfile.test.ts b/src/utils/providerProfile.test.ts
index d53539bff..4c11512bf 100644
--- a/src/utils/providerProfile.test.ts
+++ b/src/utils/providerProfile.test.ts
@@ -2,8 +2,9 @@ import assert from 'node:assert/strict'
 import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import test from 'node:test'
+import test, { afterEach, beforeEach } from 'node:test'
 
+import { acquireEnvMutex, releaseEnvMutex } from '../entrypoints/sdk/shared.js'
 import { DEFAULT_CODEX_BASE_URL } from '../services/api/providerConfig.js'
 import {
   applySavedProfileToCurrentSession,
@@ -51,6 +52,14 @@ async function importFreshProviderProfileModule() {
 
 const missingCodexAuthPath = join(tmpdir(), 'openclaude-missing-codex-auth.json')
 
+beforeEach(async () => {
+  await acquireEnvMutex()
+})
+
+afterEach(() => {
+  releaseEnvMutex()
+})
+
 test('matching persisted ollama env is reused for ollama launch', async () => {
   const env = await buildLaunchEnv({
     profile: 'ollama',
@@ -603,13 +612,15 @@ test('saveProfileFile defaults to user config instead of the working directory',
       OPENAI_MODEL: 'gpt-4o',
     })
 
-    const filePath = saveProfileFile(persisted)
+    const filePath = saveProfileFile(persisted, { configDir })
 
     assert.equal(filePath, join(configDir, PROFILE_FILE_NAME))
-    assert.equal(getDefaultProfileFilePath(), join(configDir, PROFILE_FILE_NAME))
+    assert.equal(getDefaultProfileFilePath(configDir), join(configDir, PROFILE_FILE_NAME))
     assert.equal(existsSync(join(cwd, PROFILE_FILE_NAME)), false)
-    assert.equal(statSync(configDir).mode & 0o777, 0o700)
-    assert.deepEqual(loadProfileFile(), persisted)
+    if (process.platform !== 'win32') {
+      assert.equal(statSync(configDir).mode & 0o777, 0o700)
+    }
+    assert.deepEqual(loadProfileFile({ configDir, cwd }), persisted)
   } finally {
     process.chdir(previousCwd)
     if (previousConfigDir === undefined) {
@@ -642,7 +653,7 @@ test('loadProfileFile keeps project-local files as a legacy fallback', () => {
       'utf8',
     )
 
-    assert.deepEqual(loadProfileFile(), legacyProfile)
+    assert.deepEqual(loadProfileFile({ configDir, cwd }), legacyProfile)
   } finally {
     process.chdir(previousCwd)
     if (previousConfigDir === undefined) {
@@ -676,7 +687,7 @@ test('loadProfileFile does not fall back when user config profile is invalid', (
       'utf8',
     )
 
-    assert.equal(loadProfileFile(), null)
+    assert.equal(loadProfileFile({ configDir, cwd }), null)
   } finally {
     process.chdir(previousCwd)
     if (previousConfigDir === undefined) {
@@ -731,6 +742,48 @@ test('deleteProfileFile clears the default profile and legacy workspace fallback
   }
 })
 
+test('deleteProfileFile with configDir and cwd clears both user config and legacy fallback', () => {
+  const cwd = mkdtempSync(join(tmpdir(), 'openclaude-delete-mixed-profile-'))
+  const configDir = mkdtempSync(join(tmpdir(), 'openclaude-delete-mixed-config-profile-'))
+  const previousConfigDir = process.env.CLAUDE_CONFIG_DIR
+  const previousCwd = process.cwd()
+
+  try {
+    process.env.CLAUDE_CONFIG_DIR = configDir
+    process.chdir(cwd)
+
+    const configProfile = createProfileFile('openai', {
+      OPENAI_API_KEY: 'sk-test',
+    })
+    const legacyProfile = createProfileFile('ollama', {
+      OPENAI_BASE_URL: 'http://localhost:11434/v1',
+      OPENAI_MODEL: 'llama3.1:8b',
+    })
+
+    saveProfileFile(configProfile, { configDir, cwd })
+    writeFileSync(
+      join(cwd, PROFILE_FILE_NAME),
+      JSON.stringify(legacyProfile, null, 2),
+      'utf8',
+    )
+
+    deleteProfileFile({ configDir, cwd })
+
+    assert.equal(existsSync(join(configDir, PROFILE_FILE_NAME)), false)
+    assert.equal(existsSync(join(cwd, PROFILE_FILE_NAME)), false)
+    assert.equal(loadProfileFile({ configDir, cwd }), null)
+  } finally {
+    process.chdir(previousCwd)
+    if (previousConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = previousConfigDir
+    }
+    rmSync(cwd, { recursive: true, force: true })
+    rmSync(configDir, { recursive: true, force: true })
+  }
+})
+
 test('buildCodexProfileEnv tags OAuth-saved profiles so logout can remove them safely', () => {
   const env = buildCodexProfileEnv({
     model: 'codexplan',
@@ -801,7 +854,7 @@ test('clearPersistedCodexOAuthProfile removes only persisted Codex OAuth profile
   }
 })
 
-test('clearPersistedCodexOAuthProfile clears both default and legacy OAuth profiles', () => {
+test('clearPersistedCodexOAuthProfile clears both default and legacy OAuth profiles', async () => {
   const cwd = mkdtempSync(join(tmpdir(), 'openclaude-clear-oauth-profile-'))
   const configDir = mkdtempSync(join(tmpdir(), 'openclaude-clear-oauth-config-'))
   const previousConfigDir = process.env.CLAUDE_CONFIG_DIR
@@ -811,27 +864,35 @@ test('clearPersistedCodexOAuthProfile clears both default and legacy OAuth profi
     process.env.CLAUDE_CONFIG_DIR = configDir
     process.chdir(cwd)
 
-    const oauthProfile = createProfileFile('codex', {
+    const {
+      PROFILE_FILE_NAME: freshProfileFileName,
+      clearPersistedCodexOAuthProfile: clearPersistedCodexOAuthProfileFresh,
+      createProfileFile: createProfileFileFresh,
+      loadProfileFile: loadProfileFileFresh,
+      saveProfileFile: saveProfileFileFresh,
+    } = await importFreshProviderProfileModule()
+
+    const oauthProfile = createProfileFileFresh('codex', {
       OPENAI_MODEL: 'codexplan',
       OPENAI_BASE_URL: DEFAULT_CODEX_BASE_URL,
       CHATGPT_ACCOUNT_ID: 'acct_oauth',
       CODEX_CREDENTIAL_SOURCE: 'oauth',
     })
 
-    saveProfileFile(oauthProfile)
+    saveProfileFileFresh(oauthProfile, { configDir })
     writeFileSync(
-      join(cwd, PROFILE_FILE_NAME),
+      join(cwd, freshProfileFileName),
       JSON.stringify(oauthProfile, null, 2),
       'utf8',
     )
 
     assert.equal(
-      clearPersistedCodexOAuthProfile(),
-      join(configDir, PROFILE_FILE_NAME),
+      clearPersistedCodexOAuthProfileFresh({ configDir, cwd }),
+      join(configDir, freshProfileFileName),
     )
-    assert.equal(existsSync(join(configDir, PROFILE_FILE_NAME)), false)
-    assert.equal(existsSync(join(cwd, PROFILE_FILE_NAME)), false)
-    assert.equal(loadProfileFile(), null)
+    assert.equal(existsSync(join(configDir, freshProfileFileName)), false)
+    assert.equal(existsSync(join(cwd, freshProfileFileName)), false)
+    assert.equal(loadProfileFileFresh({ configDir, cwd }), null)
   } finally {
     process.chdir(previousCwd)
     if (previousConfigDir === undefined) {
diff --git a/src/utils/providerProfile.ts b/src/utils/providerProfile.ts
index 4d58b13f8..9ec8d78b1 100644
--- a/src/utils/providerProfile.ts
+++ b/src/utils/providerProfile.ts
@@ -199,13 +199,14 @@ type SecretValueSource = Partial<
   >
 >
 
-type ProfileFileLocation = {
+export type ProfileFileLocation = {
+  configDir?: string
   cwd?: string
   filePath?: string
 }
 
-export function getDefaultProfileFilePath(): string {
-  return join(getClaudeConfigHomeDir(), PROFILE_FILE_NAME)
+export function getDefaultProfileFilePath(configDir?: string): string {
+  return join(configDir ?? getClaudeConfigHomeDir(), PROFILE_FILE_NAME)
 }
 
 function resolveLegacyProfileFilePath(cwd = process.cwd()): string {
@@ -217,16 +218,16 @@ function resolveProfileFilePath(options?: ProfileFileLocation): string {
     return options.filePath
   }
 
-  if (options?.cwd) {
+  if (options?.cwd && !options?.configDir) {
     return resolveLegacyProfileFilePath(options.cwd)
   }
 
-  return getDefaultProfileFilePath()
+  return getDefaultProfileFilePath(options?.configDir)
 }
 
 function resolveProfileFileReadPaths(options?: ProfileFileLocation): string[] {
   const primary = resolveProfileFilePath(options)
-  if (options?.filePath || options?.cwd) {
+  if (options?.filePath || (options?.cwd && !options?.configDir)) {
     return [primary]
   }
 
@@ -234,17 +235,17 @@ function resolveProfileFileReadPaths(options?: ProfileFileLocation): string[] {
     return [primary]
   }
 
-  const legacy = resolveLegacyProfileFilePath()
+  const legacy = resolveLegacyProfileFilePath(options?.cwd)
   return legacy === primary ? [primary] : [primary, legacy]
 }
 
 function resolveProfileFileCleanupPaths(options?: ProfileFileLocation): string[] {
   const primary = resolveProfileFilePath(options)
-  if (options?.filePath || options?.cwd) {
+  if (options?.filePath || (options?.cwd && !options?.configDir)) {
     return [primary]
   }
 
-  const legacy = resolveLegacyProfileFilePath()
+  const legacy = resolveLegacyProfileFilePath(options?.cwd)
   return legacy === primary ? [primary] : [primary, legacy]
 }
 
@@ -946,13 +947,12 @@ export function saveProfileFile(
 
 export function deleteProfileFile(options?: ProfileFileLocation): string {
   const filePath = resolveProfileFilePath(options)
-  rmSync(filePath, { force: true })
-  if (!options?.filePath && !options?.cwd) {
-    const legacyPath = resolveLegacyProfileFilePath()
-    if (legacyPath !== filePath) {
-      rmSync(legacyPath, { force: true })
-    }
+  const cleanupPaths = new Set(resolveProfileFileCleanupPaths(options))
+
+  for (const cleanupPath of cleanupPaths) {
+    rmSync(cleanupPath, { force: true })
   }
+
   return filePath
 }
 
diff --git a/src/utils/providerProfiles.test.ts b/src/utils/providerProfiles.test.ts
index f1d3a5c9b..a1c7b6cf2 100644
--- a/src/utils/providerProfiles.test.ts
+++ b/src/utils/providerProfiles.test.ts
@@ -4,6 +4,7 @@ import { join } from 'node:path'
 
 import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 
+import { acquireEnvMutex, releaseEnvMutex } from '../entrypoints/sdk/shared.js'
 import type { ProviderProfile } from './config.js'
 
 async function importFreshProvidersModule() {
@@ -92,7 +93,8 @@ function saveMockGlobalConfig(
   mockConfigState = updater(mockConfigState)
 }
 
-beforeEach(() => {
+beforeEach(async () => {
+  await acquireEnvMutex()
   for (const key of RESTORED_KEYS) {
     delete process.env[key]
   }
@@ -101,20 +103,24 @@ beforeEach(() => {
 })
 
 afterEach(() => {
-  for (const key of RESTORED_KEYS) {
-    if (originalEnv[key] === undefined) {
-      delete process.env[key]
-    } else {
-      process.env[key] = originalEnv[key]
+  try {
+    for (const key of RESTORED_KEYS) {
+      if (originalEnv[key] === undefined) {
+        delete process.env[key]
+      } else {
+        process.env[key] = originalEnv[key]
+      }
     }
-  }
 
-  mock.restore()
-  mockConfigState = createMockConfigState()
-  process.chdir(originalCwd)
-  if (testConfigDir) {
-    rmSync(testConfigDir, { recursive: true, force: true })
-    testConfigDir = null
+    mock.restore()
+    mockConfigState = createMockConfigState()
+    process.chdir(originalCwd)
+    if (testConfigDir) {
+      rmSync(testConfigDir, { recursive: true, force: true })
+      testConfigDir = null
+    }
+  } finally {
+    releaseEnvMutex()
   }
 })
 
@@ -1206,7 +1212,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [openaiProfile],
       }))
 
-      const result = setActiveProviderProfile('openai_prof')
+      const result = setActiveProviderProfile('openai_prof', {
+        configDir: testConfigDir ?? undefined,
+      })
 
       expect(result?.id).toBe('openai_prof')
       expect(String(process.env.CLAUDE_CODE_USE_OPENAI)).toBe('1')
@@ -1244,7 +1252,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [ollamaProfile],
       }))
 
-      const result = setActiveProviderProfile('ollama_prof')
+      const result = setActiveProviderProfile('ollama_prof', {
+        configDir,
+      })
       const persisted = JSON.parse(
         readFileSync(join(configDir, '.openclaude-profile.json'), 'utf8'),
       )
@@ -1287,7 +1297,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [deepSeekProfile],
       }))
 
-      const result = setActiveProviderProfile('deepseek_prof')
+      const result = setActiveProviderProfile('deepseek_prof', {
+        configDir,
+      })
       const persisted = JSON.parse(
         readFileSync(join(configDir, '.openclaude-profile.json'), 'utf8'),
       )
@@ -1330,7 +1342,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [deepSeekProfile],
       }))
 
-      const result = setActiveProviderProfile('deepseek_vendor_prof')
+      const result = setActiveProviderProfile('deepseek_vendor_prof', {
+        configDir,
+      })
       const persisted = JSON.parse(
         readFileSync(join(configDir, '.openclaude-profile.json'), 'utf8'),
       )
@@ -1369,7 +1383,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [veniceProfile],
       }))
 
-      const result = setActiveProviderProfile('venice_prof')
+      const result = setActiveProviderProfile('venice_prof', {
+        configDir,
+      })
       const persisted = JSON.parse(
         readFileSync(join(configDir, '.openclaude-profile.json'), 'utf8'),
       )
@@ -1410,7 +1426,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [mimoProfile],
       }))
 
-      const result = setActiveProviderProfile('mimo_prof')
+      const result = setActiveProviderProfile('mimo_prof', {
+        configDir,
+      })
       const persisted = JSON.parse(
         readFileSync(join(configDir, '.openclaude-profile.json'), 'utf8'),
       )
@@ -1453,7 +1471,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [bedrockProfile],
       }))
 
-      const result = setActiveProviderProfile('bedrock_prof')
+      const result = setActiveProviderProfile('bedrock_prof', {
+        configDir,
+      })
       const persisted = JSON.parse(
         readFileSync(join(configDir, '.openclaude-profile.json'), 'utf8'),
       )
@@ -1495,7 +1515,9 @@ describe('setActiveProviderProfile', () => {
         providerProfiles: [anthropicProfile],
       }))
 
-      const result = setActiveProviderProfile('anthro_persisted_prof')
+      const result = setActiveProviderProfile('anthro_persisted_prof', {
+        configDir,
+      })
       const persisted = JSON.parse(
         readFileSync(join(configDir, '.openclaude-profile.json'), 'utf8'),
       )
@@ -1531,7 +1553,9 @@ describe('setActiveProviderProfile', () => {
       providerProfiles: [anthropicProfile],
     }))
 
-    const result = setActiveProviderProfile('anthro_prof')
+    const result = setActiveProviderProfile('anthro_prof', {
+      configDir: testConfigDir ?? undefined,
+    })
 
     expect(result?.id).toBe('anthro_prof')
     expect(process.env.ANTHROPIC_MODEL).toBe('claude-sonnet-4-6')
@@ -1569,12 +1593,16 @@ describe('setActiveProviderProfile', () => {
     }))
 
     // First activate the openai profile
-    setActiveProviderProfile('openai_prof')
+    setActiveProviderProfile('openai_prof', {
+      configDir: testConfigDir ?? undefined,
+    })
     expect(process.env.OPENAI_MODEL).toBe('gpt-4o')
     expect(String(process.env.CLAUDE_CODE_USE_OPENAI)).toBe('1')
 
     // Now switch to the anthropic profile
-    const result = setActiveProviderProfile('anthro_prof')
+    const result = setActiveProviderProfile('anthro_prof', {
+      configDir: testConfigDir ?? undefined,
+    })
 
     expect(result?.id).toBe('anthro_prof')
     expect(process.env.ANTHROPIC_MODEL).toBe('claude-sonnet-4-6')
@@ -1614,12 +1642,16 @@ describe('setActiveProviderProfile', () => {
     }))
 
     // First activate the anthropic profile
-    setActiveProviderProfile('anthro_prof')
+    setActiveProviderProfile('anthro_prof', {
+      configDir: testConfigDir ?? undefined,
+    })
     expect(process.env.ANTHROPIC_MODEL).toBe('claude-sonnet-4-6')
     expect(process.env.ANTHROPIC_BASE_URL).toBe('https://api.anthropic.com')
 
     // Now switch to the openai profile
-    const result = setActiveProviderProfile('openai_prof')
+    const result = setActiveProviderProfile('openai_prof', {
+      configDir: testConfigDir ?? undefined,
+    })
 
     expect(result?.id).toBe('openai_prof')
     expect(String(process.env.CLAUDE_CODE_USE_OPENAI)).toBe('1')
@@ -1643,7 +1675,9 @@ describe('setActiveProviderProfile', () => {
       providerProfiles: [openaiProfile],
     }))
 
-    const result = setActiveProviderProfile('nonexistent_prof')
+    const result = setActiveProviderProfile('nonexistent_prof', {
+      configDir: testConfigDir ?? undefined,
+    })
 
     expect(result).toBeNull()
   })
@@ -1858,7 +1892,9 @@ describe('setActiveProviderProfile model cache', () => {
       ],
     }
 
-    setActiveProviderProfile('multi_provider')
+    setActiveProviderProfile('multi_provider', {
+      configDir: testConfigDir ?? undefined,
+    })
 
     const cache = getActiveOpenAIModelOptionsCache()
     const cacheValues = cache.map((opt: { value: string }) => opt.value)
@@ -1899,7 +1935,9 @@ describe('setActiveProviderProfile model cache', () => {
       },
     }
 
-    setActiveProviderProfile('multi_provider')
+    setActiveProviderProfile('multi_provider', {
+      configDir: testConfigDir ?? undefined,
+    })
 
     expect(getActiveOpenAIModelOptionsCache()).toEqual([
       {
diff --git a/src/utils/providerProfiles.ts b/src/utils/providerProfiles.ts
index c7af506ae..5a20e17f4 100644
--- a/src/utils/providerProfiles.ts
+++ b/src/utils/providerProfiles.ts
@@ -25,6 +25,7 @@ import {
   buildXiaomiMimoProfileEnv,
   buildVertexProfileEnv,
   clearManagedProfileEnv,
+  type ProfileFileLocation,
   type ProfileEnv,
   type ProviderProfile as ProviderProfileStartup,
 } from './providerProfile.js'
@@ -1128,6 +1129,7 @@ function triggerStartupDiscoveryRefreshForProfile(
 
 export function setActiveProviderProfile(
   profileId: string,
+  options?: ProfileFileLocation,
 ): ProviderProfile | null {
   const current = getGlobalConfig()
   const profiles = getProviderProfiles(current)
@@ -1158,7 +1160,7 @@ export function setActiveProviderProfile(
 
   if (startupProfile) {
     const file = createProfileFile(startupProfile.profile, startupProfile.env)
-    saveProfileFile(file)
+    saveProfileFile(file, options)
   }
 
   return activeProfile
diff --git a/src/utils/secureStorage/platformStorage.test.ts b/src/utils/secureStorage/platformStorage.test.ts
index e0dd8166c..e0e94bfbb 100644
--- a/src/utils/secureStorage/platformStorage.test.ts
+++ b/src/utils/secureStorage/platformStorage.test.ts
@@ -3,6 +3,10 @@ import { expect, test, mock, describe, beforeEach, afterEach } from "bun:test";
 import { linuxSecretStorage } from "./linuxSecretStorage.js";
 import { windowsCredentialStorage } from "./windowsCredentialStorage.js";
 import { getSecureStorageServiceName, CREDENTIALS_SERVICE_SUFFIX } from "./macOsKeychainHelpers.js";
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from "../../test/sharedMutationLock.js";
 
 // Mock execaSync
 const mockExecaSync = mock(() => ({ exitCode: 0, stdout: "" }));
@@ -13,7 +17,8 @@ mock.module("execa", () => ({
 describe("Secure Storage Platform Implementations", () => {
   const originalEnv = process.env;
 
-  beforeEach(() => {
+  beforeEach(async () => {
+    await acquireSharedMutationLock("platformStorage.test.ts");
     process.env = { ...originalEnv };
     mockExecaSync.mockClear();
     // Default mock behavior
@@ -21,7 +26,11 @@ describe("Secure Storage Platform Implementations", () => {
   });
 
   afterEach(() => {
-    process.env = originalEnv;
+    try {
+      process.env = originalEnv;
+    } finally {
+      releaseSharedMutationLock();
+    }
   });
 
   const testData = {
diff --git a/src/utils/settings/settings.ts b/src/utils/settings/settings.ts
index 23a7c0d62..844668eaa 100644
--- a/src/utils/settings/settings.ts
+++ b/src/utils/settings/settings.ts
@@ -827,9 +827,12 @@ export function getInitialSettings(): SettingsJson {
 }
 
 /**
- * @deprecated Use getInitialSettings() instead. This alias exists for backwards compatibility.
+ * @deprecated Use getInitialSettings() instead. Keep this as a function
+ * declaration so cyclic test-only module graphs never observe it in TDZ.
  */
-export const getSettings_DEPRECATED = getInitialSettings
+export function getSettings_DEPRECATED(): SettingsJson {
+  return getInitialSettings()
+}
 
 export type SettingsWithSources = {
   effective: SettingsJson
diff --git a/src/utils/storage/JSONProvider.test.ts b/src/utils/storage/JSONProvider.test.ts
new file mode 100644
index 000000000..a5d7c6c92
--- /dev/null
+++ b/src/utils/storage/JSONProvider.test.ts
@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, it } from 'bun:test'
+import { join } from 'path'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { JSONProvider } from './JSONProvider.js'
+
+const tempDirs: string[] = []
+
+const emptyGraph = {
+  entities: {},
+  relations: [],
+  summaries: [],
+  rules: [],
+  lastUpdateTime: 1,
+}
+
+function captureConsoleError<T>(run: () => T): { result: T; calls: unknown[][] } {
+  const originalConsoleError = console.error
+  const calls: unknown[][] = []
+  console.error = (...args: unknown[]) => {
+    calls.push(args)
+  }
+
+  try {
+    return {
+      result: run(),
+      calls,
+    }
+  } finally {
+    console.error = originalConsoleError
+  }
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop()
+    if (!dir) continue
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('JSONProvider', () => {
+  it('reports save failure when the graph path cannot be written', () => {
+    const projectDir = mkdtempSync(join(tmpdir(), 'openclaude-json-provider-'))
+    tempDirs.push(projectDir)
+    mkdirSync(join(projectDir, 'knowledge_graph.json'))
+
+    const provider = new JSONProvider(projectDir)
+    const { result, calls } = captureConsoleError(() =>
+      provider.saveGraph(emptyGraph),
+    )
+
+    expect(result).toBe(false)
+    expect(calls).toHaveLength(1)
+    expect(String(calls[0][0])).toContain('Failed to save project graph to JSON')
+  })
+
+  it('reports delete failure when the graph path is a directory', () => {
+    const projectDir = mkdtempSync(join(tmpdir(), 'openclaude-json-provider-'))
+    tempDirs.push(projectDir)
+    mkdirSync(join(projectDir, 'knowledge_graph.json'))
+
+    const provider = new JSONProvider(projectDir)
+    expect(provider.delete()).toBe(false)
+  })
+
+  it('reports delete success when the graph file is removed', () => {
+    const projectDir = mkdtempSync(join(tmpdir(), 'openclaude-json-provider-'))
+    tempDirs.push(projectDir)
+    writeFileSync(join(projectDir, 'knowledge_graph.json'), '{}', 'utf8')
+
+    const provider = new JSONProvider(projectDir)
+    expect(provider.delete()).toBe(true)
+  })
+})
diff --git a/src/utils/storage/JSONProvider.ts b/src/utils/storage/JSONProvider.ts
index 257c51b0a..80b508f8b 100644
--- a/src/utils/storage/JSONProvider.ts
+++ b/src/utils/storage/JSONProvider.ts
@@ -29,7 +29,7 @@ export class JSONProvider {
     }
   }
 
-  public saveGraph(graph: KnowledgeGraph): void {
+  public saveGraph(graph: KnowledgeGraph): boolean {
     try {
       const dir = dirname(this.path)
       if (!existsSync(dir)) {
@@ -38,16 +38,23 @@ export class JSONProvider {
       
       // Use established project utility for atomic writes with flushing
       writeFileSyncAndFlush_DEPRECATED(this.path, JSON.stringify(graph, null, 2), { encoding: 'utf-8' })
+      return true
     } catch (e) {
       console.error(`Failed to save project graph to JSON:`, e)
+      return false
     }
   }
 
-  public delete(): void {
-    if (existsSync(this.path)) {
-      try {
-        rmSync(this.path, { force: true })
-      } catch {}
+  public delete(): boolean {
+    if (!existsSync(this.path)) {
+      return true
+    }
+
+    try {
+      rmSync(this.path, { force: true })
+      return !existsSync(this.path)
+    } catch {
+      return false
     }
   }
 }
diff --git a/src/utils/storage/SQLiteMasterpiece.test.ts b/src/utils/storage/SQLiteMasterpiece.test.ts
index c32f0c3ec..c61d53338 100644
--- a/src/utils/storage/SQLiteMasterpiece.test.ts
+++ b/src/utils/storage/SQLiteMasterpiece.test.ts
@@ -11,32 +11,114 @@ import {
 import { mkdtempSync, rmSync, existsSync, writeFileSync, mkdirSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { getProjectsDir } from '../envUtils.js'
+import { acquireEnvMutex, releaseEnvMutex } from '../../entrypoints/sdk/shared.js'
+import { getProjectsDir, setClaudeConfigHomeDirForTesting } from '../envUtils.js'
 import { sanitizePath } from '../sessionStoragePortable.js'
 import { getFsImplementation } from '../fsOperations.js'
 
 describe('SQLite Masterpiece: Edge Cases & Multi-Project Isolation', () => {
   const originalConfigDir = process.env.CLAUDE_CONFIG_DIR
+  const originalConsoleError = console.error
+  const originalConsoleWarn = console.warn
   const rootTestDir = mkdtempSync(join(tmpdir(), 'openclaude-masterpiece-'))
-  process.env.CLAUDE_CONFIG_DIR = rootTestDir
-  
-  const project1Dir = join(rootTestDir, 'proj1')
-  const project2Dir = join(rootTestDir, 'proj2')
+  let capturedConsoleErrors: unknown[][] = []
+  let capturedConsoleWarnings: unknown[][] = []
+  let expectRecoveryLogsForCurrentTest = false
+  let originalFsCwd: (() => string) | null = null
+  let testCwd = ''
+  let project1Dir = ''
+  let project2Dir = ''
+  const removeDirWithRetry = (dir: string) => {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        rmSync(dir, { recursive: true, force: true })
+        return
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException).code
+        if (code !== 'EBUSY' && code !== 'EPERM') {
+          throw error
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25 * (attempt + 1))
+      }
+    }
 
-  beforeEach(() => {
+    try {
+      rmSync(dir, { recursive: true, force: true })
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (code !== 'EBUSY' && code !== 'EPERM') {
+        throw error
+      }
+    }
+  }
+  beforeEach(async () => {
+    await acquireEnvMutex()
+    capturedConsoleErrors = []
+    capturedConsoleWarnings = []
+    expectRecoveryLogsForCurrentTest = false
+    console.error = (...args: unknown[]) => {
+      capturedConsoleErrors.push(args)
+    }
+    console.warn = (...args: unknown[]) => {
+      capturedConsoleWarnings.push(args)
+    }
+    process.env.CLAUDE_CONFIG_DIR = rootTestDir
+    setClaudeConfigHomeDirForTesting(rootTestDir)
+    const fs = getFsImplementation()
+    originalFsCwd = fs.cwd
+    testCwd = join(
+      rootTestDir,
+      'suite-cwds',
+      `test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    )
+    project1Dir = join(testCwd, 'proj1')
+    project2Dir = join(testCwd, 'proj2')
+    fs.cwd = () => testCwd
     resetGlobalGraph()
     if (!existsSync(project1Dir)) mkdirSync(project1Dir, { recursive: true })
     if (!existsSync(project2Dir)) mkdirSync(project2Dir, { recursive: true })
   })
 
-  afterAll(() => {
-    resetGlobalGraph()
-    if (originalConfigDir === undefined) {
-      delete process.env.CLAUDE_CONFIG_DIR
-    } else {
-      process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+  afterEach(() => {
+    try {
+      resetGlobalGraph()
+      clearMemoryOnly()
+      const projectsDir = join(rootTestDir, 'projects')
+      if (existsSync(projectsDir)) {
+        removeDirWithRetry(projectsDir)
+      }
+      if (existsSync(testCwd)) {
+        removeDirWithRetry(testCwd)
+      }
+      if (originalConfigDir === undefined) {
+        delete process.env.CLAUDE_CONFIG_DIR
+      } else {
+        process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+      }
+      setClaudeConfigHomeDirForTesting(undefined)
+      if (expectRecoveryLogsForCurrentTest) {
+        expect(
+          capturedConsoleErrors.some(call =>
+            String(call[0]).includes('Failed to initialize SQLite database'),
+          ),
+        ).toBe(true)
+        expect(capturedConsoleWarnings).toHaveLength(0)
+      } else {
+        expect(capturedConsoleErrors).toHaveLength(0)
+        expect(capturedConsoleWarnings).toHaveLength(0)
+      }
+    } finally {
+      if (originalFsCwd) {
+        getFsImplementation().cwd = originalFsCwd
+      }
+      console.error = originalConsoleError
+      console.warn = originalConsoleWarn
+      releaseEnvMutex()
     }
-    rmSync(rootTestDir, { recursive: true, force: true })
+  })
+
+  afterAll(() => {
+    removeDirWithRetry(rootTestDir)
   })
 
   it('guarantees strict isolation between projects (CWD Switch)', async () => {
@@ -115,6 +197,7 @@ describe('SQLite Masterpiece: Edge Cases & Multi-Project Isolation', () => {
   })
 
   it('recovers from corrupted SQLite header (SHORT_READ/Disk Error)', async () => {
+    expectRecoveryLogsForCurrentTest = true
     const cwd = getFsImplementation().cwd()
     const projectDir = join(getProjectsDir(), sanitizePath(cwd))
     const sqlitePath = join(projectDir, 'knowledge.db')
@@ -130,7 +213,9 @@ describe('SQLite Masterpiece: Edge Cases & Multi-Project Isolation', () => {
     // 3. System should detect error during init, delete corrupted db, and rebuild from JSON
     await initOrama(cwd)
     const graph = getGlobalGraph()
-    expect(Object.values(graph.entities).some(e => e.name === 'survivor')).toBe(true)
+    expect(Object.values(graph.entities).some(e => e.name === 'survivor')).toBe(
+      true,
+    )
     expect(existsSync(sqlitePath)).toBe(true) // Recreated
   })
 
diff --git a/src/utils/storage/SQLiteProvider.test.ts b/src/utils/storage/SQLiteProvider.test.ts
index e43d1393f..9b4d6cf9a 100644
--- a/src/utils/storage/SQLiteProvider.test.ts
+++ b/src/utils/storage/SQLiteProvider.test.ts
@@ -6,34 +6,121 @@ import {
   getGlobalGraph,
   initOrama
 } from '../knowledgeGraph.js'
-import { mkdtempSync, rmSync, existsSync } from 'fs'
+import { mkdtempSync, rmSync, existsSync, renameSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { getProjectsDir } from '../envUtils.js'
+import { acquireEnvMutex, releaseEnvMutex } from '../../entrypoints/sdk/shared.js'
+import { getProjectsDir, setClaudeConfigHomeDirForTesting } from '../envUtils.js'
+import { getFsImplementation, setFsImplementation } from '../fsOperations.js'
 import { sanitizePath } from '../sessionStoragePortable.js'
+import { SQLiteProvider } from './SQLiteProvider.js'
 
 describe('SQLite Storage Layer', () => {
   const originalConfigDir = process.env.CLAUDE_CONFIG_DIR
+  const originalCwd = process.cwd()
+  const originalFs = getFsImplementation()
   const configDir = mkdtempSync(join(tmpdir(), 'openclaude-sqlite-'))
-  process.env.CLAUDE_CONFIG_DIR = configDir
-  const cwd = process.cwd()
+  let workspaceDir = ''
+  const removeDirWithRetry = (dir: string) => {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        rmSync(dir, { recursive: true, force: true })
+        return
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException).code
+        if (code !== 'EBUSY' && code !== 'EPERM') {
+          throw error
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25 * (attempt + 1))
+      }
+    }
 
-  beforeEach(() => {
+    try {
+      rmSync(dir, { recursive: true, force: true })
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (code !== 'EBUSY' && code !== 'EPERM') {
+        throw error
+      }
+    }
+  }
+
+  const removeFileWithRetry = (filePath: string) => {
+    const renamedPath = `${filePath}.deleted`
+
+    for (let attempt = 0; attempt < 12; attempt++) {
+      try {
+        rmSync(filePath, { force: true })
+        if (!existsSync(filePath)) {
+          return
+        }
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException).code
+        if (code !== 'EBUSY' && code !== 'EPERM') {
+          throw error
+        }
+      }
+
+      try {
+        if (existsSync(filePath)) {
+          renameSync(filePath, renamedPath)
+          return
+        }
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException).code
+        if (code !== 'EBUSY' && code !== 'EPERM' && code !== 'ENOENT') {
+          throw error
+        }
+      }
+
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50 * (attempt + 1))
+    }
+
+    if (existsSync(filePath)) {
+      throw new Error(`Timed out removing locked SQLite file: ${filePath}`)
+    }
+  }
+
+  beforeEach(async () => {
+    await acquireEnvMutex()
+    workspaceDir = mkdtempSync(join(tmpdir(), 'openclaude-sqlite-cwd-'))
+    process.chdir(workspaceDir)
+    setFsImplementation({
+      ...originalFs,
+      cwd: () => workspaceDir,
+    })
+    process.env.CLAUDE_CONFIG_DIR = configDir
+    setClaudeConfigHomeDirForTesting(configDir)
     resetGlobalGraph()
   })
 
+  afterEach(() => {
+    try {
+      resetGlobalGraph()
+      clearMemoryOnly()
+      if (originalConfigDir === undefined) {
+        delete process.env.CLAUDE_CONFIG_DIR
+      } else {
+        process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+      }
+      process.chdir(originalCwd)
+      setFsImplementation(originalFs)
+      setClaudeConfigHomeDirForTesting(undefined)
+      if (workspaceDir) {
+        removeDirWithRetry(workspaceDir)
+        workspaceDir = ''
+      }
+    } finally {
+      releaseEnvMutex()
+    }
+  })
+
   afterAll(() => {
-    resetGlobalGraph()
-    if (originalConfigDir === undefined) {
-      delete process.env.CLAUDE_CONFIG_DIR
-    } else {
-      process.env.CLAUDE_CONFIG_DIR = originalConfigDir
-    }
-    rmSync(configDir, { recursive: true, force: true })
+    removeDirWithRetry(configDir)
   })
 
   it('persists data in SQLite database', async () => {
-    const sqlitePath = join(getProjectsDir(), sanitizePath(cwd), 'knowledge.db')
+    const sqlitePath = join(getProjectsDir(), sanitizePath(workspaceDir), 'knowledge.db')
     
     // 1. Add data
     await addGlobalEntity('tool', 'sqlite-test', { status: 'durable' })
@@ -50,8 +137,8 @@ describe('SQLite Storage Layer', () => {
   })
 
   it('self-heals SQLite from JSON if DB is deleted', async () => {
-    const sqlitePath = join(getProjectsDir(), sanitizePath(cwd), 'knowledge.db')
-    const jsonPath = join(getProjectsDir(), sanitizePath(cwd), 'knowledge_graph.json')
+    const sqlitePath = join(getProjectsDir(), sanitizePath(workspaceDir), 'knowledge.db')
+    const jsonPath = join(getProjectsDir(), sanitizePath(workspaceDir), 'knowledge_graph.json')
 
     // 1. Add data to both
     await addGlobalEntity('tool', 'self-heal-test', { val: 'safe' })
@@ -60,12 +147,12 @@ describe('SQLite Storage Layer', () => {
 
     // 2. Delete SQLite DB but keep JSON
     clearMemoryOnly()
-    rmSync(sqlitePath)
+    removeFileWithRetry(sqlitePath)
     expect(existsSync(sqlitePath)).toBe(false)
 
     // 3. Requesting the graph should trigger hydration from JSON into a NEW SQLite DB
     // In the async architecture, we must await initialization to trigger the rebuild.
-    await initOrama(cwd)
+    await initOrama(workspaceDir)
     const graph = getGlobalGraph()
     const entity = Object.values(graph.entities).find(e => e.name === 'self-heal-test')
     expect(entity).toBeDefined()
@@ -77,18 +164,27 @@ describe('SQLite Storage Layer', () => {
 
   it('handles large transactions (Stress Test)', async () => {
     const count = 100
-    const start = Date.now()
     
     // Add 100 entities sequentially (mutation queue)
     for (let i = 0; i < count; i++) {
       await addGlobalEntity('bulk', `item_${i}`, { index: String(i) })
     }
-    
-    const duration = Date.now() - start
-    console.log(`Inserted ${count} items into SQLite+JSON+Orama in ${duration}ms`)
-    
+
     clearMemoryOnly()
     const graph = getGlobalGraph()
     expect(Object.keys(graph.entities).length).toBe(count)
   })
+
+  it('does not report a closed on-disk database as cleared', async () => {
+    const projectDir = join(getProjectsDir(), sanitizePath(workspaceDir))
+    const sqlitePath = join(projectDir, 'knowledge.db')
+
+    await addGlobalEntity('tool', 'closed-handle-test', { status: 'persisted' })
+    expect(existsSync(sqlitePath)).toBe(true)
+
+    clearMemoryOnly()
+
+    const closedProvider = new SQLiteProvider(projectDir)
+    expect(closedProvider.clear()).toBe(false)
+  })
 })
diff --git a/src/utils/storage/SQLiteProvider.ts b/src/utils/storage/SQLiteProvider.ts
index 5d14fbd7c..41b790a68 100644
--- a/src/utils/storage/SQLiteProvider.ts
+++ b/src/utils/storage/SQLiteProvider.ts
@@ -259,8 +259,31 @@ export class SQLiteProvider {
     }
   }
 
+  public clear(): boolean {
+    if (!this.db) {
+      return !existsSync(this.dbPath)
+    }
+
+    try {
+      this.db.transaction(() => {
+        this.db!.exec('DELETE FROM relations')
+        this.db!.exec('DELETE FROM entities')
+        this.db!.exec('DELETE FROM summaries')
+        this.db!.exec('DELETE FROM rules')
+        this.db!.exec('DELETE FROM sync_meta')
+      })()
+      return true
+    } catch (e) {
+      console.error('Failed to clear SQLite knowledge graph:', e)
+      return false
+    }
+  }
+
   public close(): void {
     if (this.db) {
+      try {
+        this.db.exec('PRAGMA wal_checkpoint(TRUNCATE);')
+      } catch {}
       try {
         this.db.close()
       } catch {}
diff --git a/tests/sdk/package-consumer-types.test.ts b/tests/sdk/package-consumer-types.test.ts
index e11cfdf38..12493ab43 100644
--- a/tests/sdk/package-consumer-types.test.ts
+++ b/tests/sdk/package-consumer-types.test.ts
@@ -10,7 +10,7 @@
  * - Self-referential type wrappers
  */
 import { afterAll, describe, expect, test } from 'bun:test'
-import { execSync } from 'child_process'
+import { execFileSync, execSync } from 'child_process'
 import { existsSync, mkdirSync, rmSync, writeFileSync, cpSync, readFileSync } from 'fs'
 import { join } from 'path'
 import { randomUUID } from 'crypto'
@@ -18,6 +18,7 @@ import { randomUUID } from 'crypto'
 const ROOT = join(import.meta.dir, '..', '..')
 const SDK_DTS = join(ROOT, 'src', 'entrypoints', 'sdk.d.ts')
 const CORE_TYPES_TS = join(ROOT, 'src', 'entrypoints', 'sdk', 'coreTypes.generated.ts')
+const TSC_BIN = join(ROOT, 'node_modules', 'typescript', 'bin', 'tsc')
 
 /** All temp dirs created during tests — cleaned up in afterAll */
 const tempDirs: string[] = []
@@ -92,7 +93,7 @@ function setupConsumerProject(name: string): string {
 
 /** Compile consumer.ts in the given tmpDir. Returns stdout (empty = success). */
 function tsc(tmpDir: string): string {
-  return execSync('npx tsc -p tsconfig.json --pretty false', {
+  return execFileSync(process.execPath, [TSC_BIN, '-p', 'tsconfig.json', '--pretty', 'false'], {
     cwd: tmpDir,
     encoding: 'utf-8',
     timeout: 60000,
diff --git a/tests/sdk/query-concurrency.test.ts b/tests/sdk/query-concurrency.test.ts
index 2c43be110..c237828ee 100644
--- a/tests/sdk/query-concurrency.test.ts
+++ b/tests/sdk/query-concurrency.test.ts
@@ -1,6 +1,10 @@
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test'
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
 import { query } from '../../src/entrypoints/sdk/index.js'
 import { getSessionId, getSessionProjectDir, runWithSdkContext } from '../../src/bootstrap/state.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../../src/test/sharedMutationLock.js'
 import { randomUUID } from 'crypto'
 import type { SessionId } from '../../src/types/ids.js'
 import { drainQuery, UUID_REGEX } from './helpers/query-test-doubles.js'
@@ -9,14 +13,19 @@ import { drainQuery, UUID_REGEX } from './helpers/query-test-doubles.js'
 const AUTH_KEY = 'ANTHROPIC_API_KEY'
 let savedApiKey: string | undefined
 
-beforeAll(() => {
+beforeEach(async () => {
+  await acquireSharedMutationLock('sdk-query-concurrency')
   savedApiKey = process.env[AUTH_KEY]
   if (!savedApiKey) process.env[AUTH_KEY] = 'sk-test-concurrency-stub'
 })
 
-afterAll(() => {
-  if (savedApiKey === undefined) delete process.env[AUTH_KEY]
-  else process.env[AUTH_KEY] = savedApiKey
+afterEach(() => {
+  try {
+    if (savedApiKey === undefined) delete process.env[AUTH_KEY]
+    else process.env[AUTH_KEY] = savedApiKey
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
 describe('SEC-1: env override isolation', () => {
diff --git a/tests/sdk/sdk-context-isolation.test.ts b/tests/sdk/sdk-context-isolation.test.ts
index 4a853038a..3a54a4298 100644
--- a/tests/sdk/sdk-context-isolation.test.ts
+++ b/tests/sdk/sdk-context-isolation.test.ts
@@ -11,6 +11,10 @@ import {
   setOriginalCwd,
   getParentSessionId,
 } from '../../src/bootstrap/state.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../../src/test/sharedMutationLock.js'
 import type { SessionId } from '../../src/entrypoints/agentSdkTypes.js'
 
 // Snapshot global state before each test so we can restore it
@@ -20,7 +24,8 @@ let originalOriginalCwd: string
 let originalSessionProjectDir: string | null
 
 describe('SDK context isolation', () => {
-  beforeEach(() => {
+  beforeEach(async () => {
+    await acquireSharedMutationLock('sdk-context-isolation')
     originalSessionId = getSessionId()
     originalCwd = getCwdState()
     originalOriginalCwd = getOriginalCwd()
@@ -28,10 +33,14 @@ describe('SDK context isolation', () => {
   })
 
   afterEach(() => {
-    // Restore global state after each test
-    switchSession(originalSessionId, originalSessionProjectDir)
-    setCwdState(originalCwd)
-    setOriginalCwd(originalOriginalCwd)
+    try {
+      // Restore global state after each test
+      switchSession(originalSessionId, originalSessionProjectDir)
+      setCwdState(originalCwd)
+      setOriginalCwd(originalOriginalCwd)
+    } finally {
+      releaseSharedMutationLock()
+    }
   })
 
   describe('setCwdState', () => {
diff --git a/tests/sdk/sdk-preserved-segment.test.ts b/tests/sdk/sdk-preserved-segment.test.ts
index 720f0ffcf..279cd472f 100644
--- a/tests/sdk/sdk-preserved-segment.test.ts
+++ b/tests/sdk/sdk-preserved-segment.test.ts
@@ -6,6 +6,20 @@ import { tmpdir } from 'os'
 import { getProjectDir } from '../../src/utils/sessionStoragePortable.js'
 import { query } from '../../src/entrypoints/sdk/index.js'
 import { unstable_v2_resumeSession } from '../../src/entrypoints/sdk/index.js'
+import {
+  getCwdState,
+  getOriginalCwd,
+  getSessionId,
+  getSessionProjectDir,
+  setCwdState,
+  setOriginalCwd,
+  switchSession,
+} from '../../src/bootstrap/state.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../../src/test/sharedMutationLock.js'
+import type { SessionId } from '../../src/entrypoints/agentSdkTypes.js'
 
 /**
  * Regression test for compact preserved segment handling in SDK resume.
@@ -139,12 +153,31 @@ function createCompactTranscriptWithPreservedSegment(
 }
 
 let tempDirs: string[] = []
+let originalSessionId: SessionId
+let originalSessionProjectDir: string | null
+let originalCwd: string
+let originalOriginalCwd: string
+
+beforeEach(async () => {
+  await acquireSharedMutationLock('sdk-preserved-segment')
+  originalSessionId = getSessionId()
+  originalSessionProjectDir = getSessionProjectDir()
+  originalCwd = getCwdState()
+  originalOriginalCwd = getOriginalCwd()
+})
 
 afterEach(() => {
-  for (const dir of tempDirs) {
-    rmSync(dir, { recursive: true, force: true })
+  try {
+    switchSession(originalSessionId, originalSessionProjectDir)
+    setCwdState(originalCwd)
+    setOriginalCwd(originalOriginalCwd)
+    for (const dir of tempDirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    tempDirs = []
+  } finally {
+    releaseSharedMutationLock()
   }
-  tempDirs = []
 })
 
 describe('Compact preserved segment regression', () => {
@@ -470,4 +503,4 @@ describe('Compact preserved segment regression', () => {
 
     session.close()
   })
-})
\ No newline at end of file
+})
diff --git a/tests/sdk/sdk-v2-lifecycle.test.ts b/tests/sdk/sdk-v2-lifecycle.test.ts
index 8f3899540..4011557eb 100644
--- a/tests/sdk/sdk-v2-lifecycle.test.ts
+++ b/tests/sdk/sdk-v2-lifecycle.test.ts
@@ -1,4 +1,4 @@
-import { describe, test, expect, afterEach, beforeAll, afterAll } from 'bun:test'
+import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll } from 'bun:test'
 import { randomUUID } from 'crypto'
 import { rmSync } from 'fs'
 import {
@@ -6,7 +6,20 @@ import {
   unstable_v2_resumeSession,
   unstable_v2_prompt,
 } from '../../src/entrypoints/sdk/index.js'
-import { getSessionProjectDir } from '../../src/bootstrap/state.js'
+import {
+  getCwdState,
+  getOriginalCwd,
+  getSessionId,
+  getSessionProjectDir,
+  setCwdState,
+  setOriginalCwd,
+  switchSession,
+} from '../../src/bootstrap/state.js'
+import {
+  acquireSharedMutationLock,
+  releaseSharedMutationLock,
+} from '../../src/test/sharedMutationLock.js'
+import type { SessionId } from '../../src/entrypoints/agentSdkTypes.js'
 import {
   drainQuery,
   withTempDir,
@@ -19,27 +32,46 @@ import {
 // sendMessage drains trigger init(), which checks auth. Stub it for CI.
 const AUTH_KEY = 'ANTHROPIC_API_KEY'
 let savedApiKey: string | undefined
+let originalSessionId: SessionId
+let originalSessionProjectDir: string | null
+let originalCwd: string
+let originalOriginalCwd: string
 
-beforeAll(() => {
+// Collect temp dirs for cleanup
+const tempDirs: string[] = []
+
+beforeAll(async () => {
+  await acquireSharedMutationLock('sdk-v2-lifecycle')
   savedApiKey = process.env[AUTH_KEY]
   if (!savedApiKey) process.env[AUTH_KEY] = 'sk-test-v2-lifecycle-stub'
 })
 
 afterAll(() => {
-  if (savedApiKey === undefined) delete process.env[AUTH_KEY]
-  else process.env[AUTH_KEY] = savedApiKey
+  try {
+    if (savedApiKey === undefined) delete process.env[AUTH_KEY]
+    else process.env[AUTH_KEY] = savedApiKey
+  } finally {
+    releaseSharedMutationLock()
+  }
 })
 
-// Collect temp dirs for cleanup
-const tempDirs: string[] = []
-
 afterEach(() => {
+  switchSession(originalSessionId, originalSessionProjectDir)
+  setCwdState(originalCwd)
+  setOriginalCwd(originalOriginalCwd)
   for (const dir of tempDirs) {
     try { rmSync(dir, { recursive: true, force: true }) } catch {}
   }
   tempDirs.length = 0
 })
 
+beforeEach(() => {
+  originalSessionId = getSessionId()
+  originalSessionProjectDir = getSessionProjectDir()
+  originalCwd = getCwdState()
+  originalOriginalCwd = getOriginalCwd()
+})
+
 describe('V2: session creation', () => {
   test('createSession() returns SDKSession with valid sessionId', () => {
     const session = unstable_v2_createSession({