refactor(tables): drop in-process retry, keep cause diagnostics only

In-process retry is the wrong layer for this path: the cell task is
maxAttempts:1 by design, retrying on a possibly-degraded worker may not help,
and it masks the very transient-failure signal we're trying to capture before
we understand the root cause. Removed retryTransient entirely (file + all
wrapping in cell-write, the cascade reads, and the lock acquire) and kept only
the diagnostic logging.

- Deleted lib/table/retry-transient.ts (+ test); cell-write and the cascade
  reads call getTableById/getRowById/updateRow directly again, fail-fast.
- Kept describeError + `cause`/`retryable` fields across the cell + finalization
  catch blocks; the cell-path `retryable` flag now sources from
  isRetryableInfrastructureError (the canonical classifier) for consistency.

Diagnostics-first: surface the real driver cause on the next recurrence, then
decide the actual fix (e.g. task-level maxAttempts, or addressing the worker-
side cause) from evidence rather than a speculative in-process retry.

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

Author: TheodoreSpeaks

apps/sim/background/workflow-column-execution.ts

@@ -7,14 +7,16 @@ import { generateId } from '@sim/utils/id'
 import { backoffWithJitter } from '@sim/utils/retry'
 import { task } from '@trigger.dev/sdk'
 import { eq } from 'drizzle-orm'
-import { describeError } from '@/lib/core/errors/retryable-infrastructure'
+import {
+  describeError,
+  isRetryableInfrastructureError,
+} from '@/lib/core/errors/retryable-infrastructure'
 import { createTimeoutAbortController } from '@/lib/core/execution-limits'
 import { RateLimiter } from '@/lib/core/rate-limiter/rate-limiter'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
 import { withCascadeLock } from '@/lib/table/cascade-lock'
 import { isExecCancelled } from '@/lib/table/deps'
 import { appendTableEvent } from '@/lib/table/events'
