fix(opencode): reconnect budget for the shared event stream (replacement for #1)

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
   # open: if the diff cannot be resolved, everything runs.
   changes:
     name: Changes
-    runs-on: blacksmith-2vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 5
     outputs:
       typecheck: ${{ steps.detect.outputs.typecheck }}
@@ -63,7 +63,7 @@ jobs:
       contents: read
       id-token: write
     name: Lint
-    runs-on: blacksmith-8vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
       - name: Checkout
@@ -119,7 +119,7 @@ jobs:
     name: Build and Typecheck
     needs: changes
     if: ${{ !cancelled() && (needs.changes.outputs.build != 'false' || needs.changes.outputs.typecheck != 'false') }}
-    runs-on: blacksmith-8vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
       - name: Checkout
@@ -213,7 +213,7 @@ jobs:
     name: Test
     needs: changes
     if: ${{ !cancelled() && needs.changes.outputs.test != 'false' }}
-    runs-on: blacksmith-8vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
       - name: Checkout
@@ -289,7 +289,7 @@ jobs:
     name: Test Web
     needs: changes
     if: ${{ !cancelled() && needs.changes.outputs.test_web != 'false' }}
-    runs-on: blacksmith-8vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
       - name: Checkout
@@ -353,7 +353,7 @@ jobs:
       contents: read
       id-token: write
     name: Test Server ${{ matrix.shard }}
-    runs-on: blacksmith-4vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     # Shards take 2-5 minutes. When the shared task cache throttles reads, each
     # failed fetch stalls vp for 15-90s, which pushed shards past 10 minutes.
     timeout-minutes: 20
@@ -469,7 +469,7 @@ jobs:
     name: Rust
     needs: changes
     if: ${{ !cancelled() && needs.changes.outputs.rust != 'false' }}
-    runs-on: blacksmith-4vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
       - name: Checkout
@@ -502,7 +502,7 @@ jobs:
     name: Mobile Native Static Analysis
     needs: changes
     if: ${{ !cancelled() && needs.changes.outputs.mobile_native != 'false' }}
-    runs-on: blacksmith-6vcpu-macos-26
+    runs-on: macos-26
     timeout-minutes: 10
     steps:
       - name: Checkout
@@ -535,7 +535,7 @@ jobs:
     name: Release Smoke
     needs: changes
     if: ${{ !cancelled() && needs.changes.outputs.release_smoke != 'false' }}
-    runs-on: blacksmith-8vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
       - name: Checkout
@@ -575,7 +575,7 @@ jobs:
         mobile_native_static_analysis,
         release_smoke,
       ]
-    runs-on: blacksmith-2vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     timeout-minutes: 5
     steps:
       - name: Require every job to pass

.github/workflows/mobile-fingerprint-check.yml

@@ -25,7 +25,7 @@ concurrency:
 jobs:
   fingerprint:
     name: Native fingerprint diff
-    runs-on: blacksmith-8vcpu-ubuntu-2404
+    runs-on: ubuntu-24.04
     permissions:
       contents: read
     env:

apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts

@@ -2265,6 +2265,47 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
     }).pipe(Effect.scoped),
   );
 
