fix(table): paused workflow cells route through executeResumeJob; render Pending + viewable

Three connected issues with workflows that pause mid-cell (e.g. wait blocks):

1. `/api/resume/poll` (the time-pause auto-resumer) called
   `PauseResumeManager.startResumeExecution` directly, bypassing
   `executeResumeJob` from `background/resume-execution.ts`. The wrapper is
   where the cell-context restoration + cascade-loop continuation lives —
   without it, the resumed workflow ran to completion but never wrote the
   terminal state back to the table cell. Cell stays `pending` forever
   even though the underlying execution finished.

   Fix: dynamically import `executeResumeJob` and use it for the
   `'starting'` branch. Same primitive the trigger.dev `resumeExecutionTask`
   wraps — calling it directly handles both trigger.dev-disabled local dev
   and trigger.dev-enabled prod identically.

2. The cell renderer mapped `status: 'pending'` to `kind: 'queued'` (gray
   "Queued" badge) regardless of whether the run had started. A HITL-paused
   run has `status: 'pending'` + `jobId` prefixed `paused-` + a real
   `executionId` — semantically very different from "queued, hasn't run."
   Now renders as `pending-upstream` (the existing Pending pill) for
   paused-jobId rows.

3. Right-click "View execution" was disabled for `pending` cells (gated to
   `completed | error | running`), so users couldn't open the trace for a
   paused execution. Paused runs have a viewable trace (the executionId is
   real and the log row exists). Both the per-row context menu and the
   action-bar derivation now recognize `pending` + `paused-` jobId as a
   started run.

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

Author: TheodoreSpeaks

apps/sim/app/api/resume/poll/route.ts

@@ -139,13 +139,21 @@ async function dispatchRow(row: DueRow, now: Date): Promise<RowResult> {
       })
 
       if (enqueueResult.status === 'starting') {
-        PauseResumeManager.startResumeExecution({
+        // Route through `executeResumeJob` (not `PauseResumeManager.startResumeExecution`
+        // directly) so cell-context restoration + cascade-loop continuation
+        // fires. This is the same primitive the trigger.dev `resumeExecutionTask`
+        // wraps — calling it directly handles both trigger.dev-disabled local
+        // dev and trigger.dev-enabled prod identically.
+        const { executeResumeJob } = await import('@/background/resume-execution')
+        void executeResumeJob({
           resumeEntryId: enqueueResult.resumeEntryId,
           resumeExecutionId: enqueueResult.resumeExecutionId,
-          pausedExecution: enqueueResult.pausedExecution,
+          pausedExecutionId: enqueueResult.pausedExecution.id,
           contextId: enqueueResult.contextId,
           resumeInput: enqueueResult.resumeInput,
           userId: enqueueResult.userId,
+          workflowId: row.workflowId,
+          parentExecutionId: row.executionId,
         }).catch((error) => {
           logger.error('Background time-pause resume failed', {
             executionId: row.executionId,

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx

@@ -60,6 +60,12 @@ export function resolveCellRender({
     if (!isNull) return { kind: 'value', text: stringifyValue(value) }
 
     if (inFlight && !(groupHasBlockErrors && !blockRunning)) {
+      // A `pending` cell whose jobId starts with `paused-` is mid-pause
+      // (workflow yielded for human-in-the-loop). Render as Pending rather
+      // than Queued so the user can tell it's not just waiting to start.
+      const isPaused =
+        exec?.status === 'pending' && typeof exec.jobId === 'string' && exec.jobId.startsWith('paused-')
+      if (isPaused) return { kind: 'pending-upstream' }
       if (exec?.status === 'queued' || exec?.status === 'pending') return { kind: 'queued' }
       return { kind: 'pending-upstream' }
     }

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx

@@ -659,12 +659,20 @@ export function TableGrid({
     if (_col && _gid) {
       const _exec = contextMenu.row.executions?.[_gid]
       contextMenuIsWorkflowColumn = true
-      // Only `completed` / `error` / `running` cells are guaranteed to have a
-      // server-side execution log. `queued` / `pending` haven't started yet;
-      // `cancelled` may have been cancelled before the worker ever picked the
-      // job up, so its executionId can't be relied on either.
+      // Cells with a server-side execution log: `completed` / `error` /
+      // `running`, plus HITL-paused runs (status `pending` with a `paused-`
+      // jobId — has a real executionId + viewable trace). `queued` / plain
+      // `pending` haven't started yet; `cancelled` may have been cancelled
+      // before the worker ever picked the job up.
+      const _isPaused =
+        _exec?.status === 'pending' &&
+        typeof _exec?.jobId === 'string' &&
+        _exec.jobId.startsWith('paused-')
       contextMenuHasStartedRun =
-        _exec?.status === 'completed' || _exec?.status === 'error' || _exec?.status === 'running'
+        _exec?.status === 'completed' ||
+        _exec?.status === 'error' ||
+        _exec?.status === 'running' ||
+        _isPaused
       contextMenuExecutionId = _exec?.executionId ?? null
     }
   }
@@ -2781,11 +2789,19 @@ export function TableGrid({
     }
     const exec = row.executions?.[groupId]
     const status = exec?.status
+    // A `pending` execution with a `paused-` jobId is a HITL-paused run —
+    // it has a real executionId and a viewable trace, same as
+    // running/completed/error.
+    const isPaused =
+      status === 'pending' &&
+      typeof exec?.jobId === 'string' &&
+      exec.jobId.startsWith('paused-')
     return {
       rowId: row.id,
       groupId,
       executionId: exec?.executionId ?? null,
-      canViewExecution: status === 'completed' || status === 'error' || status === 'running',
+      canViewExecution:
+        status === 'completed' || status === 'error' || status === 'running' || isPaused,
     }
   }, [normalizedSelection, rows, displayColumns])