fix(chat): apply chip handoffs as one batch; widen table copy chip path

Cursor Bugbot: a multi-context chip handoff dispatched one event per context,
and insertContextChip resolved label collisions against selectedContexts read
through a ref that only refreshes on render. Each dispatch therefore saw the
same stale list, so a second same-label selection was never ordinalized and
addContext dropped it while its @token still landed in the text. The event now
carries the whole batch and insertContextChips threads each resolved context
forward as it goes.

Greptile: an explicit multi-row ('some') selection no longer requires every
selected row to be loaded before taking the chip-carrying sync path. That
gate assumed the paged fall-through would copy more, but its loadRows returns
rowsRef.current unchanged for 'some' — the same rows, minus the chip. Renamed
the parameter to  to say what it actually gates on.

Remaining chip-less cases are inherent to the async Clipboard API, which
replaces the whole clipboard and cannot hold a custom MIME: a filtered
select-all (must page in more rows) and selections past the 500-row chip cap.
'Add to chat' covers both — it is not gesture-bound and drains to the cap.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/components/user-input/components/prompt-editor/use-prompt-editor.ts

@@ -468,35 +468,44 @@ export function usePromptEditor({
   )
 
   /**
-   * Inserts a context as an `@label` chip at the caret and registers it. Unlike
+   * Inserts contexts as `@label` chips at the caret and registers them. Unlike
    * the menu-driven inserts, this is triggered programmatically (the
    * highlight-to-chat action in the file/table viewers) rather than by a typed
    * `@`/`/` trigger, so it always inserts at the current cursor position.
+   *
+   * Takes the whole batch so label collisions resolve against the chips added
+   * earlier in the same call: `selectedContexts` is React state read through a
+   * ref, so it does not reflect an add until the next render.
    */
-  const insertContextChip = useCallback(
-    (context: ChatContext) => {
-      const prepared = prepareContextForInsert(
-        context,
-        contextManagementRef.current.selectedContexts
-      )
-      if (!prepared) {
+  const insertContextChips = useCallback(
+    (contexts: ChatContext[]) => {
+      let attached = contextManagementRef.current.selectedContexts
+      const prepared: ChatContext[] = []
+      for (const context of contexts) {
+        const next = prepareContextForInsert(context, attached)
+        if (!next) continue
+        prepared.push(next)
+        attached = [...attached, next]
+      }
+      if (prepared.length === 0) {
         textareaRef.current?.focus()
         return
       }
+
       const textarea = textareaRef.current
       if (textarea) {
         const currentValue = valueRef.current
         const insertAt = textarea.selectionStart ?? currentValue.length
         const needsSpaceBefore = insertAt > 0 && !/\s/.test(currentValue.charAt(insertAt - 1))
-        const insertText = `${needsSpaceBefore ? ' ' : ''}@${prepared.label} `
+        const insertText = `${needsSpaceBefore ? ' ' : ''}${prepared.map((c) => `@${c.label} `).join('')}`
         const newValue = `${currentValue.slice(0, insertAt)}${insertText}${currentValue.slice(insertAt)}`
 
         pendingCursorRef.current = insertAt + insertText.length
         valueRef.current = newValue
         setValueState(newValue)
       }
 
-      addContextNotified(prepared)
+      for (const context of prepared) addContextNotified(context)
     },
     [textareaRef, addContextNotified]
   )
@@ -1101,8 +1110,8 @@ export function usePromptEditor({
     clear,
     focusAtEnd,
     insertResources,
-    /** Inserts a context as an `@label` chip at the caret (highlight-to-chat). */
-    insertContextChip,
+    /** Inserts contexts as `@label` chips at the caret (highlight-to-chat). */
+    insertContextChips,
     insertSlashTrigger,
     openResourceMenu,
     /** The editor's textarea element — focus management, caret restore. */

apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx

@@ -185,9 +185,9 @@ const UserInputImpl = forwardRef<UserInputHandle, UserInputProps>(function UserI
   useEffect(() => {
     const handler = (e: Event) => {
       const detail = (e as CustomEvent<MothershipAddContextDetail>).detail
-      if (!detail?.context) return
+      if (!detail?.contexts?.length) return
       e.preventDefault()
-      editorRef.current.insertContextChip(detail.context)
+      editorRef.current.insertContextChips(detail.contexts)
       textareaRef.current?.focus()
     }
     window.addEventListener(MOTHERSHIP_ADD_CONTEXT_EVENT, handler)

apps/sim/app/workspace/[workspaceId]/home/home.tsx

@@ -27,7 +27,7 @@ import {
   MothershipHandoffStorage,
 } from '@/lib/core/utils/browser-storage'
 import {
-  addMothershipContext,
+  addMothershipContexts,
   MOTHERSHIP_SEND_MESSAGE_EVENT,
   type MothershipSendMessageDetail,
 } from '@/lib/mothership/events'
@@ -355,10 +355,9 @@ export function Home({ chatId, userName, userId, tableViewsEnabled }: HomeProps)
       sendMessage(handoff.message, undefined, handoff.contexts)
       return
     }
-    for (const context of handoff.contexts ?? []) {
-      handleContextAdd(context)
-      addMothershipContext(context)
-    }
+    const contexts = handoff.contexts ?? []
+    for (const context of contexts) handleContextAdd(context)
+    addMothershipContexts(contexts)
     // eslint-disable-next-line react-hooks/exhaustive-deps -- one-shot drain; handleContextAdd is a stable body function
   }, [chatId, workspaceId, sendMessage])
 

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

@@ -364,21 +364,24 @@ function buildTableSelectionContext(opts: {
  * cannot do this: its async Clipboard API write replaces the whole clipboard and
  * so cannot carry a custom MIME type.
  *
- * Taking this path requires a chip to carry AND every selected row already
- * loaded and within the chip cap; otherwise the canonical paged path handles the
+ * Taking this path requires a chip to carry, `rows` being the complete copy, and
+ * a set within the chip cap; otherwise the canonical paged path handles the
  * copy, including its row loading and truncation notice.
  *
+ * @param complete - Whether `rows` is everything this copy should contain. False
+ * when the paged path would load rows this caller cannot see yet, so deferring
+ * to it copies strictly more.
  * @returns True when it handled the copy, false to fall through to the paged path.
  */
 function writeLoadedRowsWithChip(opts: {
   clipboardData: DataTransfer | null
   rows: TableRowType[]
-  allLoaded: boolean
+  complete: boolean
   buildCells: (row: TableRowType) => string[]
   context: ChatContext | null
 }): boolean {
   const { rows, context } = opts
-  if (!context || !opts.allLoaded || rows.length === 0 || rows.length > MAX_TABLE_SELECTION_ROWS) {
+  if (!context || !opts.complete || rows.length === 0 || rows.length > MAX_TABLE_SELECTION_ROWS) {
     return false
   }
   opts.clipboardData?.setData(
@@ -3012,14 +3015,17 @@ export function TableGrid({
 
       if (!rowSelectionIsEmpty(rowSel)) {
         e.preventDefault()
-        // A filtered select-all ('all') covers rows beyond the loaded page, so
-        // only an explicit multi-row selection can take the chip-carrying path.
+        // Only an explicit multi-row selection can carry the chip: a filtered
+        // select-all ('all') pages in rows beyond those loaded, which the async
+        // path must fetch. For 'some' the fall-through re-reads the same loaded
+        // rows (see its `loadRows`), so it never copies more than this does —
+        // the selection is complete here even when some ids aren't loaded yet.
         if (rowSel.kind === 'some') {
           const selectedRows = currentRows.filter((row) => rowSelectionIncludes(rowSel, row.id))
           const handled = writeLoadedRowsWithChip({
             clipboardData: e.clipboardData,
             rows: selectedRows,
-            allLoaded: selectedRows.length === rowSel.ids.size,
+            complete: true,
             buildCells: (row) => cols.map((col) => cellToText(row.data[col.key], col)),
             context: buildTableSelectionContext({
               tableId,
@@ -3059,12 +3065,12 @@ export function TableGrid({
         }
         const colByKey = new Map(cols.map((c) => [c.key, c]))
 
-        // A column-header selection spans every row, so the chip-carrying path
-        // only applies once the whole table is loaded.
+        // A column-header selection spans every row, and its fall-through pages
+        // in the rest — so the chip path applies only once all of them are here.
         const handled = writeLoadedRowsWithChip({
           clipboardData: e.clipboardData,
           rows: currentRows,
-          allLoaded: currentRows.length >= selectAllTotalRef.current,
+          complete: currentRows.length >= selectAllTotalRef.current,
           buildCells: (row) =>
             colNames.map((name) => cellToText(row.data[name], colByKey.get(name))),
           context: buildTableSelectionContext({

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/user-input/utils.test.ts

@@ -78,4 +78,22 @@ describe('prepareContextForInsert', () => {
 
     expect(prepareContextForInsert(context, [])).toEqual(context)
   })
+
+  it('ordinalizes within a batch when the caller threads each result forward', () => {
+    // How insertContextChips applies a multi-context handoff: `selectedContexts`
+    // is React state read through a ref and does not reflect an add until the
+    // next render, so the batch must accumulate locally or the second colliding
+    // chip is silently dropped.
+    const batch = [tableSelection(), tableSelection({ rowIds: ['r7', 'r8', 'r9'] })]
+    let attached: ChatContext[] = []
+    const prepared: ChatContext[] = []
+    for (const context of batch) {
+      const next = prepareContextForInsert(context, attached)
+      if (!next) continue
+      prepared.push(next)
+      attached = [...attached, next]
+    }
+
+    expect(prepared.map((c) => c.label)).toEqual(['Sales (3 rows)', 'Sales (3 rows) (2)'])
+  })
 })

apps/sim/hooks/use-add-to-chat.ts

@@ -3,7 +3,7 @@
 import { useCallback } from 'react'
 import { useParams, useRouter } from 'next/navigation'
 import { MothershipHandoffStorage } from '@/lib/core/utils/browser-storage'
-import { addMothershipContext } from '@/lib/mothership/events'
+import { addMothershipContexts } from '@/lib/mothership/events'
 import type { ChatContext } from '@/stores/panel'
 
 /**
@@ -23,7 +23,7 @@ export function useAddToChat(): (context: ChatContext) => void {
 
   return useCallback(
     (context: ChatContext) => {
-      if (addMothershipContext(context)) return
+      if (addMothershipContexts([context])) return
       if (!workspaceId) return
       if (MothershipHandoffStorage.store({ contexts: [context] }, workspaceId)) {
         router.push(`/workspace/${workspaceId}/home`)

apps/sim/lib/mothership/events.ts

@@ -61,22 +61,28 @@ export function sendMothershipMessage(message: string, contexts?: ChatContext[])
 export const MOTHERSHIP_ADD_CONTEXT_EVENT = 'mothership-add-context'
 
 export interface MothershipAddContextDetail {
-  /** The context to attach as a chip in the input. */
-  context: ChatContext
+  /** The contexts to attach as chips, in insertion order. */
+  contexts: ChatContext[]
 }
 
 /**
- * Dispatches a passive "add this context chip" request to a mounted Mothership
+ * Dispatches a passive "add these context chips" request to a mounted Mothership
  * chat input — the highlight-to-chat action in the file and table viewers.
  *
+ * Carries the whole batch in one event rather than one event per context: the
+ * input resolves label collisions against its current chips, and that list only
+ * refreshes on re-render, so consecutive synchronous dispatches would each see
+ * the same stale list and drop colliding chips.
+ *
  * @returns `true` when a mounted input consumed it, `false` when none was
  * listening — callers fall back to persisting a chip-only
  * {@link MothershipHandoff} for the next chat mount.
  */
-export function addMothershipContext(context: ChatContext): boolean {
+export function addMothershipContexts(contexts: ChatContext[]): boolean {
+  if (contexts.length === 0) return false
   const consumed = dispatchClaimable<MothershipAddContextDetail>(MOTHERSHIP_ADD_CONTEXT_EVENT, {
-    context,
+    contexts,
   })
-  logger.info('Dispatched mothership add-context event', { kind: context.kind, consumed })
+  logger.info('Dispatched mothership add-context event', { count: contexts.length, consumed })
   return consumed
 }