-import { isRetryableCellError, retryTransient } from '@/lib/table/retry-transient'
 import type {
   RowData,
   RowExecutionMetadata,
@@ -69,15 +71,9 @@ export async function executeWorkflowGroupCellJob(
     // marked, so stop re-driving this row.
     if (outcome.result === 'blocked') break
     if (signal?.aborted) break
-    const freshTable = await retryTransient('cascade getTableById', () => getTableById(tableId), {
-      signal,
-    })
+    const freshTable = await getTableById(tableId)
     if (!freshTable) break
-    const freshRow = await retryTransient(
-      'cascade getRowById',
-      () => getRowById(tableId, rowId, workspaceId),
-      { signal }
-    )
+    const freshRow = await getRowById(tableId, rowId, workspaceId)
     if (!freshRow) break
     const next = pickNextEligibleGroupForRow(freshTable, freshRow)
     if (!next) break
@@ -121,9 +117,7 @@ export async function runRowCascadeLoop(
   while (true) {
     if (signal?.aborted) break
 
-    const freshTable = await retryTransient('cascade getTableById', () => getTableById(tableId), {
-      signal,
-    })
+    const freshTable = await getTableById(tableId)
     if (!freshTable) {
       logger.warn(`Table ${tableId} vanished mid-cascade`)
       break
@@ -152,11 +146,7 @@ export async function runRowCascadeLoop(
     // would re-pick the still-pending queued marker and spin.
     if (result === 'blocked') return 'blocked'
 
-    const freshRow = await retryTransient(
-      'cascade getRowById',
-      () => getRowById(tableId, rowId, workspaceId),
-      { signal }
-    )
+    const freshRow = await getRowById(tableId, rowId, workspaceId)
     if (!freshRow) break
     const next = pickNextEligibleGroupForRow(freshTable, freshRow, currentGroupId)
     if (!next) break
@@ -612,7 +602,7 @@ async function runWorkflowAndWriteTerminal(
           .catch((err) => {
             logger.warn(
               `Per-block partial write failed (table=${tableId} row=${rowId} group=${groupId})`,
-              { cause: describeError(err), retryable: isRetryableCellError(err) }
+              { cause: describeError(err), retryable: isRetryableInfrastructureError(err) }
             )
           })
       }
@@ -738,7 +728,7 @@ async function runWorkflowAndWriteTerminal(
           error: message,
           executionId,
           cause: describeError(err),
-          retryable: isRetryableCellError(err),
+          retryable: isRetryableInfrastructureError(err),
         }
       )
       terminalWritten = true
@@ -757,7 +747,7 @@ async function runWorkflowAndWriteTerminal(
         logger.error('Also failed to write error state', {
           error: toError(writeErr).message,
           cause: describeError(writeErr),
-          retryable: isRetryableCellError(writeErr),
+          retryable: isRetryableInfrastructureError(writeErr),
         })
       }
       return 'error'

apps/sim/lib/table/cascade-lock.ts

@@ -40,11 +40,6 @@ export async function withCascadeLock<T>(
   fn: () => Promise<T>
 ): Promise<{ status: 'acquired'; result: T } | { status: 'contended' }> {
   const key = cascadeLockKey(tableId, rowId)
-  // NOT wrapped in retryTransient: acquireLock is a non-idempotent `SET NX`, so
-  // a retry after a timed-out-but-applied first SET would see the key already
-  // present and return false — a false `contended` that skips the cascade. A
-  // transient Redis blip here just fails the run before pickup (no stranded
-  // cell); the dispatcher/re-drive recovers it.
   const acquired = await acquireLock(key, ownerId, LOCK_TTL_SECONDS)
   if (!acquired) return { status: 'contended' }
 

apps/sim/lib/table/cell-write.ts

@@ -12,7 +12,6 @@
 import { createLogger } from '@sim/logger'
 import { isExecCancelled } from '@/lib/table/deps'
 import { appendTableEvent } from '@/lib/table/events'
-import { retryTransient } from '@/lib/table/retry-transient'
 import type { RowData, RowExecutionMetadata, RowExecutions, WorkflowGroup } from '@/lib/table/types'
 
 const logger = createLogger('WorkflowCellWrite')
@@ -47,14 +46,12 @@ export async function writeWorkflowGroupState(
   const requestId = ctx.requestId ?? `wfgrp-${executionId}`
   const { getTableById, getRowById, updateRow } = await import('@/lib/table/service')
 
-  const table = await retryTransient('cell-write getTableById', () => getTableById(tableId))
+  const table = await getTableById(tableId)
   if (!table) {
     logger.warn(`Table ${tableId} vanished before group state write`)
     return 'wrote'
   }
-  const row = await retryTransient('cell-write getRowById', () =>
-    getRowById(tableId, rowId, workspaceId)
-  )
+  const row = await getRowById(tableId, rowId, workspaceId)
   if (!row) {
     logger.warn(`Row ${rowId} vanished before group state write`)
     return 'wrote'
@@ -102,22 +99,17 @@ export async function writeWorkflowGroupState(
   // task writes (running/completed/error) get the SQL guard so an in-flight
   // partial can't clobber a stop click or a newer run that already committed.
   const cancellationGuard = bypassStaleWorker ? undefined : { groupId, executionId }
-  // The executionId/cancellation guard makes this write idempotent — a retry
-  // after a dropped connection re-applies the same terminal state, so retrying
-  // is safe and is what stops a transient blip from stranding the cell.
-  const result = await retryTransient('cell-write updateRow', () =>
-    updateRow(
-      {
-        tableId,
-        rowId,
-        data: payload.dataPatch ?? {},
-        workspaceId,
-        executionsPatch: { [groupId]: payload.executionState },
-        cancellationGuard,
-      },
-      table,
-      requestId
-    )
+  const result = await updateRow(
+    {
+      tableId,
+      rowId,
+      data: payload.dataPatch ?? {},
+      workspaceId,
+      executionsPatch: { [groupId]: payload.executionState },
+      cancellationGuard,
+    },
+    table,
+    requestId
   )
   if (result === null) {
     logger.info(