fix(redis): keep the subscriber's live command deadline at 5s

ioredis has one `commandTimeout` for the handshake commands and every live
command on the socket, so tightening it to diagnose dead handshakes faster also
cut the initial SUBSCRIBE from 5s to 2s — on the one path where a rejection
fails the whole run. A ready-but-slow server delays SUBSCRIBE too.

Restore the 5s tolerance that subscribe has always had and derive the
readiness budget from it: one dead handshake recovers in ~10.5s, so an 11.5s
budget still lets ioredis's reconnect rescue the case that failed. The local
test mock now delegates to the shared, drift-guarded mirror of the budget
arithmetic so the derived number under test is the one production derives.

Author: waleedlatif1

apps/sim/lib/execution/execution-signal.test.ts

@@ -40,19 +40,24 @@ vi.mock('ioredis', () => ({
   },
 }))
 
-vi.mock('@/lib/core/config/redis', () => ({
-  getConfiguredRedisUrl: () => {
-    if (mockRedisUrl.error) throw mockRedisUrl.error
-    return mockRedisUrl.value
-  },
-  getRedisConnectionDefaults: () => ({}),
-  // The budget arithmetic itself is covered in redis.test.ts; here only the
-  // resulting number matters, and the readiness test reads it back by name.
-  coldConnectionBudgetMs: (inputs: unknown) => {
-    budgetInputs.value = inputs
-    return 10_000
-  },
-}))
+vi.mock('@/lib/core/config/redis', async () => {
+  const { redisConfigMock } = await import('@sim/testing')
+  return {
+    getConfiguredRedisUrl: () => {
+      if (mockRedisUrl.error) throw mockRedisUrl.error
+      return mockRedisUrl.value
+    },
+    getRedisConnectionDefaults: () => ({}),
+    // Records the inputs, then answers with the shared mirror of the real
+    // arithmetic so the derived budget here is the number production derives.
+    coldConnectionBudgetMs: (
+      inputs: Parameters<typeof redisConfigMock.coldConnectionBudgetMs>[0]
+    ) => {
+      budgetInputs.value = inputs
+      return redisConfigMock.coldConnectionBudgetMs(inputs)
+    },
+  }
+})
 
 import {
   getExecutionSignalHub,
@@ -385,11 +390,11 @@ describe('ExecutionSignalHub', () => {
       retryStrategy: (attempt: number) => number
     }
 
-    // Two dead handshakes, so the budget states the reconnect delays after
-    // attempt 1 and attempt 2 as the client's own retryStrategy would return them.
+    // One dead handshake, so the budget states the reconnect delay after
+    // attempt 1 as the client's own retryStrategy would return it.
     expect(budgetInputs.value).toEqual({
       commandTimeoutMs: options.commandTimeout,
-      retryDelaysMs: [options.retryStrategy(1), options.retryStrategy(2)],
+      retryDelaysMs: [options.retryStrategy(1)],
     })
     // And the wait must outlast at least one full dead attempt, or the retry is decorative.
     expect(SUBSCRIBER_READY_TIMEOUT_MS).toBeGreaterThan(

apps/sim/lib/execution/execution-signal.ts

@@ -11,21 +11,21 @@ import {
 const logger = createLogger('ExecutionSignalHub')
 const EXECUTION_SIGNAL_PREFIX = 'execution:signal:'
 /**
- * Tight, because this client only ever issues `SUBSCRIBE`/`UNSUBSCRIBE`, and
- * only once the connection is ready — sub-millisecond commands that never sit
- * in the offline queue behind a handshake. Its main job is bounding how long a
- * dead handshake takes to be diagnosed and torn down.
+ * Bounds the live `SUBSCRIBE` as well as the handshake commands — ioredis has
+ * one deadline for both — and an initial subscribe that rejects fails the run,
+ * so this stays at the tolerance a ready-but-slow server has always been
+ * given rather than being tightened to diagnose dead handshakes faster.
  */
-const SUBSCRIBER_COMMAND_TIMEOUT_MS = 2_000
+const SUBSCRIBER_COMMAND_TIMEOUT_MS = 5_000
 const subscriberRetryDelayMs = (attempt: number): number => Math.min(attempt * 500, 5000)
 /**
- * Room for two dead handshakes and then a healthy one, so ioredis's own
+ * Room for one dead handshake and then a healthy one, so ioredis's own
  * reconnect can be what rescues a stalled connection instead of the wait
  * expiring while the first attempt is still being diagnosed.
  */
 export const SUBSCRIBER_READY_TIMEOUT_MS = coldConnectionBudgetMs({
   commandTimeoutMs: SUBSCRIBER_COMMAND_TIMEOUT_MS,
-  retryDelaysMs: [1, 2].map(subscriberRetryDelayMs),
+  retryDelaysMs: [subscriberRetryDelayMs(1)],
 })
 export const LEGACY_EXECUTION_CANCEL_CHANNEL = 'execution:cancel'