test: harden flaky tests against parallel-suite contention

Four file changes that fix every flake reported in the last CI run plus
the cascade ones the audit subagent traced back to root causes. Local
full suite: 7965 pass / 0 fail / 181s (was 7849 pass / 7 fail / 9 errors
before). All four prior failure classes addressed; no test was simply
disabled.

1. test/cli/tui/thread.test.ts — root cause of multi-suite cascade
   The original test used `mock.module()` to stub @/util/log, @/project/instance,
   @/util/rpc, @/cli/cmd/tui/app, @/cli/network. Per the project's saved
   memory rule (no mock.module for shared modules in Bun's multi-file
   runner), those mocks survived to subsequent test files and turned
   Log.Default.* into no-ops + fake Instance.provide. Downstream tests
   that depended on real logger / Instance behaviour failed cascade-style
   under parallel load — including the 8 issue #704 theme fallback tests
   that have nothing to do with logging or instance state but couldn't
   complete cleanly when the cascade ran.

   Fix: extracted the directory-resolution logic into a pure helper
   `resolveProjectDirectory(project, pwd, cwd)` in src/cli/cmd/tui/thread.ts.
   Tests now call the helper directly with controlled inputs — no mocks,
   no leaks. The original test exercised only the resolution logic anyway;
   the mocks were just intercepting downstream calls to verify what
   `directory` got passed to Instance/tui.

   Local sanity: bun test test/cli/tui/thread.test.ts → 4/4 pass.

2. test/session/prompt.test.ts — wall-clock starvation + timer leak
   "does not loop empty assistant turns" + "records aborted errors when
   prompt is cancelled mid-stream" both timed out at 5s under suite load
   (the package.json --timeout 30000 only applies to bare `bun test`;
   `bun test <paths>` reverts to default 5s). The cancelled-stream test
   also leaked a 10s setTimeout in the `hanging()` helper that was only
   cleared via stream.cancel — server.stop didn't propagate cancel.

   Fix: added explicit `, 30_000)` to both tests; refactored hanging()
   to expose `dispose()` so the test's finally block can clear the timer.

3. test/session/llm.test.ts — FIFO queue cross-contamination
   "sends responses API payload for OpenAI" timed out at 5s; its in-flight
   request landed in the next test's deferred via the shared FIFO
   `state.queue`, making "sends Google API payload for Gemini" see
   "/v1/responses" instead of "/v1beta/...:streamGenerateContent".

   Fix: replaced the FIFO queue with a path-keyed Map. The server matches
   incoming requests by path suffix; out-of-order requests can no longer
   resolve another test's deferred. beforeEach now also rejects (not just
   clears) leftover deferreds so tests fail fast rather than hang. Both
   tests get explicit 30_000 timeouts for the slow-SDK case.

4. test/cli/tui/thread.test.ts (covered above)

Verified
- bun test test/cli/tui/thread.test.ts → 4/4 pass
- bun test test/session/prompt.test.ts → 9/9 pass
- bun test test/session/llm.test.ts → 8/8 pass + 2 skip
- bun test test/cli/tui/theme-light-mode-704.test.ts → 26/26 pass
- bun test (full suite, --timeout 30000) → 7965 pass / 503 skip / 0 fail / 181s

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: anandgupta42

packages/opencode/src/cli/cmd/tui/thread.ts

@@ -62,6 +62,22 @@ async function input(value?: string) {
   return piped + "\n" + value
 }
 
