test(runtime-fallback): cover pluginConfig DI and lazy interval

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

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

src/hooks/runtime-fallback/hook.init.test.ts

@@ -0,0 +1,124 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test"
+import type { OhMyOpenCodeConfig } from "../../config"
+import type { HookDeps, RuntimeFallbackInterval, RuntimeFallbackPluginInput } from "./types"
+
+type RuntimeFallbackModule = typeof import("./hook")
+
+const loadPluginConfigMock = mock(() => ({} satisfies OhMyOpenCodeConfig))
+const createAutoRetryHelpersMock = mock((_deps: HookDeps) => {
+  void _deps
+
+  return {
+    abortSessionRequest: async () => {},
+    clearSessionFallbackTimeout: () => {},
+    scheduleSessionFallbackTimeout: () => {},
+    autoRetryWithFallback: async () => {},
+    resolveAgentForSessionFromContext: async () => undefined,
+    cleanupStaleSessions: () => {},
+  }
+})
+const createEventHandlerMock = mock(() => async () => {})
+const createMessageUpdateHandlerMock = mock(() => async () => {})
+const createChatMessageHandlerMock = mock(() => async () => {})
+
+function registerModuleMocks(): void {
+  mock.module("../../plugin-config", () => ({
+    loadPluginConfig: loadPluginConfigMock,
+  }))
+
+  mock.module("./auto-retry", () => ({
+    createAutoRetryHelpers: createAutoRetryHelpersMock,
+  }))
+
+  mock.module("./event-handler", () => ({
+    createEventHandler: createEventHandlerMock,
+  }))
+
+  mock.module("./message-update-handler", () => ({
+    createMessageUpdateHandler: createMessageUpdateHandlerMock,
+  }))
+
+  mock.module("./chat-message-handler", () => ({
+    createChatMessageHandler: createChatMessageHandlerMock,
+  }))
+}
+
+function createMockContext(): RuntimeFallbackPluginInput {
+  return {
+    client: {
+      session: {
+        abort: async () => ({}),
+        messages: async () => ({}),
+        promptAsync: async () => ({}),
+      },
+      tui: {
+        showToast: async () => ({}),
+      },
+    },
+    directory: "/test",
+  }
+}
+
+function createMockInterval(): RuntimeFallbackInterval {
+  return {
+    unref: () => {},
+  }
+}
+
+describe("createRuntimeFallbackHook initialization", () => {
+  const originalSetInterval = globalThis.setInterval
+  let setIntervalCalls = 0
+  let createRuntimeFallbackHook: RuntimeFallbackModule["createRuntimeFallbackHook"]
+
+  beforeEach(async () => {
+    mock.restore()
+    registerModuleMocks()
+    loadPluginConfigMock.mockClear()
+    createAutoRetryHelpersMock.mockClear()
+    createEventHandlerMock.mockClear()
+    createMessageUpdateHandlerMock.mockClear()
+    createChatMessageHandlerMock.mockClear()
+    setIntervalCalls = 0
+
+    globalThis.setInterval = ((callback: Parameters<typeof originalSetInterval>[0], delay?: number) => {
+      void callback
+      void delay
+      setIntervalCalls += 1
+      return createMockInterval() as ReturnType<typeof globalThis.setInterval>
+    }) as typeof globalThis.setInterval
+
+    const cacheBuster = `${Date.now()}-${Math.random()}`
+    const runtimeFallbackModule: RuntimeFallbackModule = await import(`./hook?test=${cacheBuster}`)
+    createRuntimeFallbackHook = runtimeFallbackModule.createRuntimeFallbackHook
+  })
+
+  afterEach(() => {
+    globalThis.setInterval = originalSetInterval
+    mock.restore()
+  })
+
+  test("#given injected pluginConfig #when the hook factory runs #then loadPluginConfig is not called", () => {
+    // given
+    const pluginConfig = {} satisfies OhMyOpenCodeConfig
+
+    // when
+    createRuntimeFallbackHook(createMockContext(), { pluginConfig })
+
+    // then
+    expect(loadPluginConfigMock).not.toHaveBeenCalled()
+  })
+
+  test("#given a fresh hook #when the first event arrives #then cleanup interval starts only once", async () => {
+    // given
+    const hook = createRuntimeFallbackHook(createMockContext(), { pluginConfig: {} })
+
+    // when
+    expect(setIntervalCalls).toBe(0)
+    await hook.event({ event: { type: "session.created", properties: {} } })
+    expect(setIntervalCalls).toBe(1)
+    await hook.event({ event: { type: "session.error", properties: {} } })
+
+    // then
+    expect(setIntervalCalls).toBe(1)
+  })
+})