fix(table): don't let parallel queued stamp overwrite a worker that already started

Stamps fire in chunks of 20 via Promise.all, so queued writes race with the
worker's markWorkflowGroupPickedUp (running). When the late queued stamp
landed second it overwrote running, and the cell looked stuck in queued for
the rest of the run. Skip the stamp when the same execution is already past
queued — the worker's authority wins.

Author: TheodoreSpeaks

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

@@ -56,15 +56,15 @@ export async function writeWorkflowGroupState(
   }
   const current = row.executions?.[groupId] as RowExecutionMetadata | undefined
   // Stale-worker guard: only blocks writes FROM an old worker (status =
-  // running / completed / error / pending). A `queued` stamp is the scheduler
-  // claiming the cell for a brand-new run — the new executionId is supposed
-  // to overwrite whatever was there. Same for `cancelled` (authoritative).
-  // Without this carve-out, the new run's stamp gets rejected and the cell
-  // is stuck in its old state forever.
-  const isAuthoritativeNewStamp =
-    payload.executionState.status === 'queued' || payload.executionState.status === 'cancelled'
+  // running / completed / error / pending). A `queued` stamp from the
+  // scheduler can claim the cell for a brand-new run — that's the new
+  // authority. Same for `cancelled` (always authoritative, written by stop).
+  const isCancelStamp = payload.executionState.status === 'cancelled'
+  const isQueuedStamp = payload.executionState.status === 'queued'
+  const isNewQueuedStamp = isQueuedStamp && current?.executionId !== executionId
+  const bypassStaleWorker = isNewQueuedStamp || isCancelStamp
   if (
-    !isAuthoritativeNewStamp &&
+    !bypassStaleWorker &&
     current &&
     current.executionId &&
     current.executionId !== executionId
@@ -74,6 +74,16 @@ export async function writeWorkflowGroupState(
     )
     return 'skipped'
   }
+  // A late `queued` stamp for the SAME run that's already moved past queued
+  // (worker called markWorkflowGroupPickedUp before our parallel stamp landed)
+  // must NOT overwrite the further-along state. Without this, a cell can show
+  // "queued" forever while the worker is actually running.
+  if (isQueuedStamp && current?.executionId === executionId && current.status !== 'pending') {
+    logger.info(
+      `Skipping queued stamp — same run already at status=${current.status} (table=${tableId} row=${rowId} group=${groupId} executionId=${executionId})`
+    )
+    return 'skipped'
+  }
   if (
     current?.status === 'cancelled' &&
     current.executionId === executionId &&
@@ -89,7 +99,7 @@ export async function writeWorkflowGroupState(
   // stamps from the scheduler also bypass — they ARE the new authority. Cell-
   // 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 = isAuthoritativeNewStamp ? undefined : { groupId, executionId }
+  const cancellationGuard = bypassStaleWorker ? undefined : { groupId, executionId }
   const result = await updateRow(
     {
       tableId,