fix(chat): scope selections to the columns actually picked, and stop under-counting rows

Three findings from one Bugbot round.

Hidden columns widened cell ranges (reported twice). buildTableSelectionContext
and contextMenuColumnIds collapsed a range to an open scope when it covered
'every column', comparing against displayColumns.length — which drops hidden
columns AND expands workflow groups, so it never meant 'the whole schema'.
Selecting every visible column therefore cleared columnIds and the server
re-fetched columns the user had hidden. The collapse is removed rather than
re-based on a schema count: no count available to a caller describes the schema,
and an explicit column list is what the user actually selected. totalColumnCount
is gone from the signature.

Add-to-chat label undercounted rows. The menu derived its count from
selectedRowCount (loaded rows only) while the chip was built from the full
rowSel.ids set, so the label could promise fewer rows than were sent. Both now
read one addToChatRowIds memo, with the count passed through explicitly since it
legitimately differs from the count the delete/run labels use.

Monaco line range was off by one. A full-line highlight ends at column 1 of the
FOLLOWING line, so endLineNumber named a line that contributed no text — the
chip label and the agent prompt both claimed an extra line.

The collapse test I added last round asserted the buggy behavior as correct; it
now pins the opposite, and fails if the collapse returns.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor.tsx

@@ -390,7 +390,13 @@ export const TextEditor = memo(function TextEditor({
     const text = model.getValueInRange(sel)
     if (!text.trim()) return null
     const startLine = sel.startLineNumber
-    const endLine = sel.endLineNumber
+    // A full-line highlight ends at column 1 of the FOLLOWING line, so that line
+    // contributed no text — reporting it would claim a range one line longer
+    // than what was selected, in both the chip label and the agent's prompt.
+    const endLine =
+      sel.endColumn === 1 && sel.endLineNumber > startLine
+        ? sel.endLineNumber - 1
+        : sel.endLineNumber
     return {
       kind: 'file_selection',
       fileId: file.id,

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/context-menu/context-menu.tsx

@@ -64,6 +64,13 @@ interface ContextMenuProps {
    * {@link ContextMenuProps.workflowCellScoped}.
    */
   addToChatCellScoped?: boolean
+  /**
+   * Rows the chip will reference. Differs from {@link ContextMenuProps.selectedRowCount}
+   * because a gutter selection can extend past the loaded page and the chip
+   * carries ids the server re-fetches, so the label must not promise fewer rows
+   * than are actually sent. Defaults to `selectedRowCount`.
+   */
+  addToChatRowCount?: number
 }
 
 export function ContextMenu({
@@ -90,6 +97,7 @@ export function ContextMenu({
   disableDelete = false,
   onAddToChat,
   addToChatCellScoped = false,
+  addToChatRowCount,
 }: ContextMenuProps) {
   const count = selectedRowCount.toLocaleString()
   const deleteLabel = selectedRowCount > 1 ? `Delete ${count} rows` : 'Delete row'
@@ -111,10 +119,11 @@ export function ContextMenu({
     runningInSelectionCount === 1
       ? 'Stop running workflow'
       : `Stop ${runningInSelectionCount} running workflows`
+  const addToChatRows = addToChatRowCount ?? selectedRowCount
   const addToChatLabel = addToChatCellScoped
     ? 'Add cell range to Chat'
-    : selectedRowCount > 1
-      ? `Add ${count} rows to Chat`
+    : addToChatRows > 1
+      ? `Add ${addToChatRows.toLocaleString()} rows to Chat`
       : 'Add row to Chat'
 
   return (

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

@@ -2985,7 +2985,6 @@ export function TableGrid({
             context: buildTableSelectionContext({
               tableId,
               tableName: tableNameRef.current,
-              totalColumnCount: cols.length,
               // Every selected id, not just the loaded page: the chip carries
               // ids and the server re-fetches them, so an unloaded row still
               // reaches the agent. Only the pasted text is limited to `rows`.
@@ -3034,7 +3033,6 @@ export function TableGrid({
           context: buildTableSelectionContext({
             tableId,
             tableName: tableNameRef.current,
-            totalColumnCount: cols.length,
             rowIds: currentRows.map((row) => row.id),
             columnIds: selectedColumnIds(cols, sel),
           }),
@@ -3062,7 +3060,6 @@ export function TableGrid({
       const rangeContext = buildTableSelectionContext({
         tableId,
         tableName: tableNameRef.current,
-        totalColumnCount: cols.length,
         rowIds: rangeRowIds,
         columnIds: selectedColumnIds(cols, sel),
       })
@@ -3786,12 +3783,30 @@ export function TableGrid({
       )
     : contextMenuRowIds.length || 1
 
+  /**
+   * Rows the Add to Chat chip will reference, before the async drain that
+   * select-all and column selections perform. A gutter `some` selection can
+   * extend past the loaded page, and the chip carries ids the server re-fetches,
+   * so it uses the whole set rather than the loaded intersection
+   * `contextMenuRowIds` holds. Shared with the menu label so the count shown and
+   * the count sent can't disagree.
+   */
+  const addToChatRowIds = useMemo<string[]>(() => {
+    if (
+      rowSelection.kind === 'some' &&
+      contextMenu.row &&
+      rowSelectionIncludes(rowSelection, contextMenu.row.id)
+    ) {
+      return [...rowSelection.ids]
+    }
+    return contextMenuRowIds
+  }, [rowSelection, contextMenu.row, contextMenuRowIds])
+
   /**
    * Column ids for an "Add to chat" table selection. A spreadsheet-style cell
    * range AND a column-header selection (which spans every row of the chosen
    * columns) narrow the columns; whole-row (gutter) selections and single rows
-   * send every column (undefined). A range spanning all columns is equivalent to
-   * whole rows, so it also collapses to undefined.
+   * send every column (undefined).
    */
   const contextMenuColumnIds = useMemo<string[] | undefined>(() => {
     if (!contextMenu.isOpen || !contextMenu.row) return undefined
@@ -3807,8 +3822,11 @@ export function TableGrid({
     if (contextRowArrayIndex < sel.startRow || contextRowArrayIndex > sel.endRow) return undefined
     // Collapsed here too (not only in buildTableSelectionContext) because this
     // also decides whether the menu item reads "cell range" or "rows".
+    // Not collapsed to `undefined` when it spans every visible column: hidden
+    // columns mean "all visible" is not "all", and widening would send the agent
+    // columns the user hid. See buildTableSelectionContext.
     const ids = selectedColumnIds(displayColumns, sel)
-    return ids.length > 0 && ids.length < displayColumns.length ? ids : undefined
+    return ids.length > 0 ? ids : undefined
   }, [contextMenu.isOpen, contextMenu.row, rowSelection, normalizedSelection, rows, displayColumns])
 
   const addToChat = useAddToChat()
@@ -3818,14 +3836,7 @@ export function TableGrid({
     // `contextMenuRowIds` reflects; drain up to the cap so the chip references as
     // many rows as it can carry (bounded by MAX_TABLE_SELECTION_ROWS) instead of a
     // silent loaded-only subset — mirroring how the copy path loads before writing.
-    const gutterSelection = rowSelectionRef.current
-    // Prefer the whole gutter selection over the loaded intersection.
-    let sourceRowIds =
-      gutterSelection.kind === 'some' &&
-      contextMenu.row &&
-      rowSelectionIncludes(gutterSelection, contextMenu.row.id)
-        ? [...gutterSelection.ids]
-        : contextMenuRowIds
+    let sourceRowIds = addToChatRowIds
     if (contextMenuIsSelectAll || isColumnSelectionRef.current) {
       try {
         const { rows: loaded } = await ensureRowsLoadedUpToRef.current(MAX_TABLE_SELECTION_ROWS)
@@ -3844,20 +3855,17 @@ export function TableGrid({
     const context = buildTableSelectionContext({
       tableId,
       tableName: tableData?.name,
-      totalColumnCount: displayColumns.length,
       rowIds: sourceRowIds,
       columnIds: contextMenuColumnIds,
     })
     if (context) addToChat(context)
   }, [
     addToChat,
-    contextMenuRowIds,
+    addToChatRowIds,
     contextMenuColumnIds,
     contextMenuIsSelectAll,
-    contextMenu.row,
     tableId,
     tableData?.name,
-    displayColumns.length,
   ])
 
   const pendingUpdate = updateRowMutation.isPending ? updateRowMutation.variables : null
@@ -4582,8 +4590,9 @@ export function TableGrid({
         disableInsert={!canManualAddRow}
         disableDuplicate={!canInsertFullRow}
         disableDelete={!canDeleteRow}
-        onAddToChat={contextMenuRowIds.length > 0 ? handleAddSelectionToChat : undefined}
+        onAddToChat={addToChatRowIds.length > 0 ? handleAddSelectionToChat : undefined}
         addToChatCellScoped={Boolean(contextMenuColumnIds)}
+        addToChatRowCount={contextMenuIsSelectAll ? selectedRowCount : addToChatRowIds.length}
       />
 
       <ExpandedCellPopover

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/utils.test.ts

@@ -30,7 +30,7 @@ describe('selectedColumnIds', () => {
 })
 
 describe('buildTableSelectionContext', () => {
-  const base = { tableId: 't1', tableName: 'Sales', totalColumnCount: 3 }
+  const base = { tableId: 't1', tableName: 'Sales' }
 
   it('returns null before the table name has loaded, or with nothing selected', () => {
     expect(buildTableSelectionContext({ ...base, tableName: undefined, rowIds: ['r1'] })).toBeNull()
@@ -49,23 +49,30 @@ describe('buildTableSelectionContext', () => {
     expect(context.label).toContain(`${MAX_TABLE_SELECTION_ROWS} rows`)
   })
 
-  it('collapses a range covering every column to an open scope', () => {
-    // Equivalent to whole rows — leaving it open keeps the server correct if the
-    // schema changes, instead of pinning a now-stale column list.
+  it('keeps a full-width range scoped rather than widening it to every column', () => {
+    // Callers can only count rendered columns, which drop hidden ones and expand
+    // workflow groups — so "covers everything visible" is not "covers the
+    // schema". Widening here would re-fetch columns the user had hidden.
     const context = buildTableSelectionContext({
       ...base,
       rowIds: ['r1'],
       columnIds: ['c0', 'c1', 'c2'],
     })
 
+    if (context?.kind !== 'table_selection') throw new Error('expected a table_selection')
+    expect(context.columnIds).toEqual(['c0', 'c1', 'c2'])
+  })
+
+  it('leaves the scope open only when no columns are given (whole rows)', () => {
+    const context = buildTableSelectionContext({ ...base, rowIds: ['r1'] })
+
     if (context?.kind !== 'table_selection') throw new Error('expected a table_selection')
     expect(context.columnIds).toBeUndefined()
   })
 
   it('keeps a narrower range scoped, capped at the column limit', () => {
     const context = buildTableSelectionContext({
       ...base,
-      totalColumnCount: MAX_TABLE_SELECTION_COLUMNS + 50,
       rowIds: ['r1'],
       columnIds: Array.from({ length: MAX_TABLE_SELECTION_COLUMNS + 10 }, (_, i) => `c${i}`),
     })

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

@@ -373,26 +373,27 @@ export function selectedColumnIds(
 
 /**
  * Materializes a `table_selection` chat context from a grid selection, applying
- * the shared row/column caps. `columnIds` narrows the context to a cell range; a
- * range covering every column is equivalent to whole rows, so it collapses to an
- * open scope (the server then includes all columns, and stays correct if the
- * schema changes). Returns null before the table name has loaded or when nothing
- * is selected.
+ * the shared row/column caps. `columnIds` narrows the context to a cell range;
+ * omit it for a whole-row selection, where the agent should see every column.
+ * Returns null before the table name has loaded or when nothing is selected.
+ *
+ * A range is never widened back to an open scope for "covering everything":
+ * the only counts available to callers come from the rendered grid, which both
+ * drops hidden columns and expands workflow groups, so "all of them" cannot be
+ * compared to the schema. Treating a full-width range as whole rows would let
+ * the server re-fetch columns the user had hidden.
  */
 export function buildTableSelectionContext(opts: {
   tableId: string
   tableName: string | undefined
-  totalColumnCount: number
   rowIds: string[]
   columnIds?: string[]
 }): ChatContext | null {
-  const { tableId, tableName, totalColumnCount, columnIds } = opts
+  const { tableId, tableName, columnIds } = opts
   if (!tableName || opts.rowIds.length === 0) return null
   const rowIds = opts.rowIds.slice(0, MAX_TABLE_SELECTION_ROWS)
   const scopedColumnIds =
-    columnIds && columnIds.length > 0 && columnIds.length < totalColumnCount
-      ? columnIds.slice(0, MAX_TABLE_SELECTION_COLUMNS)
-      : undefined
+    columnIds && columnIds.length > 0 ? columnIds.slice(0, MAX_TABLE_SELECTION_COLUMNS) : undefined
   return {
     kind: 'table_selection',
     tableId,