fix(chat): keep shared resource tab open + round-trip selection chip cut/copy

Cursor:
- handleInitialContextRemove closed a file/table's slideover tab whenever any one
  of its chips was removed, even when other selection chips still referenced it.
  onContextRemove now also passes the remaining contexts; the tab closes only
  once no remaining chip resolves to that resource.
- file_selection/table_selection chips can't fit a portable sim:kind/id link, so
  cutting one from the chat input left a bare @Label with no backing data. The
  copy/cut path now detects a sole selection chip and rides its full context on
  the text/x-sim-selection MIME so paste restores it; mixed selections keep the
  portable/plain path.

Author: mzxchandra

apps/sim/app/workspace/[workspaceId]/home/components/chat-surface-context/chat-surface-context.tsx

@@ -26,8 +26,13 @@ interface ChatSurfaceContextValue {
   userId?: string
   /** Notifies the surface owner that a context chip was added to the input. */
   onContextAdd: (context: ChatContext) => void
-  /** Notifies the surface owner that a context chip was removed from the input. */
-  onContextRemove: (context: ChatContext) => void
+  /**
+   * Notifies the surface owner that a context chip was removed from the input.
+   * `remaining` is the input's context list AFTER the removal, so the owner can
+   * tell whether any other chip still references the removed chip's resource
+   * before closing a shared slideover tab.
+   */
+  onContextRemove: (context: ChatContext, remaining: ChatContext[]) => void
   /** Opens a workspace resource referenced from rendered message content. */
   onWorkspaceResourceSelect: (resource: MothershipResource) => void
 }
@@ -42,7 +47,7 @@ interface ChatSurfaceProviderProps {
   chatId?: string
   userId?: string
   onContextAdd?: (context: ChatContext) => void
-  onContextRemove?: (context: ChatContext) => void
+  onContextRemove?: (context: ChatContext, remaining: ChatContext[]) => void
   onWorkspaceResourceSelect?: (resource: MothershipResource) => void
   children: ReactNode
 }
