diff --git a/apps/sim/app/api/table/[tableId]/columns/route.ts b/apps/sim/app/api/table/[tableId]/columns/route.ts
index 7eecb5ee466..c749ddbbff3 100644
--- a/apps/sim/app/api/table/[tableId]/columns/route.ts
+++ b/apps/sim/app/api/table/[tableId]/columns/route.ts
@@ -15,8 +15,10 @@ import {
   deleteColumn,
   renameColumn,
   updateColumnConstraints,
+  updateColumnOptions,
   updateColumnType,
 } from '@/lib/table'
+import { columnMatchesRef } from '@/lib/table/column-keys'
 import { accessError, checkAccess, normalizeColumn, rootErrorMessage } from '@/app/api/table/utils'
 
 const logger = createLogger('TableColumnsAPI')
@@ -68,7 +70,8 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Colum
       msg.includes('already exists') ||
       msg.includes('maximum column') ||
       msg.includes('Invalid column') ||
-      msg.includes('exceeds maximum')
+      msg.includes('exceeds maximum') ||
+      msg.includes('option')
     ) {
       return NextResponse.json({ error: msg }, { status: 400 })
     }
@@ -116,9 +119,50 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
       )
     }
 
-    if (updates.type) {
+    // A payload that repeats the current type must not go through
+    // `updateColumnType` — it early-returns on an unchanged type and would drop
+    // any `options` alongside it. Only a real type change routes there; an
+    // unchanged type with options routes to the options-only update.
+    const currentColumn = table.schema.columns.find((c) =>
+      columnMatchesRef(c, validated.columnName)
+    )
+    const typeChanging = updates.type !== undefined && updates.type !== currentColumn?.type
+
+    // Every write below is its own locked transaction, so any of them paired
+    // with a constraint write that is going to fail commits and then errors.
+    // Gate on the type the column ENDS UP with, not on whether the type is
+    // changing: an options-only update on an existing select column carries the
+    // same hazard as a conversion does.
+    const resultingType = updates.type ?? currentColumn?.type
+    if (updates.unique === true && resultingType === 'select') {
+      return NextResponse.json({ error: 'Cannot set a select column as unique' }, { status: 400 })
+    }
+
+    if (typeChanging) {
       updatedTable = await updateColumnType(
-        { tableId, columnName: updates.name ?? validated.columnName, newType: updates.type },
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          newType: updates.type as NonNullable<typeof updates.type>,
+          ...(updates.options !== undefined ? { options: updates.options } : {}),
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the conversion validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
+        requestId
+      )
+    } else if (updates.options !== undefined || updates.multiple !== undefined) {
+      updatedTable = await updateColumnOptions(
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          options: updates.options ?? currentColumn?.options ?? [],
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the removal guard validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
         requestId
       )
     }
@@ -162,7 +206,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
       msg.includes('Invalid column') ||
       msg.includes('exceeds maximum') ||
       msg.includes('incompatible') ||
-      msg.includes('duplicate')
+      msg.includes('duplicate') ||
+      msg.includes('option')
     ) {
       return NextResponse.json({ error: msg }, { status: 400 })
     }
diff --git a/apps/sim/app/api/table/[tableId]/export/route.ts b/apps/sim/app/api/table/[tableId]/export/route.ts
index df217ec7d31..6d717bdcdc3 100644
--- a/apps/sim/app/api/table/[tableId]/export/route.ts
+++ b/apps/sim/app/api/table/[tableId]/export/route.ts
@@ -8,7 +8,9 @@ import { neutralizeCsvFormula } from '@/lib/core/utils/csv'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { captureServerEvent } from '@/lib/posthog/server'
-import { buildNameById, getColumnId, rowDataIdToName } from '@/lib/table/column-keys'
+import { namedRowMapper } from '@/lib/table/cell-format'
+import { getColumnId } from '@/lib/table/column-keys'
+import { formatCsvCell } from '@/lib/table/export-format'
 import { queryRows } from '@/lib/table/rows/service'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 
@@ -52,7 +54,7 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
   const columns = table.schema.columns
   // Stored row data is id-keyed; CSV headers and JSON keys are display names, so
   // translate id → name on the way out (export is a name-friendly boundary).
-  const nameById = buildNameById(table.schema)
+  const toNamedRow = namedRowMapper(columns)
   const safeName = sanitizeFilename(table.name)
   const filename = `${safeName}.${format}`
 
@@ -100,14 +102,12 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
 
           for (const row of result.rows) {
             if (format === 'csv') {
-              const values = columns.map((c) => formatCsvValue(row.data[getColumnId(c)]))
+              const values = columns.map((c) => formatCsvCell(c, row.data[getColumnId(c)]))
               controller.enqueue(encoder.encode(`${toCsvRow(values)}\n`))
             } else {
               const prefix = firstJsonRow ? '' : ','
               firstJsonRow = false
-              controller.enqueue(
-                encoder.encode(prefix + JSON.stringify(rowDataIdToName(row.data, nameById)))
-              )
+              controller.enqueue(encoder.encode(prefix + JSON.stringify(toNamedRow(row.data))))
             }
           }
 
@@ -144,18 +144,6 @@ function sanitizeFilename(name: string): string {
   return cleaned || 'table'
 }
 
-/**
- * Serializes a cell for CSV. Only string cells are formula-neutralized; numbers,
- * booleans, dates, and JSON objects can never form a trigger and pass through verbatim.
- */
-function formatCsvValue(value: unknown): string {
-  if (value === null || value === undefined) return ''
-  if (value instanceof Date) return value.toISOString()
-  if (typeof value === 'object') return JSON.stringify(value)
-  if (typeof value === 'string') return neutralizeCsvFormula(value)
-  return String(value)
-}
-
 function toCsvRow(values: string[]): string {
   return values.map(escapeCsvField).join(',')
 }
diff --git a/apps/sim/app/api/table/row-wire.ts b/apps/sim/app/api/table/row-wire.ts
index 89c4cb93af7..d8458e56ec5 100644
--- a/apps/sim/app/api/table/row-wire.ts
+++ b/apps/sim/app/api/table/row-wire.ts
@@ -1,13 +1,13 @@
 import { AuthType, type AuthTypeValue } from '@/lib/auth/hybrid'
 import type { Filter, RowData, Sort, TableSchema } from '@/lib/table'
+import { namedRowMapper } from '@/lib/table/cell-format'
 import {
   buildIdByName,
-  buildNameById,
   filterNamesToIds,
-  rowDataIdToName,
   rowDataNameToId,
   sortNamesToIds,
-} from '@/lib/table'
+} from '@/lib/table/column-keys'
+import { resolveFilterSelectValues } from '@/lib/table/select-values'
 
 export interface RowWireTranslators {
   /** Inbound row data: wire keys → storage column ids. */
@@ -36,11 +36,12 @@ export function rowWireTranslators(
     return { dataIn: identity, dataOut: identity, filterIn: identity, sortIn: identity }
   }
   const idByName = buildIdByName(schema)
-  const nameById = buildNameById(schema)
   return {
+    dataOut: namedRowMapper(schema.columns),
     dataIn: (data) => rowDataNameToId(data, idByName),
-    dataOut: (data) => rowDataIdToName(data, nameById),
-    filterIn: (filter) => filterNamesToIds(filter, idByName),
+    // Rekey field refs name → id, then resolve select operand names → ids.
+    filterIn: (filter) =>
+      resolveFilterSelectValues(filterNamesToIds(filter, idByName), schema.columns),
     sortIn: (sort) => sortNamesToIds(sort, idByName),
   }
 }
diff --git a/apps/sim/app/api/table/utils.ts b/apps/sim/app/api/table/utils.ts
index 7424258ad0e..0b2c07ba1f5 100644
--- a/apps/sim/app/api/table/utils.ts
+++ b/apps/sim/app/api/table/utils.ts
@@ -279,5 +279,7 @@ export function normalizeColumn(col: ColumnDefinition): ColumnDefinition {
     required: col.required ?? false,
     unique: col.unique ?? false,
     ...(col.workflowGroupId ? { workflowGroupId: col.workflowGroupId } : {}),
+    ...(col.options ? { options: col.options } : {}),
+    ...(col.multiple ? { multiple: true } : {}),
   }
 }
diff --git a/apps/sim/app/api/v1/tables/[tableId]/columns/route.ts b/apps/sim/app/api/v1/tables/[tableId]/columns/route.ts
index 0eeebfb99ce..55b4e0a81d8 100644
--- a/apps/sim/app/api/v1/tables/[tableId]/columns/route.ts
+++ b/apps/sim/app/api/v1/tables/[tableId]/columns/route.ts
@@ -14,8 +14,10 @@ import {
   deleteColumn,
   renameColumn,
   updateColumnConstraints,
+  updateColumnOptions,
   updateColumnType,
 } from '@/lib/table'
