fix(tui): expand paste placeholders at submit time (#149)

handle_paste stores large pastes in paste_contents and inserts a
[Pasted ~N lines #K] placeholder, but nothing ever read the store back:
PromptInputState::take() returned the composer text verbatim, so the
model received the literal placeholder instead of the pasted content.

take() now rebuilds each placeholder from its stored content and
expands it before returning; the placeholder format lives in one
helper shared with handle_paste so the two cannot drift. clear()
drops stored contents (placeholders live in text, so once text is
cleared they are unreachable) while paste_counter stays monotonic to
keep stale placeholder ids from colliding after undo.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: BunsDev

src-rust/crates/tui/src/prompt_input.rs

@@ -1789,8 +1789,18 @@ pub fn handle_paste(content: &str, paste_counter: &mut u32) -> (String, Option<S
         return (content.to_string(), None);
     }
     *paste_counter += 1;
-    let placeholder = format!("[Pasted ~{} lines #{}]", line_count, paste_counter);
-    (placeholder, Some(content.to_string()))
+    (
+        paste_placeholder(line_count, *paste_counter),
+        Some(content.to_string()),
+    )
+}
+
+/// The placeholder shown in the input in place of a large paste.
+///
+/// `PromptInputState::take` rebuilds this exact string from the stored
+/// content to expand placeholders at submit time, so the two must not drift.
+fn paste_placeholder(line_count: usize, id: u32) -> String {
+    format!("[Pasted ~{line_count} lines #{id}]")
 }
 
 /// Normalize a pasted string into a filesystem path if it looks like one.
@@ -3148,11 +3158,26 @@ impl PromptInputState {
         self.visual_anchor = None;
         self.vim_command_buf.clear();
         self.vim_search_buf.clear();
+        // Placeholders live in `text`, so once that is gone the stored paste
+        // contents are unreachable. `paste_counter` stays monotonic so a
+        // stale placeholder (e.g. restored via undo) can never collide with
+        // a later paste's id.
+        self.paste_contents.clear();
     }
 
     /// Take the current text, clearing the input.
+    ///
+    /// Placeholders inserted by [`handle_paste`] are expanded back to their
+    /// stored paste contents, so callers receive what the user actually
+    /// pasted rather than the `[Pasted ~N lines #K]` marker.
     pub fn take(&mut self) -> String {
-        let text = self.text.clone();
+        let mut text = std::mem::take(&mut self.text);
+        for (id, content) in &self.paste_contents {
+            let placeholder = paste_placeholder(content.lines().count(), *id);
+            if text.contains(&placeholder) {
+                text = text.replace(&placeholder, content);
+            }
+        }
         self.clear();
         text
     }
@@ -4266,6 +4291,64 @@ mod tests {
         assert_eq!(counter, 2);
     }
 
+    #[test]
+    fn take_expands_paste_placeholders() {
+        let mut s = PromptInputState::new();
+        s.paste("look at this: ");
+        let big = "x".repeat(200);
+        s.paste(&big);
+        let taken = s.take();
+        assert!(
+            taken.contains(&big),
+            "placeholder should expand to the pasted content"
+        );
+        assert!(
+            !taken.contains("[Pasted ~"),
+            "no placeholder should survive take(): {taken}"
+        );
+        assert!(
+            s.paste_contents.is_empty(),
+            "paste store should be dropped after take()"
+        );
+    }
+
+    #[test]
+    fn take_expands_multiple_pastes() {
+        let mut s = PromptInputState::new();
+        let first = "a".repeat(160);
+        let second = "line\n".repeat(4);
+        s.paste(&first);
+        s.paste(" between ");
+        s.paste(&second);
+        let taken = s.take();
+        assert!(taken.contains(&first));
+        assert!(taken.contains(" between "));
+        assert!(taken.contains(&second));
+        assert!(!taken.contains("[Pasted ~"));
+    }
+
+    #[test]
+    fn take_drops_deleted_placeholder_content() {
+        let mut s = PromptInputState::new();
+        let big = "y".repeat(200);
+        s.paste(&big);
+        // User deleted the placeholder and typed something else instead —
+        // the stored content must not leak into the submitted text.
+        s.text = "typed instead".to_string();
+        s.cursor = s.text.len();
+        let taken = s.take();
+        assert_eq!(taken, "typed instead");
+        assert!(s.paste_contents.is_empty());
+    }
+
+    #[test]
+    fn clear_drops_paste_contents() {
+        let mut s = PromptInputState::new();
+        s.paste(&"z".repeat(200));
+        s.clear();
+        assert!(s.paste_contents.is_empty());
+    }
+
     // ---- compute_typeahead ---------------------------------------------
 
     // Helper constants for tests