@@ -74,8 +79,8 @@ export function ChatSurfaceProvider({
   const stableOnContextAdd = useCallback((context: ChatContext) => {
     onContextAddRef.current?.(context)
   }, [])
-  const stableOnContextRemove = useCallback((context: ChatContext) => {
-    onContextRemoveRef.current?.(context)
+  const stableOnContextRemove = useCallback((context: ChatContext, remaining: ChatContext[]) => {
+    onContextRemoveRef.current?.(context, remaining)
   }, [])
   const stableOnWorkspaceResourceSelect = useCallback((resource: MothershipResource) => {
     onWorkspaceResourceSelectRef.current?.(resource)

apps/sim/app/workspace/[workspaceId]/home/components/user-input/components/chip-clipboard-codec.ts

@@ -160,6 +160,31 @@ export function serializeSelectionForClipboard(
   return result
 }
 
+/**
+ * Finds the selection-scoped chips (`file_selection` / `table_selection`) whose
+ * highlighted token falls inside `selectedText`. These kinds carry an inline
+ * text blob / row-id array that can't fit a portable `sim:kind/id` link, so the
+ * chat input's copy/cut path round-trips them through the custom
+ * `text/x-sim-selection` clipboard MIME instead. Uses the overlay's exact
+ * tokenization so a label that is a substring of another never false-matches.
+ */
+export function selectionContextsInText(
+  selectedText: string,
+  contexts: ChatContext[]
+): ChatContext[] {
+  const ranges = computeMentionHighlightRanges(selectedText, extractContextTokens(contexts))
+  if (ranges.length === 0) return []
+  const found: ChatContext[] = []
+  for (const range of ranges) {
+    const label = stripMentionTrigger(range.token)
+    const matched = contexts.find((c) => c.label === label)
+    if (matched && (matched.kind === 'file_selection' || matched.kind === 'table_selection')) {
+      found.push(matched)
+    }
+  }
+  return found
+}
+
 /**
  * Parses all portable chip markdown links from a string, in source order.
  *

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

@@ -1,10 +1,14 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { readSelectionContextFromClipboard } from '@/lib/copilot/chat/selection-clipboard'
+import {
+  attachSelectionContextToClipboard,
+  readSelectionContextFromClipboard,
+} from '@/lib/copilot/chat/selection-clipboard'
 import { snapSelectionToChips } from '@/app/workspace/[workspaceId]/home/components/user-input/chip-selection'
 import {
   chipDisplayToken,
   chipLinkToContext,
   parseChipLinks,
+  selectionContextsInText,
   serializeSelectionForClipboard,
 } from '@/app/workspace/[workspaceId]/home/components/user-input/components/chip-clipboard-codec'
 import {
@@ -1033,6 +1037,15 @@ export function usePromptEditor({
    * text and round-trip by name. Returns true when it took over the clipboard
    * (the caller must then perform the cut deletion itself, since the default
    * was prevented).
+   *
+   * Selection chips (`file_selection` / `table_selection`) can't fit a portable
+   * link — their inline text / row-id payload lives only in the context. When
+   * the selection is exactly one such chip (the common copy/cut of a
+   * highlight-to-chat chip), ride its full context on the custom
+   * `text/x-sim-selection` MIME so paste restores it; otherwise it would leave a
+   * bare `@label` with no backing data. Mixed selections keep the portable/plain
+   * path (the single-slot MIME can't carry more than one), so the chip degrades
+   * to its label text there rather than dropping the rest of the selection.
    */
   const writeSanitizedClipboard = useCallback(
     (e: React.ClipboardEvent<HTMLTextAreaElement>): boolean => {
@@ -1041,10 +1054,18 @@ export function usePromptEditor({
       const end = textarea.selectionEnd ?? 0
       const selected = textarea.value.slice(start, end)
       if (!selected) return false
-      const serialized = serializeSelectionForClipboard(
-        selected,
-        contextManagementRef.current.selectedContexts
-      )
+      const contexts = contextManagementRef.current.selectedContexts
+      const selectionChips = selectionContextsInText(selected, contexts)
+      const soleSelectionChip =
+        selectionChips.length === 1 &&
+        selected.replace(chipDisplayToken(selectionChips[0]), '').trim().length === 0
+      if (soleSelectionChip) {
+        e.preventDefault()
+        e.clipboardData.setData('text/plain', selected)
+        attachSelectionContextToClipboard(e.clipboardData, selectionChips[0])
+        return true
+      }
+      const serialized = serializeSelectionForClipboard(selected, contexts)
       if (serialized === selected) return false
       e.preventDefault()
       e.clipboardData.setData('text/plain', serialized)

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

@@ -245,7 +245,7 @@ const UserInputImpl = forwardRef<UserInputHandle, UserInputProps>(function UserI
       }
     }
     const removed = prev.filter((p) => !curr.some((c) => contextId(c) === contextId(p)))
-    if (removed.length > 0) removed.forEach((ctx) => onContextRemoveRef.current?.(ctx))
+    if (removed.length > 0) removed.forEach((ctx) => onContextRemoveRef.current?.(ctx, curr))
     prevSelectedContextsRef.current = curr
   }, [editor.contexts])
 

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

@@ -414,9 +414,18 @@ export function Home({ chatId, userName, userId, tableViewsEnabled }: HomeProps)
     }
   }
 
-  function handleInitialContextRemove(context: ChatContext) {
+  function handleInitialContextRemove(context: ChatContext, remaining: ChatContext[]) {
     const resolved = resolveResourceFromContext(context)
     if (!resolved) return
+    // A whole-file chip and one or more of its selection chips (or several
+    // selections of the same file/table) all resolve to the same resource tab.
+    // Only close the tab once no remaining chip still references it, so removing
+    // one of several chips doesn't yank a slideover the others still point at.
+    const stillReferenced = remaining.some((other) => {
+      const otherResolved = resolveResourceFromContext(other)
+      return otherResolved?.type === resolved.type && otherResolved.id === resolved.id
+    })
+    if (stillReferenced) return
     removeResource(resolved.type, resolved.id)
   }