fix(ci): resolve mock.module() cross-file leakage in test suite

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

src/features/background-agent/abort-with-timeout.test.ts

@@ -6,9 +6,11 @@ mock.module("../../shared", () => ({
   log: logMock,
 }))
 
-import { abortWithTimeout } from "./abort-with-timeout"
 import type { OpencodeClient } from "./opencode-client"
 
+const { abortWithTimeout } = await import("./abort-with-timeout")
+mock.restore()
+
 function createClient(abort: (...args: Array<unknown>) => Promise<unknown>): OpencodeClient {
   return {
     session: {

src/features/background-agent/fallback-retry-handler.test.ts

@@ -17,14 +17,15 @@ mock.module("../../shared/provider-model-id-transform", () => ({
   transformModelForProvider: mock((_provider: string, model: string) => model),
 }))
 
-import { tryFallbackRetry } from "./fallback-retry-handler"
-import { shouldRetryError } from "../../shared/model-error-classifier"
-import { selectFallbackProvider } from "../../shared/model-error-classifier"
-import { readProviderModelsCache } from "../../shared"
 import type { BackgroundTask } from "./types"
 import type { ConcurrencyManager } from "./concurrency"
 import type { OpencodeClient, QueueItem } from "./constants"
 
+const { tryFallbackRetry } = await import("./fallback-retry-handler")
+const { shouldRetryError, selectFallbackProvider } = await import("../../shared/model-error-classifier")
+const { readProviderModelsCache } = await import("../../shared")
+mock.restore()
+
 function createDeferredPromise(): {
   promise: Promise<void>
   resolve: () => void

src/features/background-agent/manager.test.ts

@@ -20,6 +20,7 @@ import { MIN_IDLE_TIME_MS } from "./constants"
 import { BackgroundManager } from "./manager"
 import { ConcurrencyManager } from "./concurrency"
 import { initTaskToastManager, _resetTaskToastManagerForTesting } from "../task-toast-manager/manager"
+mock.restore()
 
 
 const TASK_TTL_MS = 30 * 60 * 1000

src/features/background-agent/session-status-classifier.test.ts

@@ -1,11 +1,13 @@
 import { describe, test, expect, mock, afterAll } from "bun:test"
-import { isActiveSessionStatus, isTerminalSessionStatus } from "./session-status-classifier"
 
 const mockLog = mock()
 mock.module("../../shared", () => ({ log: mockLog }))
 
 afterAll(() => { mock.restore() })
 
+const { isActiveSessionStatus, isTerminalSessionStatus } = await import("./session-status-classifier")
+mock.restore()
+
 describe("isActiveSessionStatus", () => {
   describe("#given a known active session status", () => {
     test('#when type is "busy" #then returns true', () => {

src/hooks/anthropic-context-window-limit-recovery/message-builder.test.ts

@@ -33,7 +33,9 @@ mock.module("../session-recovery/storage/text-part-injector", () => ({
 }))
 
 async function importFreshMessageBuilder(): Promise<typeof import("./message-builder")> {
-  return import(`./message-builder?test=${Date.now()}-${Math.random()}`)
+  const module = await import(`./message-builder?test=${Date.now()}-${Math.random()}`)
+  mock.restore()
+  return module
 }
 
 afterAll(() => {

src/hooks/auto-slash-command/executor-resolution.test.ts

@@ -1,13 +1,19 @@
-import { afterAll, describe, expect, it, mock } from "bun:test"
+import { afterEach, describe, expect, it, spyOn } from "bun:test"
 import type { LoadedSkill } from "../../features/opencode-skill-loader"
+import * as shared from "../../shared"
+import * as slashcommand from "../../tools/slashcommand"
+import { executeSlashCommand } from "./executor"
 
-mock.module("../../shared", () => ({
+let resolveCommandsInTextSpy: { mockRestore: () => void } | undefined
-  resolveCommandsInText: async (content: string) => content,
+let resolveFileReferencesInTextSpy: { mockRestore: () => void } | undefined
-  resolveFileReferencesInText: async (content: string) => content,
+let discoverCommandsSyncSpy: { mockRestore: () => void } | undefined
-}))
 
-mock.module("../../tools/slashcommand", () => ({
+function setupExecutorSpies(): void {
-  discoverCommandsSync: () => [
+  resolveCommandsInTextSpy = spyOn(shared, "resolveCommandsInText")
+    .mockImplementation(async (content: string) => content)
+  resolveFileReferencesInTextSpy = spyOn(shared, "resolveFileReferencesInText")
+    .mockImplementation(async (content: string) => content)
+  discoverCommandsSyncSpy = spyOn(slashcommand, "discoverCommandsSync").mockReturnValue([
     {
       name: "shadowed",
       metadata: { name: "shadowed", description: "builtin" },
@@ -20,18 +26,19 @@ mock.module("../../tools/slashcommand", () => ({
       content: "project template",
       scope: "project",
     },
-  ],
+  ])
-}))
+}
 
-mock.module("../../features/opencode-skill-loader", () => ({
+function restoreExecutorSpies(): void {
-  discoverAllSkills: async (): Promise<LoadedSkill[]> => [],
+  resolveCommandsInTextSpy?.mockRestore()
-}))
+  resolveFileReferencesInTextSpy?.mockRestore()
+  discoverCommandsSyncSpy?.mockRestore()
+  resolveCommandsInTextSpy = undefined
+  resolveFileReferencesInTextSpy = undefined
+  discoverCommandsSyncSpy = undefined
+}
 
-afterAll(() => {
+afterEach(restoreExecutorSpies)
-  mock.restore()
-})
-
-const { executeSlashCommand } = await import("./executor")
 
 function createRestrictedSkill(): LoadedSkill {
   return {
@@ -49,6 +56,7 @@ function createRestrictedSkill(): LoadedSkill {
 describe("executeSlashCommand resolution semantics", () => {
   it("returns project command when project and builtin names collide", async () => {
     //#given
+    setupExecutorSpies()
     const parsed = {
       command: "shadowed",
       args: "",
@@ -67,6 +75,7 @@ describe("executeSlashCommand resolution semantics", () => {
 
   it("blocks slash skill invocation when invoking agent is missing", async () => {
     //#given
+    setupExecutorSpies()
     const parsed = {
       command: "restricted-skill",
       args: "",
@@ -83,6 +92,7 @@ describe("executeSlashCommand resolution semantics", () => {
 
   it("allows slash skill invocation when invoking agent matches restriction", async () => {
     //#given
+    setupExecutorSpies()
     const parsed = {
       command: "restricted-skill",
       args: "",

src/hooks/legacy-plugin-toast/hook.test.ts

@@ -53,7 +53,9 @@ function createEvent(type: string, parentID?: string) {
 }
 
 async function importFreshModule() {
-  return import(`./hook?t=${Date.now()}-${Math.random()}`)
+  const module = await import(`./hook?t=${Date.now()}-${Math.random()}`)
+  mock.restore()
+  return module
 }
 
 describe("createLegacyPluginToastHook", () => {

src/hooks/model-fallback/hook.test.ts

@@ -57,12 +57,13 @@ afterAll(() => {
   mock.restore()
 })
 
-import {
+const {
   clearPendingModelFallback,
   createModelFallbackHook,
   setSessionFallbackChain,
   setPendingModelFallback,
-} from "./hook"
+} = await import("./hook")
+mock.restore()
 
 describe("model fallback hook", () => {
   beforeEach(() => {
@@ -452,3 +453,5 @@ describe("model fallback hook", () => {
     clearPendingModelFallback(sessionID)
   })
 })
+
+export {}

src/hooks/read-image-resizer/hook.test.ts

@@ -1,9 +1,13 @@
 /// <reference types="bun-types" />
 
-import { beforeEach, describe, expect, it, mock } from "bun:test"
+import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from "bun:test"
 import type { PluginInput } from "@opencode-ai/plugin"
 
 import type { ImageDimensions, ResizeResult } from "./types"
+import * as imageDimensions from "./image-dimensions"
+import * as imageResizer from "./image-resizer"
+import * as sessionModelState from "../../shared/session-model-state"
+import { createReadImageResizerHook } from "./hook"
 
 const mockParseImageDimensions = mock((): ImageDimensions | null => null)
 const mockCalculateTargetDimensions = mock((): ImageDimensions | null => null)
@@ -13,20 +17,17 @@ const mockGetSessionModel = mock((_sessionID: string) => ({
   modelID: "claude-sonnet-4-6",
 } as { providerID: string; modelID: string } | undefined))
 
-mock.module("./image-dimensions", () => ({
+let parseImageDimensionsSpy: { mockRestore: () => void } | undefined
-  parseImageDimensions: mockParseImageDimensions,
+let calculateTargetDimensionsSpy: { mockRestore: () => void } | undefined
-}))
+let resizeImageSpy: { mockRestore: () => void } | undefined
+let getSessionModelSpy: { mockRestore: () => void } | undefined
 
-mock.module("./image-resizer", () => ({
+function setupHookSpies(): void {
-  calculateTargetDimensions: mockCalculateTargetDimensions,
+  parseImageDimensionsSpy = spyOn(imageDimensions, "parseImageDimensions").mockImplementation(mockParseImageDimensions)
-  resizeImage: mockResizeImage,
+  calculateTargetDimensionsSpy = spyOn(imageResizer, "calculateTargetDimensions").mockImplementation(mockCalculateTargetDimensions)
-}))
+  resizeImageSpy = spyOn(imageResizer, "resizeImage").mockImplementation(mockResizeImage)
-
+  getSessionModelSpy = spyOn(sessionModelState, "getSessionModel").mockImplementation(mockGetSessionModel)
-mock.module("../../shared/session-model-state", () => ({
+}
-  getSessionModel: mockGetSessionModel,
-}))
-
-import { createReadImageResizerHook } from "./hook"
 
 type ToolOutput = {
   title: string
@@ -52,6 +53,7 @@ function createInput(tool: string): { tool: string; sessionID: string; callID: s
 
 describe("createReadImageResizerHook", () => {
   beforeEach(() => {
+    setupHookSpies()
     mockParseImageDimensions.mockReset()
     mockCalculateTargetDimensions.mockReset()
     mockResizeImage.mockReset()
@@ -59,6 +61,17 @@ describe("createReadImageResizerHook", () => {
     mockGetSessionModel.mockReturnValue({ providerID: "anthropic", modelID: "claude-sonnet-4-6" })
   })
 
+  afterEach(() => {
+    parseImageDimensionsSpy?.mockRestore()
+    calculateTargetDimensionsSpy?.mockRestore()
+    resizeImageSpy?.mockRestore()
+    getSessionModelSpy?.mockRestore()
+    parseImageDimensionsSpy = undefined
+    calculateTargetDimensionsSpy = undefined
+    resizeImageSpy = undefined
+    getSessionModelSpy = undefined
+  })
+
   it("skips non-Read tools", async () => {
     //#given
     const hook = createReadImageResizerHook(createMockContext())

src/hooks/session-recovery/recover-tool-result-missing.test.ts

@@ -22,6 +22,7 @@ afterAll(() => {
 })
 
 const { recoverToolResultMissing } = await import("./recover-tool-result-missing")
+mock.restore()
 
 function createMockClient(messages: MessageData[] = []) {
   const promptAsync = mock(() => Promise.resolve({}))

src/plugin/event.model-fallback.test.ts

@@ -1,19 +1,23 @@
 declare const require: (name: string) => any
-const { afterEach, afterAll, describe, expect, mock, test } = require("bun:test")
+const { afterEach, describe, expect, spyOn, test } = require("bun:test")
-
-mock.module("../shared/connected-providers-cache", () => ({
-  readConnectedProvidersCache: () => null,
-  readProviderModelsCache: () => null,
-}))
-
-afterAll(() => { mock.restore() })
 
 import { createEventHandler } from "./event"
 import { createChatMessageHandler } from "./chat-message"
 import { _resetForTesting, setMainSession } from "../features/claude-code-session-state"
 import { createModelFallbackHook, clearPendingModelFallback } from "../hooks/model-fallback/hook"
+import * as connectedProvidersCache from "../shared/connected-providers-cache"
+
+let readConnectedProvidersCacheSpy: { mockRestore: () => void } | undefined
+let readProviderModelsCacheSpy: { mockRestore: () => void } | undefined
+
+function setupConnectedProviderCacheMocks(): void {
+  readConnectedProvidersCacheSpy = spyOn(connectedProvidersCache, "readConnectedProvidersCache").mockReturnValue(null)
+  readProviderModelsCacheSpy = spyOn(connectedProvidersCache, "readProviderModelsCache").mockReturnValue(null)
+}
+
 describe("createEventHandler - model fallback", () => {
   const createHandler = (args?: { hooks?: any; pluginConfig?: any }) => {
+    setupConnectedProviderCacheMocks()
     const abortCalls: string[] = []
     const promptCalls: string[] = []
 
@@ -54,6 +58,10 @@ describe("createEventHandler - model fallback", () => {
   }
 
   afterEach(() => {
+    readConnectedProvidersCacheSpy?.mockRestore()
+    readProviderModelsCacheSpy?.mockRestore()
+    readConnectedProvidersCacheSpy = undefined
+    readProviderModelsCacheSpy = undefined
     _resetForTesting()
   })
 
@@ -442,6 +450,7 @@ describe("createEventHandler - model fallback", () => {
 
     const modelFallback = createModelFallbackHook()
 
+    setupConnectedProviderCacheMocks()
     const eventHandler = createEventHandler({
       ctx: {
         directory: "/tmp",

src/plugin/fallback.cliproxyapi-matrix.test.ts

@@ -1,17 +1,8 @@
 declare const require: (name: string) => any
-const { afterEach, afterAll, describe, expect, mock, test } = require("bun:test")
+const { afterEach, describe, expect, spyOn, test } = require("bun:test")
 
 const PROVIDER_ID = "cliproxyapi"
 
-mock.module("../shared/connected-providers-cache", () => ({
-  readConnectedProvidersCache: () => [PROVIDER_ID],
-  readProviderModelsCache: () => ({
-    connected: [PROVIDER_ID],
-  }),
-}))
-
-afterAll(() => { mock.restore() })
-
 import { createEventHandler } from "./event"
 import { createChatMessageHandler } from "./chat-message"
 import { createModelFallbackHook } from "../hooks/model-fallback/hook"
@@ -20,6 +11,7 @@ import type { RuntimeFallbackPluginInput } from "../hooks/runtime-fallback/types
 import { _resetForTesting } from "../features/claude-code-session-state"
 import { _resetForTesting as _resetModelFallbackForTesting } from "../hooks/model-fallback/hook"
 import { SessionCategoryRegistry } from "../shared/session-category-registry"
+import * as connectedProvidersCache from "../shared/connected-providers-cache"
 
 type EventHandlerArgs = Parameters<typeof createEventHandler>[0]
 type ChatMessageHandlerArgs = Parameters<typeof createChatMessageHandler>[0]
@@ -92,6 +84,9 @@ type PromptAsyncCall = {
   parts?: Array<{ type?: string; text?: string }>
 }
 
+let readConnectedProvidersCacheSpy: { mockRestore: () => void } | undefined
+let readProviderModelsCacheSpy: { mockRestore: () => void } | undefined
+
 function createPluginConfig(mode: HarnessMode) {
   return {
     agents: {
@@ -114,6 +109,7 @@ function createHarness(args: {
   promptAsyncImpl?: (call: PromptAsyncCall) => Promise<unknown>
   sessionTimeoutMs?: number
 }) {
+  setupConnectedProviderCacheMocks()
   const abortCalls: string[] = []
   const promptCalls: string[] = []
   const promptAsyncCalls: PromptAsyncCall[] = []
@@ -353,6 +349,24 @@ async function triggerAssistantMessageError(
   }))
 }
 
+afterEach(() => {
+  readConnectedProvidersCacheSpy?.mockRestore()
+  readProviderModelsCacheSpy?.mockRestore()
+  readConnectedProvidersCacheSpy = undefined
+  readProviderModelsCacheSpy = undefined
+})
+
+function setupConnectedProviderCacheMocks(): void {
+  readConnectedProvidersCacheSpy = spyOn(connectedProvidersCache, "readConnectedProvidersCache").mockReturnValue([
+    PROVIDER_ID,
+  ])
+  readProviderModelsCacheSpy = spyOn(connectedProvidersCache, "readProviderModelsCache").mockReturnValue({
+    connected: [PROVIDER_ID],
+    models: {},
+    updatedAt: new Date(0).toISOString(),
+  })
+}
+
 afterEach(() => {
   _resetForTesting()
   _resetModelFallbackForTesting()

src/shared/log-legacy-plugin-startup-warning.test.ts

@@ -37,7 +37,10 @@ afterAll(() => {
 })
 
 async function importFreshStartupWarningModule(): Promise<typeof import("./log-legacy-plugin-startup-warning")> {
-  return import(`./log-legacy-plugin-startup-warning?test=${Date.now()}-${Math.random()}`)
+  const module = await import(`./log-legacy-plugin-startup-warning?test=${Date.now()}-${Math.random()}`)
+  mock.restore()
+  consoleWarnSpy = spyOn(console, "warn").mockImplementation(() => {})
+  return module
 }
 
 describe("logLegacyPluginStartupWarning", () => {

src/shared/model-capabilities.test.ts

@@ -1,3 +1,4 @@
+import type { ModelCapabilitiesSnapshot } from "./model-capabilities"
 import { afterAll, describe, expect, test, mock } from "bun:test"
 
 // Mock connected-providers-cache to prevent local disk cache from polluting test results.
@@ -14,11 +15,8 @@ afterAll(() => {
   mock.restore()
 })
 
-import {
+const { getModelCapabilities, getBundledModelCapabilitiesSnapshot } = await import("./model-capabilities")
-  getModelCapabilities,
+mock.restore()
-  getBundledModelCapabilitiesSnapshot,
-  type ModelCapabilitiesSnapshot,
-} from "./model-capabilities"
 import { AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS } from "./model-requirements"
 
 describe("getModelCapabilities", () => {

src/shared/model-error-classifier.test.ts

@@ -9,7 +9,8 @@ mock.module("./connected-providers-cache", () => ({
 
 afterAll(() => { mock.restore() })
 
-import { shouldRetryError, selectFallbackProvider } from "./model-error-classifier"
+const { shouldRetryError, selectFallbackProvider } = await import("./model-error-classifier")
+mock.restore()
 
 describe("model-error-classifier", () => {
   beforeEach(() => {
@@ -107,3 +108,5 @@ describe("model-error-classifier", () => {
     expect(result).toBe(true)
   })
 })
+
+export {}