+import { columnMatchesRef } from '@/lib/table/column-keys'
 import { accessError, checkAccess, normalizeColumn } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -86,7 +88,15 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Colum
     if (validationResponse) return validationResponse
 
     if (error instanceof Error) {
-      if (error.message.includes('already exists') || error.message.includes('maximum column')) {
+      // Same caller-error set the internal columns route maps — an invalid
+      // select option set is a bad request, not a server fault.
+      if (
+        error.message.includes('already exists') ||
+        error.message.includes('maximum column') ||
+        error.message.includes('Invalid column') ||
+        error.message.includes('exceeds maximum') ||
+        error.message.includes('option')
+      ) {
         return NextResponse.json({ error: error.message }, { status: 400 })
       }
       if (error.message === 'Table not found') {
@@ -138,9 +148,50 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
       )
     }
 
-    if (updates.type) {
+    // A payload that repeats the current type must not go through
+    // `updateColumnType` — it early-returns on an unchanged type and would drop
+    // any `options` alongside it. Only a real type change routes there; an
+    // unchanged type with options routes to the options-only update.
+    const currentColumn = table.schema.columns.find((c) =>
+      columnMatchesRef(c, validated.columnName)
+    )
+    const typeChanging = updates.type !== undefined && updates.type !== currentColumn?.type
+
+    // Every write below is its own locked transaction, so any of them paired
+    // with a constraint write that is going to fail commits and then errors.
+    // Gate on the type the column ENDS UP with, not on whether the type is
+    // changing: an options-only update on an existing select column carries the
+    // same hazard as a conversion does.
+    const resultingType = updates.type ?? currentColumn?.type
+    if (updates.unique === true && resultingType === 'select') {
+      return NextResponse.json({ error: 'Cannot set a select column as unique' }, { status: 400 })
+    }
+
+    if (typeChanging) {
       updatedTable = await updateColumnType(
-        { tableId, columnName: updates.name ?? validated.columnName, newType: updates.type },
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          newType: updates.type as NonNullable<typeof updates.type>,
+          ...(updates.options !== undefined ? { options: updates.options } : {}),
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the conversion validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
+        requestId
+      )
+    } else if (updates.options !== undefined || updates.multiple !== undefined) {
+      updatedTable = await updateColumnOptions(
+        {
+          tableId,
+          columnName: updates.name ?? validated.columnName,
+          options: updates.options ?? currentColumn?.options ?? [],
+          ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the removal guard validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
+        },
         requestId
       )
     }
@@ -195,7 +246,8 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
         msg.includes('Invalid column') ||
         msg.includes('exceeds maximum') ||
         msg.includes('incompatible') ||
-        msg.includes('duplicate')
+        msg.includes('duplicate') ||
+        msg.includes('option')
       ) {
         return NextResponse.json({ error: msg }, { status: 400 })
       }
diff --git a/apps/sim/app/api/v1/tables/[tableId]/rows/[rowId]/route.ts b/apps/sim/app/api/v1/tables/[tableId]/rows/[rowId]/route.ts
index 419da80ad35..c7040a0239f 100644
--- a/apps/sim/app/api/v1/tables/[tableId]/rows/[rowId]/route.ts
+++ b/apps/sim/app/api/v1/tables/[tableId]/rows/[rowId]/route.ts
@@ -13,13 +13,9 @@ import { parseRequest, validationErrorResponseFromError } from '@/lib/api/server
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { RowData, TableSchema } from '@/lib/table'
-import {
-  buildIdByName,
-  buildNameById,
-  rowDataIdToName,
-  rowDataNameToId,
-  updateRow,
-} from '@/lib/table'
+import { updateRow } from '@/lib/table'
+import { namedRowMapper } from '@/lib/table/cell-format'
+import { buildIdByName, rowDataNameToId } from '@/lib/table/column-keys'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -88,13 +84,13 @@ export const GET = withRouteHandler(async (request: NextRequest, context: RowRou
       return NextResponse.json({ error: 'Row not found' }, { status: 404 })
     }
 
-    const nameById = buildNameById(result.table.schema as TableSchema)
+    const toNamedRow = namedRowMapper((result.table.schema as TableSchema).columns)
     return NextResponse.json({
       success: true,
       data: {
         row: {
           id: row.id,
-          data: rowDataIdToName(row.data as RowData, nameById),
+          data: toNamedRow(row.data as RowData),
           position: row.position,
           createdAt:
             row.createdAt instanceof Date ? row.createdAt.toISOString() : String(row.createdAt),
@@ -142,7 +138,7 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: RowR
     }
 
     const idByName = buildIdByName(table.schema as TableSchema)
-    const nameById = buildNameById(table.schema as TableSchema)
+    const toNamedRow = namedRowMapper((table.schema as TableSchema).columns)
     const updatedRow = await updateRow(
       {
         tableId,
@@ -168,7 +164,7 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: RowR
       data: {
         row: {
           id: updatedRow.id,
-          data: rowDataIdToName(updatedRow.data, nameById),
+          data: toNamedRow(updatedRow.data),
           position: updatedRow.position,
           createdAt:
             updatedRow.createdAt instanceof Date
diff --git a/apps/sim/app/api/v1/tables/[tableId]/rows/route.ts b/apps/sim/app/api/v1/tables/[tableId]/rows/route.ts
index c1ffacf2218..55bfeec39b3 100644
--- a/apps/sim/app/api/v1/tables/[tableId]/rows/route.ts
+++ b/apps/sim/app/api/v1/tables/[tableId]/rows/route.ts
@@ -17,21 +17,23 @@ import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { Filter, RowData, TableSchema } from '@/lib/table'
 import {
   batchInsertRows,
-  buildIdByName,
-  buildNameById,
   deleteRowsByFilter,
   deleteRowsByIds,
-  filterNamesToIds,
   insertRow,
-  rowDataIdToName,
-  rowDataNameToId,
-  sortNamesToIds,
   updateRowsByFilter,
   validateBatchRows,
   validateRowData,
   validateRowSize,
 } from '@/lib/table'
+import { namedRowMapper } from '@/lib/table/cell-format'
+import {
+  buildIdByName,
+  filterNamesToIds,
+  rowDataNameToId,
+  sortNamesToIds,
+} from '@/lib/table/column-keys'
 import { queryRows } from '@/lib/table/rows/service'
+import { resolveFilterSelectValues } from '@/lib/table/select-values'
 import { TableQueryValidationError } from '@/lib/table/sql'
 import { accessError, checkAccess, rowWriteErrorResponse } from '@/app/api/table/utils'
 import {
@@ -68,7 +70,7 @@ async function handleBatchInsert(
 
   // External callers key row data by column name; storage keys by id.
   const idByName = buildIdByName(table.schema as TableSchema)
-  const nameById = buildNameById(table.schema as TableSchema)
+  const toNamedRow = namedRowMapper((table.schema as TableSchema).columns)
   const rows = (validated.rows as RowData[]).map((r) => rowDataNameToId(r, idByName))
 
   const validation = await validateBatchRows({
@@ -95,7 +97,7 @@ async function handleBatchInsert(
       data: {
         rows: insertedRows.map((r) => ({
           id: r.id,
-          data: rowDataIdToName(r.data, nameById),
+          data: toNamedRow(r.data),
           position: r.position,
           createdAt: r.createdAt instanceof Date ? r.createdAt.toISOString() : r.createdAt,
           updatedAt: r.updatedAt instanceof Date ? r.updatedAt.toISOString() : r.updatedAt,
@@ -154,9 +156,12 @@ export const GET = withRouteHandler(async (request: NextRequest, context: TableR
 
     // Translate name-keyed filter/sort fields → column ids; translate rows back.
     const idByName = buildIdByName(table.schema as TableSchema)
-    const nameById = buildNameById(table.schema as TableSchema)
+    const toNamedRow = namedRowMapper((table.schema as TableSchema).columns)
     const filter = validated.filter
-      ? filterNamesToIds(validated.filter as Filter, idByName)
+      ? resolveFilterSelectValues(
+          filterNamesToIds(validated.filter as Filter, idByName),
+          (table.schema as TableSchema).columns
+        )
       : undefined
     const sort = validated.sort ? sortNamesToIds(validated.sort, idByName) : undefined
 
@@ -178,7 +183,7 @@ export const GET = withRouteHandler(async (request: NextRequest, context: TableR
       data: {
         rows: result.rows.map((r) => ({
           id: r.id,
-          data: rowDataIdToName(r.data, nameById),
+          data: toNamedRow(r.data),
           position: r.position,
           createdAt: r.createdAt instanceof Date ? r.createdAt.toISOString() : String(r.createdAt),
           updatedAt: r.updatedAt instanceof Date ? r.updatedAt.toISOString() : String(r.updatedAt),
@@ -253,7 +258,7 @@ export const POST = withRouteHandler(
       }
 
       const idByName = buildIdByName(table.schema as TableSchema)
-      const nameById = buildNameById(table.schema as TableSchema)
+      const toNamedRow = namedRowMapper((table.schema as TableSchema).columns)
       const rowData = rowDataNameToId(validated.data as RowData, idByName)
 
       const validation = await validateRowData({
@@ -279,7 +284,7 @@ export const POST = withRouteHandler(
         data: {
           row: {
             id: row.id,
-            data: rowDataIdToName(row.data, nameById),
+            data: toNamedRow(row.data),
             position: row.position,
             createdAt: row.createdAt instanceof Date ? row.createdAt.toISOString() : row.createdAt,
             updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : row.updatedAt,
@@ -346,7 +351,10 @@ export const PUT = withRouteHandler(async (request: NextRequest, context: TableR
     const result = await updateRowsByFilter(
       table,
       {
-        filter: filterNamesToIds(validated.filter as Filter, idByName),
+        filter: resolveFilterSelectValues(
+          filterNamesToIds(validated.filter as Filter, idByName),
+          (table.schema as TableSchema).columns
+        ),
         data: patchData,
         limit: validated.limit,
         actorUserId,
@@ -442,7 +450,10 @@ export const DELETE = withRouteHandler(
       const result = await deleteRowsByFilter(
         table,
         {
-          filter: filterNamesToIds(validated.filter as Filter, idByName),
+          filter: resolveFilterSelectValues(
+            filterNamesToIds(validated.filter as Filter, idByName),
+            (table.schema as TableSchema).columns
+          ),
           limit: validated.limit,
         },
         requestId
diff --git a/apps/sim/app/api/v1/tables/[tableId]/rows/upsert/route.ts b/apps/sim/app/api/v1/tables/[tableId]/rows/upsert/route.ts
index caf0e0a6df2..d35e34646aa 100644
--- a/apps/sim/app/api/v1/tables/[tableId]/rows/upsert/route.ts
+++ b/apps/sim/app/api/v1/tables/[tableId]/rows/upsert/route.ts
@@ -6,13 +6,9 @@ import { parseRequest, validationErrorResponseFromError } from '@/lib/api/server
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { RowData, TableSchema } from '@/lib/table'
-import {
-  buildIdByName,
-  buildNameById,
-  rowDataIdToName,
-  rowDataNameToId,
-  upsertRow,
-} from '@/lib/table'
+import { upsertRow } from '@/lib/table'
+import { namedRowMapper } from '@/lib/table/cell-format'
+import { buildIdByName, rowDataNameToId } from '@/lib/table/column-keys'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -63,7 +59,7 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Upser
     }
 
     const idByName = buildIdByName(table.schema as TableSchema)
-    const nameById = buildNameById(table.schema as TableSchema)
+    const toNamedRow = namedRowMapper((table.schema as TableSchema).columns)
     const upsertResult = await upsertRow(
       {
         tableId,
@@ -81,7 +77,7 @@ export const POST = withRouteHandler(async (request: NextRequest, context: Upser
       data: {
         row: {
           id: upsertResult.row.id,
-          data: rowDataIdToName(upsertResult.row.data, nameById),
+          data: toNamedRow(upsertResult.row.data),
           createdAt:
             upsertResult.row.createdAt instanceof Date
               ? upsertResult.row.createdAt.toISOString()
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-config-sidebar.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-config-sidebar.tsx
index 0f21afa12cc..2c0a9cffda4 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-config-sidebar.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-config-sidebar.tsx
@@ -5,14 +5,24 @@ import { Button, ChipCombobox, ChipInput, cn, FieldDivider, Label, Switch, toast
 import { X } from '@sim/emcn/icons'
 import { toError } from '@sim/utils/errors'
 import { findValidationIssue, isValidationError } from '@/lib/api/client/errors'
-import type { ColumnDefinition } from '@/lib/table'
+import type { ColumnDefinition, SelectOption } from '@/lib/table'
 import {
   FieldError,
   RequiredLabel,
 } from '@/app/workspace/[workspaceId]/tables/[tableId]/components/sidebar-fields'
 import { useAddTableColumn, useUpdateColumn } from '@/hooks/queries/tables'
+import { SelectOptionsEditor } from '../select-field'
 import { PLAIN_COLUMN_TYPE_OPTIONS } from './column-types'
 
+/** Whether a column type carries an option set. */
+function isSelectType(type: ColumnDefinition['type']): boolean {
+  return type === 'select'
+}
+
+function optionsEqual(a: SelectOption[], b: SelectOption[]): boolean {
+  return JSON.stringify(a) === JSON.stringify(b)
+}
+
 /**
  * Discriminates the two flows the column-config sidebar handles. Workflow
  * configuration is a separate component (`<WorkflowSidebar>`) so this surface
@@ -94,11 +104,30 @@ function ColumnConfigBody({
   const [uniqueInput, setUniqueInput] = useState<boolean>(() =>
     config.mode === 'edit' ? !!existingColumn?.unique : false
   )
+  const [optionsInput, setOptionsInput] = useState<SelectOption[]>(() =>
+    config.mode === 'edit' ? (existingColumn?.options ?? []) : []
+  )
+  const [multipleInput, setMultipleInput] = useState<boolean>(() =>
+    config.mode === 'edit' ? !!existingColumn?.multiple : false
+  )
   const [showValidation, setShowValidation] = useState(false)
   const [nameError, setNameError] = useState<string | null>(null)
+  const [optionsError, setOptionsError] = useState<string | null>(null)
 
   const saveDisabled = updateColumn.isPending || addColumn.isPending
   const trimmedName = nameInput.trim()
+  const wantsOptions = isSelectType(typeInput)
+  const trimmedOptions = optionsInput.map((o) => ({ ...o, name: o.name.trim() }))
+
+  /** Client-side option validation mirroring the server rules; returns an error message or null. */
+  function validateOptions(): string | null {
+    if (!wantsOptions) return null
+    if (trimmedOptions.length === 0) return 'Add at least one option'
+    if (trimmedOptions.some((o) => !o.name)) return 'Option names cannot be empty'
+    const names = trimmedOptions.map((o) => o.name.toLowerCase())
+    if (new Set(names).size !== names.length) return 'Option names must be unique'
+    return null
+  }
 
   async function handleSave() {
     if (!trimmedName) {
@@ -106,12 +135,21 @@ function ColumnConfigBody({
       return
     }
 
+    const optionsIssue = validateOptions()
+    if (optionsIssue) {
+      setOptionsError(optionsIssue)
+      return
+    }
+
     try {
       if (config.mode === 'create') {
         await addColumn.mutateAsync({
           name: trimmedName,
           type: typeInput,
-          ...(uniqueInput ? { unique: true } : {}),
+          // Select columns don't expose a unique constraint.
+          ...(!wantsOptions && uniqueInput ? { unique: true } : {}),
+          ...(wantsOptions ? { options: trimmedOptions } : {}),
+          ...(wantsOptions && multipleInput ? { multiple: true } : {}),
         })
         toast.success(`Added "${trimmedName}"`)
         onClose()
@@ -122,12 +160,28 @@ function ColumnConfigBody({
       // name to detect an actual rename.
       const renamed = trimmedName !== (existingColumn?.name ?? config.columnName)
       const typeChanged = !!existingColumn && existingColumn.type !== typeInput
-      const uniqueChanged = !!existingColumn && !!existingColumn.unique !== uniqueInput
+      const uniqueChanged =
+        !wantsOptions && !!existingColumn && !!existingColumn.unique !== uniqueInput
+      // Select columns don't offer a Unique control, so converting a unique
+      // column to select would strand the constraint with no way to clear it.
+      const uniqueCleared = wantsOptions && !!existingColumn?.unique
+      const optionsChanged =
+        wantsOptions && !optionsEqual(existingColumn?.options ?? [], trimmedOptions)
+      const multipleChanged = wantsOptions && !!existingColumn?.multiple !== multipleInput
 
-      const updates: { name?: string; type?: ColumnDefinition['type']; unique?: boolean } = {
+      const updates: {
+        name?: string
+        type?: ColumnDefinition['type']
+        unique?: boolean
+        options?: SelectOption[]
+        multiple?: boolean
+      } = {
         ...(renamed ? { name: trimmedName } : {}),
         ...(typeChanged ? { type: typeInput } : {}),
         ...(uniqueChanged ? { unique: uniqueInput } : {}),
+        ...(uniqueCleared ? { unique: false } : {}),
+        ...(wantsOptions && (typeChanged || optionsChanged) ? { options: trimmedOptions } : {}),
+        ...(wantsOptions && (typeChanged || multipleChanged) ? { multiple: multipleInput } : {}),
       }
       if (Object.keys(updates).length === 0) {
         onClose()
@@ -207,17 +261,48 @@ function ColumnConfigBody({
           </>
         )}
 
-        <FieldDivider />
-        <div className='flex flex-col gap-[9.5px]'>
-          <div className='flex items-center justify-between pl-0.5'>
-            <Label htmlFor='column-sidebar-unique'>Unique</Label>
-            <Switch
-              id='column-sidebar-unique'
-              checked={uniqueInput}
-              onCheckedChange={(v) => setUniqueInput(!!v)}
-            />
-          </div>
-        </div>
+        {wantsOptions && (
+          <>
+            <FieldDivider />
+            <div className='flex flex-col gap-[9.5px]'>
+              <RequiredLabel>Options</RequiredLabel>
+              <SelectOptionsEditor
+                options={optionsInput}
+                onChange={(next) => {
+                  setOptionsInput(next)
+                  if (optionsError) setOptionsError(null)
+                }}
+              />
+              {optionsError && <FieldError message={optionsError} />}
+            </div>
+            <FieldDivider />
+            <div className='flex items-center justify-between pl-0.5'>
+              <Label htmlFor='column-sidebar-multiple'>Multiselect</Label>
+              <Switch
+                id='column-sidebar-multiple'
+                checked={multipleInput}
+                onCheckedChange={(v) => setMultipleInput(!!v)}
+              />
+            </div>
+          </>
+        )}
+
+        {/* Select columns don't expose a unique constraint. */}
+        {!wantsOptions && (
+          <>
+            <FieldDivider />
+            <div className='flex flex-col gap-[9.5px]'>
+              <div className='flex items-center justify-between pl-0.5'>
+                <Label htmlFor='column-sidebar-unique'>Unique</Label>
+                <Switch
+                  id='column-sidebar-unique'
+                  checked={uniqueInput}
+                  onCheckedChange={(v) => setUniqueInput(!!v)}
+                />
+              </div>
+            </div>
+          </>
+        )}
       </div>
 
       <div className='flex items-center justify-end gap-2 border-[var(--border)] border-t px-2 py-3'>
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-types.ts b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-types.ts
index 9b4a7af4790..6ca8023e80b 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-types.ts
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-types.ts
@@ -2,6 +2,7 @@ import type React from 'react'
 import {
   Calendar as CalendarIcon,
   PlayOutline,
+  TagIcon,
   TypeBoolean,
   TypeJson,
   TypeNumber,
@@ -28,6 +29,7 @@ export const COLUMN_TYPE_OPTIONS: ColumnTypeOption[] = [
   { type: 'boolean', label: 'Boolean', icon: TypeBoolean },
   { type: 'date', label: 'Date', icon: CalendarIcon },
   { type: 'json', label: 'JSON', icon: TypeJson },
+  { type: 'select', label: 'Select', icon: TagIcon },
   { type: 'workflow', label: 'Workflow', icon: PlayOutline },
 ]
 
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/row-modal/row-modal.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/row-modal/row-modal.tsx
index 28c971bda9f..efee32d04e8 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/row-modal/row-modal.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/row-modal/row-modal.tsx
@@ -27,6 +27,7 @@ import {
   localPartsToDateValue,
   todayLocalCalendarDate,
 } from '../../utils'
+import { SelectValueEditor } from '../select-field'
 
 const logger = createLogger('RowModal')
 
@@ -275,6 +276,14 @@ function ColumnField({ column, value, onChange }: ColumnFieldProps) {
     )
   }
 
+  if (column.type === 'select') {
+    return (
+      <ChipModalField type='custom' title={title} required={column.required} hint={hint}>
+        <SelectValueEditor column={column} value={value} onChange={onChange} fullWidth />
+      </ChipModalField>
+    )
+  }
+
   return (
     <ChipModalField
       type='input'
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/index.ts b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/index.ts
new file mode 100644
index 00000000000..274f18de92c
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/index.ts
@@ -0,0 +1,3 @@
+export { SelectOptionsEditor } from './select-options-editor'
+export { resolveSelectOptions, SelectPill, selectedOptionIds, toSelectedIds } from './select-pill'
+export { SelectValueEditor } from './select-value-editor'
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-options-editor.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-options-editor.tsx
new file mode 100644
index 00000000000..848a0c86921
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-options-editor.tsx
@@ -0,0 +1,104 @@
+'use client'
+
+import { useEffect, useRef, useState } from 'react'
+import { Button, ChipInput } from '@sim/emcn'
+import { X } from '@sim/emcn/icons'
+import { generateShortId } from '@sim/utils/id'
+import type { SelectOption } from '@/lib/table'
+
+interface SelectOptionsEditorProps {
+  options: SelectOption[]
+  onChange: (options: SelectOption[]) => void
+}
+
+/**
+ * Add/remove/rename the options of a `select` column. Option ids are stable
+ * across edits so existing cell data survives renames. New options are added by
+ * typing into the trailing empty row — the first keystroke materializes the
+ * option and focus jumps into it so typing flows straight through.
+ */
+export function SelectOptionsEditor({ options, onChange }: SelectOptionsEditorProps) {
+  const inputRefs = useRef<Map<string, HTMLInputElement>>(new Map())
+  const trailingRef = useRef<HTMLInputElement>(null)
+  const [pendingFocusId, setPendingFocusId] = useState<string | null>(null)
+
+  // The new row and `pendingFocusId` land in the same commit, so the ref is
+  // registered by the time this effect runs.
+  useEffect(() => {
+    if (!pendingFocusId) return
+    const el = inputRefs.current.get(pendingFocusId)
+    if (el) {
+      el.focus()
+      const end = el.value.length
+      el.setSelectionRange(end, end)
+    }
+    setPendingFocusId(null)
+  }, [pendingFocusId])
+
+  const update = (id: string, patch: Partial<SelectOption>) => {
+    onChange(options.map((o) => (o.id === id ? { ...o, ...patch } : o)))
+  }
+
+  const remove = (id: string) => {
+    inputRefs.current.delete(id)
+    onChange(options.filter((o) => o.id !== id))
+  }
+
+  /** Typing into the trailing row promotes it to a real option and keeps focus. */
+  const materialize = (name: string) => {
+    const id = generateShortId()
+    onChange([...options, { id, name }])
+    setPendingFocusId(id)
+  }
+
+  return (
+    <div className='flex flex-col gap-1'>
+      {options.map((option) => (
+        <div key={option.id} className='flex items-center gap-1.5'>
+          <ChipInput
+            ref={(el) => {
+              if (el) inputRefs.current.set(option.id, el)
+              else inputRefs.current.delete(option.id)
+            }}
+            value={option.name}
+            onChange={(e) => update(option.id, { name: e.target.value })}
+            onKeyDown={(e) => {
+              // Enter jumps to the trailing row so options can be added in a row.
+              if (e.key === 'Enter') {
+                e.preventDefault()
+                trailingRef.current?.focus()
+              }
+            }}
+            placeholder='Option name'
+            spellCheck={false}
+            autoComplete='off'
+            className='min-w-0 flex-1'
+          />
+          <Button
+            variant='ghost'
+            size='sm'
+            onClick={() => remove(option.id)}
+            className='!p-1 size-7 shrink-0'
+            aria-label={`Remove ${option.name || 'option'}`}
+          >
+            <X className='size-[12px]' />
+          </Button>
+        </div>
+      ))}
+      <div className='flex items-center gap-1.5'>
+        <ChipInput
+          ref={trailingRef}
+          value=''
+          onChange={(e) => {
+            if (e.target.value) materialize(e.target.value)
+          }}
+          placeholder='Add option'
+          spellCheck={false}
+          autoComplete='off'
+          className='min-w-0 flex-1'
+        />
+        <span className='size-7 shrink-0' aria-hidden />
+      </div>
+    </div>
+  )
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-pill.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-pill.tsx
new file mode 100644
index 00000000000..699d6d2b5f4
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-pill.tsx
@@ -0,0 +1,44 @@
+'use client'
+
+import { Badge, cn } from '@sim/emcn'
+import type { ColumnDefinition, SelectOption } from '@/lib/table'
+
+/** Reads the raw stored option ids from a cell value (single string or array). */
+export function toSelectedIds(value: unknown): string[] {
+  if (Array.isArray(value)) return value.filter((v): v is string => typeof v === 'string')
+  if (typeof value === 'string' && value !== '') return [value]
+  return []
+}
+
+/**
+ * Resolves a `select` cell's stored ids to their declared options, preserving
+ * selection order. An id with no matching option — stale after that option was
+ * deleted — is dropped, so the cell falls back to empty ("None") rather than
+ * showing an orphaned reference.
+ */
+export function resolveSelectOptions(column: ColumnDefinition, value: unknown): SelectOption[] {
+  const byId = new Map((column.options ?? []).map((o) => [o.id, o]))
+  return toSelectedIds(value)
+    .map((id) => byId.get(id))
+    .filter((o): o is SelectOption => o != null)
+}
+
+/** The still-valid option ids of a cell (orphaned/removed ids dropped). */
+export function selectedOptionIds(column: ColumnDefinition, value: unknown): string[] {
+  return resolveSelectOptions(column, value).map((o) => o.id)
+}
+
+interface SelectPillProps {
+  option: SelectOption
+  size?: 'sm' | 'md'
+  className?: string
+}
+
+/** A single option pill, rendered through the shared neutral `Badge`. */
+export function SelectPill({ option, size = 'sm', className }: SelectPillProps) {
+  return (
+    <Badge variant='gray' size={size} className={cn('max-w-full', className)}>
+      <span className='truncate'>{option.name}</span>
+    </Badge>
+  )
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-value-editor.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-value-editor.tsx
new file mode 100644
index 00000000000..cdd89e8e821
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/select-field/select-value-editor.tsx
@@ -0,0 +1,87 @@
+'use client'
+
+import { useMemo } from 'react'
+import { ChipDropdown } from '@sim/emcn'
+import type { ColumnDefinition } from '@/lib/table'
+import { SelectPill, selectedOptionIds } from './select-pill'
+
+interface SelectValueEditorProps {
+  column: ColumnDefinition
+  value: unknown
+  /** Single columns emit a string id or null; multiselect emits a string[]. */
+  onChange: (next: string | string[] | null) => void
+  fullWidth?: boolean
+  align?: 'start' | 'center' | 'end'
+}
+
+const CLEAR_VALUE = ''
+
+/**
+ * Option picker for `select`/`multiselect` cells in a form context (the row
+ * modal) — a `ChipDropdown` pill that lists each option as its colored pill and
+ * writes option ids back through `onChange`. Inline grid editing uses a bare
+ * `DropdownMenu` instead (see `InlineSelectEditor`).
+ */
+export function SelectValueEditor({
+  column,
+  value,
+  onChange,
+  fullWidth,
+  align = 'start',
+}: SelectValueEditorProps) {
+  const isMulti = !!column.multiple
+  const options = useMemo(
+    () =>
+      (column.options ?? []).map((option) => ({
+        value: option.id,
+        label: <SelectPill option={option} />,
+      })),
+    [column.options]
+  )
+
+  if (isMulti) {
+    return (
+      <ChipDropdown
+        multiple
+        value={selectedOptionIds(column, value)}
+        // A required multiselect can't be emptied — ignore the toggle that would
+        // remove the last option, since an empty selection can never be committed.
+        onChange={(ids) => {
+          if (column.required && ids.length === 0) return
+          onChange(ids)
+        }}
+        options={options}
+        showAllOption={false}
+        // In multiple mode ChipDropdown ignores `placeholder` and renders
+        // `allLabel` when nothing is selected — which would read as if every
+        // option were chosen. There is no "All" entry here, so this is the
+        // empty label.
+        allLabel='Select options'
+        align={align}
+        fullWidth={fullWidth}
+        matchTriggerWidth={false}
+      />
+    )
+  }
+
+  // Offer a "None" entry to clear the cell — except on a required column, where
+  // clearing to null can never be committed (required validation rejects it).
+  const singleOptions = column.required
+    ? options
+    : [
+        { value: CLEAR_VALUE, label: <span className='text-[var(--text-muted)]'>None</span> },
+        ...options,
+      ]
+
+  return (
+    <ChipDropdown
+      value={selectedOptionIds(column, value)[0] ?? CLEAR_VALUE}
+      onChange={(id) => onChange(id === CLEAR_VALUE ? null : id)}
+      options={singleOptions}
+      placeholder='Select an option'
+      align={align}
+      fullWidth={fullWidth}
+      matchTriggerWidth={false}
+    />
+  )
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-filter/table-filter.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-filter/table-filter.tsx
index 4073f24e098..a0af627d296 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-filter/table-filter.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-filter/table-filter.tsx
@@ -6,9 +6,25 @@ import { Plus, X } from '@sim/emcn/icons'
 import { generateShortId } from '@sim/utils/id'
 import type { ColumnDefinition, Filter, FilterRule } from '@/lib/table'
 import { getColumnId } from '@/lib/table/column-keys'
-import { COMPARISON_OPERATORS, VALUELESS_OPERATORS } from '@/lib/table/query-builder/constants'
+import {
+  COMPARISON_OPERATORS,
+  MULTI_SELECT_FILTER_OPERATORS,
+  SINGLE_SELECT_FILTER_OPERATORS,
+  VALUELESS_OPERATORS,
+} from '@/lib/table/query-builder/constants'
 import { filterRulesToFilter, filterToRules } from '@/lib/table/query-builder/converters'
 
+const SINGLE_SELECT_COMPARISON_OPERATORS = COMPARISON_OPERATORS.filter((o) =>
+  SINGLE_SELECT_FILTER_OPERATORS.has(o.value)
+)
+const MULTI_SELECT_COMPARISON_OPERATORS = COMPARISON_OPERATORS.filter((o) =>
+  MULTI_SELECT_FILTER_OPERATORS.has(o.value)
+)
+
+function selectFilterOperators(column: ColumnDefinition | undefined): Set<string> {
+  return column?.multiple ? MULTI_SELECT_FILTER_OPERATORS : SINGLE_SELECT_FILTER_OPERATORS
+}
+
 interface TableFilterProps {
   columns: ColumnDefinition[]
   filter: Filter | null
@@ -31,6 +47,11 @@ export function TableFilter({ columns, filter, onApply, onClose }: TableFilterPr
     [columns]
   )
 
+  const columnById = useMemo(
+    () => new Map(columns.map((col) => [getColumnId(col), col])),
+    [columns]
+  )
+
   const handleAdd = useCallback(() => {
     setRules((prev) => [...prev, createRule(columns)])
   }, [columns])
@@ -53,6 +74,32 @@ export function TableFilter({ columns, filter, onApply, onClose }: TableFilterPr
     setRules((prev) => prev.map((r) => (r.id === id ? { ...r, [field]: value } : r)))
   }, [])
 
+  // Switching a rule's column across the select boundary changes what values and
+  // operators are valid, so clear the value and coerce an unsupported operator
+  // back to `eq` — otherwise a stale free-text value or a range operator would
+  // apply against a select column and be rejected server-side.
+  const handleColumnChange = useCallback(
+    (id: string, columnId: string) => {
+      setRules((prev) =>
+        prev.map((r) => {
+          if (r.id !== id) return r
+          const previous = columnById.get(r.column)
+          const next = columnById.get(columnId)
+          const wasSelect = previous?.type === 'select'
+          const isSelect = next?.type === 'select'
+          if (!wasSelect && !isSelect) return { ...r, column: columnId }
+          // Single- and multi-select take different operators, so a switch
+          // between them has to fall back too, not just select ↔ non-select.
+          const allowed = selectFilterOperators(next)
+          const fallback = next?.multiple ? 'contains' : 'eq'
+          const operator = isSelect && !allowed.has(r.operator) ? fallback : r.operator
+          return { ...r, column: columnId, operator, value: '' }
+        })
+      )
+    },
+    [columnById]
+  )
+
   const handleToggleLogical = useCallback((id: string) => {
     setRules((prev) =>
       prev.map((r) =>
@@ -65,8 +112,8 @@ export function TableFilter({ columns, filter, onApply, onClose }: TableFilterPr
     const validRules = rulesRef.current.filter(
       (r) => r.column && (r.value || VALUELESS_OPERATORS.has(r.operator))
     )
-    onApply(filterRulesToFilter(validRules))
-  }, [onApply])
+    onApply(filterRulesToFilter(validRules, columns))
+  }, [columns, onApply])
 
   const handleClear = useCallback(() => {
     setRules([createRule(columns)])
@@ -82,7 +129,9 @@ export function TableFilter({ columns, filter, onApply, onClose }: TableFilterPr
             rule={rule}
             isFirst={index === 0}
             columns={columnOptions}
+            columnById={columnById}
             onUpdate={handleUpdate}
+            onColumnChange={handleColumnChange}
             onRemove={handleRemove}
             onApply={handleApply}
             onToggleLogical={handleToggleLogical}
@@ -124,7 +173,9 @@ interface FilterRuleRowProps {
   rule: FilterRule
   isFirst: boolean
   columns: Array<{ value: string; label: string }>
+  columnById: ReadonlyMap<string, ColumnDefinition>
   onUpdate: (id: string, field: keyof FilterRule, value: string) => void
+  onColumnChange: (id: string, columnId: string) => void
   onRemove: (id: string) => void
   onApply: () => void
   onToggleLogical: (id: string) => void
@@ -134,7 +185,9 @@ const FilterRuleRow = memo(function FilterRuleRow({
   rule,
   isFirst,
   columns,
+  columnById,
   onUpdate,
+  onColumnChange,
   onRemove,
   onApply,
   onToggleLogical,
@@ -147,6 +200,24 @@ const FilterRuleRow = memo(function FilterRuleRow({
       ? [...columns, { value: rule.column, label: rule.column }]
       : columns
 
+  const selectedColumn = columnById.get(rule.column)
+  const isSelect = selectedColumn?.type === 'select'
+  const operatorOptions = !isSelect
+    ? COMPARISON_OPERATORS
+    : selectedColumn?.multiple
+      ? MULTI_SELECT_COMPARISON_OPERATORS
+      : SINGLE_SELECT_COMPARISON_OPERATORS
+
+  // A stale id (option since deleted) stays selectable so the rule still shows.
+  const selectValueOptions = isSelect
+    ? (() => {
+        const opts = (selectedColumn.options ?? []).map((o) => ({ value: o.id, label: o.name }))
+        return rule.value && !opts.some((o) => o.value === rule.value)
+          ? [...opts, { value: rule.value, label: rule.value }]
+          : opts
+      })()
+    : []
+
   return (
     <div className='flex items-center gap-1.5'>
       {isFirst ? (
@@ -163,7 +234,7 @@ const FilterRuleRow = memo(function FilterRuleRow({
       <ChipDropdown
         options={columnOptions}
         value={rule.column}
-        onChange={(value) => onUpdate(rule.id, 'column', value)}
+        onChange={(value) => onColumnChange(rule.id, value)}
         placeholder='Column'
         align='start'
         matchTriggerWidth={false}
@@ -171,7 +242,7 @@ const FilterRuleRow = memo(function FilterRuleRow({
       />
 
       <ChipDropdown
-        options={COMPARISON_OPERATORS}
+        options={operatorOptions}
         value={rule.operator}
         onChange={(value) => onUpdate(rule.id, 'operator', value)}
         placeholder='Operator'
@@ -182,6 +253,16 @@ const FilterRuleRow = memo(function FilterRuleRow({
 
       {VALUELESS_OPERATORS.has(rule.operator) ? (
         <div className='h-[30px] flex-1' />
+      ) : isSelect ? (
+        <ChipDropdown
+          options={selectValueOptions}
+          value={rule.value}
+          onChange={(value) => onUpdate(rule.id, 'value', value)}
+          placeholder='Select a value'
+          align='start'
+          matchTriggerWidth={false}
+          className='min-w-[100px] flex-1'
+        />
       ) : (
         <ChipInput
           value={rule.value}
@@ -208,11 +289,13 @@ const FilterRuleRow = memo(function FilterRuleRow({
 })
 
 function createRule(columns: ColumnDefinition[]): FilterRule {
+  const first = columns[0]
   return {
     id: generateShortId(),
     logicalOperator: 'and',
-    column: columns[0] ? getColumnId(columns[0]) : '',
-    operator: 'eq',
+    column: first ? getColumnId(first) : '',
+    // A multi-select can't be compared for equality — default it to membership.
+    operator: first?.type === 'select' && first.multiple ? 'contains' : 'eq',
     value: '',
   }
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx
index edc4a92302e..283dfa21d8c 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx
@@ -5,9 +5,10 @@ import { useEffect, useRef, useState } from 'react'
 import { Badge, Checkbox, cn, Tooltip } from '@sim/emcn'
 import { parse } from 'tldts'
 import { faviconUrl } from '@/lib/core/utils/favicon'
-import type { RowExecutionMetadata } from '@/lib/table'
+import type { RowExecutionMetadata, SelectOption } from '@/lib/table'
 import { StatusBadge } from '@/app/workspace/[workspaceId]/logs/utils'
 import { storageToDisplay } from '../../../utils'
+import { resolveSelectOptions, SelectPill } from '../../select-field'
 import type { DisplayColumn } from '../types'
 import { SimResourceCell, type SimResourceType } from './sim-resource-cell'
 
@@ -25,6 +26,7 @@ export type CellRenderKind =
   | { kind: 'no-output' }
   // Plain typed cells
   | { kind: 'boolean'; checked: boolean }
+  | { kind: 'select'; options: SelectOption[] }
   | { kind: 'json'; text: string }
   | { kind: 'date'; text: string }
   | { kind: 'url'; text: string; href: string; domain: string }
@@ -120,6 +122,11 @@ export function resolveCellRender({
   }
 
   if (column.type === 'boolean') return { kind: 'boolean', checked: Boolean(value) }
+  // Always render select cells as the `select` kind — an empty one shows a muted
+  // "None" so every select cell reads as a clickable dropdown.
+  if (column.type === 'select') {
+    return { kind: 'select', options: resolveSelectOptions(column, value) }
+  }
   if (isNull) return { kind: 'empty' }
   if (column.type === 'json') return { kind: 'json', text: JSON.stringify(value) }
   if (column.type === 'date') return { kind: 'date', text: String(value) }
@@ -346,6 +353,20 @@ export function CellRender({ kind, isEditing }: CellRenderProps): React.ReactEle
         </div>
       )
 
+    case 'select':
+      // Chip-only view: just the option pills. Pills stay visible while editing —
+      // the inline editor overlays an invisible trigger and portals its menu
+      // below, so the cell keeps showing the current selection.
+      return (
+        <span className='flex min-w-0 items-center gap-1 overflow-hidden'>
+          {kind.options.length > 0 ? (
+            kind.options.map((option) => <SelectPill key={option.id} option={option} />)
+          ) : (
+            <span className='text-[var(--text-muted)] text-small'>None</span>
+          )}
+        </span>
+      )
+
     case 'json':
       return (
         <span
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/expanded-cell-popover.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/expanded-cell-popover.tsx
index ce99edc0894..84a61ebab39 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/expanded-cell-popover.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/expanded-cell-popover.tsx
@@ -30,9 +30,6 @@ const EXPANDED_CELL_HEIGHT = 280
 /**
  * Anchored cell editor. Floats over the double-clicked cell, minimum width
  * {@link EXPANDED_CELL_MIN_WIDTH}, fixed height, internally scrollable.
- *
- * Workflow and boolean cells are read-only here — workflow cells are driven
- * by the scheduler, booleans toggle inline.
  */
 export function ExpandedCellPopover({
   expandedCell,
@@ -71,6 +68,12 @@ export function ExpandedCellPopover({
     if (!target) return ''
     const { value } = target
     if (value == null) return ''
+    // Read-only viewers get the same date format the grid renders, not the raw
+    // stored string. (This branch never sees a `select` cell — the grid routes
+    // those to the inline dropdown.)
+    if (target.column.type === 'date' && typeof value === 'string') {
+      return storageToDisplay(value, { seconds: true })
+    }
     if (typeof value === 'string') return value
     return JSON.stringify(value, null, 2)
   }, [target])
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/inline-editors.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/inline-editors.tsx
index 20ac51847a2..e3caa259fe8 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/inline-editors.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/inline-editors.tsx
@@ -1,7 +1,19 @@
 'use client'
 
 import { useCallback, useEffect, useRef, useState } from 'react'
-import { Calendar, cn, Popover, PopoverAnchor, PopoverContent, toast } from '@sim/emcn'
+import {
+  Calendar,
+  cn,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+  Popover,
+  PopoverAnchor,
+  PopoverContent,
+  toast,
+} from '@sim/emcn'
+import { Check } from '@sim/emcn/icons'
 import type { ColumnDefinition } from '@/lib/table'
 import { isCalendarDateString } from '@/lib/table/dates'
 import { useTimezone } from '@/hooks/queries/general-settings'
@@ -14,6 +26,7 @@ import {
   storageToDisplay,
   todayLocalCalendarDate,
 } from '../../../utils'
+import { SelectPill, selectedOptionIds } from '../../select-field'
 
 interface InlineEditorProps {
   value: unknown
@@ -323,10 +336,102 @@ function InlineTextEditor({
   )
 }
 
+/**
+ * Inline editor for `select`/`multiselect` columns. Renders the canonical
+ * `DropdownMenu` anchored to the cell (an invisible full-cell trigger, no pill
+ * chrome) and opens it immediately. Single-select commits on pick; multiselect
+ * toggles and commits when the menu closes. Escape discards the draft, matching
+ * the text/date inline editors.
+ */
+function InlineSelectEditor({ value, column, onSave, onCancel }: InlineEditorProps) {
+  const isMulti = !!column.multiple
+  const allOptions = column.options ?? []
+  const [draft, setDraft] = useState<string[]>(() => selectedOptionIds(column, value))
+  const [open, setOpen] = useState(true)
+  const latestRef = useRef(draft)
+  const doneRef = useRef(false)
+  const cancelledRef = useRef(false)
+
+  const setDraftAnd = (next: string[]) => {
+    latestRef.current = next
+    setDraft(next)
+  }
+
+  const commit = useCallback(() => {
+    if (doneRef.current) return
+    doneRef.current = true
+    if (cancelledRef.current) {
+      onCancel()
+      return
+    }
+    const ids = latestRef.current
+    onSave(isMulti ? ids : (ids[0] ?? null), 'enter')
+  }, [isMulti, onSave, onCancel])
+
+  // Escape closes the Radix menu (firing `onOpenChange(false)`); capture it
+  // first so the close handler discards instead of committing.
+  useEffect(() => {
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') cancelledRef.current = true
+    }
+    document.addEventListener('keydown', onKeyDown, true)
+    return () => document.removeEventListener('keydown', onKeyDown, true)
+  }, [])
+
+  const handleOpenChange = (next: boolean) => {
+    setOpen(next)
+    if (!next) commit()
+  }
+
+  const handleSelectOption = (event: Event, id: string) => {
+    if (!isMulti) {
+      // Picking closes the menu → `handleOpenChange` commits the new value.
+      setDraftAnd([id])
+      return
+    }
+    // Keep the menu open across toggles; commit the set on close.
+    event.preventDefault()
+    const has = latestRef.current.includes(id)
+    const next = has ? latestRef.current.filter((v) => v !== id) : [...latestRef.current, id]
+    // A required multiselect can't be emptied — ignore removing the last option.
+    if (column.required && next.length === 0) return
+    setDraftAnd(next)
+  }
+
+  return (
+    <DropdownMenu open={open} onOpenChange={handleOpenChange}>
+      <DropdownMenuTrigger asChild>
+        <button
+          type='button'
+          aria-label={`Edit ${column.name}`}
+          className='absolute inset-0 cursor-pointer opacity-0'
+        />
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align='start' sideOffset={2} className='min-w-[180px]'>
+        {!isMulti && !column.required && (
+          <DropdownMenuItem onSelect={() => setDraftAnd([])}>
+            <span className='text-[var(--text-muted)]'>None</span>
+            {draft.length === 0 && <Check className='!ml-auto' />}
+          </DropdownMenuItem>
+        )}
+        {allOptions.map((option) => (
+          <DropdownMenuItem key={option.id} onSelect={(e) => handleSelectOption(e, option.id)}>
+            <SelectPill option={option} />
+            {draft.includes(option.id) && <Check className='!ml-auto' />}
+          </DropdownMenuItem>
+        ))}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  )
+}
+
 /** Dispatches to the right editor variant based on the column type. */
 export function InlineEditor(props: InlineEditorProps) {
   if (props.column.type === 'date') {
     return <InlineDateEditor {...props} />
   }
+  if (props.column.type === 'select') {
+    return <InlineSelectEditor {...props} />
+  }
   return <InlineTextEditor {...props} />
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/headers/column-type-icon.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/headers/column-type-icon.tsx
index a1d747c463d..dfaf662fbf6 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/headers/column-type-icon.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/headers/column-type-icon.tsx
@@ -5,6 +5,7 @@ import { Tooltip } from '@sim/emcn'
 import {
   Calendar as CalendarIcon,
   PlayOutline,
+  TagIcon,
   TypeBoolean,
   TypeJson,
   TypeNumber,
@@ -19,6 +20,7 @@ export const COLUMN_TYPE_ICONS: Record<string, React.ElementType> = {
   boolean: TypeBoolean,
   date: CalendarIcon,
   json: TypeJson,
+  select: TagIcon,
 }
 
 interface ColumnTypeIconProps {
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx
index 330df1c2d2d..f10d9e0e720 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx
@@ -5,6 +5,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr
 import { cn, toast, useToast } from '@sim/emcn'
 import { Loader, TableX } from '@sim/emcn/icons'
 import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
 import { useVirtualizer } from '@tanstack/react-virtual'
 import { useParams } from 'next/navigation'
 import { usePostHog } from 'posthog-js/react'
@@ -42,6 +43,7 @@ import {
 import type { ColumnConfig } from '../column-config-sidebar'
 import { ContextMenu } from '../context-menu'
 import { NewColumnDropdown } from '../new-column-dropdown'
+import { resolveSelectOptions } from '../select-field'
 import type { WorkflowConfig } from '../workflow-sidebar'
 import { ExpandedCellPopover } from './cells'
 import { ADD_COL_WIDTH, COL_WIDTH, SELECTION_TINT_BG } from './constants'
@@ -243,12 +245,49 @@ interface TableGridProps {
   >
 }
 
-/** Serialize a cell value to its tab-separated clipboard representation. */
-function cellToText(value: unknown): string {
+/**
+ * Serialize a cell value to its tab-separated clipboard representation. A
+ * `select` cell stores option ids, so resolve them to the option name(s)
+ * (comma-joined for multi) — the clipboard shows the label, not the id.
+ */
+function cellToText(value: unknown, column?: DisplayColumn): string {
   if (value === null || value === undefined) return ''
+  if (column?.type === 'select') {
+    return resolveSelectOptions(column, value)
+      .map((o) => o.name)
+      .join(', ')
+  }
   return typeof value === 'object' ? JSON.stringify(value) : String(value)
 }
 
+/**
+ * Value-equality for a cell's stored value vs a pending edit. Primitives compare
+ * with `===`; arrays/objects (multiselect id arrays, json) compare structurally
+ * so a no-op edit — e.g. opening a multiselect and closing it unchanged — isn't
+ * treated as a change and doesn't write a row update or push an undo entry.
+ */
+function cellValuesEqual(a: unknown, b: unknown, column?: DisplayColumn): boolean {
+  if (a === b) return true
+  // An untouched multiselect cell is stored as null, but the editor commits `[]`
+  // for an empty selection — without this, opening and dismissing one unchanged
+  // would write a row update and push an undo entry. Multiselect only: on a json
+  // cell `[]` and null are genuinely different values, and treating them as equal
+  // would silently drop the edit that clears a stored `[]` (or writes one).
+  if (column?.type === 'select' && column.multiple) {
+    if (isEmptySelection(a) && isEmptySelection(b)) return true
+  }
+  if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+    return JSON.stringify(a) === JSON.stringify(b)
+  }
+  return false
+}
+
+/** An empty multiselect, however it was stored: absent, null, or `[]`. */
+function isEmptySelection(value: unknown): boolean {
+  if (Array.isArray(value)) return value.length === 0
+  return value === null || value === undefined
+}
+
 /**
  * Split updates into chunks bounded by the server batch-size limit, dispatching
  * up to 3 chunks concurrently. On the first chunk failure the remaining chunks
@@ -398,6 +437,11 @@ export function TableGrid({
     ensureAllRowsLoaded,
     ensureRowsLoadedUpTo,
     refetchRows,
+    // Server-bound scopes use this, not `queryOptions.filter` — a condition the
+    // current schema invalidated is pruned from the rows query, so a bulk action
+    // carrying the raw filter would target a predicate the grid isn't showing
+    // (and one the server rejects outright).
+    filter: effectiveFilter,
   } = useTable({ workspaceId, tableId, queryOptions })
 
   const { data: tableRunState } = useTableRunState(tableId)
@@ -529,7 +573,7 @@ export function TableGrid({
   ) {
     // Table-scoped runs (Run all / Run empty / Run N empty) honor the active
     // filter; an explicit rowIds scope (Run selected) already names its rows.
-    const filter = rowIds ? undefined : (queryOptions.filter ?? undefined)
+    const filter = rowIds ? undefined : (effectiveFilter ?? undefined)
     onRunColumn(groupId, runMode, rowIds, limit, filter)
   }
 
@@ -823,7 +867,7 @@ export function TableGrid({
     workspaceId,
     tableId,
     q: submittedQuery,
-    filter: queryOptions.filter,
+    filter: effectiveFilter,
     sort: queryOptions.sort,
   })
 
@@ -1432,6 +1476,12 @@ export function TableGrid({
           }
         } else if (column.type === 'date') {
           text = storageToDisplay(String(val), { seconds: true })
+        } else if (column.type === 'select') {
+          // Cells store option ids; measure the rendered pill labels instead so
+          // auto-fit doesn't size the column to opaque ids.
+          text = resolveSelectOptions(column, val)
+            .map((o) => o.name)
+            .join(', ')
         } else {
           text = String(val)
         }
@@ -2008,6 +2058,16 @@ export function TableGrid({
         return
       }
 
+      // Select: open the inline option dropdown when editable; never the big
+      // text popover. Read-only cells do nothing (like booleans).
+      if (column?.type === 'select') {
+        if (canEditRef.current) {
+          setEditingCell({ rowId, columnName })
+          setInitialCharacter(null)
+        }
+        return
+      }
+
       // Workflow-output cell with no value → let the user write over the status pill.
       if (column?.workflowGroupId && canEditRef.current) {
         const row = rowsRef.current.find((r) => r.id === rowId)
@@ -2494,8 +2554,9 @@ export function TableGrid({
         } catch (error) {
           // Rejects if the row load failed or the payload is too large for the
           // clipboard — either way nothing landed, so report a plain failure
-          // rather than implying a size cap was hit.
-          logger.error(`Failed to ${verbLower} rows`, { error })
+          // rather than implying a size cap was hit. Log the message explicitly:
+          // a DOMException (e.g. lost transient activation) serializes to `{}`.
+          logger.error(`Failed to ${verbLower} rows`, { error: getErrorMessage(error) })
           dismissToastRef.current(loadingToastId)
           toast.error(`Failed to ${verbLower} — please try again`)
           return
@@ -2569,7 +2630,7 @@ export function TableGrid({
               ? () => ensureRowsLoadedUpToRef.current(TABLE_LIMITS.MAX_COPY_ROWS)
               : async () => ({ rows: rowsRef.current, hasMore: false }),
           selectRow: (row) => rowSelectionIncludes(rowSel, row.id),
-          buildCells: (row) => cols.map((col) => cellToText(row.data[col.key])),
+          buildCells: (row) => cols.map((col) => cellToText(row.data[col.key], col)),
           verb: 'Copied',
           estimatedCount: rowSel.kind === 'some' ? rowSel.ids.size : selectAllTotalRef.current,
         })
@@ -2590,10 +2651,12 @@ export function TableGrid({
           const name = cols[c]?.key
           if (name) colNames.push(name)
         }
+        const colByKey = new Map(cols.map((c) => [c.key, c]))
         writeSelectionToClipboard({
           loadRows: () => ensureRowsLoadedUpToRef.current(TABLE_LIMITS.MAX_COPY_ROWS),
           selectRow: () => true,
-          buildCells: (row) => colNames.map((name) => cellToText(row.data[name])),
+          buildCells: (row) =>
+            colNames.map((name) => cellToText(row.data[name], colByKey.get(name))),
           verb: 'Copied',
           estimatedCount: selectAllTotalRef.current,
         })
@@ -2606,7 +2669,7 @@ export function TableGrid({
         for (let c = sel.startCol; c <= sel.endCol; c++) {
           if (c >= cols.length) break
           const row = currentRows[r]
-          cells.push(row ? cellToText(row.data[cols[c].key]) : '')
+          cells.push(row ? cellToText(row.data[cols[c].key], cols[c]) : '')
         }
         lines.push(cells.join('\t'))
       }
@@ -2631,7 +2694,7 @@ export function TableGrid({
               ? () => ensureRowsLoadedUpToRef.current(TABLE_LIMITS.MAX_COPY_ROWS)
               : async () => ({ rows: rowsRef.current, hasMore: false }),
           selectRow: (row) => rowSelectionIncludes(rowSel, row.id),
-          buildCells: (row) => cols.map((col) => cellToText(row.data[col.key])),
+          buildCells: (row) => cols.map((col) => cellToText(row.data[col.key], col)),
           verb: 'Cut',
           estimatedCount: rowSel.kind === 'some' ? rowSel.ids.size : selectAllTotalRef.current,
           afterCopy: (copied) =>
@@ -2657,10 +2720,12 @@ export function TableGrid({
           const name = cols[c]?.key
           if (name) colNames.push(name)
         }
+        const colByKey = new Map(cols.map((c) => [c.key, c]))
         writeSelectionToClipboard({
           loadRows: () => ensureRowsLoadedUpToRef.current(TABLE_LIMITS.MAX_COPY_ROWS),
           selectRow: () => true,
-          buildCells: (row) => colNames.map((name) => cellToText(row.data[name])),
+          buildCells: (row) =>
+            colNames.map((name) => cellToText(row.data[name], colByKey.get(name))),
           verb: 'Cut',
           estimatedCount: selectAllTotalRef.current,
           afterCopy: (copied) => clearCutRows(copied, colNames),
@@ -2680,7 +2745,7 @@ export function TableGrid({
         for (let c = sel.startCol; c <= sel.endCol; c++) {
           if (c < cols.length) {
             const colName = cols[c].key
-            cells.push(cellToText(row.data[colName]))
+            cells.push(cellToText(row.data[colName], cols[c]))
             previousData[colName] = row.data[colName] ?? null
             updates[colName] = null
           }
@@ -2887,7 +2952,8 @@ export function TableGrid({
 
       const oldValue = row.data[columnName] ?? null
       const normalizedValue = value ?? null
-      const changed = oldValue !== normalizedValue
+      const column = columnsRef.current.find((c) => c.key === columnName)
+      const changed = !cellValuesEqual(oldValue, normalizedValue, column)
 
       if (changed) {
         pushUndoRef.current({
@@ -3151,6 +3217,10 @@ export function TableGrid({
           columnPosition: adjustedPosition >= 0 ? adjustedPosition : cols.length,
           columnUnique: entry.def?.unique ?? false,
           columnRequired: entry.def?.required ?? false,
+          // Without these a deleted select column can't be re-created — it is
+          // invalid with no options, and the saved cell data is option ids.
+          ...(entry.def?.options ? { columnOptions: entry.def.options } : {}),
+          ...(entry.def?.multiple ? { columnMultiple: true } : {}),
           cellData,
           previousOrder: orderSnapshot,
           previousWidth,
@@ -3309,7 +3379,7 @@ export function TableGrid({
    *  mirroring the action bar's Play/Refresh; deselected rows are excluded. */
   const runSelection = (runMode: RunMode) => {
     if (contextMenuIsSelectAll) {
-      const filter = queryOptions.filter ?? undefined
+      const filter = effectiveFilter ?? undefined
       const excluded =
         rowSelection.kind === 'all' && rowSelection.excluded
           ? [...rowSelection.excluded]
@@ -3332,7 +3402,7 @@ export function TableGrid({
         rowSelection.kind === 'all' && rowSelection.excluded
           ? [...rowSelection.excluded]
           : undefined
-      onStopAllRows(queryOptions.filter ?? undefined, excluded)
+      onStopAllRows(effectiveFilter ?? undefined, excluded)
     } else {
       onStopRows(contextMenuRowIds)
     }
@@ -3460,7 +3530,7 @@ export function TableGrid({
           rowIds: rows.map((r) => r.id),
           allRows: true,
           rowCount: Math.max(0, selectAllTotalRef.current - excluded),
-          filter: queryOptions.filter ?? undefined,
+          filter: effectiveFilter ?? undefined,
           excludeRowIds: rowSelection.excluded ? [...rowSelection.excluded] : undefined,
         }
       }
@@ -3485,7 +3555,14 @@ export function TableGrid({
     }
     if (rowIds.length === 0) return null
     return { groupIds: [...groupIdsInRect], rowIds, allRows: false, rowCount: rowIds.length }
-  }, [rowSelection, normalizedSelection, rows, displayColumns, tableWorkflowGroupIds])
+  }, [
+    rowSelection,
+    normalizedSelection,
+    rows,
+    displayColumns,
+    tableWorkflowGroupIds,
+    effectiveFilter,
+  ])
 
   const selectionStats = useMemo<SelectionSnapshot['selectionStats']>(() => {
     if (!selectedRunScope) {
@@ -3661,7 +3738,7 @@ export function TableGrid({
                                 onSelectGroup={handleGroupSelect}
                                 onOpenConfig={() => handleConfigureWorkflowGroup(g.groupId)}
                                 onRunColumn={userPermissions.canEdit ? handleRunColumn : undefined}
-                                hasActiveFilter={Boolean(queryOptions.filter)}
+                                hasActiveFilter={Boolean(effectiveFilter)}
                                 selectedRowIds={selectedRowIds}
                                 onInsertLeft={
                                   userPermissions.canEdit ? handleInsertColumnLeft : undefined
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table.ts b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table.ts
index 6995f7819e8..9fcf4dd7db5 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table.ts
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table.ts
@@ -2,8 +2,15 @@
 
 import { useCallback, useMemo } from 'react'
 import { useQueryClient } from '@tanstack/react-query'
-import type { ColumnDefinition, TableDefinition, TableRow, WorkflowGroup } from '@/lib/table'
+import type {
+  ColumnDefinition,
+  Filter,
+  TableDefinition,
+  TableRow,
+  WorkflowGroup,
+} from '@/lib/table'
 import { TABLE_LIMITS } from '@/lib/table/constants'
+import { pruneFilterForColumns } from '@/lib/table/query-builder/converters'
 import type { FlattenOutputsBlockInput } from '@/lib/workflows/blocks/flatten-outputs'
 import { getBlock } from '@/blocks'
 import {
@@ -38,6 +45,13 @@ export interface UseTableReturn {
   rows: TableRow[]
   /** Filter-scoped total row count (server COUNT(*) for the active filter); null until loaded. */
   rowTotal: number | null
+  /**
+   * The filter actually sent to the server: `queryOptions.filter` minus any
+   * condition the current schema makes invalid. Anything server-bound —
+   * select-all run/stop/delete — must scope with THIS, not the raw filter, or
+   * the action targets a predicate the grid isn't displaying.
+   */
+  filter: Filter | null
   isLoadingRows: boolean
   refetchRows: () => void
   /**
@@ -78,6 +92,16 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
   const queryClient = useQueryClient()
   const { data: tableData, isLoading: isLoadingTable } = useTableQuery(workspaceId, tableId)
 
+  // Applied filters outlive the schema they were built against: converting a
+  // column to `select`, or toggling its `multiple`, can strand an operator the
+  // server rejects outright, which would fail every subsequent rows query. Prune
+  // here, above every consumer of the rows query key, so the paged helpers below
+  // can't rebuild the key from the unpruned filter and drift.
+  const filter = useMemo(
+    () => pruneFilterForColumns(queryOptions.filter ?? null, tableData?.schema?.columns ?? []),
+    [queryOptions.filter, tableData?.schema?.columns]
+  )
+
   const {
     data: rowsData,
     isLoading: isLoadingRows,
@@ -89,7 +113,7 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
     workspaceId,
     tableId,
     pageSize: TABLE_LIMITS.MAX_QUERY_LIMIT,
-    filter: queryOptions.filter,
+    filter,
     sort: queryOptions.sort,
     enabled: Boolean(workspaceId && tableId),
   })
@@ -118,7 +142,7 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
       workspaceId,
       tableId,
       pageSize: TABLE_LIMITS.MAX_QUERY_LIMIT,
-      filter: queryOptions.filter,
+      filter,
       sort: queryOptions.sort,
     })
 
@@ -140,7 +164,7 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
     }
 
     return queryClient.getQueryData(opts.queryKey)?.pages.flatMap((p) => p.rows) ?? []
-  }, [workspaceId, tableId, queryOptions.filter, queryOptions.sort, queryClient, fetchNextPage])
+  }, [workspaceId, tableId, filter, queryOptions.sort, queryClient, fetchNextPage])
 
   const ensureRowsLoadedUpTo = useCallback(
     async (maxRows: number): Promise<{ rows: TableRow[]; hasMore: boolean }> => {
@@ -150,7 +174,7 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
         workspaceId,
         tableId,
         pageSize: TABLE_LIMITS.MAX_QUERY_LIMIT,
-        filter: queryOptions.filter,
+        filter,
         sort: queryOptions.sort,
       })
 
@@ -176,7 +200,7 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
         hasMore: all.length > maxRows || hasMoreTableRows(pages),
       }
     },
-    [workspaceId, tableId, queryOptions.filter, queryOptions.sort, queryClient, fetchNextPage]
+    [workspaceId, tableId, filter, queryOptions.sort, queryClient, fetchNextPage]
   )
 
   const fetchNextPageWrapped = useCallback(async () => {
@@ -237,6 +261,7 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
     isLoadingTable,
     rows,
     rowTotal,
+    filter,
     isLoadingRows,
     refetchRows,
     fetchNextPage: fetchNextPageWrapped,
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx
index 0f7485636bb..3094439a10e 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx
@@ -272,7 +272,16 @@ export function Table({
 
   // Single source of truth for `useTable` — drives both the grid render and
   // the wrapper's slideouts/modals. The grid receives the bundle as props.
-  const { tableData, columns, tableWorkflowGroups, workflows } = useTable({
+  const {
+    tableData,
+    columns,
+    tableWorkflowGroups,
+    workflows,
+    // Server-bound scopes use this: a filter condition the current schema
+    // invalidated is pruned from the rows query, so the delete must target the
+    // same predicate the grid is displaying.
+    filter: effectiveFilter,
+  } = useTable({
     workspaceId,
     tableId,
     queryOptions,
@@ -640,10 +649,13 @@ export function Table({
   const filterConfig = useMemo(
     () => ({
       mode: 'toggle' as const,
-      active: filterOpen || !!queryOptions.filter,
+      // The pruned filter, not the raw one: a condition the current schema
+      // invalidated is not applied to the grid, so showing the chip as active
+      // (and reopening that rule) would claim a filter the rows do not reflect.
+      active: filterOpen || !!effectiveFilter,
       onToggle: handleToggleFilter,
     }),
-    [filterOpen, queryOptions.filter, handleToggleFilter]
+    [filterOpen, effectiveFilter, handleToggleFilter]
   )
 
   return (
@@ -698,7 +710,7 @@ export function Table({
       {filterOpen && (
         <TableFilter
           columns={columns}
-          filter={queryOptions.filter}
+          filter={effectiveFilter}
           onApply={handleFilterApply}
           onClose={() => setFilterOpen(false)}
         />
@@ -878,7 +890,7 @@ export function Table({
         title='Delete rows'
         text={`Delete ${deletingAll ? deletingAll.estimatedCount.toLocaleString() : 0} ${
           deletingAll?.estimatedCount === 1 ? 'row' : 'rows'
-        }${queryOptions.filter ? ' matching the current filter' : ''}? This can't be undone.`}
+        }${effectiveFilter ? ' matching the current filter' : ''}? This can't be undone.`}
         confirm={{
           label: 'Delete',
           pending: deleteRowsAsyncMutation.isPending,
@@ -887,7 +899,7 @@ export function Table({
             if (!deletingAll) return
             const { excludeRowIds, estimatedCount } = deletingAll
             deleteRowsAsyncMutation.mutate({
-              filter: queryOptions.filter ?? undefined,
+              filter: effectiveFilter ?? undefined,
               sort: queryOptions.sort,
               excludeRowIds: excludeRowIds.length > 0 ? excludeRowIds : undefined,
               estimatedCount,
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.test.ts b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.test.ts
index eace4541f1f..5945be6c388 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.test.ts
@@ -125,6 +125,38 @@ describe('cleanCellValue', () => {
     expect(cleanCellValue('2024', { name: 'n', type: 'number' } as const)).toBe(2024)
     expect(cleanCellValue('true', { name: 'b', type: 'boolean' } as const)).toBe(true)
   })
+
+  it('resolves select names to option ids so the optimistic cache holds ids', () => {
+    const column = {
+      name: 'status',
+      type: 'select',
+      options: [
+        { id: 'opt_a', name: 'Open' },
+        { id: 'opt_b', name: 'Closed' },
+      ],
+    } as const
+    expect(cleanCellValue('Open', column)).toBe('opt_a')
+    expect(cleanCellValue('open', column)).toBe('opt_a')
+    expect(cleanCellValue('opt_b', column)).toBe('opt_b')
+    expect(cleanCellValue('Archived', column)).toBeNull()
+    expect(cleanCellValue('', column)).toBeNull()
+  })
+
+  it('round-trips a multiselect through its comma-joined clipboard form', () => {
+    const column = {
+      name: 'tags',
+      type: 'select',
+      multiple: true,
+      options: [
+        { id: 'opt_a', name: 'Bug' },
+        { id: 'opt_b', name: 'Docs' },
+      ],
+    } as const
+    expect(cleanCellValue('Bug, Docs', column)).toEqual(['opt_a', 'opt_b'])
+    expect(cleanCellValue(['opt_b'], column)).toEqual(['opt_b'])
+    expect(cleanCellValue('Bug, Bug', column)).toEqual(['opt_a'])
+    expect(cleanCellValue('Nope', column)).toEqual([])
+  })
 })
 
 describe('formatValueForInput', () => {
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.ts b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.ts
index 84e03eefaf0..cbeb8c122d4 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.ts
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.ts
@@ -71,9 +71,51 @@ export function cleanCellValue(
     if (value === '' || value === null || value === undefined) return null
     return displayToStorage(String(value), timeZone)
   }
+  if (column.type === 'select') {
+    return cleanSelectValue(value, column)
+  }
   return value || null
 }
 
+/**
+ * Client-side mirror of the server's `select` coercion: a cell stores option
+ * ids, but pasted or imported text carries names. Resolving here — not only on
+ * the server — is what keeps the optimistic cache holding ids, so the pasted
+ * cell renders its pill immediately instead of blanking until the refetch.
+ */
+function cleanSelectValue(value: unknown, column: ColumnDefinition): unknown {
+  const options = column.options ?? []
+  const resolve = (raw: unknown): string | null => {
+    if (typeof raw !== 'string') return null
+    const match =
+      options.find((o) => o.id === raw) ??
+      options.find((o) => o.name === raw) ??
+      options.find((o) => o.name.toLowerCase() === raw.toLowerCase())
+    return match ? match.id : null
+  }
+
+  if (column.multiple) {
+    // Comma-delimited is the multi cell's own clipboard/CSV format, so a paste
+    // of one round-trips. Option names containing commas are a known ambiguity.
+    const raw = Array.isArray(value)
+      ? value
+      : typeof value === 'string'
+        ? value
+            .split(',')
+            .map((part) => part.trim())
+            .filter((part) => part !== '')
+        : []
+    const ids: string[] = []
+    for (const entry of raw) {
+      const id = resolve(entry)
+      if (id !== null && !ids.includes(id)) ids.push(id)
+    }
+    return ids
+  }
+
+  return resolve(Array.isArray(value) ? value[0] : value)
+}
+
 /**
  * Format a stored value for display in an input field. Defensive against
  * shape drift: a column whose declared type lags its actual data (e.g. a
diff --git a/apps/sim/background/workflow-column-execution.ts b/apps/sim/background/workflow-column-execution.ts
index 20c66c55d37..9f59db93f15 100644
--- a/apps/sim/background/workflow-column-execution.ts
+++ b/apps/sim/background/workflow-column-execution.ts
@@ -20,8 +20,9 @@ import { RateLimiter } from '@/lib/core/rate-limiter/rate-limiter'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
 import { retryTableAdmission } from '@/lib/table/admission-retry'
 import { withCascadeLock } from '@/lib/table/cascade-lock'
+import { fillMissingColumns, mapInputValues, namedRowMapper } from '@/lib/table/cell-format'
 import { getColumnId } from '@/lib/table/column-keys'
-import { isExecCancelled } from '@/lib/table/deps'
+import { isEmptyCellValue, isExecCancelled } from '@/lib/table/deps'
 import { getMaxTableDispatchConcurrency } from '@/lib/table/dispatch-concurrency'
 import { appendTableEvent } from '@/lib/table/events'
 import type {
@@ -308,18 +309,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 enrichInputs: Record<string, unknown> = {}
-      for (const m of group.inputMappings ?? []) {
-        if (ownOutputColumns.has(m.columnName)) continue
-        enrichInputs[m.inputName] = row.data[m.columnName]
-      }
+      const enrichInputs = mapInputValues(
+        row.data,
+        table.schema.columns,
+        (group.inputMappings ?? []).filter((m) => !ownOutputColumns.has(m.columnName))
+      )
 
       // Skip (don't error) rows missing a required input — common when a table
       // is partially filled. Clear any prior output values so a stale result
       // doesn't linger (and doesn't mark the group `completed`-and-filled, which
       // would block the auto cascade from re-enriching once inputs return).
-      const isEmpty = (v: unknown) => v === undefined || v === null || v === ''
+      const isEmpty = isEmptyCellValue
       const missingRequired = enrichment.inputs.some(
         (i) => i.required && isEmpty(enrichInputs[i.id])
       )
@@ -668,17 +670,17 @@ async function runWorkflowAndWriteTerminal(
       // `inputRow` is name-keyed: the workflow author references columns by name
       // in the Start block and downstream blocks, while stored `row.data` is
       // id-keyed. Translate, skipping this group's own output columns.
+      // NOTE: `outputs[].columnName` / `inputMappings[].columnName` hold column
+      // **ids**, not names — a known misnomer (renaming it is a schema migration).
       const ownOutputColumnIds = new Set(group.outputs.map((o) => o.columnName))
-      const inputRow: Record<string, unknown> = {}
-      for (const col of table.schema.columns) {
-        const id = getColumnId(col)
-        if (ownOutputColumnIds.has(id)) continue
-        inputRow[col.name] = row.data[id]
-      }
-
-      const headers = table.schema.columns
-        .filter((c) => !ownOutputColumnIds.has(getColumnId(c)))
-        .map((c) => c.name)
+      const inputColumns = table.schema.columns.filter(
+        (c) => !ownOutputColumnIds.has(getColumnId(c))
+      )
+      // One column list drives both the row and its headers so they cannot drift.
+      // The mapper also resolves select option ids to names — the workflow author
+      // sees "Open", not `opt_a1b2`.
+      const inputRow = fillMissingColumns(namedRowMapper(inputColumns)(row.data), inputColumns)
+      const headers = inputColumns.map((c) => c.name)
 
       // When the group has explicit input mappings, feed the workflow's
       // Start-block fields from the mapped columns (`inputName ← row[columnId]`).
@@ -686,10 +688,7 @@ async function runWorkflowAndWriteTerminal(
       // Start field still resolves when it matches a column name. `row`/`rawRow`
       // always carry the full (name-keyed) row for downstream reference.
       const inputMappings = group.inputMappings ?? []
-      const mappedInputs: Record<string, unknown> = {}
-      for (const m of inputMappings) {
-        mappedInputs[m.inputName] = row.data[m.columnName]
-      }
+      const mappedInputs = mapInputValues(row.data, table.schema.columns, inputMappings)
 
       const input = {
         ...(inputMappings.length > 0 ? mappedInputs : inputRow),
diff --git a/apps/sim/hooks/queries/tables.ts b/apps/sim/hooks/queries/tables.ts
index 7510875ebbf..8ce978c28ef 100644
--- a/apps/sim/hooks/queries/tables.ts
+++ b/apps/sim/hooks/queries/tables.ts
@@ -212,6 +212,23 @@ function invalidateTableSchema(queryClient: ReturnType<typeof useQueryClient>, t
   queryClient.invalidateQueries({ queryKey: tableKeys.lists() })
 }
 
+/**
+ * Invalidate only the schema, not the rows — so cells re-render from the
+ * refetched schema without a (potentially large) rows refetch.
+ *
+ * Only for changes that are genuinely metadata-only server-side (rename,
+ * constraints, a select's option labels). Anything that rewrites stored cells
+ * must use {@link invalidateTableSchema}: deleting a column strips keys, a type
+ * change migrates select ids ↔ names, and a single↔multi toggle rewraps them.
+ */
+function invalidateTableSchemaOnly(
+  queryClient: ReturnType<typeof useQueryClient>,
+  tableId: string
+) {
+  queryClient.invalidateQueries({ queryKey: tableKeys.detail(tableId) })
+  queryClient.invalidateQueries({ queryKey: tableKeys.lists() })
+}
+
 /**
  * Fetch all tables for a workspace.
  */
@@ -533,7 +550,7 @@ export function useAddTableColumn({ workspaceId, tableId }: RowMutationContext)
       toast.error(error.message, { duration: 5000 })
     },
     onSettled: () => {
-      invalidateTableSchema(queryClient, tableId)
+      invalidateTableSchemaOnly(queryClient, tableId)
     },
   })
 }
@@ -1165,6 +1182,24 @@ export function useDeleteTableRowsAsync({ workspaceId, tableId }: RowMutationCon
 
 type UpdateColumnParams = Omit<UpdateTableColumnBodyInput, 'workspaceId'>
 
+/**
+ * Whether an update drops a `select` option the column currently declares —
+ * the one options edit the server answers by rewriting cells.
+ */
+function removesSelectOption(
+  previousDetail: TableDefinition | undefined,
+  { columnName, updates }: UpdateColumnParams
+): boolean {
+  if (updates.options === undefined || previousDetail === undefined) return false
+  const lower = columnName.toLowerCase()
+  const column = previousDetail.schema.columns.find(
+    (c) => getColumnId(c) === columnName || c.name.toLowerCase() === lower
+  )
+  if (!column?.options?.length) return false
+  const keptIds = new Set(updates.options.map((o) => o.id))
+  return column.options.some((o) => !keptIds.has(o.id))
+}
+
 /**
  * Update a column (rename, type change, or constraint update).
  */
@@ -1210,8 +1245,19 @@ export function useUpdateColumn({ workspaceId, tableId }: RowMutationContext) {
       if (isValidationError(error)) return
       toast.error(error.message, { duration: 5000 })
     },
-    onSettled: () => {
-      invalidateTableSchema(queryClient, tableId)
+    onSettled: (_data, _error, variables, context) => {
+      // A type change, a select single↔multi toggle, or removing an option
+      // rewrites stored cells server-side (option ids ↔ names, scalar ↔ array,
+      // removed ids cleared). Those need the rows refetched too — the
+      // schema-only path would leave the cache holding pre-migration values,
+      // which the grid hides but emptiness checks, filters, and dependent-group
+      // eligibility still act on. Everything else really is metadata-only.
+      const rewritesRows =
+        variables.updates.type !== undefined ||
+        variables.updates.multiple !== undefined ||
+        removesSelectOption(context?.previousDetail, variables)
+      if (rewritesRows) invalidateTableSchema(queryClient, tableId)
+      else invalidateTableSchemaOnly(queryClient, tableId)
     },
   })
 }
diff --git a/apps/sim/hooks/use-table-undo.test.ts b/apps/sim/hooks/use-table-undo.test.ts
index 3caee9dcca7..3c19882c6e3 100644
--- a/apps/sim/hooks/use-table-undo.test.ts
+++ b/apps/sim/hooks/use-table-undo.test.ts
@@ -229,3 +229,37 @@ describe('useTableUndo – delete-column undo cell restore chunking', () => {
     expect(mockMutateAsync.mock.calls[1][0].updates).toHaveLength(2)
   })
 })
+
+describe('useTableUndo – restoring a deleted select column', () => {
+  const selectAction: TableUndoAction = {
+    type: 'delete-column',
+    columnName: 'status',
+    columnId: 'col_status',
+    columnType: 'select' as const,
+    columnPosition: 0,
+    columnUnique: false,
+    columnRequired: false,
+    columnOptions: [{ id: 'opt_open', name: 'Open' }],
+    columnMultiple: true,
+    cellData: [],
+    previousOrder: null,
+    previousWidth: null,
+    previousPinnedColumns: null,
+  }
+
+  it('re-creates the column with its options and cardinality', async () => {
+    // A select column is invalid without an option set, so an undo that omits
+    // them is rejected outright — and the saved cells are option ids with
+    // nothing to attach to.
+    mockPopUndo.mockReturnValueOnce(makeEntry(selectAction))
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+
+    const payload = mockMutate.mock.calls[0][0]
+    expect(payload.type).toBe('select')
+    expect(payload.options).toEqual([{ id: 'opt_open', name: 'Open' }])
+    expect(payload.multiple).toBe(true)
+    expect(payload.id).toBe('col_status')
+  })
+})
diff --git a/apps/sim/hooks/use-table-undo.ts b/apps/sim/hooks/use-table-undo.ts
index dd403c4c27c..a65672c3f78 100644
--- a/apps/sim/hooks/use-table-undo.ts
+++ b/apps/sim/hooks/use-table-undo.ts
@@ -268,6 +268,10 @@ export function useTableUndo({
                   type: action.columnType,
                   required: action.columnRequired,
                   unique: action.columnUnique,
+                  // A select column is rejected without its options, and the
+                  // cell data restored below is keyed by those option ids.
+                  ...(action.columnOptions ? { options: action.columnOptions } : {}),
+                  ...(action.columnMultiple ? { multiple: true } : {}),
                   position: action.columnPosition,
                 },
                 {
diff --git a/apps/sim/lib/api/client/request.ts b/apps/sim/lib/api/client/request.ts
index 85a7d2ac7fb..a68eb96fd13 100644
--- a/apps/sim/lib/api/client/request.ts
+++ b/apps/sim/lib/api/client/request.ts
@@ -161,6 +161,26 @@ function isSchemaValidationError(error: unknown): boolean {
   )
 }
 
+/**
+ * Compresses a ZodError's issues into a short, readable "field: reason" summary
+ * so a failed response tells you which field was wrong instead of a bare
+ * "Response failed contract validation".
+ */
+function summarizeSchemaIssues(error: unknown): string {
+  const issues = (error as { issues?: unknown }).issues
+  if (!Array.isArray(issues)) return ''
+  const summary = issues
+    .slice(0, 3)
+    .map((issue) => {
+      const path = Array.isArray(issue?.path) ? issue.path.join('.') : ''
+      const message = typeof issue?.message === 'string' ? issue.message : 'invalid'
+      return path ? `${path}: ${message}` : message
+    })
+    .join('; ')
+  const extra = issues.length > 3 ? ` (+${issues.length - 3} more)` : ''
+  return summary ? `${summary}${extra}` : ''
+}
+
 export async function requestJson<C extends AnyApiRouteContract>(
   contract: C,
   input: ApiClientRequest<C>
@@ -199,9 +219,12 @@ export async function requestJson<C extends AnyApiRouteContract>(
     return contract.response.schema.parse(parsed) as ContractJsonResponse<C>
   } catch (error) {
     if (isSchemaValidationError(error)) {
+      const details = summarizeSchemaIssues(error)
       throw new ApiClientError({
         status: response.status,
-        message: 'Response failed contract validation',
+        message: details
+          ? `Response failed contract validation — ${details}`
+          : 'Response failed contract validation',
         body: parsed,
         rawBody: raw,
       })
diff --git a/apps/sim/lib/api/contracts/tables.ts b/apps/sim/lib/api/contracts/tables.ts
index c357cc585e8..73aa2a00fb1 100644
--- a/apps/sim/lib/api/contracts/tables.ts
+++ b/apps/sim/lib/api/contracts/tables.ts
@@ -13,7 +13,7 @@ import type {
   TableRow,
   TableRowsCursor,
 } from '@/lib/table'
-import { COLUMN_TYPES, NAME_PATTERN, TABLE_LIMITS } from '@/lib/table/constants'
+import { COLUMN_TYPES, MAX_SELECT_OPTIONS, NAME_PATTERN, TABLE_LIMITS } from '@/lib/table/constants'
 import { CSV_MAX_FILE_SIZE_BYTES } from '@/lib/table/import'
 
 export const domainObjectSchema = <T>() => z.custom<T>(isRecordLike)
@@ -24,6 +24,61 @@ export const domainObjectSchema = <T>() => z.custom<T>(isRecordLike)
  */
 export const columnTypeSchema = z.enum(COLUMN_TYPES)
 
+/** One choice in a `select` column. `id` is the stable cell key. */
+export const selectOptionSchema = z.object({
+  id: z.string().min(1, 'Option id is required'),
+  name: z
+    .string()
+    .min(1, 'Option name is required')
+    .max(100, 'Option name must be 100 characters or less'),
+})
+
+export const selectOptionsSchema = z
+  .array(selectOptionSchema)
+  .max(MAX_SELECT_OPTIONS, `A select column cannot have more than ${MAX_SELECT_OPTIONS} options`)
+
+/**
+ * Cross-field rule: a `select` column must declare a non-empty option set;
+ * other types must not carry options or `multiple`. Skipped when `type` is
+ * absent (an options-only update on an existing select column).
+ */
+function refineColumnOptions(
+  data: {
+    type?: (typeof COLUMN_TYPES)[number]
+    options?: z.infer<typeof selectOptionsSchema>
+    multiple?: boolean
+  },
+  ctx: z.RefinementCtx
+): void {
+  if (data.type === 'select') {
+    if (!data.options || data.options.length === 0) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['options'],
+        message: 'A select column must define at least one option',
+      })
+    }
+    return
+  }
+  if (data.type === undefined) return
+  if (data.options && data.options.length > 0) {
+    ctx.addIssue({
+      code: 'custom',
+      path: ['options'],
+      message: 'options are only allowed on select columns',
+    })
+  }
+  // `multiple` stored on a non-select column is inert until a later
+  // convert-to-select inherits it, silently producing a multiselect.
+  if (data.multiple) {
+    ctx.addIssue({
+      code: 'custom',
+      path: ['multiple'],
+      message: 'multiple is only allowed on select columns',
+    })
+  }
+}
+
 /**
  * Identifier for tables/columns: starts with letter or underscore, contains
  * only alphanumerics + underscores, capped at `MAX_TABLE_NAME_LENGTH`.
@@ -78,16 +133,22 @@ export const getTableQuerySchema = z.object({
   workspaceId: z.string().min(1, 'Workspace ID is required'),
 })
 
-export const tableColumnSchema = z.object({
-  /** Stable column id (server-assigned). Absent on legacy/ pre-backfill columns. */
-  id: z.string().optional(),
-  name: columnNameSchema,
-  type: columnTypeSchema,
-  required: z.boolean().optional().default(false),
-  unique: z.boolean().optional().default(false),
-  /** Set when the column is a workflow group's output. */
-  workflowGroupId: z.string().optional(),
-})
+export const tableColumnSchema = z
+  .object({
+    /** Stable column id (server-assigned). Absent on legacy/ pre-backfill columns. */
+    id: z.string().optional(),
+    name: columnNameSchema,
+    type: columnTypeSchema,
+    required: z.boolean().optional().default(false),
+    unique: z.boolean().optional().default(false),
+    /** Set when the column is a workflow group's output. */
+    workflowGroupId: z.string().optional(),
+    /** Declared options for a `select` column. */
+    options: selectOptionsSchema.optional(),
+    /** A `select` column that accepts multiple options per cell. */
+    multiple: z.boolean().optional(),
+  })
+  .superRefine(refineColumnOptions)
 
 export const createTableBodySchema = z.object({
   name: tableNameSchema,
@@ -112,27 +173,35 @@ export const renameTableBodySchema = z.object({
 
 export const createTableColumnBodySchema = z.object({
   workspaceId: z.string().min(1, 'Workspace ID is required'),
-  column: z.object({
-    // Optional stable id — first-party undo of a delete re-creates the column
-    // with its original id so saved (id-keyed) cell data restores correctly.
-    id: z.string().optional(),
-    name: columnNameSchema,
-    type: columnTypeSchema,
-    required: z.boolean().optional(),
-    unique: z.boolean().optional(),
-    position: z.number().int().min(0).optional(),
-  }),
+  column: z
+    .object({
+      // Optional stable id — first-party undo of a delete re-creates the column
+      // with its original id so saved (id-keyed) cell data restores correctly.
+      id: z.string().optional(),
+      name: columnNameSchema,
+      type: columnTypeSchema,
+      required: z.boolean().optional(),
+      unique: z.boolean().optional(),
+      position: z.number().int().min(0).optional(),
+      options: selectOptionsSchema.optional(),
+      multiple: z.boolean().optional(),
+    })
+    .superRefine(refineColumnOptions),
 })
 
 export const updateTableColumnBodySchema = z.object({
   workspaceId: z.string().min(1, 'Workspace ID is required'),
   columnName: columnNameSchema,
-  updates: z.object({
-    name: columnNameSchema.optional(),
-    type: columnTypeSchema.optional(),
-    required: z.boolean().optional(),
-    unique: z.boolean().optional(),
-  }),
+  updates: z
+    .object({
+      name: columnNameSchema.optional(),
+      type: columnTypeSchema.optional(),
+      required: z.boolean().optional(),
+      unique: z.boolean().optional(),
+      options: selectOptionsSchema.optional(),
+      multiple: z.boolean().optional(),
+    })
+    .superRefine(refineColumnOptions),
 })
 
 export const deleteTableColumnBodySchema = z.object({
diff --git a/apps/sim/lib/copilot/generated/tool-catalog-v1.ts b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
index 77fa9e44091..ab599c3cf6e 100644
--- a/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
+++ b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
@@ -4086,7 +4086,8 @@ export const UserTable: ToolCatalogEntry = {
           },
           column: {
             type: 'object',
-            description: 'Column definition for add_column: { name, type, unique?, position? }',
+            description:
+              'Column definition for add_column: { name, type, unique?, position? }. For a select (enum) column also pass { options: ["Open", "Closed"], multiple?: true } — options is a list of display names and is required for select.',
           },
           columnName: {
             type: 'string',
@@ -4200,6 +4201,11 @@ export const UserTable: ToolCatalogEntry = {
               "Import mode for import_file. 'append' (default) adds rows; 'replace' truncates existing rows in a transaction before inserting the new rows.",
             enum: ['append', 'replace'],
           },
+          multiple: {
+            type: 'boolean',
+            description:
+              'Whether a select (enum) cell may hold several options (default false). Switching an existing column from true to false fails if any row has more than one option selected.',
+          },
           name: {
             type: 'string',
             description:
@@ -4213,12 +4219,18 @@ export const UserTable: ToolCatalogEntry = {
           newType: {
             type: 'string',
             description:
-              'New column type (optional for update_column). Types: string, number, boolean, date, json',
+              "New column type (optional for update_column). Types: string, number, boolean, date, json, select. Converting a column to select also requires options; the conversion fails if any existing cell value doesn't match one of them.",
           },
           offset: {
             type: 'number',
             description: 'Number of rows to skip (optional for query_rows, default 0)',
           },
+          options: {
+            type: 'array',
+            description:
+              'Choices for a select (enum) column, as a list of display names, e.g. ["Open", "Closed"]. Required when creating or converting to a select column. On update_column this REPLACES the option list: options kept by name keep their cells, and cells holding a removed option are cleared. Max 100.',
+            items: { type: 'string' },
+          },
           outputColumnNames: {
             type: 'object',
             description:
@@ -4301,7 +4313,7 @@ export const UserTable: ToolCatalogEntry = {
           schema: {
             type: 'object',
             description:
-              "Table schema with columns array (required for 'create'). Each column: { name, type, unique? }",
+              'Table schema with columns array (required for \'create\'). Each column: { name, type, unique? }. A select (enum) column also takes { options: ["Open", "Closed"], multiple?: true } — options is a list of display names and is required for select.',
           },
           scope: {
             type: 'string',
diff --git a/apps/sim/lib/copilot/generated/tool-schemas-v1.ts b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
index 00646f08622..c7a5d93aac0 100644
--- a/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
+++ b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
@@ -3876,7 +3876,8 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             },
             column: {
               type: 'object',
-              description: 'Column definition for add_column: { name, type, unique?, position? }',
+              description:
+                'Column definition for add_column: { name, type, unique?, position? }. For a select (enum) column also pass { options: ["Open", "Closed"], multiple?: true } — options is a list of display names and is required for select.',
             },
             columnName: {
               type: 'string',
@@ -4003,6 +4004,11 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
                 "Import mode for import_file. 'append' (default) adds rows; 'replace' truncates existing rows in a transaction before inserting the new rows.",
               enum: ['append', 'replace'],
             },
+            multiple: {
+              type: 'boolean',
+              description:
+                'Whether a select (enum) cell may hold several options (default false). Switching an existing column from true to false fails if any row has more than one option selected.',
+            },
             name: {
               type: 'string',
               description:
@@ -4016,12 +4022,20 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             newType: {
               type: 'string',
               description:
-                'New column type (optional for update_column). Types: string, number, boolean, date, json',
+                "New column type (optional for update_column). Types: string, number, boolean, date, json, select. Converting a column to select also requires options; the conversion fails if any existing cell value doesn't match one of them.",
             },
             offset: {
               type: 'number',
               description: 'Number of rows to skip (optional for query_rows, default 0)',
             },
+            options: {
+              type: 'array',
+              description:
+                'Choices for a select (enum) column, as a list of display names, e.g. ["Open", "Closed"]. Required when creating or converting to a select column. On update_column this REPLACES the option list: options kept by name keep their cells, and cells holding a removed option are cleared. Max 100.',
+              items: {
+                type: 'string',
+              },
+            },
             outputColumnNames: {
               type: 'object',
               description:
@@ -4114,7 +4128,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             schema: {
               type: 'object',
               description:
-                "Table schema with columns array (required for 'create'). Each column: { name, type, unique? }",
+                'Table schema with columns array (required for \'create\'). Each column: { name, type, unique? }. A select (enum) column also takes { options: ["Open", "Closed"], multiple?: true } — options is a list of display names and is required for select.',
             },
             scope: {
               type: 'string',
diff --git a/apps/sim/lib/copilot/tools/handlers/function-execute.ts b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
index bc32699d66a..0fbb4cebafd 100644
--- a/apps/sim/lib/copilot/tools/handlers/function-execute.ts
+++ b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
@@ -4,7 +4,7 @@ import { resolveWorkflowAliasForWorkspace } from '@/lib/copilot/vfs/workflow-ali
 import { isPlanAliasPath, workflowAliasSandboxPath } from '@/lib/copilot/vfs/workflow-aliases'
 import { isFeatureEnabled } from '@/lib/core/config/feature-flags'
 import { getColumnId } from '@/lib/table/column-keys'
-import { formatCsvValue, neutralizeCsvFormula, toCsvRow } from '@/lib/table/export-format'
+import { formatCsvCell, neutralizeCsvFormula, toCsvRow } from '@/lib/table/export-format'
 import { queryRows } from '@/lib/table/rows/service'
 import { getTableById, listTables } from '@/lib/table/service'
 import { getOrCreateTableSnapshot, SNAPSHOT_MAX_BYTES } from '@/lib/table/snapshot-cache'
@@ -394,7 +394,7 @@ export async function resolveInputFiles(
       const csvLines = [toCsvRow(columns.map((column) => neutralizeCsvFormula(column.name)))]
       for (const row of rows.rows) {
         csvLines.push(
-          toCsvRow(columns.map((column) => formatCsvValue(row.data[getColumnId(column)])))
+          toCsvRow(columns.map((column) => formatCsvCell(column, row.data[getColumnId(column)])))
         )
       }
       const csvContent = csvLines.join('\n')
diff --git a/apps/sim/lib/copilot/tools/server/table/user-table.test.ts b/apps/sim/lib/copilot/tools/server/table/user-table.test.ts
index b7320df3254..8c515ef18f3 100644
--- a/apps/sim/lib/copilot/tools/server/table/user-table.test.ts
+++ b/apps/sim/lib/copilot/tools/server/table/user-table.test.ts
@@ -6,6 +6,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { TableDefinition } from '@/lib/table'
 
 const {
+  mockUpdateColumnType,
+  mockUpdateColumnOptions,
   mockResolveWorkspaceFileReference,
   mockDownloadWorkspaceFile,
   mockGetTableById,
@@ -25,6 +27,8 @@ const {
   mockRunTableUpdate,
   fakeEnrichment,
 } = vi.hoisted(() => ({
+  mockUpdateColumnType: vi.fn(),
+  mockUpdateColumnOptions: vi.fn(),
   mockResolveWorkspaceFileReference: vi.fn(),
   mockDownloadWorkspaceFile: vi.fn(),
   mockGetTableById: vi.fn(),
@@ -92,7 +96,8 @@ vi.mock('@/lib/table/columns/service', () => ({
   deleteColumns: vi.fn(),
   renameColumn: vi.fn(),
   updateColumnConstraints: vi.fn(),
-  updateColumnType: vi.fn(),
+  updateColumnType: mockUpdateColumnType,
+  updateColumnOptions: mockUpdateColumnOptions,
 }))
 
 vi.mock('@/lib/table/rows/service', () => ({
@@ -132,7 +137,10 @@ vi.mock('@/lib/table/billing', () => ({
   getWorkspaceTableLimits: mockGetWorkspaceTableLimits,
 }))
 
-import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
+import {
+  normalizeSelectOptionsInput,
+  userTableServerTool,
+} from '@/lib/copilot/tools/server/table/user-table'
 
 function buildTable(overrides: Partial<TableDefinition> = {}): TableDefinition {
   return {
@@ -163,6 +171,60 @@ async function flushDetached(): Promise<void> {
   await Promise.resolve()
 }
 
+describe('normalizeSelectOptionsInput', () => {
+  it('generates a stable id for a bare-name string option', () => {
+    const [opt] = normalizeSelectOptionsInput(['Open']) ?? []
+    expect(opt.name).toBe('Open')
+    expect(typeof opt.id).toBe('string')
+    expect(opt.id.length).toBeGreaterThan(0)
+  })
+
+  it('generates an id for an object option without one', () => {
+    const [opt] = normalizeSelectOptionsInput([{ name: 'Closed' }]) ?? []
+    expect(opt.name).toBe('Closed')
+    expect(opt.id.length).toBeGreaterThan(0)
+  })
+
+  it('preserves an explicitly supplied id', () => {
+    const result = normalizeSelectOptionsInput([{ id: 'opt_keep', name: 'Open' }])
+    expect(result).toEqual([{ id: 'opt_keep', name: 'Open' }])
+  })
+
+  it('reuses the id of an existing option with the same name', () => {
+    // The agent re-sends options as bare names on every edit. Minting fresh ids
+    // would orphan every cell holding them — silently clearing the column.
+    const existing = [
+      { id: 'opt_low', name: 'Low' },
+      { id: 'opt_high', name: 'High' },
+    ]
+    const result = normalizeSelectOptionsInput(['Low', 'Medium', 'High'], existing) ?? []
+
+    expect(result[0]).toEqual({ id: 'opt_low', name: 'Low' })
+    expect(result[2]).toEqual({ id: 'opt_high', name: 'High' })
+    // Only the genuinely new option gets a fresh id.
+    expect(result[1].name).toBe('Medium')
+    expect(result[1].id).not.toBe('opt_low')
+    expect(result[1].id).not.toBe('opt_high')
+  })
+
+  it('matches an existing option name case-insensitively', () => {
+    const result = normalizeSelectOptionsInput(['open'], [{ id: 'opt_open', name: 'Open' }]) ?? []
+    expect(result[0].id).toBe('opt_open')
+    expect(result[0].name).toBe('open')
+  })
+
+  it('mints a fresh id when there is no existing column to match against', () => {
+    const result = normalizeSelectOptionsInput(['Open']) ?? []
+    expect(result[0].id.length).toBeGreaterThan(0)
+    expect(result[0].name).toBe('Open')
+  })
+
+  it('returns undefined for a non-array (validation rejects it downstream)', () => {
+    expect(normalizeSelectOptionsInput(undefined)).toBeUndefined()
+    expect(normalizeSelectOptionsInput('Open')).toBeUndefined()
+  })
+})
+
 describe('userTableServerTool.import_file', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -1003,3 +1065,76 @@ describe('userTableServerTool.update_rows_by_filter', () => {
     expect(mockUpdateRowsByFilter).toHaveBeenCalledTimes(1)
   })
 })
+
+describe('userTableServerTool.update_column — select routing', () => {
+  const selectTable = buildTable({
+    schema: {
+      columns: [
+        {
+          id: 'col_status',
+          name: 'status',
+          type: 'select',
+          options: [{ id: 'opt_open', name: 'Open' }],
+        },
+      ],
+    },
+  })
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGetTableById.mockResolvedValue(selectTable)
+    mockUpdateColumnOptions.mockResolvedValue(selectTable)
+    mockUpdateColumnType.mockResolvedValue(selectTable)
+  })
+
+  it('routes an unchanged type with options to updateColumnOptions', async () => {
+    // `updateColumnType` early-returns when the type is unchanged, so routing
+    // there would silently drop the new option set and still report success.
+    await userTableServerTool.execute(
+      {
+        operation: 'update_column',
+        args: {
+          tableId: 'tbl_1',
+          columnName: 'status',
+          newType: 'select',
+          options: ['Open', 'Closed'],
+        },
+      },
+      { userId: 'user-1', workspaceId: 'workspace-1' } as never
+    )
+
+    expect(mockUpdateColumnType).not.toHaveBeenCalled()
+    expect(mockUpdateColumnOptions).toHaveBeenCalledTimes(1)
+    expect(
+      mockUpdateColumnOptions.mock.calls[0][0].options.map((o: { name: string }) => o.name)
+    ).toEqual(['Open', 'Closed'])
+  })
+
+  it('routes a genuine type change to updateColumnType', async () => {
+    await userTableServerTool.execute(
+      {
+        operation: 'update_column',
+        args: { tableId: 'tbl_1', columnName: 'status', newType: 'string' },
+      },
+      { userId: 'user-1', workspaceId: 'workspace-1' } as never
+    )
+
+    expect(mockUpdateColumnType).toHaveBeenCalledTimes(1)
+    expect(mockUpdateColumnOptions).not.toHaveBeenCalled()
+  })
+
+  it('accepts a multiple-only toggle by reusing the current options', async () => {
+    await userTableServerTool.execute(
+      {
+        operation: 'update_column',
+        args: { tableId: 'tbl_1', columnName: 'status', multiple: true },
+      },
+      { userId: 'user-1', workspaceId: 'workspace-1' } as never
+    )
+
+    expect(mockUpdateColumnOptions).toHaveBeenCalledTimes(1)
+    const arg = mockUpdateColumnOptions.mock.calls[0][0]
+    expect(arg.multiple).toBe(true)
+    expect(arg.options).toEqual([{ id: 'opt_open', name: 'Open' }])
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/table/user-table.ts b/apps/sim/lib/copilot/tools/server/table/user-table.ts
index 5f437d52ba0..aac6adf93e2 100644
--- a/apps/sim/lib/copilot/tools/server/table/user-table.ts
+++ b/apps/sim/lib/copilot/tools/server/table/user-table.ts
@@ -1,7 +1,7 @@
 import { AuditAction, AuditResourceType, recordAudit } from '@sim/audit'
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
-import { generateId } from '@sim/utils/id'
+import { generateId, generateShortId } from '@sim/utils/id'
 import { UserTable } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
@@ -26,11 +26,11 @@ import {
   TABLE_LIMITS,
   validateMapping,
 } from '@/lib/table'
+import { namedRowMapper } from '@/lib/table/cell-format'
 import {
   buildIdByName,
-  buildNameById,
+  columnMatchesRef,
   filterNamesToIds,
-  rowDataIdToName,
   rowDataNameToId,
   sortNamesToIds,
 } from '@/lib/table/column-keys'
@@ -41,6 +41,7 @@ import {
   deleteColumns,
   renameColumn,
   updateColumnConstraints,
+  updateColumnOptions,
   updateColumnType,
 } from '@/lib/table/columns/service'
 import { markTableDeleteFailed, runTableDelete } from '@/lib/table/delete-runner'
@@ -59,13 +60,16 @@ import {
   updateRow,
   updateRowsByFilter,
 } from '@/lib/table/rows/service'
+import { resolveFilterSelectValues } from '@/lib/table/select-values'
 import { createTable, deleteTable, getTableById, renameTable } from '@/lib/table/service'
 import type {
   ColumnDefinition,
   Filter,
   RowData,
+  SelectOption,
   TableDefinition,
   TableDeleteJobPayload,
+  TableSchema,
   TableUpdateJobPayload,
   WorkflowGroup,
   WorkflowGroupDependencies,
@@ -305,6 +309,50 @@ function limitError(limit: unknown): string | null {
   return null
 }
 
+/**
+ * Normalizes agent-authored `select` options into the stored `{ id, name }`
+ * shape. The copilot agent supplies option **names** (a bare string, or an
+ * object with a `name`); the stable option id is generated here so the model
+ * never authors the cell key. An entry that already carries a non-empty `id`
+ * (e.g. re-sending an existing option on an options edit) keeps it, so existing
+ * cell data survives the update. Non-array input returns `undefined`, letting
+ * downstream validation reject a malformed / missing option set.
+ */
+export function normalizeSelectOptionsInput(
+  raw: unknown,
+  existing: SelectOption[] = []
+): SelectOption[] | undefined {
+  if (!Array.isArray(raw)) return undefined
+  // Cells reference the option id, so an edit that re-sends the same option by
+  // name must reuse its id — minting a fresh one would orphan every cell
+  // holding it, silently clearing the column.
+  const idByName = new Map<string, string>()
+  for (const option of existing) {
+    const key = option.name.toLowerCase()
+    if (!idByName.has(key)) idByName.set(key, option.id)
+  }
+  const resolveId = (name: string): string => idByName.get(name.toLowerCase()) ?? generateShortId()
+
+  return raw.map((entry) => {
+    if (typeof entry === 'string') return { id: resolveId(entry), name: entry }
+    const e = (entry ?? {}) as { id?: unknown; name?: unknown }
+    const name = typeof e.name === 'string' ? e.name : String(e.name ?? '')
+    const id = typeof e.id === 'string' && e.id.length > 0 ? e.id : resolveId(name)
+    return { id, name }
+  })
+}
+
+/** Rewrites every `select` column's options in an agent-authored create schema. */
+function normalizeSchemaSelectColumns(schema: TableSchema): TableSchema {
+  if (!schema || !Array.isArray(schema.columns)) return schema
+  return {
+    ...schema,
+    columns: schema.columns.map((col) =>
+      col.type === 'select' ? { ...col, options: normalizeSelectOptionsInput(col.options) } : col
+    ),
+  }
+}
+
 async function batchInsertAll(
   tableId: string,
   rows: RowData[],
@@ -367,7 +415,8 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             {
               name: args.name,
               description: args.description,
-              schema: args.schema,
+              // Agent authors select options by name; generate their stable ids here.
+              schema: normalizeSchemaSelectColumns(args.schema as TableSchema),
               workspaceId,
               userId: context.userId,
               maxTables: planLimits.maxTables,
@@ -495,7 +544,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           assertNotAborted()
           // The LLM authors row data by column name; storage keys by id.
           const idByName = buildIdByName(table.schema)
-          const nameById = buildNameById(table.schema)
+          const toNamedRow = namedRowMapper(table.schema.columns)
           const row = await insertRow(
             {
               tableId: args.tableId,
@@ -511,7 +560,12 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           return {
             success: true,
             message: `Inserted row ${row.id}`,
-            data: { row: { ...row, data: rowDataIdToName(row.data, nameById) } },
+            data: {
+              row: {
+                ...row,
+                data: toNamedRow(row.data),
+              },
+            },
           }
         }
 
@@ -534,7 +588,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           const requestId = generateId().slice(0, 8)
           assertNotAborted()
           const idByName = buildIdByName(table.schema)
-          const nameById = buildNameById(table.schema)
+          const toNamedRow = namedRowMapper(table.schema.columns)
           const rows = await batchInsertRows(
             {
               tableId: args.tableId,
@@ -550,7 +604,10 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             success: true,
             message: `Inserted ${rows.length} rows`,
             data: {
-              rows: rows.map((r) => ({ ...r, data: rowDataIdToName(r.data, nameById) })),
+              rows: rows.map((r) => ({
+                ...r,
+                data: toNamedRow(r.data),
+              })),
               insertedCount: rows.length,
             },
           }
@@ -576,12 +633,15 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             return { success: false, message: `Row not found: ${args.rowId}` }
           }
 
-          const nameById = buildNameById(rowTable.schema)
+          const toNamedRow = namedRowMapper(rowTable.schema.columns)
           return {
             success: true,
             message: `Row ${row.id}`,
             data: {
-              row: { ...row, data: rowDataIdToName(row.data, nameById) },
+              row: {
+                ...row,
+                data: toNamedRow(row.data),
+              },
             },
           }
         }
@@ -606,14 +666,19 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
 
           const requestId = generateId().slice(0, 8)
           const idByName = buildIdByName(table.schema)
-          const nameById = buildNameById(table.schema)
+          const toNamedRow = namedRowMapper(table.schema.columns)
           // The model may request any number; we serve at most MAX_QUERY_LIMIT per page so a single
           // tool result can't drain a whole table. `totalCount` in the response signals truncation,
           // and the model pages with `offset`.
           const result = await queryRows(
             table,
             {
-              filter: args.filter ? filterNamesToIds(args.filter, idByName) : undefined,
+              filter: args.filter
+                ? resolveFilterSelectValues(
+                    filterNamesToIds(args.filter, idByName),
+                    table.schema.columns
+                  )
+                : undefined,
               sort: args.sort ? sortNamesToIds(args.sort, idByName) : undefined,
               limit:
                 args.limit !== undefined
@@ -630,7 +695,10 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             message: `Returned ${result.rows.length} of ${result.totalCount} rows`,
             data: {
               ...result,
-              rows: result.rows.map((r) => ({ ...r, data: rowDataIdToName(r.data, nameById) })),
+              rows: result.rows.map((r) => ({
+                ...r,
+                data: toNamedRow(r.data),
+              })),
             },
           }
         }
@@ -657,7 +725,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           const requestId = generateId().slice(0, 8)
           assertNotAborted()
           const idByName = buildIdByName(table.schema)
-          const nameById = buildNameById(table.schema)
+          const toNamedRow = namedRowMapper(table.schema.columns)
           const updatedRow = await updateRow(
             {
               tableId: args.tableId,
@@ -683,7 +751,12 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           return {
             success: true,
             message: `Updated row ${updatedRow.id}`,
-            data: { row: { ...updatedRow, data: rowDataIdToName(updatedRow.data, nameById) } },
+            data: {
+              row: {
+                ...updatedRow,
+                data: toNamedRow(updatedRow.data),
+              },
+            },
           }
         }
 
@@ -733,7 +806,10 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
 
           const requestId = generateId().slice(0, 8)
           const idByName = buildIdByName(table.schema)
-          const idFilter = filterNamesToIds(args.filter, idByName)
+          const idFilter = resolveFilterSelectValues(
+            filterNamesToIds(args.filter, idByName),
+            table.schema.columns
+          )
           const idData = rowDataNameToId(args.data, idByName)
 
           // Inline handles up to MAX_BULK_OPERATION_SIZE rows in one request; a larger operation
@@ -828,7 +904,10 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
 
           const requestId = generateId().slice(0, 8)
           const idByName = buildIdByName(table.schema)
-          const idFilter = filterNamesToIds(args.filter, idByName)
+          const idFilter = resolveFilterSelectValues(
+            filterNamesToIds(args.filter, idByName),
+            table.schema.columns
+          )
 
           // Inline handles up to MAX_BULK_OPERATION_SIZE rows; a larger delete (an explicit limit
           // above the cap, or unbounded "delete everything matching") hands off to the background
@@ -1392,6 +1471,8 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
                 type: string
                 unique?: boolean
                 position?: number
+                options?: unknown
+                multiple?: boolean
               }
             | undefined
           if (!col?.name || !col?.type) {
@@ -1406,7 +1487,12 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           }
           const requestId = generateId().slice(0, 8)
           assertNotAborted()
-          const updated = await addTableColumn(args.tableId, col, requestId)
+          // Agent authors select options by name; generate their stable ids here.
+          const columnToAdd =
+            col.type === 'select'
+              ? { ...col, options: normalizeSelectOptionsInput(col.options) }
+              : { ...col, options: undefined }
+          const updated = await addTableColumn(args.tableId, columnToAdd, requestId)
           return {
             success: true,
             message: `Added column "${col.name}" (${col.type}) to table`,
@@ -1498,10 +1584,17 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           }
           const newType = (args as Record<string, unknown>).newType as string | undefined
           const uniqFlag = (args as Record<string, unknown>).unique as boolean | undefined
-          if (newType === undefined && uniqFlag === undefined) {
+          const rawOptions = (args as Record<string, unknown>).options
+          const multiple = (args as Record<string, unknown>).multiple as boolean | undefined
+          if (
+            newType === undefined &&
+            uniqFlag === undefined &&
+            rawOptions === undefined &&
+            multiple === undefined
+          ) {
             return {
               success: false,
-              message: 'At least one of newType or unique must be provided',
+              message: 'At least one of newType, unique, options, or multiple must be provided',
             }
           }
           const tableForUpdate = await getTableById(args.tableId)
@@ -1509,23 +1602,65 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             return { success: false, message: `Table not found: ${args.tableId}` }
           }
           const requestId = generateId().slice(0, 8)
+          // The agent authors options by name; mint ids here, reusing the id of
+          // any option whose name already exists so its cells survive the edit.
+          const currentColumn = tableForUpdate.schema.columns.find((c) =>
+            columnMatchesRef(c, colName)
+          )
+          const existingOptions = currentColumn?.options ?? []
+          const options = normalizeSelectOptionsInput(rawOptions, existingOptions)
+          // An agent restating the current type alongside new options must not
+          // go through `updateColumnType` — it early-returns on an unchanged
+          // type and would drop them. Mirrors the HTTP columns route.
+          const typeChanging = newType !== undefined && newType !== currentColumn?.type
           let result: TableDefinition | undefined
-          if (newType !== undefined) {
-            if (!(COLUMN_TYPES as readonly string[]).includes(newType)) {
-              return {
-                success: false,
-                message: `Invalid column type "${newType}". Must be one of: ${COLUMN_TYPES.join(', ')}`,
-              }
+          if (newType !== undefined && !(COLUMN_TYPES as readonly string[]).includes(newType)) {
+            return {
+              success: false,
+              message: `Invalid column type "${newType}". Must be one of: ${COLUMN_TYPES.join(', ')}`,
             }
+          }
+          // Each write below is its own locked transaction, so pairing any of
+          // them with a constraint write that is going to fail commits and then
+          // errors. Gate on the type the column ENDS UP with — an options-only
+          // update on an existing select column carries the same hazard as a
+          // conversion. Same guard the HTTP column routes apply.
+          const resultingType = newType ?? currentColumn?.type
+          if (uniqFlag === true && resultingType === 'select') {
+            return {
+              success: false,
+              message: `Cannot set column "${colName}" as unique: select columns cannot be unique.`,
+            }
+          }
+          if (typeChanging) {
             assertNotAborted()
             result = await updateColumnType(
               {
                 tableId: args.tableId,
                 columnName: colName,
                 newType: newType as (typeof COLUMN_TYPES)[number],
+                options,
+                multiple,
               },
               requestId
             )
+          } else if (options !== undefined || multiple !== undefined) {
+            // Editing an existing select column's option set / mode without a
+            // type change. `multiple` alone is a valid update — the catalog
+            // documents it as independent — so fall back to the column's current
+            // options rather than demanding the caller resend the whole list.
+            const nextOptions = options ?? existingOptions
+            if (nextOptions.length === 0) {
+              return {
+                success: false,
+                message: `Column "${colName}" is not a select column. Pass newType: "select" with options to convert it.`,
+              }
+            }
+            assertNotAborted()
+            result = await updateColumnOptions(
+              { tableId: args.tableId, columnName: colName, options: nextOptions, multiple },
+              requestId
+            )
           }
           if (uniqFlag !== undefined) {
             assertNotAborted()
@@ -1537,7 +1672,9 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           return {
             success: true,
             message: `Updated column "${colName}"`,
-            data: { schema: result?.schema },
+            // A payload that only restates the current type is a no-op; still
+            // report the live schema rather than an undefined one.
+            data: { schema: (result ?? tableForUpdate).schema },
           }
         }
 
diff --git a/apps/sim/lib/table/__tests__/cell-format.test.ts b/apps/sim/lib/table/__tests__/cell-format.test.ts
new file mode 100644
index 00000000000..08033570473
--- /dev/null
+++ b/apps/sim/lib/table/__tests__/cell-format.test.ts
@@ -0,0 +1,177 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  fillMissingColumns,
+  formatCellValue,
+  mapInputValues,
+  namedRowMapper,
+} from '@/lib/table/cell-format'
+import type { ColumnDefinition } from '@/lib/table/types'
+
+const status: ColumnDefinition = {
+  id: 'col_status',
+  name: 'Status',
+  type: 'select',
+  options: [
+    { id: 'opt_open', name: 'Open' },
+    { id: 'opt_closed', name: 'Closed' },
+  ],
+}
+
+const tags: ColumnDefinition = {
+  id: 'col_tags',
+  name: 'Tags',
+  type: 'select',
+  multiple: true,
+  options: [
+    { id: 'opt_a', name: 'Alpha' },
+    { id: 'opt_b', name: 'Beta' },
+  ],
+}
+
+const title: ColumnDefinition = { id: 'col_title', name: 'Title', type: 'string' }
+const count: ColumnDefinition = { id: 'col_count', name: 'Count', type: 'number' }
+const done: ColumnDefinition = { id: 'col_done', name: 'Done', type: 'boolean' }
+const due: ColumnDefinition = { id: 'col_due', name: 'Due', type: 'date' }
+const meta: ColumnDefinition = { id: 'col_meta', name: 'Meta', type: 'json' }
+
+describe('formatCellValue — select', () => {
+  it('resolves a single option id to its name', () => {
+    expect(formatCellValue('opt_open', status)).toBe('Open')
+  })
+
+  it('resolves multi option ids to names in selection order', () => {
+    expect(formatCellValue(['opt_b', 'opt_a'], tags)).toEqual(['Beta', 'Alpha'])
+  })
+
+  it('drops an id whose option was deleted', () => {
+    expect(formatCellValue('gone', status)).toBeNull()
+    expect(formatCellValue(['opt_a', 'gone'], tags)).toEqual(['Alpha'])
+  })
+
+  it('renders an unset cell as null (single) and [] (multi)', () => {
+    expect(formatCellValue(null, status)).toBeNull()
+    expect(formatCellValue([], tags)).toEqual([])
+  })
+})
+
+describe('formatCellValue — identity for non-select types', () => {
+  // `rawRow` is documented public trigger output; these must pass through
+  // byte-identical or deployed workflows break.
+  it('passes through string, number, boolean, date and json untouched', () => {
+    const json = { nested: { a: 1 } }
+    expect(formatCellValue('hello', title)).toBe('hello')
+    expect(formatCellValue(-5, count)).toBe(-5)
+    expect(formatCellValue(false, done)).toBe(false)
+    expect(formatCellValue('2026-07-06T16:04:55-07:00', due)).toBe('2026-07-06T16:04:55-07:00')
+    expect(formatCellValue('2026-07-06', due)).toBe('2026-07-06')
+    expect(formatCellValue(json, meta)).toBe(json)
+  })
+
+  it('passes a json column holding a plain string through unquoted', () => {
+    expect(formatCellValue('https://example.com', meta)).toBe('https://example.com')
+  })
+
+  it('passes null and undefined through', () => {
+    expect(formatCellValue(null, title)).toBeNull()
+    expect(formatCellValue(undefined, title)).toBeUndefined()
+  })
+})
+
+describe('namedRowMapper', () => {
+  const toNamed = namedRowMapper([title, status, tags])
+
+  it('translates keys and select values in one pass', () => {
+    expect(
+      toNamed({ col_title: 'Login broken', col_status: 'opt_open', col_tags: ['opt_a'] })
+    ).toEqual({ Title: 'Login broken', Status: 'Open', Tags: ['Alpha'] })
+  })
+
+  it('drops keys with no matching column', () => {
+    expect(toNamed({ col_title: 'x', col_deleted: 'orphan' })).toEqual({ Title: 'x' })
+  })
+
+  it('omits absent columns rather than filling them', () => {
+    expect(toNamed({ col_title: 'x' })).toEqual({ Title: 'x' })
+  })
+
+  it('round-trips a name through id keying', () => {
+    expect(toNamed({ col_title: 'x' })).toHaveProperty('Title')
+  })
+
+  it('translates only the columns it was built with', () => {
+    const partial = namedRowMapper([title])
+    expect(partial({ col_title: 'x', col_status: 'opt_open' })).toEqual({ Title: 'x' })
+  })
+})
+
+describe('fillMissingColumns', () => {
+  const columns = [title, status, tags]
+
+  it('emits one entry per column, absent ones as null', () => {
+    expect(fillMissingColumns({ Title: 'x' }, columns)).toEqual({
+      Title: 'x',
+      Status: null,
+      Tags: null,
+    })
+  })
+
+  it('fills an absent multiselect with null, not an empty array', () => {
+    // `[]` is not treated as empty by downstream emptiness checks, so filling
+    // with it would change which rows enrichment skips.
+    expect(fillMissingColumns({}, [tags]).Tags).toBeNull()
+  })
+
+  it('preserves already-present values including falsy ones', () => {
+    expect(fillMissingColumns({ Title: '', Status: 'Open' }, columns)).toEqual({
+      Title: '',
+      Status: 'Open',
+      Tags: null,
+    })
+  })
+
+  it('is a superset of the sparse row it widens', () => {
+    const toNamed = namedRowMapper(columns)
+    const sparse = toNamed({ col_title: 'x', col_status: 'opt_open' })
+    const dense = fillMissingColumns(sparse, columns)
+    for (const [key, value] of Object.entries(sparse)) expect(dense[key]).toEqual(value)
+    expect(Object.keys(dense)).toEqual(columns.map((c) => c.name))
+  })
+})
+
+describe('mapInputValues', () => {
+  const columns = [title, status, tags]
+
+  it('resolves mappings keyed by column id to outward values', () => {
+    expect(
+      mapInputValues({ col_status: 'opt_open', col_title: 'x' }, columns, [
+        { inputName: 'state', columnName: 'col_status' },
+        { inputName: 'name', columnName: 'col_title' },
+      ])
+    ).toEqual({ state: 'Open', name: 'x' })
+  })
+
+  it('skips a mapping whose column no longer exists', () => {
+    expect(
+      mapInputValues({ col_title: 'x' }, columns, [
+        { inputName: 'gone', columnName: 'col_deleted' },
+      ])
+    ).toEqual({})
+  })
+
+  it('leaves an absent cell undefined rather than formatting it', () => {
+    // An absent multiselect must not become `[]` — callers' required-input
+    // emptiness checks treat `[]` as present, which would run enrichments on
+    // rows they currently skip.
+    const out = mapInputValues({}, columns, [
+      { inputName: 'state', columnName: 'col_status' },
+      { inputName: 'labels', columnName: 'col_tags' },
+      { inputName: 'name', columnName: 'col_title' },
+    ])
+    expect(out.state).toBeUndefined()
+    expect(out.labels).toBeUndefined()
+    expect(out.name).toBeUndefined()
+  })
+})
diff --git a/apps/sim/lib/table/__tests__/column-conversion.test.ts b/apps/sim/lib/table/__tests__/column-conversion.test.ts
new file mode 100644
index 00000000000..71726cf00e0
--- /dev/null
+++ b/apps/sim/lib/table/__tests__/column-conversion.test.ts
@@ -0,0 +1,115 @@
+/**
+ * @vitest-environment node
+ *
+ * Guards for the select column-type conversion rules. These paths had no
+ * coverage and every case below was a shipped defect caught in review.
+ */
+import { describe, expect, it } from 'vitest'
+import { isValueCompatibleWithType, selectValueForConversion } from '@/lib/table/columns/service'
+import type { ColumnDefinition, SelectOption } from '@/lib/table/types'
+
+const OPTIONS: SelectOption[] = [
+  { id: 'opt_a', name: 'Alpha' },
+  { id: 'opt_b', name: 'Beta' },
+]
+
+const single: ColumnDefinition = {
+  id: 'col_s',
+  name: 'status',
+  type: 'select',
+  options: OPTIONS,
+}
+const multi: ColumnDefinition = { ...single, id: 'col_m', multiple: true }
+
+describe('selectValueForConversion', () => {
+  it('resolves a single option id to its name', () => {
+    expect(selectValueForConversion(single, 'opt_a')).toBe('Alpha')
+  })
+
+  it('joins a multiselect into one string', () => {
+    expect(selectValueForConversion(multi, ['opt_a', 'opt_b'])).toBe('Alpha, Beta')
+  })
+
+  it('nulls an empty or fully-orphaned selection', () => {
+    expect(selectValueForConversion(multi, [])).toBeNull()
+    expect(selectValueForConversion(multi, ['gone'])).toBeNull()
+    expect(selectValueForConversion(single, 'gone')).toBeNull()
+  })
+})
+
+describe('isValueCompatibleWithType — empty strings', () => {
+  it('does not let an empty string satisfy a numeric target', () => {
+    // Regression: '' was briefly compatible with EVERY type, so a text column
+    // with blank cells could convert to number and strand them.
+    expect(isValueCompatibleWithType('', 'number')).toBe(false)
+    expect(isValueCompatibleWithType('', 'boolean')).toBe(false)
+    expect(isValueCompatibleWithType('', 'date')).toBe(false)
+  })
+
+  it('still allows a cleared select cell to convert', () => {
+    expect(isValueCompatibleWithType('', 'select', OPTIONS)).toBe(true)
+  })
+})
+
+describe('isValueCompatibleWithType — select cardinality', () => {
+  it('rejects several options for a single-select target', () => {
+    expect(isValueCompatibleWithType(['opt_a', 'opt_b'], 'select', OPTIONS, false)).toBe(false)
+  })
+
+  it('accepts several options for a multi-select target', () => {
+    expect(isValueCompatibleWithType(['opt_a', 'opt_b'], 'select', OPTIONS, true)).toBe(true)
+  })
+
+  it('accepts a lone option either way', () => {
+    expect(isValueCompatibleWithType(['opt_a'], 'select', OPTIONS, false)).toBe(true)
+    expect(isValueCompatibleWithType('opt_a', 'select', OPTIONS, false)).toBe(true)
+  })
+
+  it('rejects a value that is not a declared option', () => {
+    expect(isValueCompatibleWithType('gone', 'select', OPTIONS, false)).toBe(false)
+  })
+
+  it('round-trips a multiselect through text', () => {
+    // multiselect → string flattens to `Alpha, Beta`; converting back must read
+    // that the same way the write-path coercion does, not as one unknown option.
+    const flattened = selectValueForConversion(multi, ['opt_a', 'opt_b'])
+    expect(flattened).toBe('Alpha, Beta')
+    expect(isValueCompatibleWithType(flattened, 'select', OPTIONS, true)).toBe(true)
+    // A single-select target genuinely can't hold both.
+    expect(isValueCompatibleWithType(flattened, 'select', OPTIONS, false)).toBe(false)
+  })
+
+  it('rejects a blank source value when the target select is required', () => {
+    // `required` only rejects null/undefined on a write, so a required string
+    // column legitimately holds ''. Converting it stores null (or [] for a
+    // multi), which would then fail that column's own required check on the
+    // next update of the row.
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, false, true)).toBe(false)
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, true, true)).toBe(false)
+    // Optional target is unchanged — a cleared cell stays convertible.
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, false, false)).toBe(true)
+  })
+
+  it('still rejects a comma string holding an undeclared option', () => {
+    expect(isValueCompatibleWithType('Alpha, Gone', 'select', OPTIONS, true)).toBe(false)
+  })
+})
+
+describe('isValueCompatibleWithType — string target', () => {
+  it('rejects structured values that text cannot represent', () => {
+    expect(isValueCompatibleWithType(['opt_a'], 'string')).toBe(false)
+    expect(isValueCompatibleWithType({ a: 1 }, 'string')).toBe(false)
+  })
+
+  it('accepts primitives', () => {
+    expect(isValueCompatibleWithType('Alpha', 'string')).toBe(true)
+    expect(isValueCompatibleWithType(42, 'string')).toBe(true)
+    expect(isValueCompatibleWithType(true, 'string')).toBe(true)
+  })
+
+  it('accepts a multiselect once flattened for conversion', () => {
+    // This is the pairing updateColumnType relies on: flatten, then check.
+    const flattened = selectValueForConversion(multi, ['opt_a', 'opt_b'])
+    expect(isValueCompatibleWithType(flattened, 'string')).toBe(true)
+  })
+})
diff --git a/apps/sim/lib/table/__tests__/column-keys.test.ts b/apps/sim/lib/table/__tests__/column-keys.test.ts
index 08832e09906..493858e68f7 100644
--- a/apps/sim/lib/table/__tests__/column-keys.test.ts
+++ b/apps/sim/lib/table/__tests__/column-keys.test.ts
@@ -11,6 +11,7 @@ vi.mock('@sim/utils/id', () => ({
   generateId: mockGenerateId,
 }))
 
+import { namedRowMapper } from '@/lib/table/cell-format'
 import {
   buildIdByName,
   buildNameById,
@@ -18,7 +19,6 @@ import {
   generateColumnId,
   getColumnId,
   remapGroupColumnRefs,
-  rowDataIdToName,
   rowDataNameToId,
   sortNamesToIds,
   withGeneratedColumnIds,
@@ -71,18 +71,19 @@ describe('row data translation', () => {
     ],
   }
   const idByName = buildIdByName(schema)
-  const nameById = buildNameById(schema)
+  // The outbound half lives in `cell-format` (it also translates select values).
+  const toNamedRow = namedRowMapper(schema.columns)
 
   it('round-trips name → id → name', () => {
     const wire = { email: 'a@b.c', age: 30 }
     const stored = rowDataNameToId(wire, idByName)
     expect(stored).toEqual({ col_1: 'a@b.c', age: 30 })
-    expect(rowDataIdToName(stored, nameById)).toEqual(wire)
+    expect(toNamedRow(stored)).toEqual(wire)
   })
 
   it('drops keys with no matching column (orphans / unknowns)', () => {
     expect(rowDataNameToId({ email: 'x', ghost: 1 }, idByName)).toEqual({ col_1: 'x' })
-    expect(rowDataIdToName({ col_1: 'x', col_gone: 9 }, nameById)).toEqual({ email: 'x' })
+    expect(toNamedRow({ col_1: 'x', col_gone: 9 })).toEqual({ email: 'x' })
   })
 })
 
diff --git a/apps/sim/lib/table/__tests__/find-row-matches.test.ts b/apps/sim/lib/table/__tests__/find-row-matches.test.ts
index 076a50686df..ce76c12932a 100644
--- a/apps/sim/lib/table/__tests__/find-row-matches.test.ts
+++ b/apps/sim/lib/table/__tests__/find-row-matches.test.ts
@@ -38,7 +38,7 @@ vi.mock('@/lib/table/validation', () => ({
   checkBatchUniqueConstraintsDb: vi.fn(async () => ({ valid: true, errors: [] })),
 }))
 
-import { findRowMatches } from '@/lib/table/rows/service'
+import { buildSelectFindNameExpr, findRowMatches } from '@/lib/table/rows/service'
 import { buildFilterClause, buildSortClause } from '@/lib/table/sql'
 
 const COLUMNS: ColumnDefinition[] = [
@@ -113,3 +113,51 @@ describe('findRowMatches', () => {
     expect(buildSortClause).toHaveBeenCalledWith({ name: 'asc' }, expect.any(String), COLUMNS)
   })
 })
+
+describe('buildSelectFindNameExpr', () => {
+  const options = [{ id: 'opt_a', name: 'Alpha' }]
+
+  it('gates the array expansion on the cell actually being an array', () => {
+    // `jsonb_array_elements_text` throws "cannot extract elements from a scalar"
+    // on a JSON null — which is what a cleared/cut multiselect cell holds — so an
+    // unguarded expansion took down Find for the whole table. Verified against
+    // Postgres; this asserts the guard survives in the emitted SQL.
+    const expr = buildSelectFindNameExpr([
+      { id: 'tags', name: 'tags', type: 'select', multiple: true, options },
+    ]) as string
+    expect(expr).toContain("jsonb_typeof(o.data->'tags') = 'array'")
+    const guardAt = expr.indexOf("jsonb_typeof(o.data->'tags') = 'array'")
+    const expandAt = expr.indexOf('jsonb_array_elements_text')
+    expect(guardAt).toBeGreaterThan(-1)
+    expect(expandAt).toBeGreaterThan(guardAt)
+  })
+
+  it('joins multiselect names in stored order', () => {
+    // Sort and export both spell the ordering out via WITH ORDINALITY; Find has
+    // to agree or a search for the label the grid shows can miss the row.
+    const expr = buildSelectFindNameExpr([
+      { id: 'tags', name: 'tags', type: 'select', multiple: true, options },
+    ]) as string
+    expect(expr).toContain('WITH ORDINALITY')
+    expect(expr).toContain("', ' ORDER BY e.ord")
+  })
+
+  it('keeps a scalar left over from a single→multi toggle searchable', () => {
+    const expr = buildSelectFindNameExpr([
+      { id: 'tags', name: 'tags', type: 'select', multiple: true, options },
+    ]) as string
+    // The non-array arm falls back to the single mapping rather than NULL.
+    expect(expr).toContain("CASE kv.value WHEN 'opt_a' THEN 'Alpha' ELSE kv.value END")
+  })
+
+  it('needs no expansion for a single-select column', () => {
+    const expr = buildSelectFindNameExpr([
+      { id: 'status', name: 'status', type: 'select', options },
+    ]) as string
+    expect(expr).not.toContain('jsonb_array_elements_text')
+  })
+
+  it('returns null when the schema has no select columns', () => {
+    expect(buildSelectFindNameExpr(COLUMNS)).toBeNull()
+  })
+})
diff --git a/apps/sim/lib/table/__tests__/sql.test.ts b/apps/sim/lib/table/__tests__/sql.test.ts
index ca293848779..367a9eb1704 100644
--- a/apps/sim/lib/table/__tests__/sql.test.ts
+++ b/apps/sim/lib/table/__tests__/sql.test.ts
@@ -13,7 +13,17 @@
  * substrings like `::timestamptz` against the generated SQL.
  */
 import { describe, expect, it } from 'vitest'
-import { buildFilterClause, buildSortClause } from '@/lib/table/sql'
+import {
+  MULTI_SELECT_FILTER_OPERATORS,
+  SINGLE_SELECT_FILTER_OPERATORS,
+  UI_TO_WIRE_OPERATOR,
+} from '@/lib/table/query-builder/constants'
+import {
+  buildFilterClause,
+  buildSortClause,
+  MULTI_SELECT_OPERATORS,
+  SINGLE_SELECT_OPERATORS,
+} from '@/lib/table/sql'
 import type { ColumnDefinition, Filter, Sort } from '@/lib/table/types'
 
 type SqlNode =
@@ -427,6 +437,128 @@ describe('SQL Builder', () => {
     })
   })
 
+  describe('select columns', () => {
+    const statusCol: ColumnDefinition = {
+      id: 'status',
+      name: 'status',
+      type: 'select',
+      options: [
+        { id: 'opt_open', name: 'Open' },
+        { id: 'opt_closed', name: 'Closed' },
+      ],
+    }
+    const tagsCol: ColumnDefinition = {
+      id: 'tags',
+      name: 'tags',
+      type: 'select',
+      multiple: true,
+      options: [{ id: 'opt_a', name: 'Alpha' }],
+    }
+
+    it('filters a select by option id via containment', () => {
+      const out = render(buildFilterClause({ status: 'opt_open' }, TABLE, [statusCol]))
+      expect(out).toContain('user_table_rows.data @>')
+      expect(out).toContain('"status":"opt_open"')
+    })
+
+    it('rejects a range operator on a select column', () => {
+      expect(() => buildFilterClause({ status: { $gt: 'opt_open' } }, TABLE, [statusCol])).toThrow(
+        'not supported on select'
+      )
+    })
+
+    it('rejects a pattern operator on a select column', () => {
+      expect(() =>
+        buildFilterClause({ status: { $contains: 'Open' } }, TABLE, [statusCol])
+      ).toThrow('not supported on select')
+    })
+
+    it('treats a multiselect empty array as $empty', () => {
+      const out = render(buildFilterClause({ tags: { $empty: true } }, TABLE, [tagsCol]))
+      expect(out).toContain("= '[]'")
+    })
+
+    it('filters a multiselect by ARRAY membership, not scalar equality', () => {
+      // `{"tags":["opt_a"]} @> {"tags":"opt_a"}` is FALSE in Postgres — the
+      // operand has to be wrapped or the filter silently matches nothing.
+      const out = render(buildFilterClause({ tags: { $contains: 'opt_a' } }, TABLE, [tagsCol]))
+      expect(out).toContain('user_table_rows.data @>')
+      expect(out).toContain('"tags":["opt_a"]')
+      expect(out).not.toContain('"tags":"opt_a"')
+      expect(out).not.toContain('ILIKE')
+    })
+
+    it('negates multiselect membership for $ncontains', () => {
+      const out = render(buildFilterClause({ tags: { $ncontains: 'opt_a' } }, TABLE, [tagsCol]))
+      expect(out).toContain('NOT (')
+      expect(out).toContain('"tags":["opt_a"]')
+    })
+
+    it('rejects explicit equality on a multiselect — it could never match', () => {
+      expect(() => buildFilterClause({ tags: { $eq: 'opt_a' } }, TABLE, [tagsCol])).toThrow(
+        'not supported on multi-select'
+      )
+    })
+
+    it('reads the equality shorthand on a multiselect as membership', () => {
+      // The shorthand bypasses the operator whitelist, so it has to compile to
+      // membership itself or it silently matches nothing.
+      const out = render(buildFilterClause({ tags: 'opt_a' }, TABLE, [tagsCol]))
+      expect(out).toContain('"tags":["opt_a"]')
+    })
+
+    it('rejects membership operators on a single select', () => {
+      expect(() =>
+        buildFilterClause({ status: { $contains: 'opt_open' } }, TABLE, [statusCol])
+      ).toThrow('not supported on select')
+    })
+
+    it('still uses ILIKE for $contains on a plain string column', () => {
+      const strCol: ColumnDefinition = { id: 'name', name: 'name', type: 'string' }
+      const out = render(buildFilterClause({ name: { $contains: 'jo' } }, TABLE, [strCol]))
+      expect(out).toContain('ILIKE')
+    })
+
+    it('sorts a select column alphabetically by option name via CASE', () => {
+      const out = render(buildSortClause({ status: 'asc' }, TABLE, [statusCol]))
+      expect(out).toContain('CASE')
+      expect(out).toContain("WHEN 'opt_open' THEN 'Open'")
+      expect(out).toContain("WHEN 'opt_closed' THEN 'Closed'")
+      expect(out.trim().endsWith('ASC NULLS LAST')).toBe(true)
+    })
+
+    it('sorts a multiselect by its option names, not the raw id array', () => {
+      // A multi cell extracts as `["opt_b","opt_a"]`, which matches no single-id
+      // CASE branch — without the array arm it would order on that opaque text.
+      const out = render(buildSortClause({ tags: 'asc' }, TABLE, [tagsCol]))
+      expect(out).toContain('jsonb_array_elements_text')
+      expect(out).toContain('string_agg')
+      expect(out).toContain('ORDER BY e.ord')
+      // The scalar arm survives for values left over from a single→multi toggle.
+      expect(out).toContain('CASE')
+      expect(out.trim().endsWith('ASC NULLS LAST')).toBe(true)
+    })
+  })
+
+  describe('select operator whitelists stay in step with the filter UI', () => {
+    // The picker offers exactly the UI set and `pruneFilterForColumns` DROPS
+    // anything outside it, so a UI set narrower than the server's silently
+    // discards a filter the server would have accepted (this shipped: `in`/`nin`
+    // were missing from the single-select set). Assert the mapping instead of
+    // trusting the two lists to be kept in sync by hand.
+    const toWire = (op: string) => UI_TO_WIRE_OPERATOR[op] ?? `$${op}`
+
+    it('single-select UI operators map onto the server whitelist exactly', () => {
+      const mapped = new Set([...SINGLE_SELECT_FILTER_OPERATORS].map(toWire))
+      expect(mapped).toEqual(SINGLE_SELECT_OPERATORS)
+    })
+
+    it('multi-select UI operators map onto the server whitelist exactly', () => {
+      const mapped = new Set([...MULTI_SELECT_FILTER_OPERATORS].map(toWire))
+      expect(mapped).toEqual(MULTI_SELECT_OPERATORS)
+    })
+  })
+
   describe('Field name validation', () => {
     it('accepts valid identifiers', () => {
       const valid = ['name', 'user_id', '_private', 'Count123', 'a']
diff --git a/apps/sim/lib/table/__tests__/trigger.test.ts b/apps/sim/lib/table/__tests__/trigger.test.ts
new file mode 100644
index 00000000000..64b5c4afc5e
--- /dev/null
+++ b/apps/sim/lib/table/__tests__/trigger.test.ts
@@ -0,0 +1,212 @@
+/**
+ * @vitest-environment node
+ *
+ * `fireTableTrigger` is fire-and-forget — it swallows every error (trigger.ts).
+ * An `expect` thrown inside a mock would therefore be silently eaten and the
+ * test would pass green, so every assertion runs on the captured payload AFTER
+ * the `await`, never inside a mock factory.
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockFetchActiveWebhooks, mockProcessPolledWebhookEvent } = vi.hoisted(() => ({
+  mockFetchActiveWebhooks: vi.fn(),
+  mockProcessPolledWebhookEvent: vi.fn(),
+}))
+
+vi.mock('@/lib/webhooks/polling/utils', () => ({
+  fetchActiveWebhooks: mockFetchActiveWebhooks,
+}))
+vi.mock('@/lib/webhooks/processor', () => ({
+  processPolledWebhookEvent: mockProcessPolledWebhookEvent,
+}))
+
+import { fireTableTrigger } from '@/lib/table/trigger'
+import type { RowData, TableSchema } from '@/lib/table/types'
+
+const schema: TableSchema = {
+  columns: [
+    { id: 'col_title', name: 'Title', type: 'string' },
+    {
+      id: 'col_status',
+      name: 'Status',
+      type: 'select',
+      options: [
+        { id: 'opt_open', name: 'Open' },
+        { id: 'opt_closed', name: 'Closed' },
+      ],
+    },
+    {
+      id: 'col_tags',
+      name: 'Tags',
+      type: 'select',
+      multiple: true,
+      options: [
+        { id: 'opt_a', name: 'Alpha' },
+        { id: 'opt_b', name: 'Beta' },
+      ],
+    },
+  ],
+}
+
+interface Payload {
+  row: Record<string, unknown> | null
+  rawRow: Record<string, unknown>
+  previousRow: Record<string, unknown> | null
+  changedColumns: string[]
+  headers: string[]
+  rowId: string
+}
+
+function webhookEntry(config: Record<string, unknown> = {}) {
+  return {
+    webhook: { id: 'wh_1', providerConfig: { tableId: 'tbl_1', eventType: 'insert', ...config } },
+    workflow: { id: 'wf_1' },
+  }
+}
+
+function firedPayloads(): Payload[] {
+  return mockProcessPolledWebhookEvent.mock.calls.map((call) => call[2] as Payload)
+}
+
+async function fire(
+  eventType: 'insert' | 'update',
+  data: RowData,
+  oldRows: Map<string, RowData> | null = null
+) {
+  await fireTableTrigger(
+    'tbl_1',
+    'Issues',
+    eventType,
+    [{ id: 'row_1', data } as never],
+    oldRows,
+    schema,
+    'req_1'
+  )
+}
+
+describe('fireTableTrigger — select values', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockProcessPolledWebhookEvent.mockResolvedValue({ success: true })
+    mockFetchActiveWebhooks.mockResolvedValue([webhookEntry()])
+  })
+
+  it('emits option names, not stored option ids, in row and rawRow', async () => {
+    await fire('insert', { col_title: 'Login broken', col_status: 'opt_open', col_tags: ['opt_a'] })
+
+    const [payload] = firedPayloads()
+    expect(payload.rawRow).toEqual({
+      Title: 'Login broken',
+      Status: 'Open',
+      Tags: ['Alpha'],
+    })
+    expect(payload.row).toEqual({ Title: 'Login broken', Status: 'Open', Tags: ['Alpha'] })
+  })
+
+  it('emits option names in previousRow on an update', async () => {
+    mockFetchActiveWebhooks.mockResolvedValue([webhookEntry({ eventType: 'update' })])
+    await fire(
+      'update',
+      { col_status: 'opt_closed' },
+      new Map([['row_1', { col_status: 'opt_open' }]])
+    )
+
+    const [payload] = firedPayloads()
+    expect(payload.previousRow).toEqual({ Status: 'Open' })
+    expect(payload.rawRow).toEqual({ Status: 'Closed' })
+  })
+
+  it('drops an option id whose option was deleted', async () => {
+    await fire('insert', { col_status: 'opt_gone' })
+
+    const [payload] = firedPayloads()
+    expect(payload.rawRow.Status).toBeNull()
+  })
+})
+
+describe('fireTableTrigger — payload shape', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockProcessPolledWebhookEvent.mockResolvedValue({ success: true })
+    mockFetchActiveWebhooks.mockResolvedValue([webhookEntry()])
+  })
+
+  it('row fills every column while rawRow omits absent ones', async () => {
+    await fire('insert', { col_title: 'only this' })
+
+    const [payload] = firedPayloads()
+    expect(payload.rawRow).toEqual({ Title: 'only this' })
+    expect(payload.row).toEqual({ Title: 'only this', Status: null, Tags: null })
+  })
+
+  it('row key set matches headers exactly', async () => {
+    await fire('insert', { col_title: 'x' })
+
+    const [payload] = firedPayloads()
+    expect(Object.keys(payload.row as Record<string, unknown>)).toEqual(payload.headers)
+  })
+
+  it('omits row when includeHeaders is false', async () => {
+    mockFetchActiveWebhooks.mockResolvedValue([webhookEntry({ includeHeaders: false })])
+    await fire('insert', { col_title: 'x' })
+
+    const [payload] = firedPayloads()
+    expect(payload.row).toBeNull()
+    expect(payload.rawRow).toEqual({ Title: 'x' })
+  })
+
+  it('reports changedColumns by display name', async () => {
+    mockFetchActiveWebhooks.mockResolvedValue([webhookEntry({ eventType: 'update' })])
+    await fire(
+      'update',
+      { col_status: 'opt_closed' },
+      new Map([['row_1', { col_status: 'opt_open' }]])
+    )
+
+    const [payload] = firedPayloads()
+    expect(payload.changedColumns).toEqual(['Status'])
+  })
+})
+
+describe('fireTableTrigger — gating', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockProcessPolledWebhookEvent.mockResolvedValue({ success: true })
+  })
+
+  it('fires nothing for a different table', async () => {
+    mockFetchActiveWebhooks.mockResolvedValue([webhookEntry({ tableId: 'tbl_other' })])
+    await fire('insert', { col_title: 'x' })
+    expect(mockProcessPolledWebhookEvent).not.toHaveBeenCalled()
+  })
+
+  it('fires nothing when the event type does not match', async () => {
+    mockFetchActiveWebhooks.mockResolvedValue([webhookEntry({ eventType: 'update' })])
+    await fire('insert', { col_title: 'x' })
+    expect(mockProcessPolledWebhookEvent).not.toHaveBeenCalled()
+  })
+
+  it('skips a row whose watched column did not change', async () => {
+    mockFetchActiveWebhooks.mockResolvedValue([
+      webhookEntry({ eventType: 'update', watchColumns: 'Tags' }),
+    ])
+    await fire(
+      'update',
+      { col_status: 'opt_closed' },
+      new Map([['row_1', { col_status: 'opt_open' }]])
+    )
+    expect(mockProcessPolledWebhookEvent).not.toHaveBeenCalled()
+  })
+
+  it('fires when a watched column changed', async () => {
+    mockFetchActiveWebhooks.mockResolvedValue([
+      webhookEntry({ eventType: 'update', watchColumns: 'Status' }),
+    ])
+    await fire(
+      'update',
+      { col_status: 'opt_closed' },
+      new Map([['row_1', { col_status: 'opt_open' }]])
+    )
+    expect(mockProcessPolledWebhookEvent).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/apps/sim/lib/table/__tests__/validation.test.ts b/apps/sim/lib/table/__tests__/validation.test.ts
index 40e3187270c..bcb9a224ab8 100644
--- a/apps/sim/lib/table/__tests__/validation.test.ts
+++ b/apps/sim/lib/table/__tests__/validation.test.ts
@@ -87,6 +87,27 @@ describe('Validation', () => {
       }
     })
 
+    it('rejects select-only fields on a non-select column', () => {
+      // Both are inert on a string column, but `updateColumnType` inherits them
+      // on a later convert-to-select — options would be silently replaced and
+      // `multiple` would turn an intended single-select into a multiselect.
+      const withOptions = validateColumnDefinition({
+        name: 'status',
+        type: 'string',
+        options: [{ id: 'opt_a', name: 'Open' }],
+      })
+      expect(withOptions.valid).toBe(false)
+      expect(withOptions.errors[0]).toContain('cannot define options')
+
+      const withMultiple = validateColumnDefinition({
+        name: 'status',
+        type: 'string',
+        multiple: true,
+      })
+      expect(withMultiple.valid).toBe(false)
+      expect(withMultiple.errors[0]).toContain('cannot be multiple')
+    })
+
     it('should reject empty column name', () => {
       const result = validateColumnDefinition({ name: '', type: 'string' })
       expect(result.valid).toBe(false)
@@ -405,6 +426,50 @@ describe('Validation', () => {
       coerceRowValues(patch as never, schema)
       expect(patch.founded).toBe('nope')
     })
+
+    describe('select coercion', () => {
+      const selectSchema: TableSchema = {
+        columns: [
+          {
+            id: 'status',
+            name: 'status',
+            type: 'select',
+            options: [
+              { id: 'opt_open', name: 'Open' },
+              { id: 'opt_closed', name: 'Closed' },
+            ],
+          },
+          {
+            id: 'tags',
+            name: 'tags',
+            type: 'select',
+            multiple: true,
+            options: [
+              { id: 'opt_a', name: 'Alpha' },
+              { id: 'opt_b', name: 'Beta' },
+            ],
+          },
+        ],
+      }
+
+      it('resolves a single-select name to its id', () => {
+        const patch: Record<string, unknown> = { status: 'Open' }
+        coerceRowValues(patch as never, selectSchema)
+        expect(patch.status).toBe('opt_open')
+      })
+
+      it('splits a comma-delimited multiselect string into resolved ids', () => {
+        const patch: Record<string, unknown> = { tags: 'Alpha, Beta' }
+        coerceRowValues(patch as never, selectSchema)
+        expect(patch.tags).toEqual(['opt_a', 'opt_b'])
+      })
+
+      it('resolves a multiselect array of names to ids and dedupes', () => {
+        const patch: Record<string, unknown> = { tags: ['Alpha', 'opt_a', 'Beta'] }
+        coerceRowValues(patch as never, selectSchema)
+        expect(patch.tags).toEqual(['opt_a', 'opt_b'])
+      })
+    })
   })
 
   describe('getUniqueColumns', () => {
diff --git a/apps/sim/lib/table/cell-format.ts b/apps/sim/lib/table/cell-format.ts
new file mode 100644
index 00000000000..9fe544885e2
--- /dev/null
+++ b/apps/sim/lib/table/cell-format.ts
@@ -0,0 +1,104 @@
+/**
+ * Outbound representation of stored table rows — the counterpart to the inbound
+ * `coerceValueToColumnType` switch in `validation.ts`.
+ *
+ * Row data is keyed by a column's stable **id**, and a `select` cell's stored
+ * value is an opaque option **id**. Turning a row into the form consumers see
+ * therefore needs two translations — keys and values — and they must happen
+ * together: every past bug in this area came from a boundary translating the
+ * keys and forgetting the values. {@link namedRowMapper} fuses them into a
+ * single pass so they cannot drift apart again.
+ */
+
+import { getColumnId } from '@/lib/table/column-keys'
+import { selectValueToNames } from '@/lib/table/select-values'
+import type { ColumnDefinition, JsonValue, RowData } from '@/lib/table/types'
+
+/**
+ * One stored cell value → the value consumers see. `select` resolves option
+ * ids to names (an array when `multiple`, dropping ids whose option was
+ * deleted); every other column type passes through untouched.
+ *
+ * The passthrough is load-bearing, not laziness: `rawRow` is documented public
+ * trigger output, so a `date`, `json`, `number`, `boolean`, or `string` cell
+ * must reach consumers byte-identical to what is stored.
+ */
+export function formatCellValue(value: unknown, column: ColumnDefinition): JsonValue {
+  if (column.type === 'select') return selectValueToNames(column, value)
+  return value as JsonValue
+}
+
+/**
+ * Builds the id-keyed → name-keyed row translator for a set of columns,
+ * translating keys and values in one pass.
+ *
+ * Returns a closure because callers hoist it once per request or export stream:
+ * a per-row signature would rebuild the column index for every row inside the
+ * paginated export loop. Keys with no current column — e.g. a column deleted by
+ * a not-yet-finished background strip — are dropped, so orphaned keys never
+ * surface.
+ *
+ * Takes a column list rather than a schema so callers can pass a filtered set
+ * (workflow-column inputs exclude the group's own output columns).
+ */
+export function namedRowMapper(columns: ColumnDefinition[]): (data: RowData) => RowData {
+  const byId = new Map<string, ColumnDefinition>()
+  for (const column of columns) byId.set(getColumnId(column), column)
+
+  return (data: RowData): RowData => {
+    const out: RowData = {}
+    for (const [id, value] of Object.entries(data)) {
+      const column = byId.get(id)
+      if (column !== undefined) out[column.name] = formatCellValue(value, column)
+    }
+    return out
+  }
+}
+
+/**
+ * Widens an already name-keyed row to one entry per column, filling absent
+ * cells with `null`.
+ *
+ * For payloads whose field set must match a sibling `headers` array — the table
+ * trigger's `row` and the workflow-column `inputRow`. Pass the same column list
+ * used to build those headers so the two cannot drift.
+ *
+ * Absent cells become `null` rather than being run through
+ * {@link formatCellValue}: an empty multi-select would otherwise render as `[]`,
+ * which downstream emptiness checks do not treat as empty.
+ */
+export function fillMissingColumns(named: RowData, columns: ColumnDefinition[]): RowData {
+  const out: RowData = {}
+  for (const column of columns) out[column.name] = named[column.name] ?? null
+  return out
+}
+
+/**
+ * Resolves a workflow group's input mappings to their outward cell values.
+ *
+ * `WorkflowGroupInputMapping.columnName` holds a column **id**, not a name (the
+ * field name is a known misnomer; renaming it is a persisted-schema migration).
+ * Mappings referencing a column that no longer exists are skipped.
+ *
+ * An absent cell stays `undefined` rather than being formatted: an empty
+ * multi-select would otherwise become `[]`, which the callers' required-input
+ * emptiness checks do not treat as empty, silently running enrichments on rows
+ * they currently skip.
+ */
+export function mapInputValues(
+  data: RowData,
+  columns: ColumnDefinition[],
+  mappings: Array<{ inputName: string; columnName: string }>
+): Record<string, unknown> {
+  const byId = new Map<string, ColumnDefinition>()
+  for (const column of columns) byId.set(getColumnId(column), column)
+
+  const out: Record<string, unknown> = {}
+  for (const mapping of mappings) {
+    const column = byId.get(mapping.columnName)
+    if (column === undefined) continue
+    const value = data[mapping.columnName]
+    out[mapping.inputName] = value === undefined ? undefined : formatCellValue(value, column)
+  }
+  return out
+}
diff --git a/apps/sim/lib/table/cell-write.test.ts b/apps/sim/lib/table/cell-write.test.ts
index b4fa0fcffe4..dccc5c2f2f6 100644
--- a/apps/sim/lib/table/cell-write.test.ts
+++ b/apps/sim/lib/table/cell-write.test.ts
@@ -39,6 +39,15 @@ const TABLE: TableDefinition = {
     columns: [
       { id: 'first-output', name: 'First output', type: 'string' },
       { id: 'second-output', name: 'Second output', type: 'string' },
+      {
+        id: 'status-output',
+        name: 'Status output',
+        type: 'select',
+        options: [
+          { id: 'opt_open', name: 'Open' },
+          { id: 'opt_closed', name: 'Closed' },
+        ],
+      },
     ],
   },
   rowCount: 1,
@@ -146,6 +155,38 @@ describe('writeWorkflowGroupState', () => {
     )
   })
 
+  it('emits the stored option id for a select column, not the raw workflow value', async () => {
+    // The workflow returns the option *name*; storage keys on the option id.
+    // Emitting the raw name would make the grid resolve it as an id, find
+    // nothing, and render the cell empty until the next refetch.
+    const dataPatch = { 'status-output': 'Open' }
+    await expect(
+      writeWorkflowGroupState(CONTEXT, { executionState: RUNNING_STATE, dataPatch })
+    ).resolves.toBe('wrote')
+
+    expect(mockAppendTableEvent).toHaveBeenCalledWith(
+      expect.objectContaining({ outputs: { 'status-output': 'opt_open' } })
+    )
+    // The patch object feeds the progress writer's identity-compared retry
+    // bookkeeping, so it must survive untouched.
+    expect(dataPatch).toEqual({ 'status-output': 'Open' })
+  })
+
+  it('resolves select values in a cumulative event snapshot with no data patch', async () => {
+    await expect(
+      writeWorkflowGroupState(CONTEXT, {
+        executionState: RUNNING_STATE,
+        eventOutputs: { 'first-output': 'first', 'status-output': 'Closed' },
+      })
+    ).resolves.toBe('wrote')
+
+    expect(mockAppendTableEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        outputs: { 'first-output': 'first', 'status-output': 'opt_closed' },
+      })
+    )
+  })
+
   it('suppresses events when stale or cancelled SQL guards reject writes', async () => {
     mockWriteExecutionsPatch.mockResolvedValueOnce('guard-rejected')
     await expect(writeWorkflowGroupState(CONTEXT, { executionState: RUNNING_STATE })).resolves.toBe(
diff --git a/apps/sim/lib/table/cell-write.ts b/apps/sim/lib/table/cell-write.ts
index 9c89ea77b70..15756b71603 100644
--- a/apps/sim/lib/table/cell-write.ts
+++ b/apps/sim/lib/table/cell-write.ts
@@ -21,6 +21,7 @@ import type {
   TableDefinition,
   WorkflowGroup,
 } from '@/lib/table/types'
+import { coerceRowValues } from '@/lib/table/validation'
 
 const logger = createLogger('WorkflowCellWrite')
 
@@ -97,8 +98,17 @@ export async function writeWorkflowGroupState(
     return 'skipped'
   }
 
-  const eventOutputs = payload.eventOutputs ?? dataPatch
-  const hasOutputs = eventOutputs && Object.keys(eventOutputs).length > 0
+  // The SSE snapshot must carry what was persisted, not the raw block output.
+  // `updateRow` coerces its own merged copy, so the patch object here still
+  // holds the workflow's value — for a `select` column that's the option *name*
+  // ("Open"), which the grid resolves as an option id, finds nothing, and
+  // renders as an empty cell until the next refetch. Coerce a copy: the patch
+  // object itself is identity-compared for the progress writer's retry
+  // bookkeeping, so it must not be mutated.
+  const rawEventOutputs = payload.eventOutputs ?? dataPatch
+  const hasOutputs = rawEventOutputs && Object.keys(rawEventOutputs).length > 0
+  const eventOutputs = hasOutputs ? { ...rawEventOutputs } : rawEventOutputs
+  if (hasOutputs && eventOutputs) coerceRowValues(eventOutputs, table.schema)
   const runningBlockIds = payload.executionState.runningBlockIds
   const blockErrors = payload.executionState.blockErrors
   void appendTableEvent({
diff --git a/apps/sim/lib/table/column-keys.ts b/apps/sim/lib/table/column-keys.ts
index ec770b047ea..eb34f094861 100644
--- a/apps/sim/lib/table/column-keys.ts
+++ b/apps/sim/lib/table/column-keys.ts
@@ -171,17 +171,8 @@ export function sortNamesToIds(sort: Sort, idByName: ReadonlyMap<string, string>
   return out
 }
 
-/**
- * Remaps a stored row keyed by column **id** back to **name** keying for the
- * wire. Used at the name-translating boundaries on the way out. Ids with no
- * current column (e.g. a column deleted by a not-yet-finished background strip)
- * are dropped, so orphaned keys never surface.
- */
-export function rowDataIdToName(data: RowData, nameById: Map<string, string>): RowData {
-  const out: RowData = {}
-  for (const [id, value] of Object.entries(data)) {
-    const name = nameById.get(id)
-    if (name !== undefined) out[name] = value
-  }
-  return out
-}
+// The outbound direction (stored id-keyed row → name-keyed) deliberately does
+// NOT live here: a `select` cell's value also needs translating, and keeping the
+// key half separately callable is what let boundaries translate the keys and
+// forget the values. Use `namedRowMapper` from `@/lib/table/cell-format`, which
+// does both in one pass.
diff --git a/apps/sim/lib/table/columns/service.ts b/apps/sim/lib/table/columns/service.ts
index 4eafabd456d..6aecd5dce09 100644
--- a/apps/sim/lib/table/columns/service.ts
+++ b/apps/sim/lib/table/columns/service.ts
@@ -15,19 +15,30 @@ import { createLogger } from '@sim/logger'
 import { and, count, eq, sql } from 'drizzle-orm'
 import { columnMatchesRef, generateColumnId, getColumnId } from '@/lib/table/column-keys'
 import { COLUMN_TYPES, NAME_PATTERN, TABLE_LIMITS } from '@/lib/table/constants'
+import type { DbTransaction } from '@/lib/table/planner'
 import { stripGroupExecutions } from '@/lib/table/rows/executions'
+import { selectValueToNames } from '@/lib/table/select-values'
 import { withLockedTable } from '@/lib/table/service'
 import { scaledStatementTimeoutMs, setTableTxTimeouts } from '@/lib/table/tx'
 import type {
+  ColumnDefinition,
   DeleteColumnData,
+  JsonValue,
   RenameColumnData,
   RowData,
+  SelectOption,
   TableDefinition,
   TableMetadata,
   TableSchema,
   UpdateColumnConstraintsData,
+  UpdateColumnOptionsData,
   UpdateColumnTypeData,
 } from '@/lib/table/types'
+import {
+  resolveSelectOptionId,
+  splitMultiSelectInput,
+  validateColumnDefinition,
+} from '@/lib/table/validation'
 import { assertValidSchema, stripGroupDeps } from '@/lib/table/workflow-columns'
 
 const logger = createLogger('TableColumnService')
@@ -50,6 +61,8 @@ export async function addTableColumn(
     required?: boolean
     unique?: boolean
     position?: number
+    options?: SelectOption[]
+    multiple?: boolean
   },
   requestId: string
 ): Promise<TableDefinition> {
@@ -91,7 +104,15 @@ export async function addTableColumn(
       type: column.type as TableSchema['columns'][number]['type'],
       required: column.required ?? false,
       unique: column.unique ?? false,
+      ...(column.options ? { options: column.options } : {}),
+      ...(column.multiple ? { multiple: true } : {}),
     }
+
+    const columnValidation = validateColumnDefinition(newColumn)
+    if (!columnValidation.valid) {
+      throw new Error(`Invalid column: ${columnValidation.errors.join('; ')}`)
+    }
+
     const newColumnId = getColumnId(newColumn)
 
     const columns = [...schema.columns]
@@ -502,29 +523,102 @@ export async function updateColumnType(
         )
       )
 
+    // Options the column will carry after the change — a `select` value is only
+    // compatible if it resolves against this set.
+    const isSelectType = data.newType === 'select'
+    const targetOptions = data.options ?? column.options ?? []
+    const targetMultiple = data.multiple ?? column.multiple
+    // Leaving `select` behind: stored cells hold option ids, which mean nothing
+    // once the column is text/number/etc. Check compatibility against the option
+    // NAME — that's what the cell will actually become (migrated below).
+    const convertingAwayFromSelect = column.type === 'select' && !isSelectType
+    // The constraint the column ends up with, which may be arriving in this same
+    // request. `updateColumnConstraints` runs as its own transaction afterwards,
+    // so validating against the column's CURRENT flag would let the conversion
+    // commit and only then fail the constraint.
+    const targetRequired = !!(data.required ?? column.required)
+
+    // Rows missing the key (or holding null/`[]`) are filtered out of `rows`
+    // entirely, so the loop below can never see them — they have to be counted
+    // separately, through the same predicate the constraint write will use.
+    if (targetRequired) {
+      const emptyCount = await countEmptyCells(trx, data.tableId, columnKey)
+      if (emptyCount > 0) {
+        throw new Error(
+          `Cannot change column "${column.name}" to a required "${data.newType}": ${emptyCount} row(s) have null, missing, or empty values. Fill them first, or apply the type change without making the column required.`
+        )
+      }
+    }
+
     let incompatibleCount = 0
+    let blankCount = 0
     for (const row of rows) {
       const rowData = row.data as RowData
       const value = rowData[columnKey]
       if (value === null || value === undefined) continue
 
-      if (!isValueCompatibleWithType(value, data.newType)) {
-        incompatibleCount++
+      const effective = convertingAwayFromSelect ? selectValueForConversion(column, value) : value
+
+      if (
+        !isValueCompatibleWithType(
+          effective,
+          data.newType,
+          targetOptions,
+          !!targetMultiple,
+          targetRequired
+        )
+      ) {
+        if (effective === null || effective === '') blankCount++
+        else incompatibleCount++
       }
     }
 
+    if (blankCount > 0) {
+      throw new Error(
+        `Cannot change column "${column.name}" to a required "${data.newType}": ${blankCount} row(s) are empty. Fill them first, or apply the type change without making the column required.`
+      )
+    }
+
     if (incompatibleCount > 0) {
       throw new Error(
         `Cannot change column "${column.name}" to type "${data.newType}": ${incompatibleCount} row(s) have incompatible values. Fix or remove the incompatible values first.`
       )
     }
 
-    const updatedColumns = schema.columns.map((c, i) =>
-      i === columnIndex ? { ...c, type: data.newType } : c
-    )
+    const updatedColumns = schema.columns.map((c, i) => {
+      if (i !== columnIndex) return c
+      // Drop any prior select config, then re-add when the target type uses it.
+      const { options: _prevOptions, multiple: _prevMultiple, ...rest } = c
+      return isSelectType
+        ? {
+            ...rest,
+            type: data.newType,
+            options: data.options ?? c.options,
+            ...(targetMultiple ? { multiple: true } : {}),
+            // Select columns carry no unique constraint: it would compare the
+            // stored option id, capping each option at one row table-wide, and
+            // the UI hides the toggle so it could never be cleared again. Drop
+            // it here rather than in each caller — the sidebar was the only one
+            // clearing it, leaving the v1 and agent paths to strand it.
+            unique: false,
+          }
+        : { ...rest, type: data.newType }
+    })
+
+    const columnValidation = validateColumnDefinition(updatedColumns[columnIndex])
+    if (!columnValidation.valid) {
+      throw new Error(`Invalid column: ${columnValidation.errors.join('; ')}`)
+    }
+
     const updatedSchema: TableSchema = { ...schema, columns: updatedColumns }
     const now = new Date()
 
+    if (convertingAwayFromSelect) {
+      await migrateSelectCellsToNames(trx, data.tableId, columnKey, column.options ?? [])
+    } else if (isSelectType) {
+      await migrateCellsToSelectIds(trx, data.tableId, columnKey, targetOptions, !!targetMultiple)
+    }
+
     await trx
       .update(userTableDefinitions)
       .set({ schema: updatedSchema, updatedAt: now })
@@ -576,23 +670,20 @@ export async function updateColumnConstraints(
       )
     }
     if (data.required === true && !column.required) {
-      const [result] = await trx
-        .select({ count: count() })
-        .from(userTableRows)
-        .where(
-          and(
-            eq(userTableRows.tableId, data.tableId),
-            sql`(NOT (${userTableRows.data} ? ${columnKey}) OR ${userTableRows.data}->>${columnKey}::text IS NULL)`
-          )
-        )
-
-      if (result.count > 0) {
+      const emptyCount = await countEmptyCells(trx, data.tableId, columnKey)
+      if (emptyCount > 0) {
         throw new Error(
-          `Cannot set column "${column.name}" as required: ${result.count} row(s) have null or missing values`
+          `Cannot set column "${column.name}" as required: ${emptyCount} row(s) have null, missing, or empty values`
         )
       }
     }
 
+    if (data.unique === true && column.type === 'select') {
+      throw new Error(
+        `Cannot set column "${column.name}" as unique: select columns compare stored option ids, which would allow only one row per option.`
+      )
+    }
+
     if (data.unique === true && !column.unique) {
       const duplicates = (await trx.execute(
         sql`SELECT ${userTableRows.data}->>${columnKey}::text AS val, count(*) AS cnt FROM ${userTableRows} WHERE table_id = ${data.tableId} AND ${userTableRows.data} ? ${columnKey} AND ${userTableRows.data}->>${columnKey}::text IS NOT NULL GROUP BY val HAVING count(*) > 1 LIMIT 1`
@@ -629,17 +720,471 @@ export async function updateColumnConstraints(
 }
 
 /**
- * Checks if a value is compatible with a target column type.
+ * Updates the option set (and optional single/multi mode) of a `select` column
+ * without changing its type. Existing cell values are left untouched — ids that
+ * no longer match an option render as a neutral fallback pill until reassigned;
+ * a single↔multi toggle is reconciled lazily on the next row write.
+ */
+export async function updateColumnOptions(
+  data: UpdateColumnOptionsData,
+  requestId: string
+): Promise<TableDefinition> {
+  return withLockedTable(data.tableId, async (table, trx) => {
+    const schema = table.schema
+    const columnIndex = schema.columns.findIndex((c) => columnMatchesRef(c, data.columnName))
+    if (columnIndex === -1) {
+      throw new Error(`Column "${data.columnName}" not found`)
+    }
+
+    const column = schema.columns[columnIndex]
+    if (column.type !== 'select') {
+      throw new Error(`Cannot set options on column "${column.name}" of type "${column.type}"`)
+    }
+
+    const columnKey = getColumnId(column)
+
+    const { multiple: _prevMultiple, ...columnRest } = column
+    const updatedColumn = {
+      ...columnRest,
+      options: data.options,
+      ...((data.multiple ?? column.multiple) ? { multiple: true } : {}),
+    }
+    const columnValidation = validateColumnDefinition(updatedColumn)
+    if (!columnValidation.valid) {
+      throw new Error(`Invalid column: ${columnValidation.errors.join('; ')}`)
+    }
+
+    const updatedColumns = schema.columns.map((c, i) => (i === columnIndex ? updatedColumn : c))
+    const updatedSchema: TableSchema = { ...schema, columns: updatedColumns }
+    const now = new Date()
+
+    const nextMultiple = !!(data.multiple ?? column.multiple)
+    const wasMultiple = !!column.multiple
+    const keptIds = new Set(data.options.map((o) => o.id))
+    const removedAny = (column.options ?? []).some((o) => !keptIds.has(o.id))
+    const togglingCardinality = nextMultiple !== wasMultiple
+    const targetRequired = !!(data.required ?? column.required)
+
+    // Newly imposing `required` in the same request: rows that are ALREADY empty
+    // would fail the separate constraint write after this one commits, so they
+    // have to be caught here, through the same predicate that write will use.
+    if (targetRequired && !column.required) {
+      const emptyCount = await countEmptyCells(trx, data.tableId, columnKey)
+      if (emptyCount > 0) {
+        throw new Error(
+          `Cannot make column "${column.name}" required: ${emptyCount} row(s) have null, missing, or empty values. Fill them first.`
+        )
+      }
+    }
+
+    if (togglingCardinality || removedAny) {
+      const timeoutMs = scaledStatementTimeoutMs(table.rowCount ?? 0, {
+        baseMs: 60_000,
+        perRowMs: 2,
+      })
+      await setTableTxTimeouts(trx, { statementMs: timeoutMs, idleMs: timeoutMs })
+    }
+
+    // Removal runs FIRST, before the multi→single guard and the shape migration.
+    // Both of those read the cells: the guard would otherwise count options this
+    // same request is dropping, and the migration keeps a multi cell's FIRST
+    // element — which could be a removed id sitting ahead of a kept one, so the
+    // surviving option would be discarded and the dead one kept.
+    //
+    // Cells are still in their pre-toggle shape here, so this passes the CURRENT
+    // cardinality, not the target one.
+    if (removedAny) {
+      // On a required column, clearing is not an option: it would leave rows the
+      // write path rejects, and `updateColumnConstraints` refuses to CREATE that
+      // state, so producing it here would be inconsistent. Make the caller
+      // reassign those rows first.
+      //
+      // Gated on the constraint the column ENDS UP with, which may be arriving
+      // in this same request: validating against the current flag both blocks a
+      // removal paired with `required: false` that is about to be fine, and lets
+      // a removal paired with `required: true` clear cells and then fail the
+      // constraint write, leaving this change committed behind an error.
+      if (targetRequired) {
+        const strandedCount = await countCellsLosingTheirOptions(
+          trx,
+          data.tableId,
+          columnKey,
+          data.options,
+          wasMultiple
+        )
+        if (strandedCount > 0) {
+          throw new Error(
+            `Cannot remove options from required column "${column.name}": ${strandedCount} row(s) would be left empty. Reassign those rows to a remaining option first.`
+          )
+        }
+      }
+      await clearRemovedSelectOptions(trx, data.tableId, columnKey, data.options, wasMultiple)
+    }
+
+    // Switching multiple → single drops all but the first option in any cell
+    // that still holds several — block it rather than silently losing data.
+    // Counted after the removal above, so dropping surplus options and turning
+    // multiselect off in one save is allowed when every cell ends up with one.
+    if (wasMultiple && !nextMultiple) {
+      const rows = await trx
+        .select({ data: userTableRows.data })
+        .from(userTableRows)
+        .where(
+          and(eq(userTableRows.tableId, data.tableId), sql`${userTableRows.data} ? ${columnKey}`)
+        )
+
+      let multiValuedCount = 0
+      for (const row of rows) {
+        const value = (row.data as RowData)[columnKey]
+        if (Array.isArray(value) && value.length > 1) multiValuedCount++
+      }
+
+      if (multiValuedCount > 0) {
+        throw new Error(
+          `Cannot switch column "${column.name}" to single-select: ${multiValuedCount} row(s) have multiple options selected. Reduce them to one option first.`
+        )
+      }
+    }
+
+    // A single↔multi toggle changes the stored shape (scalar id vs array of
+    // ids). Multi filters compile to array containment, which never matches a
+    // scalar, so leaving cells un-normalized would silently drop every
+    // pre-toggle row out of its own column's filters.
+    if (togglingCardinality) {
+      await migrateCellsToSelectIds(trx, data.tableId, columnKey, data.options, nextMultiple)
+    }
+
+    await trx
+      .update(userTableDefinitions)
+      .set({ schema: updatedSchema, updatedAt: now })
+      .where(eq(userTableDefinitions.id, data.tableId))
+
+    logger.info(
+      `[${requestId}] Updated options for column "${column.name}" in table ${data.tableId}`
+    )
+
+    return { ...table, schema: updatedSchema, updatedAt: now }
+  })
+}
+
+/**
+ * Rewrites a column's cells from stored option **ids** to option **names**, for
+ * a column that is ceasing to be a `select`. A multi cell joins comma-separated
+ * — the same shape it exports as.
+ *
+ * An id whose option no longer exists becomes null, matching
+ * {@link selectValueForConversion}, which is what the compatibility check ran
+ * on. Passing it through instead would leave an opaque `opt_…` in a typed cell
+ * the check had already accounted as empty.
+ *
+ * Set-based: one statement per stored shape, driven by a jsonb id→name map, so
+ * cost is independent of row count.
+ */
+async function migrateSelectCellsToNames(
+  trx: DbTransaction,
+  tableId: string,
+  columnKey: string,
+  options: SelectOption[]
+): Promise<void> {
+  const nameById = JSON.stringify(Object.fromEntries(options.map((o) => [o.id, o.name])))
+  await trx.execute(
+    sql`UPDATE ${userTableRows}
+        SET data = jsonb_set(data, ARRAY[${columnKey}::text],
+          COALESCE(${nameById}::jsonb -> (data->>${columnKey}::text), 'null'::jsonb))
+        WHERE table_id = ${tableId}
+          AND jsonb_typeof(data->${columnKey}::text) = 'string'`
+  )
+  await trx.execute(
+    sql`UPDATE ${userTableRows}
+        SET data = jsonb_set(data, ARRAY[${columnKey}::text], COALESCE(to_jsonb((
+              SELECT string_agg(${nameById}::jsonb ->> e.v, ', ' ORDER BY e.ord)
+              FROM jsonb_array_elements_text(data->${columnKey}::text) WITH ORDINALITY AS e(v, ord)
+              WHERE ${nameById}::jsonb ? e.v
+            )), 'null'::jsonb))
+        WHERE table_id = ${tableId}
+          AND jsonb_typeof(data->${columnKey}::text) = 'array'`
+  )
+}
+
+/**
+ * Rewrites a column's cells into the canonical `select` storage shape: the
+ * option **id**, wrapped in an array when the column is `multiple`.
+ *
+ * Needed in both directions of a select change. Converting *to* select, cells
+ * hold option names (that is what made them compatible) but every reader —
+ * pills, filters, exports — resolves by id. Toggling single→multi, cells hold a
+ * scalar id while multi filters compile to array containment, which a scalar
+ * never matches. Either way the cell silently drops out until it is re-edited.
+ *
+ * The map keys ids, names, and lower-cased names — ids so re-running is a no-op,
+ * lower-cased names because `resolveSelectOptionId` accepts a case-mismatched
+ * name and a cell that passed that check must actually migrate. Duplicate option
+ * names are rejected case-insensitively at validation, so the folded key is
+ * unambiguous; lookups still try the exact form first to preserve its precedence.
+ */
+async function migrateCellsToSelectIds(
+  trx: DbTransaction,
+  tableId: string,
+  columnKey: string,
+  options: SelectOption[],
+  multiple: boolean
+): Promise<void> {
+  // Ids are written last so an id always outranks any option's name, matching
+  // `resolveSelectOptionId`'s id-before-name precedence. A single flat pass
+  // would let a later option whose *name* equals an earlier option's *id*
+  // overwrite that id entry and repoint its cells at the wrong option.
+  // A Map, not plain-object assignment: an option named `__proto__` would set
+  // the prototype instead of an own key and drop out of the serialized map.
+  const refs = new Map<string, string>()
+  for (const o of options) {
+    refs.set(o.name.toLowerCase(), o.id)
+    refs.set(o.name, o.id)
+  }
+  for (const o of options) {
+    refs.set(o.id, o.id)
+  }
+  const idByRef = JSON.stringify(Object.fromEntries(refs))
+
+  if (multiple) {
+    // A string cell reaching a multi target is either one option name or the
+    // comma-joined form a multiselect converts to text as. Try the whole string
+    // first so an option whose own name contains a comma still wins, then split
+    // — mirroring `splitMultiSelectInput` on the write path, including its
+    // first-occurrence dedup.
+    await trx.execute(
+      sql`UPDATE ${userTableRows}
+          SET data = jsonb_set(data, ARRAY[${columnKey}::text],
+            CASE WHEN data->>${columnKey}::text = '' THEN '[]'::jsonb
+                 WHEN COALESCE(${idByRef}::jsonb -> (data->>${columnKey}::text), ${idByRef}::jsonb -> lower(data->>${columnKey}::text)) IS NOT NULL
+                   THEN jsonb_build_array(COALESCE(${idByRef}::jsonb -> (data->>${columnKey}::text), ${idByRef}::jsonb -> lower(data->>${columnKey}::text)))
+                 ELSE COALESCE((
+                   SELECT jsonb_agg(v ORDER BY ord) FROM (
+                     SELECT COALESCE(${idByRef}::jsonb -> btrim(part), ${idByRef}::jsonb -> lower(btrim(part)), to_jsonb(btrim(part))) AS v,
+                            min(o) AS ord
+                     FROM unnest(string_to_array(data->>${columnKey}::text, ',')) WITH ORDINALITY AS u(part, o)
+                     WHERE btrim(part) <> ''
+                     GROUP BY 1
+                   ) d), '[]'::jsonb)
+            END)
+          WHERE table_id = ${tableId}
+            AND jsonb_typeof(data->${columnKey}::text) = 'string'`
+    )
+    await trx.execute(
+      sql`UPDATE ${userTableRows}
+          SET data = jsonb_set(data, ARRAY[${columnKey}::text], COALESCE((
+                SELECT jsonb_agg(COALESCE(${idByRef}::jsonb -> e.v, ${idByRef}::jsonb -> lower(e.v), to_jsonb(e.v)) ORDER BY e.ord)
+                FROM jsonb_array_elements_text(data->${columnKey}::text) WITH ORDINALITY AS e(v, ord)
+              ), '[]'::jsonb))
+          WHERE table_id = ${tableId}
+            AND jsonb_typeof(data->${columnKey}::text) = 'array'`
+    )
+    return
+  }
+
+  // A cleared cell is stored as '' — compatibility lets it through, so it has
+  // to land as null rather than an '' that fails option membership on the next
+  // write.
+  await trx.execute(
+    sql`UPDATE ${userTableRows}
+        SET data = jsonb_set(data, ARRAY[${columnKey}::text],
+          CASE WHEN data->>${columnKey}::text = '' THEN 'null'::jsonb
+               ELSE COALESCE(${idByRef}::jsonb -> (data->>${columnKey}::text), ${idByRef}::jsonb -> lower(data->>${columnKey}::text), data->${columnKey}::text)
+          END)
+        WHERE table_id = ${tableId}
+          AND jsonb_typeof(data->${columnKey}::text) = 'string'`
+  )
+  // Compatibility already rejected multi-valued cells for a single target, so
+  // any array here holds at most one option.
+  await trx.execute(
+    sql`UPDATE ${userTableRows}
+        SET data = jsonb_set(data, ARRAY[${columnKey}::text],
+          COALESCE(${idByRef}::jsonb -> (data->${columnKey}::text->>0), ${idByRef}::jsonb -> lower(data->${columnKey}::text->>0), data->${columnKey}::text->0, 'null'::jsonb))
+        WHERE table_id = ${tableId}
+          AND jsonb_typeof(data->${columnKey}::text) = 'array'`
+  )
+}
+
+/**
+ * Rows whose cell counts as empty for a `required` constraint: the key is
+ * missing, the value is JSON null, or it is an emptied multiselect `[]`.
+ *
+ * Single source of truth. `updateColumnType`'s pre-flight and
+ * `updateColumnConstraints` both ask this question, and they run as separate
+ * transactions — when the two definitions drifted, a combined type+required
+ * request passed the first check, committed the conversion, and only then
+ * failed the constraint write.
+ */
+async function countEmptyCells(
+  trx: DbTransaction,
+  tableId: string,
+  columnKey: string
+): Promise<number> {
+  const [result] = await trx
+    .select({ count: count() })
+    .from(userTableRows)
+    .where(
+      and(
+        eq(userTableRows.tableId, tableId),
+        sql`(NOT (${userTableRows.data} ? ${columnKey})
+             OR ${userTableRows.data}->>${columnKey}::text IS NULL
+             OR ${userTableRows.data}->${columnKey}::text = '[]'::jsonb)`
+      )
+    )
+  return result?.count ?? 0
+}
+
+/**
+ * Rows that removing these options would leave with no selection at all — a
+ * single cell holding a removed id, or a multi cell whose every element is
+ * being removed. Rows that keep at least one option are unaffected.
+ */
+async function countCellsLosingTheirOptions(
+  trx: DbTransaction,
+  tableId: string,
+  columnKey: string,
+  options: SelectOption[],
+  multiple: boolean
+): Promise<number> {
+  const keptIds = JSON.stringify(options.map((o) => o.id))
+
+  if (multiple) {
+    const [result] = await trx
+      .select({ count: count() })
+      .from(userTableRows)
+      .where(
+        and(
+          eq(userTableRows.tableId, tableId),
+          sql`jsonb_typeof(${userTableRows.data}->${columnKey}::text) = 'array'`,
+          sql`${userTableRows.data}->${columnKey}::text <> '[]'::jsonb`,
+          // The type guard above is not ordered against this predicate, so the
+          // element expansion has to guard its own argument — otherwise a scalar
+          // cell left over from a single→multi toggle raises "cannot get array
+          // length of a scalar" before the guard is ever applied.
+          sql`NOT EXISTS (
+                SELECT 1 FROM jsonb_array_elements_text(
+                  CASE WHEN jsonb_typeof(${userTableRows.data}->${columnKey}::text) = 'array'
+                       THEN ${userTableRows.data}->${columnKey}::text ELSE '[]'::jsonb END
+                ) e
+                WHERE ${keptIds}::jsonb @> jsonb_build_array(e)
+              )`
+        )
+      )
+    return result?.count ?? 0
+  }
+
+  const [result] = await trx
+    .select({ count: count() })
+    .from(userTableRows)
+    .where(
+      and(
+        eq(userTableRows.tableId, tableId),
+        sql`jsonb_typeof(${userTableRows.data}->${columnKey}::text) = 'string'`,
+        sql`${userTableRows.data}->>${columnKey}::text <> ''`,
+        sql`NOT (${keptIds}::jsonb @> jsonb_build_array(${userTableRows.data}->${columnKey}::text))`
+      )
+    )
+  return result?.count ?? 0
+}
+
+/**
+ * Clears stored ids that are no longer in a `select` column's option set.
+ *
+ * A single cell holding a removed option becomes null; a multi cell drops just
+ * the removed elements. Kept set-based off a jsonb array of the surviving ids.
  */
-function isValueCompatibleWithType(
+async function clearRemovedSelectOptions(
+  trx: DbTransaction,
+  tableId: string,
+  columnKey: string,
+  options: SelectOption[],
+  multiple: boolean
+): Promise<void> {
+  const keptIds = JSON.stringify(options.map((o) => o.id))
+
+  if (multiple) {
+    await trx.execute(
+      sql`UPDATE ${userTableRows}
+          SET data = jsonb_set(data, ARRAY[${columnKey}::text], COALESCE((
+                SELECT jsonb_agg(e.v ORDER BY e.ord)
+                FROM jsonb_array_elements(data->${columnKey}::text) WITH ORDINALITY AS e(v, ord)
+                WHERE ${keptIds}::jsonb @> jsonb_build_array(e.v)
+              ), '[]'::jsonb))
+          WHERE table_id = ${tableId}
+            AND jsonb_typeof(data->${columnKey}::text) = 'array'
+            AND NOT (${keptIds}::jsonb @> (data->${columnKey}::text))`
+    )
+    return
+  }
+
+  await trx.execute(
+    sql`UPDATE ${userTableRows}
+        SET data = jsonb_set(data, ARRAY[${columnKey}::text], 'null'::jsonb)
+        WHERE table_id = ${tableId}
+          AND jsonb_typeof(data->${columnKey}::text) = 'string'
+          AND data->>${columnKey}::text <> ''
+          AND NOT (${keptIds}::jsonb @> jsonb_build_array(data->${columnKey}::text))`
+  )
+}
+
+/**
+ * The value a `select` cell becomes when its column converts to another type:
+ * the option **name**, since the stored id is meaningless outside the column.
+ * Multi-select flattens to a comma-joined string — the same shape a multi cell
+ * exports as — and an empty or fully-orphaned cell becomes null.
+ */
+export function selectValueForConversion(column: ColumnDefinition, value: unknown): JsonValue {
+  const names = selectValueToNames(column, value)
+  if (Array.isArray(names)) return names.length > 0 ? names.join(', ') : null
+  return names
+}
+
+/**
+ * Checks if a value is compatible with a target column type. For `select`,
+ * `targetOptions` is the option set the column will carry after the change: a
+ * value is compatible only if every part of it resolves to one of those options
+ * (by id or name). This blocks a conversion that would otherwise strand or
+ * silently drop values on the next row write.
+ *
+ * Callers converting *away* from `select` must pass the resolved option
+ * name(s), not the stored ids — see {@link selectValueForConversion}.
+ */
+export function isValueCompatibleWithType(
   value: unknown,
-  targetType: (typeof COLUMN_TYPES)[number]
+  targetType: (typeof COLUMN_TYPES)[number],
+  targetOptions: SelectOption[] = [],
+  targetMultiple = false,
+  targetRequired = false
 ): boolean {
   if (value === null || value === undefined) return true
 
   switch (targetType) {
     case 'string':
-      return true
+      // Arrays and objects can't become text — the write-path coercion rejects
+      // them and would null the cell. Multi-select values are flattened before
+      // this check, so anything still structured here is genuinely lossy.
+      return typeof value !== 'object'
+    case 'select': {
+      // A cleared select cell is written as '' — still convertible, unless the
+      // target is required. Required only rejects null/undefined on a write, so
+      // a required string column legitimately holds ''; the migration turns that
+      // into null (or [] for a multi), and every later update of that row would
+      // then fail its own required check.
+      if (value === '') return !targetRequired
+      // Read the value exactly as the write-path coercion will. A multi target
+      // splits a comma-delimited string, so a multiselect → text → multiselect
+      // round-trip (text holding this feature's own `Bug, Docs` export shape)
+      // stays convertible instead of being rejected as one unknown option.
+      const parts = targetMultiple
+        ? splitMultiSelectInput(value as JsonValue)
+        : Array.isArray(value)
+          ? value
+          : [value]
+      // A single-select target can't hold several options. `updateColumnOptions`
+      // blocks the same transition; without this the next coerce would silently
+      // keep only the first id.
+      if (!targetMultiple && parts.length > 1) return false
+      return parts.every((v) => resolveSelectOptionId(v as JsonValue, targetOptions) !== null)
+    }
     case 'number': {
       if (typeof value === 'number') return Number.isFinite(value)
       if (typeof value === 'string') {
diff --git a/apps/sim/lib/table/constants.ts b/apps/sim/lib/table/constants.ts
index 350d8ceae8e..5201815e8f3 100644
--- a/apps/sim/lib/table/constants.ts
+++ b/apps/sim/lib/table/constants.ts
@@ -148,7 +148,10 @@ export function getTablePlanLimits(): TablePlanLimitsByPlan {
   }
 }
 
-export const COLUMN_TYPES = ['string', 'number', 'boolean', 'date', 'json'] as const
+export const COLUMN_TYPES = ['string', 'number', 'boolean', 'date', 'json', 'select'] as const
+
+/** Maximum number of options a `select`/`multiselect` column may declare. */
+export const MAX_SELECT_OPTIONS = 100
 
 export const NAME_PATTERN = /^[a-z_][a-z0-9_]*$/i
 
diff --git a/apps/sim/lib/table/deps.test.ts b/apps/sim/lib/table/deps.test.ts
index b1ab3f8a314..fe6d017fa59 100644
--- a/apps/sim/lib/table/deps.test.ts
+++ b/apps/sim/lib/table/deps.test.ts
@@ -4,7 +4,9 @@
 import { describe, expect, it } from 'vitest'
 import {
   areGroupDepsSatisfied,
+  areOutputsFilled,
   getUnmetGroupDeps,
+  isEmptyCellValue,
   isExecCancelled,
   isExecCancelledAfter,
   optimisticallyScheduleNewlyEligibleGroups,
@@ -114,3 +116,41 @@ describe('isExecCancelledAfter — dispatcher tombstone', () => {
     expect(isExecCancelledAfter({ status: 'cancelled' } as RowExecutionMetadata, since)).toBe(false)
   })
 })
+
+describe('isEmptyCellValue — multiselect', () => {
+  it('treats an emptied multiselect as empty', () => {
+    // `[]` is truthy, so a naive null/undefined/'' check reads it as filled —
+    // which would make dependents eligible off a cleared selection.
+    expect(isEmptyCellValue([])).toBe(true)
+  })
+
+  it('treats a multiselect holding options as filled', () => {
+    expect(isEmptyCellValue(['opt_a'])).toBe(false)
+  })
+
+  it('still treats null, undefined and empty string as empty', () => {
+    expect(isEmptyCellValue(null)).toBe(true)
+    expect(isEmptyCellValue(undefined)).toBe(true)
+    expect(isEmptyCellValue('')).toBe(true)
+  })
+
+  it('treats other scalars as filled, including false and 0', () => {
+    expect(isEmptyCellValue(false)).toBe(false)
+    expect(isEmptyCellValue(0)).toBe(false)
+    expect(isEmptyCellValue('Open')).toBe(false)
+  })
+})
+
+describe('areOutputsFilled — multiselect output', () => {
+  const group = makeGroup({ id: 'g1' })
+
+  it('reports an emptied multiselect output as unfilled', () => {
+    const row = { id: 'r1', data: { g1_out: [] } } as unknown as TableRow
+    expect(areOutputsFilled(group, row)).toBe(false)
+  })
+
+  it('reports a populated multiselect output as filled', () => {
+    const row = { id: 'r1', data: { g1_out: ['opt_a'] } } as unknown as TableRow
+    expect(areOutputsFilled(group, row)).toBe(true)
+  })
+})
diff --git a/apps/sim/lib/table/deps.ts b/apps/sim/lib/table/deps.ts
index 55a5db6b9a1..e74442d402e 100644
--- a/apps/sim/lib/table/deps.ts
+++ b/apps/sim/lib/table/deps.ts
@@ -51,6 +51,18 @@ export function isExecCancelledAfter(exec: RowExecutionMetadata | undefined, sin
   return Number.isFinite(at) && at > since.getTime()
 }
 
+/**
+ * True when a cell holds no value.
+ *
+ * An emptied multi-select is stored as `[]`, which is not falsy — checking only
+ * for null/undefined/`''` would read it as filled, making dependent groups
+ * eligible and running enrichments on rows that should be skipped.
+ */
+export function isEmptyCellValue(value: unknown): boolean {
+  if (Array.isArray(value)) return value.length === 0
+  return value === null || value === undefined || value === ''
+}
+
 /**
  * A dependency column counts as unmet when its value is empty OR explicitly
  * `false`. An unchecked checkbox is treated as "dependency not satisfied", so
@@ -58,7 +70,7 @@ export function isExecCancelledAfter(exec: RowExecutionMetadata | undefined, sin
  * (true→false) never triggers a rerun.
  */
 function isDepValueUnmet(value: unknown): boolean {
-  return value === null || value === undefined || value === '' || value === false
+  return isEmptyCellValue(value) || value === false
 }
 
 /**
@@ -70,8 +82,7 @@ function isDepValueUnmet(value: unknown): boolean {
 export function areOutputsFilled(group: WorkflowGroup, row: TableRow): boolean {
   if (group.outputs.length === 0) return true
   for (const o of group.outputs) {
-    const v = row.data[o.columnName]
-    if (v === null || v === undefined || v === '') return false
+    if (isEmptyCellValue(row.data[o.columnName])) return false
   }
   return true
 }
diff --git a/apps/sim/lib/table/export-format.test.ts b/apps/sim/lib/table/export-format.test.ts
new file mode 100644
index 00000000000..61d6d104067
--- /dev/null
+++ b/apps/sim/lib/table/export-format.test.ts
@@ -0,0 +1,65 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { formatCsvCell, resolveSelectExportValue } from '@/lib/table/export-format'
+import type { ColumnDefinition } from '@/lib/table/types'
+
+const singleSelect: ColumnDefinition = {
+  id: 'col_status',
+  name: 'status',
+  type: 'select',
+  options: [
+    { id: 'opt_open', name: 'Open' },
+    { id: 'opt_closed', name: 'Closed' },
+  ],
+}
+
+const multiSelect: ColumnDefinition = {
+  id: 'col_tags',
+  name: 'tags',
+  type: 'select',
+  multiple: true,
+  options: [
+    { id: 'opt_a', name: 'Alpha' },
+    { id: 'opt_b', name: 'Beta' },
+  ],
+}
+
+describe('resolveSelectExportValue', () => {
+  it('maps a single option id to its name', () => {
+    expect(resolveSelectExportValue(singleSelect, 'opt_open')).toBe('Open')
+  })
+
+  it('maps multi option ids to a names array in order', () => {
+    expect(resolveSelectExportValue(multiSelect, ['opt_b', 'opt_a'])).toEqual(['Beta', 'Alpha'])
+  })
+
+  it('drops ids with no matching option', () => {
+    expect(resolveSelectExportValue(multiSelect, ['opt_a', 'gone'])).toEqual(['Alpha'])
+  })
+
+  it('returns null for an empty single value', () => {
+    expect(resolveSelectExportValue(singleSelect, null)).toBeNull()
+  })
+})
+
+describe('formatCsvCell', () => {
+  it('renders the option name, not the id', () => {
+    expect(formatCsvCell(singleSelect, 'opt_closed')).toBe('Closed')
+  })
+
+  it('comma-joins multi option names', () => {
+    expect(formatCsvCell(multiSelect, ['opt_a', 'opt_b'])).toBe('Alpha, Beta')
+  })
+
+  it('is empty when nothing is selected', () => {
+    expect(formatCsvCell(singleSelect, null)).toBe('')
+    expect(formatCsvCell(multiSelect, [])).toBe('')
+  })
+
+  it('falls through to the plain formatter for non-select columns', () => {
+    const num: ColumnDefinition = { id: 'c', name: 'n', type: 'number' }
+    expect(formatCsvCell(num, 42)).toBe('42')
+  })
+})
diff --git a/apps/sim/lib/table/export-format.ts b/apps/sim/lib/table/export-format.ts
index 3d5256b13fc..c24c5863932 100644
--- a/apps/sim/lib/table/export-format.ts
+++ b/apps/sim/lib/table/export-format.ts
@@ -4,6 +4,15 @@
  * byte-identical files.
  */
 
+import { selectValueToNames } from '@/lib/table/select-values'
+import type { ColumnDefinition } from '@/lib/table/types'
+
+/**
+ * @deprecated Use `selectValueToNames` from `@/lib/table/select-values`. Kept as
+ * an alias so existing export callers/tests don't churn.
+ */
+export const resolveSelectExportValue = selectValueToNames
+
 export function sanitizeExportFilename(name: string): string {
   const cleaned = name.replace(/[^a-zA-Z0-9_-]+/g, '_').replace(/^_+|_+$/g, '')
   return cleaned || 'table'
@@ -29,6 +38,19 @@ export function formatCsvValue(value: unknown): string {
   return String(value)
 }
 
+/**
+ * Serializes one cell for CSV, resolving `select` option ids to their names
+ * (comma-joined for multi) so the file shows the enum label, not the id.
+ */
+export function formatCsvCell(column: ColumnDefinition, value: unknown): string {
+  if (column.type === 'select') {
+    const resolved = resolveSelectExportValue(column, value)
+    const text = Array.isArray(resolved) ? resolved.join(', ') : (resolved ?? '')
+    return neutralizeCsvFormula(text)
+  }
+  return formatCsvValue(value)
+}
+
 export function toCsvRow(values: string[]): string {
   return values.map(escapeCsvField).join(',')
 }
diff --git a/apps/sim/lib/table/export-runner.test.ts b/apps/sim/lib/table/export-runner.test.ts
index f8477eac0c6..fec72520fb9 100644
--- a/apps/sim/lib/table/export-runner.test.ts
+++ b/apps/sim/lib/table/export-runner.test.ts
@@ -47,7 +47,21 @@ const table = {
   id: 'tbl_1',
   name: 'People',
   workspaceId: 'ws_1',
-  schema: { columns: [{ id: 'col_name', name: 'name', type: 'string' }] },
+  schema: {
+    columns: [
+      { id: 'col_name', name: 'name', type: 'string' },
+      {
+        id: 'col_tags',
+        name: 'tags',
+        type: 'select',
+        multiple: true,
+        options: [
+          { id: 'opt_a', name: 'Alpha' },
+          { id: 'opt_b', name: 'Beta' },
+        ],
+      },
+    ],
+  },
 }
 
 const payload = { jobId: 'job_1', tableId: 'tbl_1', workspaceId: 'ws_1', format: 'csv' as const }
@@ -93,7 +107,7 @@ describe('runTableExport', () => {
       return Promise.resolve(handle)
     })
     mockSelectExportRowPage.mockResolvedValue([
-      { id: 'r1', data: { col_name: 'Ada' }, orderKey: 'a0' },
+      { id: 'r1', data: { col_name: 'Ada', col_tags: ['opt_a', 'opt_b'] }, orderKey: 'a0' },
     ])
   })
 
@@ -106,7 +120,8 @@ describe('runTableExport', () => {
     expect(init.context).toBe('workspace')
     expect(init.contentType).toContain('text/csv')
 
-    expect(lastHandle?.content).toBe('name\nAda\n')
+    // Select cells export as option names, comma-joined — never the stored ids.
+    expect(lastHandle?.content).toBe('name,tags\nAda,"Alpha, Beta"\n')
     expect(lastHandle?.complete).toHaveBeenCalledTimes(1)
     expect(lastHandle?.abort).not.toHaveBeenCalled()
 
@@ -118,11 +133,13 @@ describe('runTableExport', () => {
     expect(mockDeleteFile).not.toHaveBeenCalled()
   })
 
-  it('serializes JSON exports with display-name keys', async () => {
+  it('serializes JSON exports with display-name keys and option names', async () => {
     await runTableExport({ ...payload, format: 'json' })
     const init = mockCreateMultipartUpload.mock.calls[0][0]
     expect(init.key.endsWith('/People.json')).toBe(true)
-    expect(JSON.parse(lastHandle?.content ?? '')).toEqual([{ name: 'Ada' }])
+    expect(JSON.parse(lastHandle?.content ?? '')).toEqual([
+      { name: 'Ada', tags: ['Alpha', 'Beta'] },
+    ])
   })
 
   it('aborts the upload and never completes when ownership is lost (cancel)', async () => {
diff --git a/apps/sim/lib/table/export-runner.ts b/apps/sim/lib/table/export-runner.ts
index 6c72a01ff20..8af3628194c 100644
--- a/apps/sim/lib/table/export-runner.ts
+++ b/apps/sim/lib/table/export-runner.ts
@@ -1,10 +1,11 @@
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
-import { buildNameById, getColumnId, rowDataIdToName } from '@/lib/table/column-keys'
+import { namedRowMapper } from '@/lib/table/cell-format'
+import { getColumnId } from '@/lib/table/column-keys'
 import { appendTableEvent } from '@/lib/table/events'
 import {
-  formatCsvValue,
+  formatCsvCell,
   neutralizeCsvFormula,
   sanitizeExportFilename,
   toCsvRow,
@@ -59,9 +60,10 @@ export async function runTableExport(payload: TableExportPayload): Promise<void>
     if (!table) throw new Error(`Export target table ${tableId} not found`)
 
     const columns = table.schema.columns
-    // Stored row data is id-keyed; CSV headers and JSON keys are display names, so translate
-    // id → name on the way out (export is a name-friendly boundary).
-    const nameById = buildNameById(table.schema)
+    // Stored row data is id-keyed and select cells hold option ids; JSON keys are display
+    // names and values are option names, so translate both on the way out (export is a
+    // name-friendly boundary). Hoisted: the mapper is reused across every streamed page.
+    const toNamedRow = namedRowMapper(columns)
 
     const fileName = `${sanitizeExportFilename(table.name)}.${format}`
     // The key is pinned up front so the streaming upload writes exactly where the download
@@ -91,12 +93,12 @@ export async function runTableExport(payload: TableExportPayload): Promise<void>
       for (const row of page) {
         if (format === 'csv') {
           pageChunks.push(
-            `${toCsvRow(columns.map((c) => formatCsvValue(row.data[getColumnId(c)])))}\n`
+            `${toCsvRow(columns.map((c) => formatCsvCell(c, row.data[getColumnId(c)])))}\n`
           )
         } else {
           const prefix = firstJsonRow ? '' : ','
           firstJsonRow = false
-          pageChunks.push(prefix + JSON.stringify(rowDataIdToName(row.data, nameById)))
+          pageChunks.push(prefix + JSON.stringify(toNamedRow(row.data)))
         }
       }
       await handle.write(pageChunks.join(''))
diff --git a/apps/sim/lib/table/query-builder/__tests__/converters.test.ts b/apps/sim/lib/table/query-builder/__tests__/converters.test.ts
index 9af9bcb96ec..131fdf7a74a 100644
--- a/apps/sim/lib/table/query-builder/__tests__/converters.test.ts
+++ b/apps/sim/lib/table/query-builder/__tests__/converters.test.ts
@@ -6,8 +6,12 @@
  * valueless `$empty` operator that maps to two distinct UI operators.
  */
 import { describe, expect, it } from 'vitest'
-import { filterRulesToFilter, filterToRules } from '@/lib/table/query-builder/converters'
-import type { FilterRule } from '@/lib/table/types'
+import {
+  filterRulesToFilter,
+  filterToRules,
+  pruneFilterForColumns,
+} from '@/lib/table/query-builder/converters'
+import type { ColumnDefinition, FilterRule } from '@/lib/table/types'
 
 function rule(overrides: Partial<FilterRule>): FilterRule {
   return {
@@ -117,3 +121,92 @@ describe('filterToRules', () => {
     expect(filterRulesToFilter(rules)).toEqual(original)
   })
 })
+
+describe('select option ids survive as text', () => {
+  const numericIdColumn: ColumnDefinition = {
+    id: 'status',
+    name: 'status',
+    type: 'select',
+    options: [
+      { id: '1', name: 'Open' },
+      { id: 'true', name: 'Closed' },
+    ],
+  }
+
+  it('does not coerce a numeric- or boolean-looking option id', () => {
+    // Option ids are caller-supplied strings; `parseScalar` would turn these
+    // into 1 / true, and JSONB containment against the stored string then
+    // matches nothing while the picker still shows a valid option.
+    expect(
+      filterRulesToFilter([rule({ column: 'status', value: '1' })], [numericIdColumn])
+    ).toEqual({ status: '1' })
+    expect(
+      filterRulesToFilter([rule({ column: 'status', value: 'true' })], [numericIdColumn])
+    ).toEqual({ status: 'true' })
+  })
+
+  it('keeps each element of an $in list as text', () => {
+    expect(
+      filterRulesToFilter(
+        [rule({ column: 'status', operator: 'in', value: '1, true' })],
+        [numericIdColumn]
+      )
+    ).toEqual({ status: { $in: ['1', 'true'] } })
+  })
+
+  it('still coerces on a non-select column', () => {
+    const age: ColumnDefinition = { id: 'age', name: 'age', type: 'number' }
+    expect(filterRulesToFilter([rule({ column: 'age', value: '30' })], [age])).toEqual({ age: 30 })
+  })
+
+  it('survives the prune round-trip without coercion', () => {
+    const filter = { status: '1' }
+    // Nothing to prune here, but the pruned path re-serializes through the
+    // converter — that round-trip must not turn the id back into a number.
+    expect(pruneFilterForColumns(filter, [numericIdColumn])).toEqual({ status: '1' })
+  })
+})
+
+describe('pruneFilterForColumns', () => {
+  const single: ColumnDefinition = {
+    id: 'col_s',
+    name: 'status',
+    type: 'select',
+    options: [{ id: 'opt_a', name: 'Open' }],
+  }
+  const multi: ColumnDefinition = { ...single, multiple: true }
+  const text: ColumnDefinition = { id: 'col_t', name: 'name', type: 'string' }
+
+  it('drops an operator the column no longer accepts', () => {
+    // `contains` was valid while `status` was text; as a single-select it is not.
+    expect(pruneFilterForColumns({ status: { $contains: 'Op' } }, [single])).toBeNull()
+    // ...and `eq` is the one a multiselect rejects.
+    expect(pruneFilterForColumns({ status: 'opt_a' }, [multi])).toBeNull()
+  })
+
+  it('keeps the operators each cardinality does accept', () => {
+    const eq = { status: 'opt_a' }
+    expect(pruneFilterForColumns(eq, [single])).toBe(eq)
+    const contains = { status: { $contains: 'opt_a' } }
+    expect(pruneFilterForColumns(contains, [multi])).toBe(contains)
+  })
+
+  it('keeps sibling conditions when one is pruned', () => {
+    const pruned = pruneFilterForColumns(
+      { status: { $contains: 'Op' }, name: { $contains: 'ada' } },
+      [single, text]
+    )
+    expect(pruned).toEqual({ name: { $contains: 'ada' } })
+  })
+
+  it('leaves non-select and unresolved columns for the server to judge', () => {
+    const onText = { name: { $contains: 'ada' } }
+    expect(pruneFilterForColumns(onText, [text])).toBe(onText)
+    const unknown = { gone: { $contains: 'x' } }
+    expect(pruneFilterForColumns(unknown, [single])).toBe(unknown)
+  })
+
+  it('returns the same object when nothing is pruned', () => {
+    expect(pruneFilterForColumns(null, [single])).toBeNull()
+  })
+})
diff --git a/apps/sim/lib/table/query-builder/constants.ts b/apps/sim/lib/table/query-builder/constants.ts
index ada8bc8c882..a881fd0aba4 100644
--- a/apps/sim/lib/table/query-builder/constants.ts
+++ b/apps/sim/lib/table/query-builder/constants.ts
@@ -28,6 +28,42 @@ export const COMPARISON_OPERATORS = [
  */
 export const VALUELESS_OPERATORS = new Set<string>(['isEmpty', 'isNotEmpty'])
 
+/**
+ * Operators a `select` column supports (values are opaque option ids). A
+ * multi-select cell holds several ids, so it asks about membership — equality
+ * against the whole array can never be true.
+ *
+ * These must stay in step with the server whitelist in `lib/table/sql.ts`: the
+ * filter picker offers exactly these, and `pruneFilterForColumns` DROPS
+ * anything outside them, so an operator missing here is silently discarded from
+ * a filter the server would have accepted. `sql.test.ts` asserts the two sets
+ * agree through `UI_TO_WIRE_OPERATOR` rather than leaving it to a comment.
+ */
+export const SINGLE_SELECT_FILTER_OPERATORS = new Set<string>([
+  'eq',
+  'ne',
+  'in',
+  'nin',
+  'isEmpty',
+  'isNotEmpty',
+])
+export const MULTI_SELECT_FILTER_OPERATORS = new Set<string>([
+  'contains',
+  'ncontains',
+  'isEmpty',
+  'isNotEmpty',
+])
+
+/**
+ * UI operator → wire operator. `isEmpty`/`isNotEmpty` both serialize to
+ * `$empty` (they differ only in the boolean payload); every other operator is
+ * its own name prefixed with `$`, matching `toRuleValue`.
+ */
+export const UI_TO_WIRE_OPERATOR: Record<string, string> = {
+  isEmpty: '$empty',
+  isNotEmpty: '$empty',
+}
+
 export const LOGICAL_OPERATORS = [
   { value: 'and', label: 'and' },
   { value: 'or', label: 'or' },
diff --git a/apps/sim/lib/table/query-builder/converters.ts b/apps/sim/lib/table/query-builder/converters.ts
index 4d6b5f8753e..297a244c3e4 100644
--- a/apps/sim/lib/table/query-builder/converters.ts
+++ b/apps/sim/lib/table/query-builder/converters.ts
@@ -4,7 +4,13 @@
 
 import { generateShortId } from '@sim/utils/id'
 import { isRecordLike } from '@sim/utils/object'
+import { columnMatchesRef } from '@/lib/table/column-keys'
+import {
+  MULTI_SELECT_FILTER_OPERATORS,
+  SINGLE_SELECT_FILTER_OPERATORS,
+} from '@/lib/table/query-builder/constants'
 import type {
+  ColumnDefinition,
   Filter,
   FilterRule,
   JsonValue,
@@ -13,8 +19,18 @@ import type {
   SortRule,
 } from '@/lib/table/types'
 
-/** Converts UI filter rules to a Filter object for API queries. */
-export function filterRulesToFilter(rules: FilterRule[]): Filter | null {
+/**
+ * Converts UI filter rules to a Filter object for API queries.
+ *
+ * Pass `columns` whenever they are known. A `select` value is an opaque option
+ * id, and ids are caller-supplied strings — an id of `"1"`, `"true"` or
+ * `"null"` would otherwise be coerced to a number/boolean/null and then compared
+ * against the stored JSON string by containment, matching nothing.
+ */
+export function filterRulesToFilter(
+  rules: FilterRule[],
+  columns: ColumnDefinition[] = []
+): Filter | null {
   if (rules.length === 0) return null
 
   const orGroups: Filter[] = []
@@ -34,7 +50,8 @@ export function filterRulesToFilter(rules: FilterRule[]): Filter | null {
     // applied; the row just contributes no condition.
     if (!rule.column) continue
 
-    const ruleValue = toRuleValue(rule.operator, rule.value)
+    const isSelect = columns.find((c) => columnMatchesRef(c, rule.column))?.type === 'select'
+    const ruleValue = toRuleValue(rule.operator, rule.value, isSelect)
     const existing = currentGroup[rule.column]
     currentGroup[rule.column] =
       existing === undefined
@@ -63,6 +80,38 @@ export function filterToRules(filter: Filter | null): FilterRule[] {
   return parseFilterGroup(filter)
 }
 
+/**
+ * Drops filter conditions a `select` column no longer accepts.
+ *
+ * The server rejects an unsupported operator on a select column outright, so a
+ * filter applied before a column became `select` — or before its `multiple`
+ * flag flipped — would make every subsequent query throw and leave the grid
+ * stuck until the user cleared the filter by hand. Pruning the dead condition
+ * instead degrades to a broader result set, which is recoverable.
+ *
+ * Only conditions on a column we can positively identify as `select` are
+ * dropped; an unresolved column name is left for the server to judge.
+ */
+export function pruneFilterForColumns(
+  filter: Filter | null,
+  columns: ColumnDefinition[]
+): Filter | null {
+  if (!filter) return null
+
+  const rules = filterToRules(filter)
+  const kept = rules.filter((rule) => {
+    const column = columns.find((c) => columnMatchesRef(c, rule.column))
+    if (column?.type !== 'select') return true
+    const allowed = column.multiple ? MULTI_SELECT_FILTER_OPERATORS : SINGLE_SELECT_FILTER_OPERATORS
+    return allowed.has(rule.operator)
+  })
+
+  if (kept.length === rules.length) return filter
+  // Columns forwarded: the round-trip through rules would otherwise re-coerce a
+  // select option id like `"1"` into a number on the way back out.
+  return filterRulesToFilter(kept, columns)
+}
+
 /** Converts a single UI sort rule to a Sort object for API queries. */
 export function sortRuleToSort(rule: SortRule | null): Sort | null {
   if (!rule || !rule.column) return null
@@ -94,10 +143,10 @@ export function sortToRules(sort: Sort | null): SortRule[] {
   }))
 }
 
-function toRuleValue(operator: string, value: string): JsonValue {
+function toRuleValue(operator: string, value: string, keepAsText = false): JsonValue {
   if (operator === 'isEmpty') return { $empty: true }
   if (operator === 'isNotEmpty') return { $empty: false }
-  const parsedValue = parseValue(value, operator)
+  const parsedValue = parseValue(value, operator, keepAsText)
   return operator === 'eq' ? parsedValue : { [`$${operator}`]: parsedValue }
 }
 
@@ -143,14 +192,18 @@ function applyLogicalOperators(groups: FilterRule[][]): FilterRule[] {
 const ARRAY_OPERATORS = new Set(['in', 'nin'])
 const TEXT_MATCH_OPERATORS = new Set(['contains', 'ncontains', 'startsWith', 'endsWith'])
 
-function parseValue(value: string, operator: string): JsonValue {
+function parseValue(value: string, operator: string, keepAsText = false): JsonValue {
   if (ARRAY_OPERATORS.has(operator)) {
     return value
       .split(',')
       .map((part) => part.trim())
-      .map((part) => parseScalar(part))
+      .map((part) => (keepAsText ? part : parseScalar(part)))
   }
 
+  // An opaque identifier (a select option id) must never be coerced — see
+  // `filterRulesToFilter`.
+  if (keepAsText) return value
+
   // Substring/prefix/suffix matches are textual — keep the raw string so a value
   // like "123" isn't coerced to a number the SQL builder's ILIKE path can't use.
   if (TEXT_MATCH_OPERATORS.has(operator)) {
diff --git a/apps/sim/lib/table/rows/service.ts b/apps/sim/lib/table/rows/service.ts
index 1caa3ec5a16..8e10b62ce80 100644
--- a/apps/sim/lib/table/rows/service.ts
+++ b/apps/sim/lib/table/rows/service.ts
@@ -762,6 +762,43 @@ export interface FindRowMatch {
 /** Max matching cells returned by {@link findRowMatches}; one extra is fetched to detect truncation. */
 const FIND_MATCH_LIMIT = 1000
 
+/**
+ * Builds a SQL text expression that resolves a scanned select cell (`kv.value`,
+ * keyed by `kv.key`) to its option **name(s)** — the label the user searches by,
+ * not the stored id. Single-select maps the id to its name; multiselect joins the
+ * array's option names. Non-select keys resolve to NULL. Returns `null` when the
+ * schema has no select columns (caller keeps the plain id match). Option ids/names
+ * are trusted schema data, escaped and embedded literally; the row alias is `o`.
+ */
+export function buildSelectFindNameExpr(columns: ColumnDefinition[]): string | null {
+  const selectColumns = columns.filter((c) => c.type === 'select')
+  if (selectColumns.length === 0) return null
+  const esc = (s: string) => s.replace(/'/g, "''")
+  const whens = selectColumns
+    .map((col) => {
+      const id = esc(getColumnId(col))
+      const caseWhens = (col.options ?? [])
+        .map((o) => `WHEN '${esc(o.id)}' THEN '${esc(o.name)}'`)
+        .join(' ')
+      const single = caseWhens ? `CASE kv.value ${caseWhens} ELSE kv.value END` : 'kv.value'
+      if (col.multiple) {
+        const elem = caseWhens ? `CASE e.v ${caseWhens} ELSE e.v END` : 'e.v'
+        // `jsonb_array_elements_text` throws "cannot extract elements from a
+        // scalar" on a JSON null — which a multiselect cell becomes when it is
+        // cleared, cut, or has its last option removed — so the array arm has to
+        // be gated on the cell actually being an array. Anything else falls back
+        // to the single mapping, which also keeps a scalar left over from a
+        // single→multi toggle searchable. Mirrors `buildSelectNameOrderExpr`.
+        // `ORDER BY e.ord` keeps the joined label in stored order, so Find matches
+        // the same text the grid renders, sorts by, and exports.
+        return `WHEN kv.key = '${id}' THEN CASE WHEN jsonb_typeof(o.data->'${id}') = 'array' THEN (SELECT string_agg(${elem}, ', ' ORDER BY e.ord) FROM jsonb_array_elements_text(o.data->'${id}') WITH ORDINALITY AS e(v, ord)) ELSE ${single} END`
+      }
+      return `WHEN kv.key = '${id}' THEN ${single}`
+    })
+    .join(' ')
+  return `CASE ${whens} ELSE NULL END`
+}
+
 /**
  * Case-insensitive substring search across every cell of a table's rows. Each
  * matching cell becomes a {@link FindRowMatch} carrying its row id, column, and
@@ -806,6 +843,12 @@ export async function findRowMatches(
 
   const orderBySql = buildRowOrderBySql(options.sort, tableName, columns)
   const pattern = `%${escapeLikePattern(options.q)}%`
+  // Select cells store option ids; also match the resolved option name so a search
+  // for the visible label finds the cell (the raw-id match below is kept too).
+  const selectNameExpr = buildSelectFindNameExpr(columns)
+  const nameMatchClause = selectNameExpr
+    ? sql` OR (${sql.raw(selectNameExpr)}) ILIKE ${pattern}`
+    : sql``
 
   const result = await db.transaction(async (trx) => {
     // Planner flags, not correctness: `enable_* = off` only penalizes a plan shape, so a
@@ -834,7 +877,7 @@ export async function findRowMatches(
       SELECT o.ordinal, o.id, kv.key AS column_name
       FROM ordered o
       CROSS JOIN LATERAL jsonb_each_text(o.data) kv
-      WHERE kv.value ILIKE ${pattern}
+      WHERE (kv.value ILIKE ${pattern}${nameMatchClause})
         AND ${inArray(sql`kv.key`, columnIds)}
       ORDER BY o.ordinal
       LIMIT ${FIND_MATCH_LIMIT + 1}
diff --git a/apps/sim/lib/table/select-values.test.ts b/apps/sim/lib/table/select-values.test.ts
new file mode 100644
index 00000000000..7c4d4b456da
--- /dev/null
+++ b/apps/sim/lib/table/select-values.test.ts
@@ -0,0 +1,102 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { resolveFilterSelectValues, selectValueToNames } from '@/lib/table/select-values'
+import type { ColumnDefinition } from '@/lib/table/types'
+
+const status: ColumnDefinition = {
+  id: 'col_status',
+  name: 'status',
+  type: 'select',
+  options: [
+    { id: 'opt_open', name: 'Open' },
+    { id: 'opt_closed', name: 'Closed' },
+  ],
+}
+
+const tags: ColumnDefinition = {
+  id: 'col_tags',
+  name: 'tags',
+  type: 'select',
+  multiple: true,
+  options: [
+    { id: 'opt_a', name: 'Alpha' },
+    { id: 'opt_b', name: 'Beta' },
+  ],
+}
+
+const title: ColumnDefinition = { id: 'col_title', name: 'title', type: 'string' }
+
+describe('selectValueToNames', () => {
+  it('maps a single option id to its name', () => {
+    expect(selectValueToNames(status, 'opt_open')).toBe('Open')
+  })
+
+  it('returns null for an empty single value', () => {
+    expect(selectValueToNames(status, null)).toBeNull()
+    expect(selectValueToNames(status, '')).toBeNull()
+  })
+
+  it('drops a single id with no matching option', () => {
+    expect(selectValueToNames(status, 'gone')).toBeNull()
+  })
+
+  it('maps multi ids to a names array in order', () => {
+    expect(selectValueToNames(tags, ['opt_b', 'opt_a'])).toEqual(['Beta', 'Alpha'])
+  })
+
+  it('drops orphaned ids in a multi value', () => {
+    expect(selectValueToNames(tags, ['opt_a', 'gone'])).toEqual(['Alpha'])
+  })
+
+  it('returns an empty array for an empty multi value', () => {
+    expect(selectValueToNames(tags, [])).toEqual([])
+  })
+})
+
+// Row-level select resolution now lives in `__tests__/cell-format.test.ts`,
+// fused with the column key translation.
+
+describe('resolveFilterSelectValues', () => {
+  const columns = [title, status, tags]
+
+  it('resolves an equality-shorthand option name to its id', () => {
+    expect(resolveFilterSelectValues({ col_status: 'Open' }, columns)).toEqual({
+      col_status: 'opt_open',
+    })
+  })
+
+  it('resolves names inside $eq/$ne/$in/$nin operators', () => {
+    expect(
+      resolveFilterSelectValues(
+        { col_status: { $ne: 'Closed' }, col_tags: { $in: ['Alpha', 'Beta'] } },
+        columns
+      )
+    ).toEqual({ col_status: { $ne: 'opt_closed' }, col_tags: { $in: ['opt_a', 'opt_b'] } })
+  })
+
+  it('accepts an id verbatim (idempotent) and leaves unknown values as-is', () => {
+    expect(resolveFilterSelectValues({ col_status: 'opt_open' }, columns)).toEqual({
+      col_status: 'opt_open',
+    })
+    expect(resolveFilterSelectValues({ col_status: 'Nope' }, columns)).toEqual({
+      col_status: 'Nope',
+    })
+  })
+
+  it('resolves names under $contains/$ncontains (multi-select membership)', () => {
+    expect(
+      resolveFilterSelectValues(
+        { col_tags: { $contains: 'Alpha' }, col_status: { $ncontains: 'Closed' } },
+        columns
+      )
+    ).toEqual({ col_tags: { $contains: 'opt_a' }, col_status: { $ncontains: 'opt_closed' } })
+  })
+
+  it('recurses into $and/$or and leaves non-select fields untouched', () => {
+    expect(
+      resolveFilterSelectValues({ $or: [{ col_status: 'Open' }, { col_title: 'x' }] }, columns)
+    ).toEqual({ $or: [{ col_status: 'opt_open' }, { col_title: 'x' }] })
+  })
+})
diff --git a/apps/sim/lib/table/select-values.ts b/apps/sim/lib/table/select-values.ts
new file mode 100644
index 00000000000..8addc65140d
--- /dev/null
+++ b/apps/sim/lib/table/select-values.ts
@@ -0,0 +1,98 @@
+/**
+ * Select-column value translation between stored option **ids** and human
+ * **names**. Cells store option ids (a single id, or a `string[]` of ids when
+ * `multiple`); the display value is the option `name`.
+ *
+ * Row-level id→name translation lives in `cell-format.ts`, which fuses it with
+ * the column key translation. What remains here is the reverse direction: a
+ * filter operand typed as an option name resolving back to the stored id.
+ */
+
+import { getColumnId } from '@/lib/table/column-keys'
+import type { ColumnDefinition, ConditionOperators, Filter, JsonValue } from '@/lib/table/types'
+import { resolveSelectOptionId } from '@/lib/table/validation'
+
+/**
+ * Resolves a `select` cell's stored option id(s) to their display name(s). A
+ * single column returns the option name (or null); a `multiple` column returns
+ * an array of names. Ids with no matching option (deleted) are dropped.
+ */
+export function selectValueToNames(
+  column: ColumnDefinition,
+  value: unknown
+): string | string[] | null {
+  const byId = new Map((column.options ?? []).map((o) => [o.id, o.name]))
+  const ids = Array.isArray(value)
+    ? value
+    : typeof value === 'string' && value !== ''
+      ? [value]
+      : []
+  const names = ids
+    .map((id) => (typeof id === 'string' ? byId.get(id) : undefined))
+    .filter((n): n is string => n != null)
+  return column.multiple ? names : (names[0] ?? null)
+}
+
+/** Resolves a single filter operand that may be an option name into its id. */
+function resolveOperand(value: JsonValue, options: ColumnDefinition['options']): JsonValue {
+  const id = resolveSelectOptionId(value, options ?? [])
+  return id ?? value
+}
+
+/**
+ * Returns a copy of an id-keyed filter with `select` field values resolved from
+ * option name → id, so a filter typed/served with option names matches the
+ * stored ids. Handles the equality shorthand, `$eq`/`$ne`/`$in`/`$nin`,
+ * `$contains`/`$ncontains` (multi-select membership), and
+ * nested `$and`/`$or`. Fields keyed by non-select columns pass through.
+ */
+export function resolveFilterSelectValues(filter: Filter, columns: ColumnDefinition[]): Filter {
+  const selectById = new Map(
+    columns.filter((c) => c.type === 'select').map((c) => [getColumnId(c), c])
+  )
+  const walk = (f: Filter): Filter => {
+    const out: Filter = {}
+    for (const [key, value] of Object.entries(f)) {
+      if ((key === '$or' || key === '$and') && Array.isArray(value)) {
+        out[key] = (value as Filter[]).map(walk)
+        continue
+      }
+      const column = selectById.get(key)
+      if (!column) {
+        out[key] = value
+        continue
+      }
+      const options = column.options
+      if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        const ops = value as ConditionOperators
+        const next: ConditionOperators = { ...ops }
+        if (ops.$eq !== undefined)
+          next.$eq = resolveOperand(ops.$eq, options) as ConditionOperators['$eq']
+        if (ops.$ne !== undefined)
+          next.$ne = resolveOperand(ops.$ne, options) as ConditionOperators['$ne']
+        if (Array.isArray(ops.$in))
+          next.$in = ops.$in.map((v) => resolveOperand(v, options)) as ConditionOperators['$in']
+        if (Array.isArray(ops.$nin))
+          next.$nin = ops.$nin.map((v) => resolveOperand(v, options)) as ConditionOperators['$nin']
+        // Multi-select asks membership, so its operands arrive under
+        // `$contains`/`$ncontains` rather than `$eq`/`$ne`.
+        if (ops.$contains !== undefined)
+          next.$contains = resolveOperand(
+            ops.$contains as JsonValue,
+            options
+          ) as ConditionOperators['$contains']
+        if (ops.$ncontains !== undefined)
+          next.$ncontains = resolveOperand(
+            ops.$ncontains as JsonValue,
+            options
+          ) as ConditionOperators['$ncontains']
+        out[key] = next
+      } else {
+        // Equality shorthand: `{ status: 'Open' }` → resolve to the id.
+        out[key] = resolveOperand(value as JsonValue, options) as Filter[string]
+      }
+    }
+    return out
+  }
+  return walk(filter)
+}
diff --git a/apps/sim/lib/table/snapshot-cache.test.ts b/apps/sim/lib/table/snapshot-cache.test.ts
index 2fe0927c537..5cef822fbdc 100644
--- a/apps/sim/lib/table/snapshot-cache.test.ts
+++ b/apps/sim/lib/table/snapshot-cache.test.ts
@@ -33,7 +33,17 @@ import { getOrCreateTableSnapshot, TableSnapshotTooLargeError } from '@/lib/tabl
 const table = {
   id: 'tbl_1',
   workspaceId: 'ws_1',
-  schema: { columns: [{ id: 'col_name', name: 'name', type: 'string' }] },
+  schema: {
+    columns: [
+      { id: 'col_name', name: 'name', type: 'string' },
+      {
+        id: 'col_status',
+        name: 'status',
+        type: 'select',
+        options: [{ id: 'opt_open', name: 'Open' }],
+      },
+    ],
+  },
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 } as any
 
@@ -54,7 +64,7 @@ describe('getOrCreateTableSnapshot', () => {
     lastHandle = null
     mockDeleteFile.mockResolvedValue(undefined)
     mockSelectExportRowPage.mockResolvedValueOnce([
-      { id: 'r1', data: { col_name: 'Ada' }, orderKey: 'a0' },
+      { id: 'r1', data: { col_name: 'Ada', col_status: 'opt_open' }, orderKey: 'a0' },
     ])
     mockSelectExportRowPage.mockResolvedValue([])
     mockCreateMultipartUpload.mockImplementation(({ key }: { key: string }) => {
@@ -103,10 +113,11 @@ describe('getOrCreateTableSnapshot', () => {
         context: 'execution',
       })
     )
-    expect(lastHandle?.content).toBe('name\nAda\n')
+    // Select cells materialize as the option name, not the stored id.
+    expect(lastHandle?.content).toBe('name,status\nAda,Open\n')
     expect(ref).toEqual({
       key: expect.stringMatching(/^table-snapshots\/ws_1\/tbl_1\/v3-[0-9a-f]{12}\.csv$/),
-      size: Buffer.byteLength('name\nAda\n'),
+      size: Buffer.byteLength('name,status\nAda,Open\n'),
       version: 3,
     })
     // Best-effort prune of v2.
@@ -151,9 +162,13 @@ describe('getOrCreateTableSnapshot', () => {
     // second materialize needs its own page sequence
     mockSelectExportRowPage.mockReset()
     mockSelectExportRowPage
-      .mockResolvedValueOnce([{ id: 'r1', data: { col_name: 'Ada' }, orderKey: 'a0' }])
+      .mockResolvedValueOnce([
+        { id: 'r1', data: { col_name: 'Ada', col_status: 'opt_open' }, orderKey: 'a0' },
+      ])
       .mockResolvedValueOnce([])
-      .mockResolvedValueOnce([{ id: 'r1', data: { col_name: 'Ada' }, orderKey: 'a0' }])
+      .mockResolvedValueOnce([
+        { id: 'r1', data: { col_name: 'Ada', col_status: 'opt_open' }, orderKey: 'a0' },
+      ])
       .mockResolvedValueOnce([])
 
     const ref = await getOrCreateTableSnapshot(table, 'req')
diff --git a/apps/sim/lib/table/snapshot-cache.ts b/apps/sim/lib/table/snapshot-cache.ts
index 716288fb98d..0c24eccfb39 100644
--- a/apps/sim/lib/table/snapshot-cache.ts
+++ b/apps/sim/lib/table/snapshot-cache.ts
@@ -17,7 +17,7 @@ import { userTableDefinitions } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
 import { getColumnId } from '@/lib/table/column-keys'
-import { formatCsvValue, neutralizeCsvFormula, toCsvRow } from '@/lib/table/export-format'
+import { formatCsvCell, neutralizeCsvFormula, toCsvRow } from '@/lib/table/export-format'
 import { selectExportRowPage } from '@/lib/table/jobs/service'
 import type { TableDefinition } from '@/lib/table/types'
 import { createMultipartUpload, deleteFile, headObject } from '@/lib/uploads/core/storage-service'
@@ -109,7 +109,9 @@ async function materialize(table: TableDefinition, key: string): Promise<number>
       if (page.length === 0) break
 
       const chunk = page
-        .map((row) => `${toCsvRow(columns.map((c) => formatCsvValue(row.data[getColumnId(c)])))}\n`)
+        .map(
+          (row) => `${toCsvRow(columns.map((c) => formatCsvCell(c, row.data[getColumnId(c)])))}\n`
+        )
         .join('')
       bytes += Buffer.byteLength(chunk)
       if (bytes > SNAPSHOT_MAX_BYTES) throw new TableSnapshotTooLargeError(table.id)
diff --git a/apps/sim/lib/table/sql.ts b/apps/sim/lib/table/sql.ts
index 5e695d93195..3b254ad3b17 100644
--- a/apps/sim/lib/table/sql.ts
+++ b/apps/sim/lib/table/sql.ts
@@ -30,7 +30,18 @@ export class TableQueryValidationError extends Error {
 }
 
 type ColumnType = ColumnDefinition['type']
-type ColumnTypeMap = ReadonlyMap<string, ColumnType>
+type ColumnMap = ReadonlyMap<string, ColumnDefinition>
+
+/**
+ * Operators that make sense on a `select` column (whose values are opaque option
+ * ids), split by cardinality. A single-select cell holds one id, so it compares
+ * for equality; a multi-select cell holds an array of ids, so the question is
+ * membership — hence contains / does-not-contain. `$eq` against an array cell
+ * can never be true (`{"t":["a"]} @> {"t":"a"}` is false in Postgres), so
+ * allowing it would silently match nothing.
+ */
+export const SINGLE_SELECT_OPERATORS = new Set(['$eq', '$ne', '$in', '$nin', '$empty'])
+export const MULTI_SELECT_OPERATORS = new Set(['$contains', '$ncontains', '$empty'])
 
 /**
  * Returns the Postgres cast needed to compare a JSONB text value of the given
@@ -50,12 +61,13 @@ function jsonbCastForType(type: ColumnType | undefined): 'numeric' | 'timestampt
 }
 
 /**
- * Maps a column's **stable id** (the JSONB storage key, via `getColumnId`) to
- * its type. Filter/sort objects arrive keyed by column id, so the lookups in the
- * clause builders use ids — not display names.
+ * Maps a column's **stable id** (the JSONB storage key, via `getColumnId`) to its
+ * definition. Filter/sort objects arrive keyed by column id, so the lookups in the
+ * clause builders use ids — not display names. The full definition (not just the
+ * type) is kept so the select branches can read `options`/`multiple`.
  */
-function buildColumnTypeMap(columns: ColumnDefinition[]): ColumnTypeMap {
-  return new Map(columns.map((col) => [getColumnId(col), col.type]))
+function buildColumnMap(columns: ColumnDefinition[]): ColumnMap {
+  return new Map(columns.map((col) => [getColumnId(col), col]))
 }
 
 /**
@@ -120,14 +132,14 @@ export function buildFilterClause(
   tableName: string,
   columns: ColumnDefinition[]
 ): SQL | undefined {
-  const columnTypeMap = buildColumnTypeMap(columns)
-  return buildFilterClauseInternal(filter, tableName, columnTypeMap)
+  const columnMap = buildColumnMap(columns)
+  return buildFilterClauseInternal(filter, tableName, columnMap)
 }
 
 function buildFilterClauseInternal(
   filter: Filter,
   tableName: string,
-  columnTypeMap: ColumnTypeMap
+  columnMap: ColumnMap
 ): SQL | undefined {
   const conditions: SQL[] = []
 
@@ -139,7 +151,7 @@ function buildFilterClauseInternal(
     // This represents a case where the filter is a logical OR of multiple filters
     // e.g. { $or: [{ status: 'active' }, { status: 'pending' }] }
     if (field === '$or' && Array.isArray(condition)) {
-      const orClause = buildLogicalClause(condition as Filter[], tableName, 'OR', columnTypeMap)
+      const orClause = buildLogicalClause(condition as Filter[], tableName, 'OR', columnMap)
       if (orClause) {
         conditions.push(orClause)
       }
@@ -149,7 +161,7 @@ function buildFilterClauseInternal(
     // This represents a case where the filter is a logical AND of multiple filters
     // e.g. { $and: [{ status: 'active' }, { status: 'pending' }] }
     if (field === '$and' && Array.isArray(condition)) {
-      const andClause = buildLogicalClause(condition as Filter[], tableName, 'AND', columnTypeMap)
+      const andClause = buildLogicalClause(condition as Filter[], tableName, 'AND', columnMap)
       if (andClause) {
         conditions.push(andClause)
       }
@@ -168,7 +180,7 @@ function buildFilterClauseInternal(
       tableName,
       field,
       condition as JsonValue | ConditionOperators,
-      columnTypeMap.get(field)
+      columnMap.get(field)
     )
     conditions.push(...fieldConditions)
   }
@@ -210,7 +222,7 @@ export function buildSortClause(
   columns: ColumnDefinition[]
 ): SQL | undefined {
   const clauses: SQL[] = []
-  const columnTypeMap = buildColumnTypeMap(columns)
+  const columnMap = buildColumnMap(columns)
 
   for (const [field, direction] of Object.entries(sort)) {
     validateFieldName(field)
@@ -221,8 +233,7 @@ export function buildSortClause(
       )
     }
 
-    const columnType = columnTypeMap.get(field)
-    clauses.push(buildSortFieldClause(tableName, field, direction, columnType))
+    clauses.push(buildSortFieldClause(tableName, field, direction, columnMap.get(field)))
   }
 
   return clauses.length > 0 ? sql.join(clauses, sql.raw(', ')) : undefined
@@ -306,16 +317,28 @@ function buildFieldCondition(
   tableName: string,
   field: string,
   condition: JsonValue | ConditionOperators,
-  columnType: ColumnType | undefined
+  column: ColumnDefinition | undefined
 ): SQL[] {
   validateFieldName(field)
 
+  const columnType = column?.type
+  const isSelect = columnType === 'select'
+  const isMultiSelect = isSelect && column?.multiple === true
   const conditions: SQL[] = []
 
   if (isRecordLike(condition)) {
     for (const [op, value] of Object.entries(condition)) {
       // Validate operator to ensure only allowed operators are used
       validateOperator(op)
+      // Select values are opaque option ids — range/pattern operators are meaningless.
+      if (isSelect) {
+        const allowed = isMultiSelect ? MULTI_SELECT_OPERATORS : SINGLE_SELECT_OPERATORS
+        if (!allowed.has(op)) {
+          throw new TableQueryValidationError(
+            `Operator "${op}" is not supported on ${isMultiSelect ? 'multi-select' : 'select'} column "${field}". Allowed: ${Array.from(allowed).join(', ')}`
+          )
+        }
+      }
 
       switch (op) {
         case '$eq':
@@ -375,12 +398,20 @@ function buildFieldCondition(
           break
 
         case '$contains':
-          conditions.push(buildLikeClause(tableName, field, value as string, 'contains'))
+          conditions.push(
+            isMultiSelect
+              ? buildArrayMembershipClause(tableName, field, value as JsonValue)
+              : buildLikeClause(tableName, field, value as string, 'contains')
+          )
           break
 
         case '$ncontains':
           conditions.push(
-            buildLikeClause(tableName, field, value as string, 'contains', { negate: true })
+            isMultiSelect
+              ? // Mirror the ILIKE negation: rows with no selection at all count
+                // as "does not contain", so an empty cell isn't silently excluded.
+                sql`NOT (${buildArrayMembershipClause(tableName, field, value as JsonValue)})`
+              : buildLikeClause(tableName, field, value as string, 'contains', { negate: true })
           )
           break
 
@@ -393,7 +424,9 @@ function buildFieldCondition(
           break
 
         case '$empty':
-          conditions.push(buildEmptyClause(tableName, field, coerceEmptyFlag(field, value)))
+          conditions.push(
+            buildEmptyClause(tableName, field, coerceEmptyFlag(field, value), isMultiSelect)
+          )
           break
 
         default:
@@ -409,7 +442,15 @@ function buildFieldCondition(
     // isRecordLike's negation can't structurally exclude ConditionOperators (no index
     // signature), unlike the prior typeof-based narrowing, so the JsonValue-only shape
     // of this branch is asserted rather than inferred.
-    conditions.push(buildContainmentClause(tableName, field, condition as JsonValue))
+    //
+    // On a multi-select the shorthand reads as "holds this option" — scalar
+    // equality against an array cell can never be true, so treat it as
+    // membership rather than compiling a filter that silently matches nothing.
+    conditions.push(
+      isMultiSelect
+        ? buildArrayMembershipClause(tableName, field, condition as JsonValue)
+        : buildContainmentClause(tableName, field, condition as JsonValue)
+    )
   }
 
   return conditions
@@ -440,11 +481,11 @@ function buildLogicalClause(
   subFilters: Filter[],
   tableName: string,
   operator: 'OR' | 'AND',
-  columnTypeMap: ColumnTypeMap
+  columnMap: ColumnMap
 ): SQL | undefined {
   const clauses: SQL[] = []
   for (const subFilter of subFilters) {
-    const clause = buildFilterClauseInternal(subFilter, tableName, columnTypeMap)
+    const clause = buildFilterClauseInternal(subFilter, tableName, columnMap)
     if (clause) {
       clauses.push(clause)
     }
@@ -462,6 +503,19 @@ function buildContainmentClause(tableName: string, field: string, value: JsonVal
   return sql`${sql.raw(`${tableName}.data`)} @> ${jsonObj}::jsonb`
 }
 
+/**
+ * Builds an array-membership clause for a multi-select cell:
+ * `data @> '{"field": [value]}'::jsonb`.
+ *
+ * The value is wrapped in an array because Postgres containment requires
+ * matching structure — `{"t":["a","b"]} @> {"t":"a"}` is **false**, while
+ * `{"t":["a","b"]} @> {"t":["a"]}` is true. Same GIN index as the scalar form.
+ */
+function buildArrayMembershipClause(tableName: string, field: string, value: JsonValue): SQL {
+  const jsonObj = JSON.stringify({ [field]: [value] })
+  return sql`${sql.raw(`${tableName}.data`)} @> ${jsonObj}::jsonb`
+}
+
 /**
  * Builds a typed range comparison against a JSONB cell.
  *
@@ -558,11 +612,24 @@ function coerceEmptyFlag(field: string, value: unknown): boolean {
 /**
  * Builds an emptiness check against a JSONB cell. `isEmpty` matches null cells
  * (absent key or JSON null, both surfaced as SQL NULL by `->>`) and empty
- * strings; the negation requires the cell to be present and non-empty.
+ * strings; the negation requires the cell to be present and non-empty. A
+ * multiselect cell holds a JSON array, so `->>'field'` renders `[]` (not '')
+ * when nothing is selected — treat that text as empty too.
  */
-function buildEmptyClause(tableName: string, field: string, isEmpty: boolean): SQL {
+function buildEmptyClause(
+  tableName: string,
+  field: string,
+  isEmpty: boolean,
+  isArray = false
+): SQL {
   const escapedField = field.replace(/'/g, "''")
   const cell = sql.raw(`${tableName}.data->>'${escapedField}'`)
+  if (isArray) {
+    // A multiselect renders `[]` when nothing is selected; treat that as empty too.
+    return isEmpty
+      ? sql`(${cell} IS NULL OR ${cell} = '' OR ${cell} = '[]')`
+      : sql`(${cell} IS NOT NULL AND ${cell} <> '' AND ${cell} <> '[]')`
+  }
   return isEmpty
     ? sql`(${cell} IS NULL OR ${cell} = '')`
     : sql`(${cell} IS NOT NULL AND ${cell} <> '')`
@@ -582,7 +649,7 @@ function buildSortFieldClause(
   tableName: string,
   field: string,
   direction: 'asc' | 'desc',
-  columnType: ColumnType | undefined
+  column: ColumnDefinition | undefined
 ): SQL {
   const escapedField = field.replace(/'/g, "''")
   const directionSql = direction.toUpperCase()
@@ -592,7 +659,20 @@ function buildSortFieldClause(
   }
 
   const jsonbExtract = `${tableName}.data->>'${escapedField}'`
-  const cast = jsonbCastForType(columnType)
+
+  // Select cells store opaque option ids; sort by the option **name** so ordering
+  // is alphabetical by the label the user sees, not by the internal id. A stored
+  // id with no matching option (deleted) falls back to the raw text.
+  if (column?.type === 'select') {
+    const orderExpr = buildSelectNameOrderExpr(
+      jsonbExtract,
+      `${tableName}.data->'${escapedField}'`,
+      column
+    )
+    return sql.raw(`${orderExpr} ${directionSql} NULLS LAST`)
+  }
+
+  const cast = jsonbCastForType(column?.type)
 
   if (cast === null) {
     // Sort as text (string, boolean, json, or unknown types)
@@ -602,3 +682,36 @@ function buildSortFieldClause(
   // NULLS LAST so rows with null/invalid values sort to the bottom regardless of direction
   return sql.raw(`(${jsonbExtract})::${cast} ${directionSql} NULLS LAST`)
 }
+
+/**
+ * Builds a `CASE` expression mapping a select cell's stored option id (the JSONB
+ * text extract) to its option name, so an ORDER BY sorts alphabetically by label.
+ * Ids and names are SQL-escaped and embedded literally (options are trusted schema
+ * data, not caller input); an unmapped id falls through to the raw extract.
+ *
+ * A multiselect cell is an array of ids, which matches no single-id branch — it
+ * sorts on its elements resolved to names and joined in stored order, the same
+ * text the grid renders and an export writes. A scalar left over from before a
+ * single→multi toggle still takes the single-id branch.
+ */
+function buildSelectNameOrderExpr(
+  jsonbExtract: string,
+  jsonbValue: string,
+  column: ColumnDefinition
+): string {
+  const options = column.options ?? []
+  if (options.length === 0) return jsonbExtract
+  const whens = options
+    .map((o) => `WHEN '${o.id.replace(/'/g, "''")}' THEN '${o.name.replace(/'/g, "''")}'`)
+    .join(' ')
+  const singleExpr = `CASE ${jsonbExtract} ${whens} ELSE ${jsonbExtract} END`
+  if (!column.multiple) return singleExpr
+
+  const nameById = JSON.stringify(
+    Object.fromEntries(new Map(options.map((o) => [o.id, o.name])))
+  ).replace(/'/g, "''")
+  return `CASE WHEN jsonb_typeof(${jsonbValue}) = 'array' THEN (
+    SELECT string_agg(COALESCE('${nameById}'::jsonb ->> e.v, e.v), ', ' ORDER BY e.ord)
+    FROM jsonb_array_elements_text(${jsonbValue}) WITH ORDINALITY AS e(v, ord)
+  ) ELSE ${singleExpr} END`
+}
diff --git a/apps/sim/lib/table/trigger.ts b/apps/sim/lib/table/trigger.ts
index 16b55852a37..cdb2b2a3169 100644
--- a/apps/sim/lib/table/trigger.ts
+++ b/apps/sim/lib/table/trigger.ts
@@ -8,7 +8,8 @@
 
 import { createLogger } from '@sim/logger'
 import { generateShortId } from '@sim/utils/id'
-import { buildNameById, getColumnId, rowDataIdToName } from '@/lib/table/column-keys'
+import { fillMissingColumns, namedRowMapper } from '@/lib/table/cell-format'
+import { buildNameById } from '@/lib/table/column-keys'
 import type { RowData, TableRow, TableSchema } from '@/lib/table/types'
 import { readCanonicalTriggerValue } from '@/lib/webhooks/polling/canonical'
 
@@ -65,7 +66,9 @@ export async function fireTableTrigger(
 
     const headers = schema.columns.map((c) => c.name)
     // The webhook payload is name-keyed (the workflow author references columns
-    // by name); stored row data is id-keyed, so translate on the way out.
+    // by name) and carries option names, not stored select ids — the mapper
+    // translates both in one pass. Hoisted: reused for every row and webhook.
+    const toNamedRow = namedRowMapper(schema.columns)
     const nameById = buildNameById(schema)
 
     // Filter to webhooks watching this table with a matching event type
@@ -99,9 +102,8 @@ export async function fireTableTrigger(
 
       for (const row of rows) {
         const previousIdData = oldRows?.get(row.id) ?? null
-        // Translate id-keyed stored data → name-keyed for the external payload.
-        const rawRow = rowDataIdToName(row.data, nameById)
-        const previousRow = previousIdData ? rowDataIdToName(previousIdData, nameById) : null
+        const rawRow = toNamedRow(row.data)
+        const previousRow = previousIdData ? toNamedRow(previousIdData) : null
         const changedColumns = previousIdData
           ? detectChangedColumns(previousIdData, row.data)
               .map((id) => nameById.get(id))
@@ -114,14 +116,9 @@ export async function fireTableTrigger(
           if (!hasWatchedChange) continue
         }
 
-        // Build mapped row if includeHeaders is enabled
-        let mappedRow: Record<string, unknown> | null = null
-        if (includeHeaders && headers.length > 0) {
-          mappedRow = {}
-          for (const col of schema.columns) {
-            mappedRow[col.name] = row.data[getColumnId(col)] ?? null
-          }
-        }
+        // `row` is `rawRow` widened so its key set matches `headers` exactly.
+        const mappedRow =
+          includeHeaders && headers.length > 0 ? fillMissingColumns(rawRow, schema.columns) : null
 
         const payload: TableTriggerPayload = {
           row: mappedRow,
diff --git a/apps/sim/lib/table/types.ts b/apps/sim/lib/table/types.ts
index 384ca5afb7e..54150a27af2 100644
--- a/apps/sim/lib/table/types.ts
+++ b/apps/sim/lib/table/types.ts
@@ -26,6 +26,15 @@ export interface ColumnOption {
   label: string
 }
 
+/**
+ * One choice in a `select`/`multiselect` column. `id` is stable — cell data
+ * references it, so renaming an option never rewrites rows.
+ */
+export interface SelectOption {
+  id: string
+  name: string
+}
+
 export interface ColumnDefinition {
   /**
    * Stable storage key for this column. Row data, metadata, workflow-group
@@ -45,6 +54,13 @@ export interface ColumnDefinition {
    * `row.data[getColumnId(col)]` is populated by the group's per-cell run.
    */
   workflowGroupId?: string
+  /**
+   * Declared options for a `select` column. Cells store option ids — a single
+   * id when `multiple` is falsy, an array of ids when `multiple` is true.
+   */
+  options?: SelectOption[]
+  /** When true, a `select` column accepts several options per cell (string[]). */
+  multiple?: boolean
 }
 
 /** One group output → one plain column. */
@@ -644,6 +660,32 @@ export interface UpdateColumnTypeData {
   tableId: string
   columnName: string
   newType: (typeof COLUMN_TYPES)[number]
+  /** Options to set when changing to a `select` type. */
+  options?: SelectOption[]
+  /** Whether the `select` column accepts multiple options per cell. */
+  multiple?: boolean
+  /**
+   * The `required` value the same request is about to set, when it changes type
+   * and constraints together. Those are separate transactions, so the
+   * conversion has to validate against the constraint the column will END UP
+   * with — otherwise it commits and the constraint write then fails.
+   */
+  required?: boolean
+}
+
+export interface UpdateColumnOptionsData {
+  tableId: string
+  columnName: string
+  options: SelectOption[]
+  /** Toggle single/multi selection alongside the options update. */
+  multiple?: boolean
+  /**
+   * The `required` value the same request is about to set. The constraint write
+   * is a separate transaction, so the options update has to validate against
+   * the constraint the column will END UP with — otherwise it clears cells and
+   * the constraint write then fails, leaving the removal committed.
+   */
+  required?: boolean
 }
 
 export interface UpdateColumnConstraintsData {
diff --git a/apps/sim/lib/table/validation.test.ts b/apps/sim/lib/table/validation.test.ts
new file mode 100644
index 00000000000..5e2b28732a0
--- /dev/null
+++ b/apps/sim/lib/table/validation.test.ts
@@ -0,0 +1,182 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import type { ColumnDefinition, RowData, TableSchema } from '@/lib/table/types'
+import {
+  coerceRowToSchema,
+  resolveSelectOptionId,
+  validateColumnDefinition,
+  validateRowAgainstSchema,
+} from '@/lib/table/validation'
+
+const selectColumn: ColumnDefinition = {
+  id: 'col_status',
+  name: 'status',
+  type: 'select',
+  options: [
+    { id: 'opt_open', name: 'Open' },
+    { id: 'opt_closed', name: 'Closed' },
+  ],
+}
+
+const multiselectColumn: ColumnDefinition = {
+  id: 'col_tags',
+  name: 'tags',
+  type: 'select',
+  multiple: true,
+  options: [
+    { id: 'opt_a', name: 'Alpha' },
+    { id: 'opt_b', name: 'Beta' },
+  ],
+}
+
+function schemaWith(...columns: ColumnDefinition[]): TableSchema {
+  return { columns }
+}
+
+describe('validateRowAgainstSchema — select', () => {
+  it('accepts a value matching an option id', () => {
+    expect(
+      validateRowAgainstSchema({ col_status: 'opt_open' }, schemaWith(selectColumn)).valid
+    ).toBe(true)
+  })
+
+  it('rejects a value that is not a declared option id', () => {
+    expect(
+      validateRowAgainstSchema({ col_status: 'opt_unknown' }, schemaWith(selectColumn)).valid
+    ).toBe(false)
+  })
+
+  it('rejects a non-string value', () => {
+    const result = validateRowAgainstSchema(
+      { col_status: 123 } as unknown as RowData,
+      schemaWith(selectColumn)
+    )
+    expect(result.valid).toBe(false)
+  })
+})
+
+describe('validateRowAgainstSchema — multiselect', () => {
+  it('accepts an array of valid option ids', () => {
+    expect(
+      validateRowAgainstSchema({ col_tags: ['opt_a', 'opt_b'] }, schemaWith(multiselectColumn))
+        .valid
+    ).toBe(true)
+  })
+
+  it('rejects an array containing an unknown id', () => {
+    expect(
+      validateRowAgainstSchema({ col_tags: ['opt_a', 'nope'] }, schemaWith(multiselectColumn)).valid
+    ).toBe(false)
+  })
+
+  it('rejects a non-array value', () => {
+    expect(
+      validateRowAgainstSchema({ col_tags: 'opt_a' }, schemaWith(multiselectColumn)).valid
+    ).toBe(false)
+  })
+
+  it('rejects an empty array when required', () => {
+    const result = validateRowAgainstSchema(
+      { col_tags: [] },
+      schemaWith({ ...multiselectColumn, required: true })
+    )
+    expect(result.valid).toBe(false)
+  })
+})
+
+describe('coerceRowToSchema — select', () => {
+  it('maps an option name to its id', () => {
+    const data: RowData = { col_status: 'Open' }
+    const result = coerceRowToSchema(data, schemaWith(selectColumn))
+    expect(result.valid).toBe(true)
+    expect(data.col_status).toBe('opt_open')
+  })
+
+  it('maps an option name case-insensitively', () => {
+    const data: RowData = { col_status: 'closed' }
+    coerceRowToSchema(data, schemaWith(selectColumn))
+    expect(data.col_status).toBe('opt_closed')
+  })
+
+  it('nulls an unmatched value on an optional column', () => {
+    const data: RowData = { col_status: 'banana' }
+    const result = coerceRowToSchema(data, schemaWith(selectColumn))
+    expect(result.valid).toBe(true)
+    expect(data.col_status).toBeNull()
+  })
+})
+
+describe('coerceRowToSchema — multiselect', () => {
+  it('resolves names and drops unmatched entries', () => {
+    const data: RowData = { col_tags: ['Alpha', 'opt_b', 'ghost'] }
+    const result = coerceRowToSchema(data, schemaWith(multiselectColumn))
+    expect(result.valid).toBe(true)
+    expect(data.col_tags).toEqual(['opt_a', 'opt_b'])
+  })
+
+  it('wraps a single string into a one-element array', () => {
+    const data: RowData = { col_tags: 'opt_a' as unknown as string[] }
+    coerceRowToSchema(data, schemaWith(multiselectColumn))
+    expect(data.col_tags).toEqual(['opt_a'])
+  })
+})
+
+describe('resolveSelectOptionId', () => {
+  const options = selectColumn.options ?? []
+
+  it('resolves a stable id', () => {
+    expect(resolveSelectOptionId('opt_open', options)).toBe('opt_open')
+  })
+
+  it('resolves a display name (case-insensitively)', () => {
+    expect(resolveSelectOptionId('closed', options)).toBe('opt_closed')
+  })
+
+  it('returns null for an unknown value (drives the type-conversion compatibility gate)', () => {
+    expect(resolveSelectOptionId('nope', options)).toBeNull()
+  })
+})
+
+describe('validateColumnDefinition — select options', () => {
+  it('accepts a well-formed select column', () => {
+    expect(validateColumnDefinition(selectColumn).valid).toBe(true)
+  })
+
+  it('requires at least one option', () => {
+    expect(validateColumnDefinition({ ...selectColumn, options: [] }).valid).toBe(false)
+  })
+
+  it('rejects duplicate option ids', () => {
+    const result = validateColumnDefinition({
+      ...selectColumn,
+      options: [
+        { id: 'dup', name: 'One' },
+        { id: 'dup', name: 'Two' },
+      ],
+    })
+    expect(result.valid).toBe(false)
+  })
+
+  it('rejects duplicate option names', () => {
+    const result = validateColumnDefinition({
+      ...selectColumn,
+      options: [
+        { id: 'a', name: 'Same' },
+        { id: 'b', name: 'same' },
+      ],
+    })
+    expect(result.valid).toBe(false)
+  })
+
+  it('rejects options on a non-select column', () => {
+    const result = validateColumnDefinition({
+      id: 'c',
+      name: 'plain',
+      type: 'string',
+      options: [{ id: 'a', name: 'One' }],
+    })
+    expect(result.valid).toBe(false)
+  })
+})
diff --git a/apps/sim/lib/table/validation.ts b/apps/sim/lib/table/validation.ts
index df773160513..8b6d58ff0e2 100644
--- a/apps/sim/lib/table/validation.ts
+++ b/apps/sim/lib/table/validation.ts
@@ -7,13 +7,20 @@ import { userTableRows } from '@sim/db/schema'
 import { and, eq, or, type SQL, sql } from 'drizzle-orm'
 import { NextResponse } from 'next/server'
 import { getColumnId } from '@/lib/table/column-keys'
-import { COLUMN_TYPES, getMaxRowSizeBytes, NAME_PATTERN, TABLE_LIMITS } from '@/lib/table/constants'
+import {
+  COLUMN_TYPES,
+  getMaxRowSizeBytes,
+  MAX_SELECT_OPTIONS,
+  NAME_PATTERN,
+  TABLE_LIMITS,
+} from '@/lib/table/constants'
 import { normalizeDateCellValue } from '@/lib/table/dates'
 import { withSeqscanOff } from '@/lib/table/planner'
 import type {
   ColumnDefinition,
   JsonValue,
   RowData,
+  SelectOption,
   TableSchema,
   ValidationResult,
 } from '@/lib/table/types'
@@ -256,12 +263,66 @@ export function validateRowAgainstSchema(data: RowData, schema: TableSchema): Va
           errors.push(`${column.name} must be valid JSON`)
         }
         break
+      case 'select': {
+        const ids = optionIds(column)
+        if (column.multiple) {
+          if (!Array.isArray(value)) {
+            errors.push(`${column.name} must be a list of options`)
+          } else if (!value.every((v) => typeof v === 'string' && ids.has(v))) {
+            errors.push(`${column.name} must only contain defined options`)
+          } else if (column.required && value.length === 0) {
+            errors.push(`Missing required field: ${column.name}`)
+          }
+        } else if (typeof value !== 'string' || !ids.has(value)) {
+          errors.push(`${column.name} must be one of the defined options`)
+        }
+        break
+      }
     }
   }
 
   return { valid: errors.length === 0, errors }
 }
 
+/** Set of valid option ids for a `select`/`multiselect` column. */
+function optionIds(column: ColumnDefinition): Set<string> {
+  return new Set((column.options ?? []).map((o) => o.id))
+}
+
+/**
+ * Resolves a raw cell value to a declared option id, accepting either the
+ * stable id or (tolerant for tool/import writes) the option's display name.
+ * Returns null when no option matches. Exported so the column-type-conversion
+ * path can gate a `select`/`multiselect` change on whether existing values
+ * actually fit the target option set.
+ */
+export function resolveSelectOptionId(value: JsonValue, options: SelectOption[]): string | null {
+  if (typeof value !== 'string') return null
+  const byId = options.find((o) => o.id === value)
+  if (byId) return byId.id
+  const byName =
+    options.find((o) => o.name === value) ??
+    options.find((o) => o.name.toLowerCase() === value.toLowerCase())
+  return byName ? byName.id : null
+}
+
+/**
+ * Splits a raw value into the parts a multi-select cell should resolve. A cell
+ * may arrive as an array (canonical) or as a single comma-delimited string —
+ * the shape a multi cell exports, copies, and converts to text as — so both the
+ * write-path coercion and the column-conversion compatibility check read it
+ * through here rather than each deciding for itself. Option names that
+ * themselves contain commas are an accepted ambiguity.
+ */
+export function splitMultiSelectInput(value: JsonValue): JsonValue[] {
+  if (Array.isArray(value)) return value
+  if (typeof value !== 'string') return [value]
+  return value
+    .split(',')
+    .map((part) => part.trim())
+    .filter((part) => part !== '')
+}
+
 /**
  * Attempts to coerce a non-null value to a column's declared type. Returns the
  * coerced value when the value already matches or can be converted without
@@ -270,9 +331,9 @@ export function validateRowAgainstSchema(data: RowData, schema: TableSchema): Va
  */
 function coerceValueToColumnType(
   value: JsonValue,
-  type: ColumnDefinition['type']
+  column: ColumnDefinition
 ): { ok: true; value: JsonValue } | { ok: false } {
-  switch (type) {
+  switch (column.type) {
     case 'string':
       if (typeof value === 'string') return { ok: true, value }
       if (typeof value === 'number' || typeof value === 'boolean') {
@@ -310,6 +371,23 @@ function coerceValueToColumnType(
       if (date && !Number.isNaN(date.getTime())) return { ok: true, value: date.toISOString() }
       return { ok: false }
     }
+    case 'select': {
+      const options = column.options ?? []
+      if (column.multiple) {
+        const raw = splitMultiSelectInput(value)
+        const ids: string[] = []
+        for (const entry of raw) {
+          const id = resolveSelectOptionId(entry, options)
+          if (id !== null && !ids.includes(id)) ids.push(id)
+        }
+        return { ok: true, value: ids }
+      }
+      // Single: tolerate an array (e.g. right after a multiple→single toggle) by
+      // resolving its first element so the value isn't dropped wholesale.
+      const single = Array.isArray(value) ? value[0] : value
+      const id = single === undefined ? null : resolveSelectOptionId(single, options)
+      return id !== null ? { ok: true, value: id } : { ok: false }
+    }
     default:
       return { ok: true, value }
   }
@@ -331,7 +409,7 @@ export function coerceRowValues(data: RowData, schema: TableSchema): void {
     const value = data[key]
     if (value === null || value === undefined) continue
 
-    const coerced = coerceValueToColumnType(value, column.type)
+    const coerced = coerceValueToColumnType(value, column)
     if (coerced.ok) {
       data[key] = coerced.value
     } else if (!column.required) {
@@ -689,5 +767,61 @@ export function validateColumnDefinition(column: ColumnDefinition): ValidationRe
     )
   }
 
+  if (column.type === 'select') {
+    errors.push(...validateSelectOptions(column))
+    // Uniqueness on a select compares the stored option id, so it caps each
+    // option at one row for the whole table — and the UI hides the toggle, so a
+    // constraint set through the API or an agent could never be cleared.
+    if (column.unique) {
+      errors.push(`Column "${column.name}" of type "select" cannot be unique`)
+    }
+  } else {
+    if (column.options !== undefined) {
+      errors.push(`Column "${column.name}" cannot define options for type "${column.type}"`)
+    }
+    // A stored `multiple` on a non-select column is inert until the column is
+    // converted, at which point `updateColumnType` inherits it — silently
+    // turning an intended single-select into a multiselect and rewriting every
+    // cell as an array.
+    if (column.multiple) {
+      errors.push(`Column "${column.name}" cannot be multiple for type "${column.type}"`)
+    }
+  }
+
   return { valid: errors.length === 0, errors }
 }
+
+/** Validates the option set declared on a `select` column. */
+function validateSelectOptions(column: ColumnDefinition): string[] {
+  const errors: string[] = []
+  const options = column.options
+  if (!Array.isArray(options) || options.length === 0) {
+    errors.push(`Column "${column.name}" of type "${column.type}" must define at least one option`)
+    return errors
+  }
+  if (options.length > MAX_SELECT_OPTIONS) {
+    errors.push(`Column "${column.name}" cannot have more than ${MAX_SELECT_OPTIONS} options`)
+  }
+  const ids = new Set<string>()
+  const names = new Set<string>()
+  for (const opt of options) {
+    if (!opt.id || typeof opt.id !== 'string') {
+      errors.push(`Column "${column.name}" has an option missing an id`)
+    } else if (ids.has(opt.id)) {
+      errors.push(`Column "${column.name}" has duplicate option id "${opt.id}"`)
+    } else {
+      ids.add(opt.id)
+    }
+    if (!opt.name || typeof opt.name !== 'string') {
+      errors.push(`Column "${column.name}" has an option missing a name`)
+    } else {
+      const key = opt.name.toLowerCase()
+      if (names.has(key)) {
+        errors.push(`Column "${column.name}" has duplicate option name "${opt.name}"`)
+      } else {
+        names.add(key)
+      }
+    }
+  }
+  return errors
+}
diff --git a/apps/sim/stores/table/types.ts b/apps/sim/stores/table/types.ts
index 55521402cef..444f41bf10d 100644
--- a/apps/sim/stores/table/types.ts
+++ b/apps/sim/stores/table/types.ts
@@ -55,6 +55,11 @@ export type TableUndoAction =
       columnPosition: number
       columnUnique: boolean
       columnRequired: boolean
+      // A `select` column is invalid without its option set, so the snapshot has
+      // to carry it or the restore is rejected — and the saved cell data, which
+      // holds option ids, would have nothing to attach to.
+      columnOptions?: ColumnDefinition['options']
+      columnMultiple?: boolean
       cellData: Array<{ rowId: string; value: unknown }>
       previousOrder: string[] | null
       previousWidth: number | null