fix: eliminate flaky CI test failures in dispatcher, dbt, and tracer tests

Root causes:
- `dispatcher.test.ts`: Bun's multi-file runner leaks `_ensureRegistered`
  hook from other files' `native/index.ts` imports. `reset()` clears
  handlers but not the hook, so `call()` triggers lazy registration
  instead of throwing. Fix: clear hook in `beforeEach`.
- `dbt-first-execution.test.ts`: `mock.module` for DuckDB leaked across
  files. Fix: spread real module exports + ensure native/index.ts import.
- `tracing-adversarial-final.test.ts`: 50ms snapshot waits too tight for
  CI under load. Fix: increase to 200ms/300ms.

Result: 0 failures in full suite (4961 pass, 340 skip).

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

Author: anandgupta42

packages/opencode/test/altimate/dbt-first-execution.test.ts

@@ -11,14 +11,26 @@
  * Set DBT_TEST_PROJECT_ROOT env var to override the project path.
  */
 
-import { describe, expect, test, beforeAll, afterAll, beforeEach, mock } from "bun:test"
+import { describe, expect, test, beforeAll, afterAll, beforeEach, mock, spyOn } from "bun:test"
 import { existsSync, readFileSync } from "fs"
 import { join } from "path"
 import { homedir } from "os"
 import type { Connector } from "@altimateai/drivers/types"
