@@ -5,10 +5,9 @@ import { Button, Checkbox, cn, handleKeyboardActivation } from '@sim/emcn'
 import { PlayOutline, Square } from '@sim/emcn/icons'
 import type { ActiveDispatch } from '@/lib/api/contracts/tables'
 import type { ColumnDefinition, TableRow as TableRowType, WorkflowGroup } from '@/lib/table'
-import { mapInputValues } from '@/lib/table/cell-format'
 import { getColumnId } from '@/lib/table/column-keys'
 import { getUnmetGroupDeps } from '@/lib/table/deps'
-import { getEnrichmentReadiness } from '@/enrichments/readiness'
+import { getEnrichmentRowReadiness } from '@/enrichments/readiness'
 import { getEnrichment } from '@/enrichments/registry'
 import type { SaveReason } from '../../types'
 import { CellContent } from './cells'
@@ -209,19 +208,10 @@ export const DataRow = React.memo(function DataRow({
       if (group.type === 'enrichment' && (group.autoRun !== false || hasAttemptedManualRun)) {
         const enrichment = getEnrichment(group.enrichmentId)
         if (enrichment) {
-          const ownOutputColumns = new Set(group.outputs.map((output) => output.columnName))
-          const enrichmentInputMappings = (group.inputMappings ?? []).filter(
-            (mapping) => !ownOutputColumns.has(mapping.columnName)
-          )
-          const inputColumnById = new Map<string, string>()
-          for (const mapping of enrichmentInputMappings) {
-            inputColumnById.set(mapping.inputName, mapping.columnName)
-          }
-          const inputs = mapInputValues(row.data, schemaColumns, enrichmentInputMappings)
-          const readiness = getEnrichmentReadiness(enrichment, inputs)
+          const readiness = getEnrichmentRowReadiness(enrichment, group, row.data, schemaColumns)
           if (!readiness.ready) {
             const mappedLabels = readiness.missingInputs.flatMap((input) => {
-              const columnId = inputColumnById.get(input.id)
+              const columnId = readiness.inputColumnById.get(input.id)
               return columnId ? [nameByColumnId.get(columnId) ?? columnId] : []
             })
             const waitingLabels =
@@ -411,7 +401,10 @@ export const DataRow = React.memo(function DataRow({
                   column.workflowGroupId
                     ? workflowGroups.find((g) => g.id === column.workflowGroupId)
                     : undefined,
-                  activeDispatches
+                  activeDispatches,
+                  column.workflowGroupId
+                    ? waitingByGroupId?.has(column.workflowGroupId) === true
+                    : false
                 )}
                 column={column}
                 isEditing={isEditing}
 
@@ -2,17 +2,20 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import type { ActiveDispatch } from '@/lib/api/contracts/tables'
 import {
   MAX_TABLE_SELECTION_COLUMNS,
   MAX_TABLE_SELECTION_ROWS,
 } from '@/lib/copilot/chat/selection-context'
 import { TABLE_LIMITS } from '@/lib/table/constants'
+import type { TableRow, WorkflowGroup } from '@/lib/table/types'
 import type { DisplayColumn } from './types'
 import {
   buildTableSelectionContext,
   canWriteRowsWithChip,
   chipRowCount,
   drainTargetForChip,
+  resolveCellExec,
   selectedColumnIds,
 } from './utils'
 
@@ -147,3 +150,49 @@ describe('drainTargetForChip', () => {
     expect(drainTargetForChip(0)).toBe(MAX_TABLE_SELECTION_ROWS)
   })
 })
+
+describe('resolveCellExec', () => {
+  const group: WorkflowGroup = {
+    id: 'group-1',
+    workflowId: '',
+    type: 'enrichment',
+    outputs: [{ blockId: '', path: '', outputId: 'email', columnName: 'email' }],
+  }
+  const dispatch: ActiveDispatch = {
+    id: 'dispatch-1',
+    status: 'dispatching',
+    mode: 'all',
+    isManualRun: false,
+    cursor: -1,
+    scope: { groupIds: [group.id] },
+  }
+  const row: TableRow = {
+    id: 'row-1',
+    data: {},
+    executions: {},
+    position: 0,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  }
+
+  it('does not synthesize Queued when the row has provider-readiness waiting inputs', () => {
+    expect(resolveCellExec(row, group, [dispatch], true)).toBeUndefined()
+  })
+
+  it('suppresses an optimistic pending stamp while provider inputs are unready', () => {
+    const pendingRow: TableRow = {
+      ...row,
+      executions: {
+        [group.id]: {
+          status: 'pending',
+          executionId: null,
+          jobId: null,
+          workflowId: '',
+          error: null,
+        },
+      },
+    }
+
+    expect(resolveCellExec(pendingRow, group, [dispatch], true)).toBeUndefined()
+  })
+})
@@ -13,7 +13,7 @@ import type {
 } from '@/lib/table'
 import { getColumnId } from '@/lib/table/column-keys'
 import { TABLE_LIMITS } from '@/lib/table/constants'
-import { areGroupDepsSatisfied, areOutputsFilled } from '@/lib/table/deps'
+import { areGroupDepsSatisfied, areOutputsFilled, isExecInFlight } from '@/lib/table/deps'
 import type { ChatContext } from '@/stores/panel'
 import type { DeletedRowSnapshot } from '@/stores/table/types'
 import type { DisplayColumn } from './types'
@@ -222,19 +222,22 @@ export function readExecution(
  * Resolves a cell's execution state with the "about to run" overlay applied:
  * for cells in an active dispatch's scope ahead of its cursor whose deps are
  * already satisfied, returns a synthetic `pending` exec so the renderer
- * shows `Queued`. Cells with a real DB exec always win — the overlay only
- * fills the gap between dispatch start and the dispatcher's per-row pending
- * stamp. Cells with unmet deps still render as `Waiting` (the renderer
- * computes that from `waitingOnLabels`).
+ * shows `Queued`. Provider-readiness waits suppress both the overlay and stale
+ * in-flight stamps so `Waiting` remains the visible state. Otherwise, cells
+ * with a real DB exec win and the overlay only fills the gap between dispatch
+ * start and the dispatcher's per-row pending stamp.
  */
 export function resolveCellExec(
   row: TableRowType,
   group: WorkflowGroup | undefined,
-  activeDispatches: ActiveDispatch[] | undefined
+  activeDispatches: ActiveDispatch[] | undefined,
+  hasWaitingInputs = false
 ): RowExecutionMetadata | undefined {
   if (!group) return undefined
   const real = row.executions?.[group.id]
+  if (hasWaitingInputs && real && isExecInFlight(real)) return undefined
   if (real) return real
+  if (hasWaitingInputs) return undefined
   if (!activeDispatches || activeDispatches.length === 0) return undefined
   if (areOutputsFilled(group, row)) return undefined
   if (!areGroupDepsSatisfied(group, row)) return undefined
 
@@ -443,7 +443,7 @@ async function runWorkflowAndWriteTerminal(
       // workflow path rather than erroring.
       if (group.type === 'enrichment' && group.enrichmentId) {
         const { getEnrichment } = await import('@/enrichments/registry')
-        const { getEnrichmentReadiness } = await import('@/enrichments/readiness')
+        const { getEnrichmentRowReadiness } = await import('@/enrichments/readiness')
         const { runEnrichment, skippedEnrichmentDetail } = await import('@/enrichments/run')
         const enrichment = getEnrichment(group.enrichmentId)
         // `tableRowExecutions.workflowId` is an opaque id for status; use the
@@ -512,19 +512,19 @@ async function runWorkflowAndWriteTerminal(
         })
         if (pickedUp === 'skipped') return 'error'
 
-        // Map table columns → enrichment input ids (skip this group's own outputs).
-        // `columnName` holds a column id; the mapper resolves select ids to names.
-        const ownOutputColumns = new Set(group.outputs.map((o) => o.columnName))
-        const enrichmentInputMappings = (group.inputMappings ?? []).filter(
-          (mapping) => !ownOutputColumns.has(mapping.columnName)
+        const readiness = getEnrichmentRowReadiness(
+          enrichment,
+          group,
+          row.data,
+          table.schema.columns
         )
-        const enrichInputs = mapInputValues(row.data, table.schema.columns, enrichmentInputMappings)
+        const enrichInputs = readiness.inputs
+        const enrichmentInputMappings = readiness.inputMappings
 
         // Skip (don't error) rows where no provider can build a valid request —
         // common when a table is partially filled. Clear any prior output values
         // so a stale result doesn't linger.
         const isEmpty = isEmptyCellValue
-        const readiness = getEnrichmentReadiness(enrichment, enrichInputs)
         if (!readiness.ready) {
           const clearPatch: RowData = {}
           for (const out of group.outputs) {
 
@@ -2,8 +2,9 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import type { ColumnDefinition, WorkflowGroup } from '@/lib/table/types'
 import { companyInfoEnrichment } from '@/enrichments/company-info/company-info'
-import { getEnrichmentReadiness } from '@/enrichments/readiness'
+import { getEnrichmentReadiness, getEnrichmentRowReadiness } from '@/enrichments/readiness'
 import { workEmailEnrichment } from '@/enrichments/work-email/work-email'
 
 describe('getEnrichmentReadiness', () => {
@@ -49,4 +50,33 @@ describe('getEnrichmentReadiness', () => {
     expect(readiness.ready).toBe(false)
     expect(readiness.missingInputs.map((input) => input.id)).toEqual(['domain'])
   })
+
+  it('formats select-backed row inputs before checking provider request builders', () => {
+    const columns: ColumnDefinition[] = [
+      {
+        id: 'domain',
+        name: 'Domain',
+        type: 'select',
+        options: [{ id: 'acme', name: 'acme.com' }],
+      },
+    ]
+    const group: WorkflowGroup = {
+      id: 'group-1',
+      workflowId: '',
+      type: 'enrichment',
+      enrichmentId: 'company-info',
+      inputMappings: [{ inputName: 'domain', columnName: 'domain' }],
+      outputs: [{ blockId: '', path: '', outputId: 'name', columnName: 'company-name' }],
+    }
+
+    const readiness = getEnrichmentRowReadiness(
+      companyInfoEnrichment,
+      group,
+      { domain: 'acme' },
+      columns
+    )
+
+    expect(readiness.ready).toBe(true)
+    expect(readiness.inputs).toEqual({ domain: 'acme.com' })
+  })
 })
@@ -1,10 +1,23 @@
+import { mapInputValues } from '@/lib/table/cell-format'
+import type {
+  ColumnDefinition,
+  RowData,
+  WorkflowGroup,
+  WorkflowGroupInputMapping,
+} from '@/lib/table/types'
 import type { EnrichmentConfig, EnrichmentInputField } from '@/enrichments/types'
 
 export interface EnrichmentReadiness {
   ready: boolean
   missingInputs: EnrichmentInputField[]
 }
 
+export interface EnrichmentRowReadiness extends EnrichmentReadiness {
+  inputs: Record<string, unknown>
+  inputMappings: WorkflowGroupInputMapping[]
+  inputColumnById: ReadonlyMap<string, string>
+}
+
 /**
  * Checks whether an enrichment has its required inputs and at least one
  * provider can build a valid request from the available values.
@@ -33,3 +46,32 @@ export function getEnrichmentReadiness(
     missingInputs: missingInputs.length > 0 ? missingInputs : enrichment.inputs,
   }
 }
+
+/**
+ * Maps a table row into an enrichment's input shape and evaluates whether any
+ * provider can build a request. Group outputs are excluded because an output
+ * column can also appear in legacy input mappings and must never feed itself.
+ */
+export function getEnrichmentRowReadiness(
+  enrichment: EnrichmentConfig,
+  group: WorkflowGroup,
+  data: RowData,
+  columns: ColumnDefinition[]
+): EnrichmentRowReadiness {
+  const ownOutputColumns = new Set(group.outputs.map((output) => output.columnName))
+  const inputMappings = (group.inputMappings ?? []).filter(
+    (mapping) => !ownOutputColumns.has(mapping.columnName)
+  )
+  const inputColumnById = new Map<string, string>()
+  for (const mapping of inputMappings) {
+    inputColumnById.set(mapping.inputName, mapping.columnName)
+  }
+  const inputs = mapInputValues(data, columns, inputMappings)
+
+  return {
+    ...getEnrichmentReadiness(enrichment, inputs),
+    inputs,
+    inputMappings,
+    inputColumnById,
+  }
+}