⚠️ Potential issue | 🟠 Major

Bug: Size check compares character count against byte threshold.

pastedText.length returns the number of characters (UTF-16 code units), not bytes. For multi-byte Unicode text, the actual byte size can be significantly larger than the character count. This check should validate byte size to be consistent with handleFileChange.

   const handlePaste = (e: React.ClipboardEvent) => {
     const pastedText = e.clipboardData.getData('text')
     if (pastedText.length > 1000) {
       e.preventDefault()
-      if (pastedText.length > 10 * 1024 * 1024) {
+      const byteSize = new TextEncoder().encode(pastedText).length
+      if (byteSize > 10 * 1024 * 1024) {
         toast.error('Pasted text exceeds 10MB limit')
         return
       }

In `@components/chat-panel.tsx` around lines 84 - 87, The pasted-text size check
uses pastedText.length (UTF-16 code units) instead of byte length; update the
validation in the paste handling code to compute the actual byte size (e.g., via
TextEncoder().encode(pastedText).length or new Blob([pastedText]).size) and
compare that byte length to 10 * 1024 * 1024 so it matches the behavior in
handleFileChange; modify the conditional that currently references
pastedText.length to use the computed byteSize and keep the same toast.error and
return flow if it exceeds the limit.

⚠️ Potential issue | 🟡 Minor

setInput('') clears any pre-typed text.

If a user types some context before pasting large text, this call erases their typed content. Per PR discussion, e.preventDefault() already stops the pasted text from being inserted, so clearing input may not be necessary.

Consider preserving existing input or showing a success toast so users understand why their input changed.

       setSelectedFile(file)
-      setInput('')
+      toast.success('Large text converted to file attachment')

+  const isConvertingPaste = useRef(false)
+
   const handlePaste = (e: React.ClipboardEvent) => {
     const pastedText = e.clipboardData.getData('text')
     if (pastedText.length > 1000) {
       e.preventDefault()
       // ... size and attachment checks ...
+      isConvertingPaste.current = true
       const file = new File([pastedText], 'pasted-text.txt', {
         type: 'text/plain'
       })
       setSelectedFile(file)
       setInput('')
+      toast.success('Large text converted to file attachment')
+      // Reset flag after state updates
+      setTimeout(() => { isConvertingPaste.current = false }, 0)
     }
   }

   onChange={e => {
+    if (isConvertingPaste.current) return
     setInput(e.target.value)
     debouncedGetSuggestions(e.target.value)
   }}

In `@components/chat-panel.tsx` at line 98, The call to setInput('') in the paste
handler is clearing any pre-typed user text; remove that setInput('') so the
existing input is preserved (locate the onPaste / paste handler in
components/chat-panel.tsx and delete the setInput('') statement), or if you must
clear to avoid a race with onChange implement the ref-based guard discussed in
the PR: add a boolean ref (e.g., skipOnChangeRef) and set it around the paste
flow, then check skipOnChangeRef.current inside the onChange handler to ignore
the spurious update instead of wiping the input.

The paste threshold (5000) is a magic number here. It should be extracted into a named constant (ideally colocated with related upload/validation constants) so it’s easier to discover, adjust, and test consistently across the codebase.

const LARGE_PASTE_CHAR_THRESHOLD = 5000

const handlePaste = (e: React.ClipboardEvent) => {
  const pastedText = e.clipboardData.getData('text')
  if (pastedText.length > LARGE_PASTE_CHAR_THRESHOLD) {
    // ...
  }
}

handlePaste always reads text from the clipboard. In some browsers/contexts, a paste may primarily contain files/HTML, and forcing getData('text') + large-text prevention could accidentally interfere with non-text pastes. Consider guarding so this logic only runs when there is meaningful plain-text content and otherwise lets the default paste behavior proceed.

const handlePaste = (e: React.ClipboardEvent) => {
  const text = e.clipboardData.getData('text/plain')
  if (!text) return

  if (text.length > LARGE_PASTE_CHAR_THRESHOLD) {
    e.preventDefault()
    if (selectedFile) {
      toast.error('Please remove the current attachment to convert large paste to file')
      return
    }

    setSelectedFile(new File([text], 'pasted-text.txt', { type: 'text/plain' }))
    setInput('')
  }
}

Converting pasted text into a File bypasses the existing 10MB check in handleFileChange. A user could paste extremely large text and end up with a huge in-memory File (and later potentially a failed upload/server rejection). You should apply the same size limit (and ideally share the constant) when creating the file from pasted content.

const MAX_FILE_BYTES = 10 * 1024 * 1024

// ... inside large paste branch
const file = new File([text], 'pasted-text.txt', { type: 'text/plain' })
if (file.size > MAX_FILE_BYTES) {
  toast.error('File size must be less than 10MB')
  return
}
setSelectedFile(file)
setInput('')

🧹 Nitpick | 🔵 Trivial

Consider adding a success toast when paste is converted to file.

When large text is converted to a file, the user sees their input cleared and a file attachment appear. Adding a success toast would make this behavior more discoverable and less confusing.

Additionally, consider wrapping handlePaste in useCallback for consistency with debouncedGetSuggestions and to avoid unnecessary re-renders if the Textarea memoizes props.

-  const handlePaste = (e: React.ClipboardEvent) => {
+  const handlePaste = useCallback((e: React.ClipboardEvent) => {
     const pastedText = e.clipboardData.getData('text')
     if (pastedText.length > 5000) {
       e.preventDefault()
       if (selectedFile) {
         toast.error(
           'Please remove the current attachment to convert large paste to file'
         )
         return
       }
       const file = new File([pastedText], 'pasted-text.txt', {
         type: 'text/plain'
       })
       setSelectedFile(file)
       setInput('')
+      toast.success('Large text converted to file attachment')
     }
-  }
+  }, [selectedFile, setInput])

In `@components/chat-panel.tsx` around lines 80 - 96, Add a success toast when
large pasted text is converted to a File: inside handlePaste, after creating the
File and calling setSelectedFile(file) and setInput(''), call toast.success with
a brief message like "Pasted text attached as file" so the user sees the
conversion. Also wrap handlePaste in React.useCallback (same pattern as
debouncedGetSuggestions) and include its dependencies (selectedFile,
setSelectedFile, setInput, toast) to avoid unnecessary re-renders and keep prop
stability for any memoized Textarea component.

⚠️ Potential issue | 🟡 Minor

Missing focus before second paste may cause test flakiness.

After the first paste creates an attachment, the focus might be lost. The second paste (lines 73-78) dispatches the event to document.activeElement, which may no longer be the chat input.

     await expect(page.getByText('pasted-text.txt')).toBeVisible();

     const largeText2 = 'B'.repeat(501);
+    await chatInput.focus();
     await page.evaluate((text) => {
       const dt = new DataTransfer();
       dt.setData('text/plain', text);

In `@tests/paste.spec.ts` around lines 72 - 78, The second paste dispatch uses
document.activeElement which may not be the chat input after the first paste;
before creating/dispatching the ClipboardEvent for largeText2, explicitly focus
the chat input element used earlier (e.g., call page.focus(selector) or inside
page.evaluate call document.querySelector('<chat-input-selector>').focus()) so
the paste event targets the correct element instead of relying on
document.activeElement; update the block that constructs the
DataTransfer/ClipboardEvent (the page.evaluate invocation that uses largeText2)
to focus the intended input element first.