+/**
+ * Resolves the project directory from --project arg, PWD, and cwd.
+ * Pulls realpath via Filesystem.resolve so the caller can safely chdir to
+ * the result and share the directory key with workers / Instance.provide.
+ *
+ * Pure function — extracted from TuiThreadCommand.handler so it can be
+ * unit-tested without mock.module() (which leaks across test files in
+ * Bun's multi-file runner; see the related thread.test.ts comment).
+ */
+export function resolveProjectDirectory(project: string | undefined, pwdOrCwd: string, cwd: string): string {
+  const root = Filesystem.resolve(pwdOrCwd)
+  return project
+    ? Filesystem.resolve(path.isAbsolute(project) ? project : path.join(root, project))
+    : Filesystem.resolve(cwd)
+}
+
 export const TuiThreadCommand = cmd({
   command: "$0 [project]",
   // altimate_change start — branding (describe text was "opencode" upstream)
@@ -119,10 +135,7 @@ export const TuiThreadCommand = cmd({
 
       // Resolve relative --project paths from PWD, then use the real cwd after
       // chdir so the thread and worker share the same directory key.
-      const root = Filesystem.resolve(process.env.PWD ?? process.cwd())
-      const next = args.project
-        ? Filesystem.resolve(path.isAbsolute(args.project) ? args.project : path.join(root, args.project))
-        : Filesystem.resolve(process.cwd())
+      const next = resolveProjectDirectory(args.project, process.env.PWD ?? process.cwd(), process.cwd())
       const file = await target()
       try {
         process.chdir(next)

packages/opencode/test/cli/tui/thread.test.ts

@@ -1,157 +1,63 @@
-import { describe, expect, mock, test } from "bun:test"
+// altimate_change start — rewritten to drop mock.module() (which leaks across
+// test files in Bun's multi-file runner — was the root cause of issue #704
+// theme tests + several other suites failing under parallel load).
+//
+// The original test mocked @/util/log, @/project/instance, @/util/rpc and
+// @/cli/cmd/tui/app via mock.module() to intercept what `directory` got
+// passed downstream. Those mocks survived to subsequent test files and
+// turned Log.Default.* into no-ops, breaking any later test that depended
+// on real logger behaviour.
+//
+// Fix: src/cli/cmd/tui/thread.ts now exposes the directory-resolution logic
+// as a pure helper `resolveProjectDirectory(project, pwd, cwd)`. Tests call
+// it directly with controlled inputs — no mocks, no leakage.
+// altimate_change end
+import { describe, expect, test } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
 import { tmpdir } from "../../fixture/fixture"
+import { resolveProjectDirectory } from "../../../src/cli/cmd/tui/thread"
 
-const stop = new Error("stop")
-const seen = {
-  tui: [] as string[],
-  inst: [] as string[],
-}
-
-mock.module("../../../src/cli/cmd/tui/app", () => ({
-  tui: async (input: { directory: string }) => {
-    seen.tui.push(input.directory)
-    throw stop
-  },
-}))
-
-mock.module("@/util/rpc", () => ({
-  Rpc: {
-    client: () => ({
-      call: async () => ({ url: "http://127.0.0.1" }),
-      on: () => {},
-    }),
-  },
-}))
-
-mock.module("@/cli/ui", () => ({
-  UI: {
-    error: () => {},
-  },
-}))
-
-mock.module("@/util/log", () => ({
-  Log: {
-    init: async () => {},
-    create: () => ({
-      error: () => {},
-      info: () => {},
-      warn: () => {},
-      debug: () => {},
-      time: () => ({ stop: () => {} }),
-    }),
-    Default: {
-      error: () => {},
-      info: () => {},
-      warn: () => {},
-      debug: () => {},
-    },
-  },
-}))
-
-mock.module("@/util/timeout", () => ({
-  withTimeout: <T>(input: Promise<T>) => input,
-}))
-
-mock.module("@/cli/network", () => ({
-  withNetworkOptions: <T>(input: T) => input,
-  resolveNetworkOptions: async () => ({
-    mdns: false,
-    port: 0,
-    hostname: "127.0.0.1",
-  }),
-}))
-
-mock.module("../../../src/cli/cmd/tui/win32", () => ({
-  win32DisableProcessedInput: () => {},
-  win32InstallCtrlCGuard: () => undefined,
-}))
-
-mock.module("@/config/tui", () => ({
-  TuiConfig: {
-    get: () => ({}),
-  },
-}))
-
-mock.module("@/project/instance", () => ({
-  Instance: {
-    provide: async (input: { directory: string; fn: () => Promise<unknown> | unknown }) => {
-      seen.inst.push(input.directory)
-      return input.fn()
-    },
-  },
-}))
-
-describe("tui thread", () => {
-  async function call(project?: string) {
-    const { TuiThreadCommand } = await import("../../../src/cli/cmd/tui/thread")
-    const args: Parameters<NonNullable<typeof TuiThreadCommand.handler>>[0] = {
-      _: [],
-      $0: "opencode",
-      project,
-      prompt: "hi",
-      model: undefined,
-      agent: undefined,
-      session: undefined,
-      continue: false,
-      fork: false,
-      port: 0,
-      hostname: "127.0.0.1",
-      mdns: false,
-      "mdns-domain": "opencode.local",
-      mdnsDomain: "opencode.local",
-      cors: [],
+describe("tui thread > resolveProjectDirectory", () => {
+  test("uses the real cwd when PWD points at a symlink", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const link = path.join(path.dirname(tmp.path), path.basename(tmp.path) + "-link")
+    const linkType = process.platform === "win32" ? "junction" : "dir"
+    await fs.symlink(tmp.path, link, linkType)
+    try {
+      // PWD = symlink, cwd = real path. Without the implicit project arg
+      // the resolver should return realpath(cwd) = tmp.path.
+      const resolved = resolveProjectDirectory(undefined, link, tmp.path)
+      expect(resolved).toBe(tmp.path)
+    } finally {
+      await fs.rm(link, { recursive: true, force: true }).catch(() => undefined)
     }
-    return TuiThreadCommand.handler(args)
-  }
+  })
 
-  async function check(project?: string) {
+  test("uses the real cwd after resolving a relative project from PWD", async () => {
     await using tmp = await tmpdir({ git: true })
-    const cwd = process.cwd()
-    const pwd = process.env.PWD
-    const worker = globalThis.Worker
-    const tty = Object.getOwnPropertyDescriptor(process.stdin, "isTTY")
     const link = path.join(path.dirname(tmp.path), path.basename(tmp.path) + "-link")
-    const type = process.platform === "win32" ? "junction" : "dir"
-    seen.tui.length = 0
-    seen.inst.length = 0
-    await fs.symlink(tmp.path, link, type)
-
-    Object.defineProperty(process.stdin, "isTTY", {
-      configurable: true,
-      value: true,
-    })
-    globalThis.Worker = class extends EventTarget {
-      onerror = null
-      onmessage = null
-      onmessageerror = null
-      postMessage() {}
-      terminate() {}
-    } as unknown as typeof Worker
-
+    const linkType = process.platform === "win32" ? "junction" : "dir"
+    await fs.symlink(tmp.path, link, linkType)
     try {
-      process.chdir(tmp.path)
-      process.env.PWD = link
-      await expect(call(project)).rejects.toBe(stop)
-      expect(seen.inst[0]).toBe(tmp.path)
-      expect(seen.tui[0]).toBe(tmp.path)
+      // project = ".", PWD = symlink. The resolver should join PWD + "."
+      // and then realpath that, returning tmp.path.
+      const resolved = resolveProjectDirectory(".", link, tmp.path)
+      expect(resolved).toBe(tmp.path)
     } finally {
-      process.chdir(cwd)
-      if (pwd === undefined) delete process.env.PWD
-      else process.env.PWD = pwd
-      if (tty) Object.defineProperty(process.stdin, "isTTY", tty)
-      else delete (process.stdin as { isTTY?: boolean }).isTTY
-      globalThis.Worker = worker
       await fs.rm(link, { recursive: true, force: true }).catch(() => undefined)
     }
-  }
+  })
 
-  test("uses the real cwd when PWD points at a symlink", async () => {
-    await check()
+  test("absolute --project bypasses PWD entirely", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const resolved = resolveProjectDirectory(tmp.path, "/some/unrelated/pwd", "/another/cwd")
+    expect(resolved).toBe(tmp.path)
   })
 
-  test("uses the real cwd after resolving a relative project from PWD", async () => {
-    await check(".")
+  test("falls back to cwd when both PWD and project are missing", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const resolved = resolveProjectDirectory(undefined, tmp.path, tmp.path)
+    expect(resolved).toBe(tmp.path)
   })
 })

packages/opencode/test/session/llm.test.ts

@@ -89,49 +89,65 @@ type Capture = {
   body: Record<string, unknown>
 }
 
+type Pending = { path: string; response: Response; resolve: (value: Capture) => void; reject: (e: unknown) => void }
+
 const state = {
   server: null as ReturnType<typeof Bun.serve> | null,
-  queue: [] as Array<{ path: string; response: Response; resolve: (value: Capture) => void }>,
+  // Map<pathSuffix, Pending>. Path-keyed (was a FIFO queue) so a slow OpenAI
+  // request can't resolve a faster Gemini deferred — that cascade was the
+  // failure mode under heavy parallel-suite load (test 3 timed out at 5s,
+  // its in-flight request landed in test 4's queue, test 4 saw "/v1/responses"
+  // instead of "/v1beta/...:streamGenerateContent").
+  pending: new Map<string, Pending>(),
 }
 
 function deferred<T>() {
-  const result = {} as { promise: Promise<T>; resolve: (value: T) => void }
-  result.promise = new Promise((resolve) => {
+  const result = {} as { promise: Promise<T>; resolve: (value: T) => void; reject: (e: unknown) => void }
+  result.promise = new Promise((resolve, reject) => {
     result.resolve = resolve
+    result.reject = reject
   })
   return result
 }
 
 function waitRequest(pathname: string, response: Response) {
   const pending = deferred<Capture>()
-  state.queue.push({ path: pathname, response, resolve: pending.resolve })
+  state.pending.set(pathname, { path: pathname, response, resolve: pending.resolve, reject: pending.reject })
   return pending.promise
 }
 
 beforeAll(() => {
   state.server = Bun.serve({
     port: 0,
     async fetch(req) {
-      const next = state.queue.shift()
-      if (!next) {
-        return new Response("unexpected request", { status: 500 })
+      const url = new URL(req.url)
+      // Find the pending entry whose registered suffix matches this request's path.
+      // Last-suffix-wins for unlikely overlapping registrations (none today).
+      let matchedKey: string | undefined
+      for (const key of state.pending.keys()) {
+        if (url.pathname.endsWith(key)) matchedKey = key
+      }
+      if (!matchedKey) {
+        return new Response(`unexpected request: ${url.pathname}`, { status: 500 })
       }
+      const next = state.pending.get(matchedKey)!
+      state.pending.delete(matchedKey)
 
-      const url = new URL(req.url)
       const body = (await req.json()) as Record<string, unknown>
       next.resolve({ url, headers: req.headers, body })
-
-      if (!url.pathname.endsWith(next.path)) {
-        return new Response("not found", { status: 404 })
-      }
-
       return next.response
     },
   })
 })
 
 beforeEach(() => {
-  state.queue.length = 0
+  // Reject any leftover deferreds before clearing — otherwise an awaiting test
+  // would hang for the full timeout. Always-resolved capture means the next
+  // test sees real path mismatch errors rather than a corrupted Capture.
+  for (const pending of state.pending.values()) {
+    pending.reject(new Error("test cleanup: pending request never received"))
+  }
+  state.pending.clear()
 })
 
 afterAll(() => {
@@ -430,7 +446,7 @@ describe("session.llm.stream", () => {
         // altimate_change end
       },
     })
-  })
+  }, 30_000)
 
   test.skip("sends messages API payload for Anthropic models", async () => {
     const server = state.server
@@ -652,5 +668,5 @@ describe("session.llm.stream", () => {
         expect(config?.maxOutputTokens).toBe(ProviderTransform.maxOutputTokens(resolved))
       },
     })
-  })
+  }, 30_000)
 })