-
-// Mock DuckDB driver so tests don't require the native duckdb package
+import * as Dispatcher from "../../src/altimate/native/dispatcher"
+
+// Import native/index.ts to ensure the lazy registration hook is set.
+// In Bun's multi-file runner, test execution order is unpredictable —
+// if dispatcher.test.ts runs first and clears the hook, this file's
+// Dispatcher.call() would fail with "No native handler" errors.
+// Re-importing here ensures the hook is always available.
+import "../../src/altimate/native"
+
+// Mock DuckDB driver so tests don't require the native duckdb package.
+// NOTE: mock.module leaks across test files in Bun — we spread the real
+// module exports to minimize damage to other test files.
+import * as realDuckdb from "@altimateai/drivers/duckdb"
 mock.module("@altimateai/drivers/duckdb", () => ({
+  ...realDuckdb,
   connect: async (config: any) => ({
     execute: async (sql: string) => {
       // Simple mock: parse SELECT literals
@@ -108,15 +120,11 @@ const HAS_DBT = !!DBT_PROJECT
 // ---------------------------------------------------------------------------
 describe("dbt Profiles Auto-Discovery", () => {
   test("parseDbtProfiles finds connections from ~/.dbt/profiles.yml", async () => {
-    const { parseDbtProfiles } = await import(
-      "../../src/altimate/native/connections/dbt-profiles"
-    )
+    const { parseDbtProfiles } = await import("../../src/altimate/native/connections/dbt-profiles")
     const profiles = await parseDbtProfiles()
     console.log(`  Found ${profiles.length} dbt profile connections`)
     if (profiles.length > 0) {
-      console.log(
-        `  Types: ${profiles.map((p: any) => p.config?.type || p.type).join(", ")}`,
-      )
+      console.log(`  Types: ${profiles.map((p: any) => p.config?.type || p.type).join(", ")}`)
     }
     expect(Array.isArray(profiles)).toBe(true)
   })
@@ -127,19 +135,15 @@ describe("dbt Profiles Auto-Discovery", () => {
     const r = await Dispatcher.call("dbt.profiles", {})
     expect(r.success).toBe(true)
     expect(Array.isArray(r.connections)).toBe(true)
-    console.log(
-      `  dbt.profiles found ${r.connection_count} connection(s)`,
-    )
+    console.log(`  dbt.profiles found ${r.connection_count} connection(s)`)
   })
 
   test("warehouse.discover includes dbt profiles", async () => {
     const { Dispatcher } = await import("../../src/altimate/native")
     const r = await Dispatcher.call("warehouse.discover", {})
     // dbt_profiles may be in the result
     if ((r as any).dbt_profiles && (r as any).dbt_profiles.length > 0) {
-      console.log(
-        `  warehouse.discover found ${(r as any).dbt_profiles.length} dbt profiles`,
-      )
+      console.log(`  warehouse.discover found ${(r as any).dbt_profiles.length} dbt profiles`)
     }
     expect(r).toHaveProperty("containers")
     expect(r).toHaveProperty("container_count")
@@ -156,9 +160,7 @@ describe.skipIf(!HAS_DBT)("dbt-First SQL Execution E2E", () => {
   })
 
   test("dbt adapter can be created from config", async () => {
-    const { read: readConfig } = await import(
-      "../../../dbt-tools/src/config"
-    )
+    const { read: readConfig } = await import("../../../dbt-tools/src/config")
     const cfg = await readConfig()
     if (!cfg) {
       console.log("  No dbt config — skipping adapter test")
@@ -173,14 +175,10 @@ describe.skipIf(!HAS_DBT)("dbt-First SQL Execution E2E", () => {
 
   test("sql.execute without warehouse tries dbt first", async () => {
     // Reset registry so no native connections are configured
-    const Registry = await import(
-      "../../src/altimate/native/connections/registry"
-    )
+    const Registry = await import("../../src/altimate/native/connections/registry")
     Registry.reset()
 
-    const { resetDbtAdapter } = await import(
-      "../../src/altimate/native/connections/register"
-    )
+    const { resetDbtAdapter } = await import("../../src/altimate/native/connections/register")
     resetDbtAdapter()
 
     const { Dispatcher } = await import("../../src/altimate/native")
@@ -207,9 +205,7 @@ describe.skipIf(!HAS_DBT)("Direct dbt Adapter Execution", () => {
 
   beforeAll(async () => {
     try {
-      const { read: readConfig } = await import(
-        "../../../dbt-tools/src/config"
-      )
+      const { read: readConfig } = await import("../../../dbt-tools/src/config")
       const cfg = await readConfig()
       if (!cfg) return
 
@@ -231,10 +227,7 @@ describe.skipIf(!HAS_DBT)("Direct dbt Adapter Execution", () => {
     if (!adapter) return
     try {
       // Try a simple query that works on most dbt projects
-      const r = await adapter.immediatelyExecuteSQL(
-        "SELECT COUNT(*) AS cnt FROM information_schema.tables",
-        "",
-      )
+      const r = await adapter.immediatelyExecuteSQL("SELECT COUNT(*) AS cnt FROM information_schema.tables", "")
       expect(r).toBeTruthy()
       console.log(`  Tables count query succeeded`)
     } catch (e: any) {
@@ -258,14 +251,10 @@ describe.skipIf(!HAS_DBT)("Direct dbt Adapter Execution", () => {
 // ---------------------------------------------------------------------------
 describe("dbt Fallback Behavior", () => {
   test("when dbt not configured, falls back to native driver silently", async () => {
-    const Registry = await import(
-      "../../src/altimate/native/connections/registry"
-    )
+    const Registry = await import("../../src/altimate/native/connections/registry")
     Registry.reset()
 
-    const { resetDbtAdapter } = await import(
-      "../../src/altimate/native/connections/register"
-    )
+    const { resetDbtAdapter } = await import("../../src/altimate/native/connections/register")
     resetDbtAdapter()
 
     // Set up a native DuckDB connection as fallback
@@ -284,9 +273,7 @@ describe("dbt Fallback Behavior", () => {
   })
 
   test("explicit warehouse param bypasses dbt entirely", async () => {
-    const Registry = await import(
-      "../../src/altimate/native/connections/registry"
-    )
+    const Registry = await import("../../src/altimate/native/connections/registry")
     Registry.reset()
     Registry.setConfigs({
       my_duck: { type: "duckdb", path: ":memory:" },

packages/opencode/test/altimate/dispatcher.test.ts

@@ -2,12 +2,22 @@ import { describe, expect, test, beforeEach, beforeAll, afterAll, mock } from "b
 import * as Dispatcher from "../../src/altimate/native/dispatcher"
 
 // Disable telemetry via env var instead of mock.module
-beforeAll(() => { process.env.ALTIMATE_TELEMETRY_DISABLED = "true" })
-afterAll(() => { delete process.env.ALTIMATE_TELEMETRY_DISABLED })
+beforeAll(() => {
+  process.env.ALTIMATE_TELEMETRY_DISABLED = "true"
+})
+afterAll(() => {
+  delete process.env.ALTIMATE_TELEMETRY_DISABLED
+})
 
 describe("Dispatcher", () => {
   beforeEach(() => {
     Dispatcher.reset()
+    // Clear lazy registration hook to prevent other test files' imports
+    // from triggering handler registration during these unit tests.
+    // Without this, Bun's multi-file runner leaks the hook from files
+    // that import native/index.ts, causing call() to resolve instead
+    // of rejecting for unregistered methods.
+    Dispatcher.setRegistrationHook(null as any)
   })
 
   describe("register and hasNativeHandler", () => {
@@ -36,9 +46,7 @@ describe("Dispatcher", () => {
 
   describe("call — no handler", () => {
     test("throws when no native handler registered", async () => {
-      await expect(Dispatcher.call("ping", {} as any)).rejects.toThrow(
-        "No native handler for ping",
-      )
+      await expect(Dispatcher.call("ping", {} as any)).rejects.toThrow("No native handler for ping")
     })
   })
 
@@ -65,7 +73,9 @@ describe("Dispatcher", () => {
     })
 
     test("tracks telemetry on error", async () => {
-      Dispatcher.register("ping", async () => { throw new Error("fail") })
+      Dispatcher.register("ping", async () => {
+        throw new Error("fail")
+      })
       await expect(Dispatcher.call("ping", {} as any)).rejects.toThrow("fail")
       // Telemetry is disabled — just verify no crash
     })

packages/opencode/test/altimate/tracing-adversarial-final.test.ts

@@ -223,15 +223,16 @@ describe("Orphaned generation — endTrace with unclosed generation", () => {
   test("snapshot mid-generation shows 'running', endTrace shows 'completed'", async () => {
     const tracer = Recap.withExporters([new FileExporter(tmpDir)])
     tracer.startTrace("s-run-complete", { prompt: "test" })
-    await new Promise((r) => setTimeout(r, 50)) // wait for initial snapshot
+    await new Promise((r) => setTimeout(r, 200)) // wait for initial snapshot
     tracer.logStepStart({ id: "1" })
     tracer.logToolCall({
-      tool: "bash", callID: "c1",
+      tool: "bash",
+      callID: "c1",
       state: { status: "completed", input: {}, output: "ok", time: { start: 1, end: 2 } },
     })
 
     // Wait for snapshot — should be "running"
-    await new Promise((r) => setTimeout(r, 50))
+    await new Promise((r) => setTimeout(r, 200))
     const snap = JSON.parse(await fs.readFile(tracer.getTracePath()!, "utf-8")) as TraceFile
     expect(snap.summary.status).toBe("running")
 
@@ -269,7 +270,8 @@ describe("Worker race — events after endTrace", () => {
     const tracer = getOrCreateRecap("race-session")!
     tracer.logStepStart({ id: "1" })
     tracer.logToolCall({
-      tool: "bash", callID: "c1",
+      tool: "bash",
+      callID: "c1",
       state: { status: "completed", input: {}, output: "ok", time: { start: 1, end: 2 } },
     })
     tracer.logStepFinish(ZERO_STEP)
@@ -294,7 +296,7 @@ describe("Worker race — events after endTrace", () => {
     }
 
     // Wait for endTrace to complete
-    await new Promise((r) => setTimeout(r, 50))
+    await new Promise((r) => setTimeout(r, 200))
 
     // Verify the late event was NOT added to the trace
     const filePath = path.join(tmpDir, "race-session.json")
@@ -325,7 +327,8 @@ describe("Worker race — events after endTrace", () => {
     const t1 = getOrCreateRecap("cycle-test")!
     t1.logStepStart({ id: "1" })
     t1.logToolCall({
-      tool: "bash", callID: "c1",
+      tool: "bash",
+      callID: "c1",
       state: { status: "completed", input: {}, output: "cycle1", time: { start: 1, end: 2 } },
     })
     t1.logStepFinish(ZERO_STEP)
@@ -338,16 +341,15 @@ describe("Worker race — events after endTrace", () => {
 
     t2.logStepStart({ id: "1" })
     t2.logToolCall({
-      tool: "read", callID: "c2",
+      tool: "read",
+      callID: "c2",
       state: { status: "completed", input: {}, output: "cycle2", time: { start: 3, end: 4 } },
     })
     t2.logStepFinish(ZERO_STEP)
     await t2.endTrace()
 
     // File should have cycle 2 data
-    const traceFile: TraceFile = JSON.parse(
-      await fs.readFile(path.join(tmpDir, "cycle-test.json"), "utf-8"),
-    )
+    const traceFile: TraceFile = JSON.parse(await fs.readFile(path.join(tmpDir, "cycle-test.json"), "utf-8"))
     expect(traceFile.spans.filter((s) => s.kind === "tool")).toHaveLength(1)
     expect(traceFile.spans.find((s) => s.kind === "tool")!.name).toBe("read")
   })
@@ -403,33 +405,35 @@ describe("buildTraceFile — status transitions", () => {
     const path1 = tracer.getTracePath()!
 
     // Wait for initial snapshot — should be "completed" (no active generation)
-    await new Promise((r) => setTimeout(r, 50))
+    await new Promise((r) => setTimeout(r, 200))
     const snap0 = JSON.parse(await fs.readFile(path1, "utf-8")) as TraceFile
     expect(snap0.summary.status).toBe("completed")
 
     // Start generation — internal state now has currentGenerationSpanId
     tracer.logStepStart({ id: "1" })
     tracer.logToolCall({
-      tool: "bash", callID: "c1",
+      tool: "bash",
+      callID: "c1",
       state: { status: "completed", input: {}, output: "ok", time: { start: 1, end: 2 } },
     })
-    await new Promise((r) => setTimeout(r, 50))
+    await new Promise((r) => setTimeout(r, 200))
     const snap1 = JSON.parse(await fs.readFile(path1, "utf-8")) as TraceFile
     expect(snap1.summary.status).toBe("running")
 
     // Finish generation — should go back to "completed"
     tracer.logStepFinish(ZERO_STEP)
-    await new Promise((r) => setTimeout(r, 50))
+    await new Promise((r) => setTimeout(r, 200))
     const snap2 = JSON.parse(await fs.readFile(path1, "utf-8")) as TraceFile
     expect(snap2.summary.status).toBe("completed")
 
     // Start another generation
     tracer.logStepStart({ id: "2" })
     tracer.logToolCall({
-      tool: "read", callID: "c2",
+      tool: "read",
+      callID: "c2",
       state: { status: "completed", input: {}, output: "ok", time: { start: 3, end: 4 } },
     })
-    await new Promise((r) => setTimeout(r, 50))
+    await new Promise((r) => setTimeout(r, 200))
     const snap3 = JSON.parse(await fs.readFile(path1, "utf-8")) as TraceFile
     expect(snap3.summary.status).toBe("running")
 
@@ -460,7 +464,7 @@ describe("Exporter ordering", () => {
     const server = Bun.serve({
       port: 0,
       async fetch() {
-        await new Promise((r) => setTimeout(r, 100))
+        await new Promise((r) => setTimeout(r, 300))
         return Response.json({ url: "http://slow.com/trace/1" })
       },
     })
@@ -491,17 +495,20 @@ describe("Snapshot debounce under load", () => {
     for (let i = 0; i < 10; i++) {
       tracer.logStepStart({ id: `${i}` })
       tracer.logToolCall({
-        tool: `tool-${i}`, callID: `c-${i}`,
+        tool: `tool-${i}`,
+        callID: `c-${i}`,
         state: { status: "completed", input: {}, output: `out-${i}`, time: { start: 1, end: 2 } },
       })
       tracer.logStepFinish({
-        id: `${i}`, reason: "stop", cost: 0.001,
+        id: `${i}`,
+        reason: "stop",
+        cost: 0.001,
         tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
       })
     }
 
     // Wait for all snapshots to settle
-    await new Promise((r) => setTimeout(r, 100))
+    await new Promise((r) => setTimeout(r, 300))
 
     const filePath = await tracer.endTrace()
     const traceFile: TraceFile = JSON.parse(await fs.readFile(filePath!, "utf-8"))