@@ -242,7 +242,7 @@ export const TableV2Block: BlockConfig<TableQueryV2Response> = {
 - like/ilike use * as the wildcard (e.g. {"field":"name","op":"ilike","value":"*jo*"}).
 - Omit Limit to get the entire matching result in one response — the query fails with a clear error if it exceeds 5MB (narrow with a filter or set a Limit).
 - With a Limit, pages can end at the Limit or the 5MB byte budget, whichever comes first — pass nextCursor back as the cursor and loop until it is null; never infer completion from page size.
-- Columns are scalar (string/number/boolean/date) or opaque json — there are no array columns; for substring use ilike with *x*.
+- For substring matching on a text column use ilike with *x*. A select column accepts only a subset of the operators — eq/ne/in/nin when single, contains/ncontains when multi (a multi-select cell holds a list) — and the query is rejected outright on anything else.
 - Use Columns to Return to keep only the fields a downstream step needs (e.g. ["col_email","name"]) — the 5MB budget counts only the returned columns, so narrowing columns is another way to fit a large table; leave it empty for every column.`,
   docsLink: 'https://docs.sim.ai/integrations/table',
   category: 'blocks',
 
@@ -76,6 +76,44 @@ describe('readTableSchemaAsExecutor', () => {
     })
   })
 
+  /**
+   * A select column's cardinality decides which filter operators it accepts, so
+   * LLM enrichment needs it to name the right subset. It is carried only for
+   * select columns, where it means something.
+   */
+  it('carries select cardinality through and omits it elsewhere', async () => {
+    mocks.readTable.mockResolvedValue({
+      table: {
+        name: 'Transactions',
+        schema: {
+          columns: [
+            { id: 'column-category', name: 'category', type: 'select' },
+            { id: 'column-tags', name: 'tags', type: 'select', multiple: true },
+            { id: 'column-amount', name: 'amount', type: 'number' },
+          ],
+        },
+      },
+    })
+
+    const result = await readTableSchemaAsExecutor({
+      tableId: 'table-1',
+      context: {
+        workflowId: 'workflow-1',
+        executorDelegationOrigin: {
+          subjectUserId: 'user-1',
+          workflowId: 'workflow-1',
+          executionId: 'execution-1',
+        },
+      },
+    })
+
+    expect(result.columns).toEqual([
+      { name: 'category', type: 'select', multiple: false },
+      { name: 'tags', type: 'select', multiple: true },
+      { name: 'amount', type: 'number' },
+    ])
+  })
+
   it('fails closed when canonical schema metadata is malformed', async () => {
     mocks.readTable.mockResolvedValueOnce({
       table: { name: 'Customers', schema: { columns: [{ name: 'email', type: 'unknown' }] } },
 
@@ -32,7 +32,12 @@ export async function readTableSchemaAsExecutor({
     if (typeof column.name !== 'string' || !isColumnType(column.type)) {
       throw new Error(`Invalid table column ${index} while enriching schema for ${tableId}`)
     }
-    return { name: column.name, type: column.type }
+    // `multiple` is a select-only concern (it decides which filter operators the
+    // column accepts), so it is carried only where it means something rather
+    // than stamped onto every column.
+    return column.type === 'select'
+      ? { name: column.name, type: column.type, multiple: column.multiple === true }
+      : { name: column.name, type: column.type }
   })
 
   return { name: table.name, columns }
 
@@ -82,6 +82,46 @@ describe('enrichTableToolDescription for table_query_rows_v2', () => {
   })
 })
 
+/**
+ * A select column rejects any operator outside its subset — the query layer
+ * throws rather than returning no rows — so the description has to name the
+ * subset per column instead of advertising the full operator list.
+ */
+describe('select columns in the v2 description', () => {
+  const SELECT_TABLE: TableSummary = {
+    name: 'Transactions',
+    columns: [
+      { name: 'category', type: 'select', multiple: false },
+      { name: 'tags', type: 'select', multiple: true },
+      { name: 'description', type: 'string' },
+    ],
+  }
+
+  const enriched = enrichTableToolDescription('Query rows.', SELECT_TABLE, 'table_query_rows_v2')
+
+  it('names the allowed operators on a single-select column', () => {
+    expect(enriched).toContain(
+      'category (single-select; only eq, ne, in, nin, isEmpty, isNotEmpty)'
+    )
+  })
+
+  it('names the allowed operators on a multi-select column', () => {
+    expect(enriched).toContain('tags (multi-select; only contains, ncontains, isEmpty, isNotEmpty)')
+  })
+
+  it('leaves non-select columns unannotated', () => {
+    expect(enriched).toContain('description (string)')
+  })
+
+  it('never claims the table has no array columns', () => {
+    expect(enriched).not.toContain('no array columns')
+  })
+
+  it('steers multi-select matching to contains rather than ilike', () => {
+    expect(enriched).toContain('match it with contains, never ilike')
+  })
+})
+
 describe('enrichTableToolParameters for table_query_rows_v2', () => {
   const { properties, required } = enrichTableToolParameters(
     V2_SCHEMA,
 
@@ -33,6 +33,22 @@ export const FILTER_OPERATIONS = new Set([
  */
 const TABLE_QUERY_ROWS_V2 = 'table_query_rows_v2'
 
+/**
+ * Renders one column line for the v2 description.
+ *
+ * A select column accepts only a subset of the operators — `eq`/`ne`/`in`/`nin`
+ * when single, `contains`/`ncontains` when multi — and the query layer THROWS on
+ * anything else (`buildFilterConditions` in `lib/table/sql.ts`). Naming the
+ * subset inline is what stops the model from reaching for `ilike` on a select
+ * column and turning a valid question into a validation error.
+ */
+function v2ColumnLine(column: TableSummary['columns'][number]): string {
+  if (column.type !== 'select') return `  - ${column.name} (${column.type})`
+  const allowed = column.multiple ? 'contains, ncontains' : 'eq, ne, in, nin'
+  const kind = column.multiple ? 'multi-select' : 'single-select'
+  return `  - ${column.name} (${kind}; only ${allowed}, isEmpty, isNotEmpty)`
+}
+
 /**
  * Builds a predicate example from real columns, preferring a numeric `gte` over
  * a string `eq` because ranking and threshold questions are what the grammar
@@ -87,6 +103,7 @@ export function enrichTableToolDescription(
   const columnList = table.columns.map((col) => `  - ${col.name} (${col.type})`).join('\n')
 
   if (toolId === TABLE_QUERY_ROWS_V2) {
+    const v2ColumnList = table.columns.map(v2ColumnLine).join('\n')
     const numberCol = table.columns.find((c) => c.type === 'number')
     const orderExample = numberCol
       ? `
@@ -101,14 +118,15 @@ INSTRUCTIONS:
 3. For multiple conditions wrap them in {"all":[...]} for AND or {"any":[...]} for OR; groups nest
 4. Operators: eq, ne, gt, gte, lt, lte, in, nin, like, ilike, nlike, nilike, contains, ncontains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty
 5. like/ilike use * as the wildcard, e.g. {"field":"name","op":"ilike","value":"*jo*"}
-6. There are no array columns - for substring matching use ilike with *x*
-7. For ranking queries (highest, lowest, Nth, top N) set order and a small limit, e.g. limit 1 for the highest, 2 for the second highest
-8. Omit limit to return every matching row; the query fails if the result exceeds 5MB, so narrow with a filter instead of guessing a limit
-9. With a limit, a page can end early at the byte budget - a non-null nextCursor means more rows remain, so pass it back as cursor and loop until it is null. Never infer completion from page size
-10. Omit the filter only when the user genuinely wants every row
+6. Any column listed below with a restricted operator set accepts ONLY those operators - the query is rejected outright otherwise. A multi-select cell holds a list, so match it with contains, never ilike
+7. For substring matching on a text column use ilike with *x*
+8. For ranking queries (highest, lowest, Nth, top N) set order and a small limit, e.g. limit 1 for the highest, 2 for the second highest
+9. Omit limit to return every matching row; the query fails if the result exceeds 5MB, so narrow with a filter instead of guessing a limit
+10. With a limit, a page can end early at the byte budget - a non-null nextCursor means more rows remain, so pass it back as cursor and loop until it is null. Never infer completion from page size
+11. Omit the filter only when the user genuinely wants every row
 
 Table "${table.name}" columns:
-${columnList}
+${v2ColumnList}
 ${v2PredicateExample(table)}${orderExample}`
   }
 
 
@@ -470,7 +470,12 @@ export type TableInfo = Pick<TableDefinition, 'id' | 'name' | 'schema'>
 /** Simplified table summary for LLM enrichment and display contexts. */
 export interface TableSummary {
   name: string
-  columns: Array<Pick<ColumnDefinition, 'name' | 'type'>>
+  /**
+   * `multiple` is carried because a select column's allowed filter operators
+   * depend on it — LLM enrichment has to name the right subset or the model
+   * writes a predicate the query layer rejects.
+   */
+  columns: Array<Pick<ColumnDefinition, 'name' | 'type' | 'multiple'>>
 }
 
 export interface TableRow {