fix(chat): enforce the table selection budget over the whole rendered content

Cursor Bugbot: the budget subtracted only the header and divider before packing
rows, then prepended the 'Selected ...' prose and the newlines afterward, so the
final content could exceed MAX_TABLE_SELECTION_CONTENT_LENGTH whenever the last
accepted row left less slack than the prefix needed. The cap the TSDoc promises
was not actually enforced.

The prior test passed while missing this: its rows were wide enough that packing
stopped far short of the limit, so the boundary was never exercised. Replaced
with rows sized to fill the budget almost exactly, asserting both that the
content stays within the cap and that it still approaches it (so the assertion
can't pass by emitting an empty table).

Also capitalize Chat in the three 'Add to Chat' menu labels, matching the
constitution's module naming and the existing 'Fix in Chat' / 'Troubleshoot in
Chat' UI strings.

Author: waleedlatif1

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

@@ -67,7 +67,7 @@ export function EditorContextMenu({
           <>
             <DropdownMenuItem disabled={!hasSelection} onSelect={onAddToChat}>
               <Blimp />
-              Add to chat
+              Add to Chat
             </DropdownMenuItem>
             <DropdownMenuSeparator />
           </>

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/menus/bubble-menu.tsx

@@ -254,7 +254,7 @@ export function EditorBubbleMenu({
             <>
               <ToolbarButton
                 icon={Blimp}
-                label='Add to chat'
+                label='Add to Chat'
                 isActive={false}
                 onClick={onAddToChat}
               />

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

@@ -85,7 +85,7 @@ export function ContextMenu({
   disableDuplicate = false,
   disableDelete = false,
   onAddToChat,
-  addToChatLabel = 'Add to chat',
+  addToChatLabel = 'Add to Chat',
 }: ContextMenuProps) {
   const count = selectedRowCount.toLocaleString()
   const deleteLabel = selectedRowCount > 1 ? `Delete ${count} rows` : 'Delete row'

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

@@ -4631,7 +4631,7 @@ export function TableGrid({
         disableDuplicate={!canInsertFullRow}
         disableDelete={!canDeleteRow}
         onAddToChat={contextMenuRowIds.length > 0 ? handleAddSelectionToChat : undefined}
-        addToChatLabel={contextMenuColumnIds ? 'Add cell range to chat' : 'Add rows to chat'}
+        addToChatLabel={contextMenuColumnIds ? 'Add cell range to Chat' : 'Add rows to Chat'}
       />
 
       <ExpandedCellPopover

apps/sim/lib/copilot/chat/process-contents.test.ts

@@ -491,6 +491,46 @@ describe('processContextsServer - table_selection contexts', () => {
     expect(result).toEqual([])
   })
 
+  it('keeps the whole rendered content within budget when rows pack tightly', async () => {
+    // Rows small enough to fill the budget almost exactly: the last accepted row
+    // leaves only a few characters of slack, so a budget that forgot to reserve
+    // the prose prefix and newlines overruns the cap here while passing on
+    // coarse fixtures that stop far short of the limit.
+    const cell = 'x'.repeat(100)
+    const rows = Array.from({ length: MAX_TABLE_SELECTION_ROWS }, (_, i) => ({
+      id: `r${i}`,
+      data: { c_notes: cell },
+    }))
+    getTableById.mockResolvedValue({
+      name: 'Sales',
+      workspaceId: 'ws-1',
+      schema: { columns: [{ id: 'c_notes', name: 'Notes' }] },
+    })
+    getRowsByIds.mockResolvedValue(rows)
+
+    const result = await processContextsServer(
+      [
+        {
+          kind: 'table_selection',
+          tableId: 'tbl-1',
+          tableName: 'Sales',
+          label: 'Sales (500 rows)',
+          rowIds: rows.map((r) => r.id),
+        } as ChatContext,
+      ],
+      'user-1',
+      'summarize',
+      'ws-1'
+    )
+
+    const [ctx] = result
+    expect(ctx.content.length).toBeLessThanOrEqual(MAX_TABLE_SELECTION_CONTENT_LENGTH)
+    // Guard against passing by emitting almost nothing — it must still be a
+    // real table that genuinely approaches the cap.
+    expect(ctx.content.length).toBeGreaterThan(MAX_TABLE_SELECTION_CONTENT_LENGTH * 0.9)
+    expect(ctx.content).toContain('omitted for length')
+  })
+
   it('spends a character budget across rows and reports what it omitted', async () => {
     // Row/column caps alone don't bound prompt cost: wide cells blow past the
     // budget long before MAX_TABLE_SELECTION_ROWS.

apps/sim/lib/copilot/chat/process-contents.ts

@@ -930,6 +930,14 @@ async function resolveFileSelectionResource(
   }
 }
 
+/**
+ * Longest form the size clause can take for `total` rows — every row omitted.
+ * Used to reserve prefix space before the real counts are known.
+ */
+function worstCaseSizeClause(total: number): string {
+  return `${total} of ${total}, ${total} omitted for length`
+}
+
 /** Renders one cell for a markdown table row, escaping the delimiters. */
 function renderTableCell(value: unknown): string {
   if (value === null || value === undefined) return ''
@@ -971,24 +979,32 @@ async function resolveTableSelectionResource(
 
   const header = `| ${columns.map((c) => c.name).join(' | ')} |`
   const divider = `| ${columns.map(() => '---').join(' | ')} |`
+  const scope = hasColumnScope ? 'cell range' : 'rows'
+  const describe = (size: string) =>
+    `Selected ${scope} from table "${table.name}" (${size}):\n\n${header}\n${divider}\n`
 
-  // Spend the character budget row by row: the row cap alone doesn't bound the
-  // prompt cost. The first row is always emitted, so a single oversized row
-  // still yields a table rather than an empty one.
+  // Spend the character budget row by row. Everything that is not a row — the
+  // prose, the table head, and every newline — is reserved up front, or the cap
+  // is silently overrun whenever the last row leaves less slack than the prefix
+  // needs. The reserve uses the longest form the size clause can take (every row
+  // omitted), since its real value isn't known until packing finishes; a few
+  // characters of unused slack beats overshooting the documented bound.
   const lines: string[] = []
-  let remaining = MAX_TABLE_SELECTION_CONTENT_LENGTH - header.length - divider.length
+  let remaining =
+    MAX_TABLE_SELECTION_CONTENT_LENGTH - describe(worstCaseSizeClause(rows.length)).length
   for (const row of rows) {
     const line = `| ${columns.map((col) => renderTableCell(row.data[getColumnId(col)])).join(' | ')} |`
-    if (lines.length > 0 && line.length > remaining) break
+    // The first row always goes in, so a single oversized row still yields a
+    // table rather than an empty one.
+    if (lines.length > 0 && line.length + 1 > remaining) break
     lines.push(line)
     remaining -= line.length + 1
   }
 
   const omitted = rows.length - lines.length
   const shown = `${lines.length} ${lines.length === 1 ? 'row' : 'rows'}`
-  const scope = hasColumnScope ? 'cell range' : 'rows'
   const size = omitted > 0 ? `${shown} of ${rows.length}, ${omitted} omitted for length` : shown
-  const content = `Selected ${scope} from table "${table.name}" (${size}):\n\n${header}\n${divider}\n${lines.join('\n')}`
+  const content = `${describe(size)}${lines.join('\n')}`
   return {
     type: 'table_selection',
     tag: label ? `@${label}` : '@',