+  // A stalled server answers nothing; each attempt's reconcile hangs until
+  // its timeout. Four stalls fit inside the new budget (the old policy spent
+  // its five attempts at a 15-second cap in about 83 seconds).
+  const stalledAttempt = [
+    out("event.subscribe"),
+    out("session.active"),
+    reply("session.active", "<hang>"),
+  ] as const;
+
+  it.effect("fails a turn as retryable only once the reconnect budget is spent", () =>
+    Effect.gen(function* () {
+      const { runtime, thread } = yield* resumed([
+        out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "<any>" }),
+        promptAccepted,
+        { type: "runtime_exit", status: "success" } as const,
+        ...stalledAttempt,
+        ...stalledAttempt,
+        ...stalledAttempt,
+        ...stalledAttempt,
+      ]);
+      const seen = yield* Deferred.make<boolean>();
+      const terminal = yield* terminalOf(runtime).pipe(
+        Effect.tap(() => Deferred.succeed(seen, true)),
+        Effect.forkScoped,
+      );
+      yield* runtime.startTurn(turnInput(thread));
+      // Past the old budget (~83 seconds) the turn is still held, not failed.
+      yield* TestClock.adjust("2 minutes");
+      assert.isTrue(Option.isNone(yield* Deferred.poll(seen)));
+      yield* TestClock.adjust("4 minutes");
+      const ended = yield* Fiber.join(terminal);
+      assert.equal(ended?.status, "failed");
+      assert.deepEqual(ended?.failure, {
+        class: "transport_error",
+        code: null,
+        message: "The OpenCode event stream was lost and could not reconnect.",
+        retryable: true,
+      });
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("shows a permission asked while the stream was down, and answers it", () =>
     Effect.gen(function* () {
       const { runtime, thread } = yield* resumed(

apps/server/src/usage/UsageService.test.ts

@@ -2538,9 +2538,13 @@ describe("UsageService", () => {
     }).pipe(Effect.scoped),
   );
 
-  it.live("reports saved usage of a removed directory only for windows it reaches", () =>
+  it.effect("reports saved usage of a removed directory only for windows it reaches", () =>
     Effect.gen(function* () {
       const { transcript, settings, home } = yield* setup;
+      // The fixture transcript is pinned to 2026-08-01; pin the service clock to
+      // the same era so the scan-cache retention window (92 days from "now")
+      // cannot age the fixture out as wall-clock time passes.
+      yield* TestClock.setTime(Date.parse("2026-08-05T00:00:00Z"));
       yield* Effect.promise(async () => {
         await NodeFSP.writeFile(transcript, claudeLine(1, 5));
         const lastWrite = Date.parse("2026-08-01T10:00:00Z") / 1000;

packages/provider-opencode/src/server/v2/adapter.ts

@@ -40,6 +40,7 @@ import {
 import type * as Cause from "effect/Cause";
 import * as DateTime from "effect/DateTime";
 import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Hex from "effect/encoding/Hex";
@@ -520,9 +521,13 @@ const isWakeTurn = (turn: OrchestrationV2ProviderTurn) =>
 
 const INTERRUPT_TIMEOUT = "10 seconds";
 const INSTRUCTIONS_KEY = "t3-code";
-const RECONNECT_ATTEMPTS = 5;
-const RECONNECT_DELAY = "2 seconds";
-const RECONCILE_TIMEOUT = "15 seconds";
+// A lost event stream holds the session's runs while reconnect retries with
+// exponential backoff inside one RECONNECT_BUDGET, sized to outlast the
+// multi-minute stalls a busy OpenCode server showed; only when it is spent
+// does the session fail, marked retryable (see failAll).
+const RECONNECT_BUDGET = "5 minutes";
+const RECONNECT_DELAY = "5 seconds";
+const RECONCILE_TIMEOUT = "60 seconds";
 const RECONNECT_WAIT = "30 seconds";
 const LOST_BACKGROUND =
   "T3 Code lost its connection to OpenCode while this subagent ran, so its result is not shown.";
@@ -2442,7 +2447,10 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
       streamFailure = message;
       yield* Deferred.succeed(reconnected, undefined);
       for (const state of threads.values()) {
-        const failure = makeProviderFailure({ message, class: "transport_error" });
+        // The stream loss is T3-side and transient, never the turn's fault:
+        // mark the failure retryable so callers re-drive instead of treating
+        // the work as rejected.
+        const failure = makeProviderFailure({ message, class: "transport_error", retryable: true });
         yield* finishTurn(state, { status: "failed", failure }, "broken");
       }
       for (const state of threads.values()) {
@@ -2614,7 +2622,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
       }
     });
 
-    const reconnect = Effect.gen(function* () {
+    const reconnectOnce = Effect.gen(function* () {
       // Release the borrow on every failure, including reconnect interruption, so spawned servers can idle-stop.
       const scope = yield* Scope.make();
       const { next, stream } = yield* Effect.gen(function* () {
@@ -2630,9 +2638,41 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
       for (const state of threads.values()) state.mcp = undefined;
       yield* lock.withPermit(reconcile).pipe(Effect.timeout(RECONCILE_TIMEOUT));
       return stream;
-    }).pipe(
-      Effect.retry({ times: RECONNECT_ATTEMPTS - 1, schedule: Schedule.spaced(RECONNECT_DELAY) }),
-    );
+    });
+
+    // Runs stay open across the whole sequence (see RECONNECT_BUDGET); every
+    // attempt's outcome is logged, because a stall that outlasts the budget
+    // otherwise surfaces only as the final timeout.
+    const reconnect = Effect.gen(function* () {
+      let attempt = 0;
+      const counted = Effect.suspend(() => {
+        attempt += 1;
+        const current = attempt;
+        return Effect.logInfo("Reconnecting to the OpenCode event stream.", {
+          attempt: current,
+        }).pipe(
+          Effect.andThen(reconnectOnce),
+          Effect.tapCause((cause) =>
+            Effect.logWarning("An OpenCode event stream reconnect attempt failed.", cause).pipe(
+              Effect.annotateLogs({ attempt: current, errorTag: causeErrorTag(cause) }),
+            ),
+          ),
+        );
+      });
+      return yield* counted.pipe(
+        Effect.retry({
+          schedule: Schedule.exponential(RECONNECT_DELAY).pipe(
+            Schedule.modifyDelay(({ duration }) =>
+              Effect.succeed(Duration.min(duration, Duration.seconds(60))),
+            ),
+          ),
+        }),
+        Effect.timeout(RECONNECT_BUDGET),
+        Effect.tap(() =>
+          Effect.logInfo("Reconnected to the OpenCode event stream.", { attempts: attempt }),
+        ),
+      );
+    });
 
     let currentScope = initial.scope;
     yield* Effect.addFinalizer(() => Scope.close(currentScope, Exit.void));