Speed up stale transport busy recovery

Author: IM.codes

src/agent/transport-session-runtime.ts

@@ -124,6 +124,11 @@ const MIN_TRANSPORT_STALE_PENDING_RECOVERY_MS = 10_000;
 const RECOVERABLE_DISPATCH_RETRY_BASE_MS = 1_000;
 const RECOVERABLE_DISPATCH_RETRY_MAX_MS = 8_000;
 const MAX_RECOVERABLE_DISPATCH_RETRIES = 15;
+// "Provider/session is already busy" while this runtime has no active accepted
+// provider turn is almost always a stale SDK-side busy marker. Do not burn the
+// full generic retry budget (≈2 minutes): preserve the turn and let
+// session-manager relaunch the provider after a few confirmations.
+const MAX_RECOVERABLE_BUSY_DISPATCH_RETRIES = 3;
 const MAX_TRANSPORT_STALE_PENDING_RECOVERY_MS = 30 * 60_000;
 const MIN_TRANSPORT_STALE_PENDING_CANCEL_FALLBACK_MS = 50;
 const MAX_TRANSPORT_STALE_PENDING_CANCEL_FALLBACK_MS = 60_000;
@@ -1526,8 +1531,10 @@ export class TransportSessionRuntime implements SessionRuntime {
           // drop the message. Re-queue and auto-retry with backoff so the work
           // completes when the provider frees up; only give up (error) once the
           // bounded retry budget is exhausted (a genuinely wedged provider).
-          if (providerError.code !== PROVIDER_ERROR_CODES.CANCELLED
-            && this.requeueAndScheduleRecoverableRetry(providerError)) {
+          const isRecoverableBusy = isRecoverableProviderBusyError(providerError);
+          const canRetryRecoverable = providerError.code !== PROVIDER_ERROR_CODES.CANCELLED
+            && (!isRecoverableBusy || this._recoverableDispatchRetries < MAX_RECOVERABLE_BUSY_DISPATCH_RETRIES);
+          if (canRetryRecoverable && this.requeueAndScheduleRecoverableRetry(providerError)) {
             return;
           }
           this._recoverableDispatchRetries = 0;

test/daemon/transport-session-runtime.test.ts

@@ -883,6 +883,32 @@ describe('TransportSessionRuntime', () => {
     });
   });
 
+  it('uses a short retry budget for stale provider busy instead of the generic recoverable budget', async () => {
+    const send = mock.provider.send as ReturnType<typeof vi.fn>;
+    send.mockRejectedValue({
+      code: PROVIDER_ERROR_CODES.PROVIDER_ERROR,
+      message: 'Codex SDK session is already busy',
+      recoverable: true,
+    });
+
+    expect(runtime.send('stale busy should relaunch quickly', 'msg-short-busy')).toBe('sent');
+    for (let expectedCalls = 1; expectedCalls <= 4; expectedCalls++) {
+      if (expectedCalls > 1) {
+        (runtime as unknown as { _lastProviderOutputAt: number })._lastProviderOutputAt = Date.now() - 10_000;
+        await waitForProviderSendCount(mock.provider, expectedCalls);
+      } else {
+        await flushDispatch();
+      }
+    }
+    await flushDispatch();
+
+    expect(send).toHaveBeenCalledTimes(4);
+    expect(runtime.getStatus()).toBe('error');
+    expect(runtime.pendingEntries).toEqual([
+      { clientMessageId: 'msg-short-busy', text: 'stale busy should relaunch quickly' },
+    ]);
+  });
+
   it('STOP during an auto-retry interrupts only the retried turn and keeps later-queued messages', async () => {
     // Regression (audit Medium): STOP must NOT clear the whole queue during an
     // auto-retry. Only the turn being retried is dropped; messages the user