fix(chat): derive the budget reserve from the same clause it reserves for

Cursor Bugbot: worstCaseSizeClause built its own string that omitted the
row/rows word the real clause always carries, so the reserve ran ~5 characters
short and a tightly packed selection could still exceed
MAX_TABLE_SELECTION_CONTENT_LENGTH. A bug in the previous fix, from duplicating
the format instead of sharing it.

Replaced with one sizeClause(shown, omitted) used for both the up-front reserve
and the final prose, so the two cannot describe the count differently. The
reserve passes (rows.length, rows.length) — max digits on both counts and the
plural forced — which is an upper bound on any real clause.

The earlier tight-packing test could not see this: a single cell width leaves
whatever remainder it leaves, and 100 left more than 5 characters. Added a
sweep over widths 60-75 that collects overflows so a failure names the width;
it catches the reported bug at width 74 (20002 vs 20000).

Author: waleedlatif1

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

@@ -531,6 +531,47 @@ describe('processContextsServer - table_selection contexts', () => {
     expect(ctx.content).toContain('omitted for length')
   })
 
+  it('holds the cap across cell widths, including ones that pack flush to it', async () => {
+    // A single width can leave slack that hides an under-reserved prefix by a
+    // few characters. Sweeping widths lands at least one run with almost no
+    // remainder, which is where an off-by-N in the reserve actually shows up.
+    getTableById.mockResolvedValue({
+      name: 'Sales',
+      workspaceId: 'ws-1',
+      schema: { columns: [{ id: 'c_notes', name: 'Notes' }] },
+    })
+
+    const overflows: Array<{ width: number; length: number }> = []
+    for (let width = 60; width <= 75; width++) {
+      const rows = Array.from({ length: MAX_TABLE_SELECTION_ROWS }, (_, i) => ({
+        id: `r${i}`,
+        data: { c_notes: 'x'.repeat(width) },
+      }))
+      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 { length } = result[0].content
+      if (length > MAX_TABLE_SELECTION_CONTENT_LENGTH) overflows.push({ width, length })
+    }
+
+    // Collected rather than asserted per-iteration so a failure names the widths.
+    expect(overflows).toEqual([])
+  })
+
   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

@@ -931,14 +931,8 @@ 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.
+ * Renders one cell for a markdown table row, escaping the delimiters.
  */
-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 ''
   const cell = typeof value === 'string' ? value : JSON.stringify(value)
@@ -983,15 +977,27 @@ async function resolveTableSelectionResource(
   const describe = (size: string) =>
     `Selected ${scope} from table "${table.name}" (${size}):\n\n${header}\n${divider}\n`
 
+  /**
+   * The size clause, e.g. `5 rows` or `189 rows of 500, 311 omitted for length`.
+   * Used for both the up-front reserve and the final prose, so the two can never
+   * describe the row count differently.
+   */
+  const sizeClause = (shownCount: number, omittedCount: number) => {
+    const shown = `${shownCount} ${shownCount === 1 ? 'row' : 'rows'}`
+    return omittedCount > 0
+      ? `${shown} of ${rows.length}, ${omittedCount} omitted for length`
+      : shown
+  }
+
   // 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.
+  // needs. The real clause isn't known until packing finishes, so reserve its
+  // longest form: every row shown AND every row omitted maximizes both counts
+  // and forces the plural. A few characters of unused slack beats overshooting.
   const lines: string[] = []
   let remaining =
-    MAX_TABLE_SELECTION_CONTENT_LENGTH - describe(worstCaseSizeClause(rows.length)).length
+    MAX_TABLE_SELECTION_CONTENT_LENGTH - describe(sizeClause(rows.length, rows.length)).length
   for (const row of rows) {
     const line = `| ${columns.map((col) => renderTableCell(row.data[getColumnId(col)])).join(' | ')} |`
     // The first row always goes in, so a single oversized row still yields a
@@ -1001,10 +1007,7 @@ async function resolveTableSelectionResource(
     remaining -= line.length + 1
   }
 
-  const omitted = rows.length - lines.length
-  const shown = `${lines.length} ${lines.length === 1 ? 'row' : 'rows'}`
-  const size = omitted > 0 ? `${shown} of ${rows.length}, ${omitted} omitted for length` : shown
-  const content = `${describe(size)}${lines.join('\n')}`
+  const content = `${describe(sizeClause(lines.length, rows.length - lines.length))}${lines.join('\n')}`
   return {
     type: 'table_selection',
     tag: label ? `@${label}` : '@',