flaxo/wynba

public

AI coding agent!!

Initial commit: coding-agent4915718a month ago3714 lines · 137.0 KB

1	use std::io::{self, IsTerminal, Write};
2	use std::time::{
3
4	use crossterm::{
5	cursor,
6	event::{
7	self, Event
8	MouseButton, MouseEventKind
9	},
10	execute, queue,
11	style::{Color
12	terminal::{self,
13	};
14	use serde_json::Value
15
16	use crate::db::StoredMessage
17	use crate::llm;
18	use crate::md::MarkdownStream
19
20	const DOCK_FOOTER: usize
21	pub const MAX_COMP:
22	// The prompt editor grows up to this many terminal rows as the input wraps.
23	const EDITOR_MAX_ROWS: usize
24	// Reject clipboard images whose base64 payload exceeds this (roughly 6 MB).
25	const MAX_IMAGE_BASE64: usize
26
27	const BORDER: Color
28	const ACCENT: Color
29	const MUTED: Color
30	const DIM: Color
31	const TEXT: Color
32
33	const USER_BG: &str
34	const USER_FG: &str
35
36	const TOOL_PENDING_BG: &str
37	const TOOL_OK_BG: &str
38	const TOOL_ERR_BG: &str
39	const TOOL_TITLE_FG: &str
40	const TOOL_CALL_FG: &str
41	const TOOL_ARGS_FG: &str
42	const TOOL_OUT_FG: &str
43	const TOOL_ERR_FG: &str
44
45	const MAX_TOOL_LINES: usize
46
47	// Claude Code-style "search" panel for sub-agent (task tool) blocks.
48	const SUBAGENT_PENDING_BG: &str
49	const SUBAGENT_PENDING_BORDER: &str
50	const SUBAGENT_PENDING_TITLE: &str
51	const SUBAGENT_PENDING_BODY: &str
52	const SUBAGENT_OK_BG: &str
53	const SUBAGENT_OK_BORDER: &str
54	const SUBAGENT_BODY_FG: &str
55	// Max context lines captured per task node (oldest half dropped when exceeded).
56	const TASK_CONTEXT_CAP: usize
57	// Coalesce stream redraws so a chatty sub-agent can't starve the terminal.
58	const STREAM_REDRAW_INTERVAL: Duration
59	const PROMPT_POLL_INTERVAL: Duration
60	const MOUSE_WHEEL_STEP: usize
61	// Normal button tracking + drag (motion only while a button is held) + SGR mode.
62	// Deliberately NOT mode 1003 (all motion), which floods the event loop with every
63	// mouse move and makes the cursor sparkle around. Mode 1002 is what powers text
64	// selection dragging.
65	const MOUSE_CAPTURE_ON: &str
66	const MOUSE_CAPTURE_OFF: &str
67	// Bracketed paste: terminal wraps pastes in \x1b[200~ ... \x1b[201~ so they
68	// arrive as a single Event::Paste instead of raw keystrokes (newlines would
69	// otherwise read as Enter and submit mid-paste).
70	const BRACKETED_PASTE_ON: &str
71	const BRACKETED_PASTE_OFF: &str
72
73	/// Kitty keyboard progressive enhancement: make modified Enter (Shift+Enter,
74	/// Alt+Enter) report as distinct CSI-u sequences so crossterm can see the
75	/// SHIFT/ALT flags. Harmless on terminals that ignore it.
76	const KITTY_KEYBOARD_FLAGS: KeyboardEnhancementFlags
77	KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES;
78
79	// ── Modified-Enter rescue (ported from Grok Build) ─────────────────────────
80	// Many terminals (Apple Terminal, older VTE, xterm.js) deliver Shift+Enter as
81	// a bare Enter with no SHIFT flag. Kitty keyboard protocol fixes this when
82	// supported; on macOS we also side-channel through CoreGraphics to see if
83	// Shift/Option is physically held when a bare Enter arrives.
84
85	/// True when this Enter chord should insert a newline instead of submitting.
86	/// Matches Grok Build's `is_mod_enter`: Shift/Alt+Enter, or bare Enter while
87	/// a newline modifier is held on terminals that drop those flags.
88	fn is_mod_enter(key:
89	key.code == KeyCode
90	&& (key
91	.modifiers
92	.intersects(KeyModifiers::ALT
93	\|\| newline_modifier_held_os())
94	}
95
96	/// macOS: read global modifier state via CoreGraphics (no special permissions).
97	/// Other OSes: always false — rely on kitty protocol / Alt+Enter / Ctrl+J.
98	#[cfg(target_os =
99	fn newline_modifier_held_os() -> bool
100	macos_newline_modifier_held()
101	}
102
103	#[cfg(not(
104	fn newline_modifier_held_os() -> bool
105	false
106	}
107
108	#[cfg(target_os =
109	fn macos_modifier_flags() -> u64
110	// CGEventSourceFlagsState — current global modifier flags.
111	#[link(name
112	unsafe extern "C"
113	fn CGEventSourceFlagsState(state_id:
114	}
115	const HID_SYSTEM_STATE: i32
116	// SAFETY: public CoreGraphics API, integer in/out, available since 10.4.
117	unsafe { CGEventSourceFlagsState(HID_SYSTEM_STATE
118	}
119
120	#[cfg(target_os =
121	fn macos_newline_modifier_held() -> bool
122	const SHIFT: u64
123	const ALTERNATE: u64
124	macos_modifier_flags() & (SHIFT
125	}
126
127	/// True when ⌘ is physically held (macOS). Used when terminals swallow SUPER
128	/// and deliver bare Backspace/Delete for Cmd+Backspace / Cmd+Delete.
129	#[cfg(target_os =
130	fn command_key_held_os() -> bool
131	const COMMAND: u64
132	macos_modifier_flags() & COMMAND
133	}
134
135	#[cfg(not(
136	fn command_key_held_os() -> bool
137	false
138	}
139
140	/// Cmd+Backspace chord: SUPER/CONTROL flag on the event, or bare Backspace
141	/// while ⌘ is held (Apple Terminal rescue).
142	fn is_cmd_backspace(key:
143	key.code == KeyCode
144	&& (key
145	.modifiers
146	.intersects(KeyModifiers::SUPER
147	\|\| (key.modifiers.
148	}
149
150	/// Cmd+Delete (forward) chord: kill whole line.
151	fn is_cmd_delete(key:
152	key.code == KeyCode
153	&& (key.modifiers.
154	\|\| (key.modifiers.
155	}
156
157	/// If the buffer ends with a lone trailing `\`, replace it with a newline
158	/// (Grok Build backslash-continuation). Returns true when applied.
159	fn try_backslash_continuation(buf:
160	if !buf.text.
161	return false;
162	}
163	// Don't eat a chip that happens to end with '\'.
164	let end =
165	if element_at(buf,
166	return false;
167	}
168	let b =
169	buf.text.replace_range(
170	// length unchanged (both 1 char)
171	*cursor_idx = end
172	true
173	}
174
175	// Selection highlight: blue background + bright foreground.
176	const SEL_BG: &str
177	const SEL_FG: &str
178
179	// Synthetic content row for the editor line (transcript rows are 0..N).
180	const EDITOR_ROW: usize
181
182	#[derive(Clone
183	struct Selection {
184	anchor: (usize
185	cur: (usize
186	}
187
188	struct PendingTool {
189	start: usize
190	name: String
191	args: Value
192	}
193
194	// A live "task" (sub-agent) call. It renders as a compact, clickable node in the
195	// transcript; the sub-agent's full context is captured here and shown on demand
196	// in a dedicated view instead of being streamed into the transcript.
197	struct TaskNode {
198	start: usize
199	end: usize
200	desc: String
201	cols: usize
202	context: Vec
203	partial: String
204	status: String
205	done: bool
206	is_error: bool
207	}
208
209	#[derive(Clone
210	pub enum MessageAction
211	Revert,
212	Fork,
213	}
214
215	pub enum PromptResult
216	Submit {
217	text: String
218	images: Vec
219	},
220	Cancel,
221	Eof,
222	MessageAction {
223	user_idx: usize
224	action: MessageAction
225	},
226	}
227
228	/// Atomic paste chip, Grok Build style (`xai-ratatui-textarea` elements).
229	///
230	/// The chip label lives in `EditorBuffer::text[start..end]` so the cursor can
231	/// walk around it with normal arrow keys. The real payload is `content` and is
232	/// substituted back in on submit / expand. Cursor positions are char indices;
233	/// navigation never lands strictly inside `[start, end)` — Left/Right jump the
234	/// whole range as one unit.
235	#[derive(Clone
236	struct PasteElement {
237	start: usize
238	end: usize
239	content: String
240	}
241
242	/// The prompt editor buffer: multi-line text (with inline paste-chip labels),
243	/// atomic paste elements, and pasted images.
244	#[derive(Clone
245	pub struct EditorBuffer
246	pub text: String
247	elements: Vec
248	pub images: Vec
249	}
250
251	// Pastes that meet these collapse into a `[Pasted: N lines]` chip (Grok Build
252	// behavior: any multi-line paste of >= PASTE_CHIP_MIN_LINES lines, or any paste
253	// larger than PASTE_CHIP_DISPLAY_BYTES bytes, becomes a chip).
254	const PASTE_CHIP_MIN_LINES: usize
255	const PASTE_CHIP_DISPLAY_BYTES: usize
256	// Two Left-clicks on the same cell within this window count as a double-click.
257	const DOUBLE_CLICK_MS: Duration
258
259	fn is_large_paste(text:
260	text.lines().count
261	}
262
263	/// Normalize line endings and strip control characters so pasted text can't
264	/// inject terminal escape sequences or garble the editor. Keeps `\n` and `\t`.
265	fn sanitize_paste(text:
266	let mut out
267	let mut chars
268	while let Some
269	match c {
270	'\r' => {
271	out.push('\
272	if chars.peek()
273	chars.next();
274	}
275	}
276	'\n' \| '\
277	c if (c
278	c => out.
279	}
280	}
281	out
282	}
283
284	fn paste_label(paste:
285	if paste.len()
286	let size =
287	format!("{:.1}
288	} else {
289	format!("{} KB"
290	};
291	format!("[Pasted: {size
292	} else {
293	let n =
294	format!("[Pasted: {} line
295	}
296	}
297
298	/// Element whose range contains `cursor` (start inclusive, end exclusive).
299	fn element_at(buf:
300	buf.elements
301	.iter()
302	.position(\|e\|
303	}
304
305	/// Element that ends exactly at `cursor` (cursor sits right after the chip —
306	/// where insert_element leaves it after a paste).
307	fn element_ending_at(buf:
308	buf.elements.iter()
309	}
310
311	/// Paste element under the cursor, or immediately to its left (Grok's
312	/// "near cursor" for repaste-to-expand).
313	fn paste_element_near_cursor(buf:
314	element_at(buf, cursor
315	}
316
317	/// Shift every element that starts at/after `from` by `delta` chars.
318	fn shift_elements_after(buf:
319	for e in &
320	if e.start >=
321	e.start = (e
322	e.end = (e
323	} else if e
324	// Edit landed inside an element — expand/shrink its end.
325	e.end = (e
326	}
327	}
328	buf.elements.retain(
329	}
330
331	/// Kill from the start of the current logical line to the cursor (macOS
332	/// Cmd+Backspace / readline Ctrl+U). Text after the cursor is kept.
333	/// If the cursor is already at BOL and not at buffer start, eat the previous
334	/// newline so repeated kills can clear multi-line input upward.
335	fn kill_to_line_start(buf:
336	let start =
337	if cursor > start
338	return delete_char_range(buf,
339	}
340	if start > 0
341	// At BOL: remove the preceding newline (join with previous line).
342	return delete_char_range(buf,
343	}
344	cursor
345	}
346
347	/// Kill from the cursor to the end of the current logical line (readline
348	/// Ctrl+K / Cmd+Delete-forward). Does not remove the trailing newline.
349	fn kill_to_line_end(buf:
350	let end =
351	if end > cursor
352	return delete_char_range(buf,
353	}
354	cursor
355	}
356
357	/// Kill the entire current logical line (BOL..EOL), and the trailing newline
358	/// if present so the following line rises up. Cursor lands at BOL of what
359	/// remains (or previous line join point).
360	fn kill_current_line(buf:
361	let start =
362	let end =
363	let n =
364	if start == end
365	// Empty line: remove the newline that creates it (prefer the one
366	// before, else the one after).
367	if start > 0
368	return delete_char_range(buf,
369	}
370	if end < n
371	return delete_char_range(buf,
372	}
373	return cursor;
374	}
375	// Include trailing newline when present so the line is fully removed.
376	let del_end =
377	delete_char_range(buf, start
378	}
379
380	/// Delete a char-range from the buffer, removing wholly-covered elements and
381	/// shifting the rest. Returns the new cursor (at `start`).
382	fn delete_char_range(buf:
383	if start >= end
384	return start;
385	}
386	// Expand deletion to whole elements that the range touches (atomic delete).
387	let mut del_start
388	let mut del_end
389	for e in &
390	if e.start <
391	del_start = del_start.
392	del_end = del_end.
393	}
394	}
395	let b0 =
396	let b1 =
397	buf.text.replace_range(
398	let removed =
399	buf.elements.retain(
400	for e in &
401	if e.start >=
402	e.start = (e
403	e.end = (e
404	}
405	}
406	del_start
407	}
408
409	/// Move left one char, jumping over paste chips atomically (Grok Build).
410	fn cursor_left(buf:
411	if cursor == 0
412	return 0;
413	}
414	let prev =
415	if let Some
416	return buf.elements[i
417	}
418	prev
419	}
420
421	/// Move right one char, jumping over paste chips atomically (Grok Build).
422	fn cursor_right(buf:
423	let n =
424	if cursor >= n
425	return n;
426	}
427	if let Some
428	return buf.elements[i
429	}
430	cursor + 1
431	}
432
433	/// Insert a paste chip label at `cursor` and register the element.
434	fn insert_paste_element(buf:
435	let label =
436	let label_len =
437	let b =
438	buf.text.insert_str(
439	shift_elements_after(buf, cursor
440	buf.elements.push(
441	start: cursor,
442	end: cursor +
443	content,
444	});
445	buf.elements.sort_by_key(
446	cursor + label_len
447	}
448
449	/// Expand (inline) element `idx`: replace the chip label with full content.
450	/// Returns the char index at the end of the inlined region.
451	fn expand_element(buf:
452	let el =
453	let b0 =
454	let b1 =
455	let old_len =
456	let new_len =
457	buf.text.replace_range(
458	let delta =
459	for e in &
460	if e.start >=
461	e.start = (e
462	e.end = (e
463	}
464	}
465	el.start + new_len
466	}
467
468	/// The full text sent to the model: chip labels substituted for their content.
469	fn submit_text(buf:
470	if buf.elements.is_empty
471	return buf.text.trim_end
472	}
473	let chars: Vec
474	let mut out
475	let mut last
476	for e in &
477	let s =
478	let en =
479	out.extend(chars
480	out.push_str(&e
481	last = en;
482	}
483	out.extend(chars
484	out.trim_end().to_string
485	}
486
487	fn has_paste_elements(buf:
488	!buf.elements.is_empty
489	}
490
491	fn clear_paste_elements(buf:
492	buf.elements.clear();
493	}
494
495	#[derive(Debug
496	enum PasteContent {
497	Text(String),
498	Image(llm::ImagePart
499	TooLarge,
500	}
501
502	fn image_ext(media_type:
503	match media_type {
504	"image/png" => "png"
505	"image/jpeg" \| "image/jpg"
506	"image/gif" => "gif"
507	"image/webp" => "webp"
508	"image/bmp" => "bmp"
509	_ => "img"
510	}
511	}
512
513	fn image_display_name(index:
514	format!("image-{}.
515	}
516
517	struct Menu {
518	user_idx: usize
519	hi: usize
520	}
521
522	#[derive(Default
523	pub struct TranscriptBuf
524	pub lines: Vec
525	pending: Vec
526	}
527
528	impl Write for TranscriptBuf
529	fn write(&mut
530	for &b in
531	if b == b
532	self.pending.retain(
533	self.lines.push(
534	} else {
535	self.pending.push(
536	}
537	}
538	Ok(buf.
539	}
540	fn flush(&mut
541	Ok(())
542	}
543	}
544
545	impl TranscriptBuf {
546	pub fn clear(
547	self.lines.clear();
548	self.pending.clear();
549	}
550	}
551
552	pub struct Tui
553	cols: u16
554	rows: u16
555	history: Vec
556	hist_idx: Option
557	last_footer: [String
558	last_model: String
559	last_provider: String
560	scroll: usize
561	tool_pending: Option
562	sel: Option
563	md: MarkdownStream
564	user_msgs: Vec
565	menu: Option
566	next_input: Option
567	revert_count: Option
568	last_stream_redraw: Option
569	task_nodes: Vec
570	current_node: Option
571	task_view: Option
572	task_view_scroll: usize
573	auto_scroll: bool
574	editor_height: usize
575	last_click: Option
576	welcome: Option
577	}
578
579	impl Tui {
580	pub fn enter()
581	if !io::stdin
582	anyhow::bail!(
583	}
584	terminal::enable_raw_mode()?;
585	write!(io::
586	// Best-effort: terminals that don't support kitty keyboard ignore this.
587	let _ =
588	queue!(io::
589	io::stdout().flush
590	let (cols,
591	Ok(Self
592	cols,
593	rows,
594	history: Vec
595	hist_idx: None
596	last_footer: Default
597	last_model: String
598	last_provider: String
599	scroll: 0,
600	tool_pending: None
601	sel: None
602	md: MarkdownStream
603	user_msgs: Vec
604	menu: None
605	next_input: None
606	revert_count: None
607	last_stream_redraw: None
608	task_nodes: Vec
609	current_node: None
610	task_view: None
611	task_view_scroll: 0,
612	auto_scroll: true,
613	editor_height: 1,
614	last_click: None
615	welcome: None
616	})
617	}
618
619	pub fn leave(
620	let mut out
621	write!(out,
622	// Pop before leaving raw mode so the terminal restores its default
623	// keyboard protocol (matches kitty/crossterm pairing).
624	let _ =
625	queue!(
626	out,
627	cursor::MoveTo(0,
628	Clear(ClearType::FromCursorDown
629	cursor::Show,
630	)?;
631	terminal::disable_raw_mode()?;
632	write!(io::
633	out.flush()?;
634	Ok(())
635	}
636
637	pub fn suspend(
638	self.leave()
639	}
640
641	pub fn resume(
642	terminal::enable_raw_mode()?;
643	write!(io::
644	let _ =
645	queue!(io::
646	io::stdout().flush
647	let (cols,
648	self.cols = cols
649	self.rows = rows
650	let footer =
651	let model =
652	let provider =
653	self.redraw(&footer
654	}
655
656	pub fn start_output(
657	self.normalize_size();
658	self.welcome = None
659	let lines =
660	if !lines.is_empty
661	lines.push(spacer_row
662	}
663	let mut row
664	row.extend_from_slice(USER_BG
665	row.extend_from_slice(USER_FG
666	row.extend_from_slice(format!
667	lines.push(row
668	lines.push(spacer_row
669	let len =
670	self.user_msgs.push(
671	self.redraw_after_output()
672	}
673
674	pub fn feed_stream(
675	self.md.feed(
676	if self.stream_redraw_due()
677	self.redraw_after_output()?;
678	}
679	Ok(())
680	}
681
682	pub fn finish_stream(
683	self.md.finish()
684	self.redraw_after_output()
685	}
686
687	pub fn text(
688	self.md.text(
689	self.redraw_after_output()
690	}
691
692	pub fn tool_start(
693	self.normalize_size();
694	// Flush any pending streaming tail first so tool rows land AFTER the
695	// assistant's text, not merged into it (finish_stream only runs when
696	// the whole agent turn ends).
697	self.md.finish()
698	let cols =
699	let start =
700	if name == "
701	let desc =
702	for l in task_node_running_lines
703	self.md.output_mut()
704	}
705	self.task_nodes.push(
706	start,
707	end: self.md
708	desc,
709	cols,
710	context: Vec::new
711	partial: String::new
712	status: String::new
713	done: false,
714	is_error: false,
715	});
716	self.current_node = Some
717	self.tool_pending = None
718	} else {
719	for l in tool_pending_lines
720	self.md.output_mut()
721	}
722	self.tool_pending = Some
723	start,
724	name: name.to_string
725	args: args.clone
726	});
727	}
728	self.redraw_after_output()
729	}
730
731	pub fn tool_delta(
732	self.normalize_size();
733	let Some(
734	return Ok(());
735	};
736	let (desc,
737	let node =
738	node.partial.push_str(
739	let segs: Vec
740	let complete =
741	let mut status_changed
742	for l in segs
743	let l =
744	if !l.is_empty
745	node.context.push(
746	}
747	if let Some
748	let next =
749	if next != node
750	node.status = next
751	status_changed = true;
752	}
753	}
754	}
755	node.partial = segs
756	if node.context.len
757	node.context.drain(
758	}
759	(node.desc.clone
760	};
761	if status_changed {
762	let new_lines =
763	let cur_end =
764	if start <= cur_end
765	self.md.output_mut()
766	}
767	}
768	if self.task_view.is_some
769	self.redraw_after_output()?;
770	}
771	Ok(())
772	}
773
774	pub fn tool_result(
775	self.normalize_size();
776	if let Some
777	let (desc,
778	let node =
779	for l in result
780	let l =
781	if !l.is_empty
782	node.context.push(
783	}
784	}
785	if node.context.len
786	node.context.drain(
787	}
788	node.done = true;
789	node.is_error = is_error
790	(node.desc.clone
791	};
792	let new_lines =
793	let new_len =
794	if start <= end
795	self.md.output_mut()
796	}
797	if let Some
798	n.end = start
799	}
800	self.redraw_after_output()
801	} else {
802	let Some(
803	return Ok(());
804	};
805	let new_lines =
806	let end =
807	if p.start <=
808	self.md.output_mut()
809	}
810	self.redraw_after_output()
811	}
812	}
813
814	// ------------------------------------------------------------------
815	// Task nodes & the context view.
816	// ------------------------------------------------------------------
817
818	pub fn open_task_view(
819	if idx < self
820	self.task_view = Some
821	self.task_view_scroll = 0;
822	}
823	}
824
825	pub fn close_task_view(
826	self.task_view = None
827	self.task_view_scroll = 0;
828	}
829
830	fn task_node_at(&mut
831	if content_row == EDITOR_ROW
832	return None;
833	}
834	let cols =
835	let (_,
836	let li =
837	self.task_nodes.iter()
838	}
839
840	fn task_view_rows(&self
841	let node =
842	let cols =
843	let bg =
844	if node.is_error {
845	TOOL_ERR_BG
846	} else {
847	SUBAGENT_OK_BG
848	}
849	} else {
850	SUBAGENT_PENDING_BG
851	};
852	let border =
853	if node.is_error {
854	TOOL_ERR_FG
855	} else {
856	SUBAGENT_OK_BORDER
857	}
858	} else {
859	SUBAGENT_PENDING_BORDER
860	};
861	let title_fg =
862	let body_fg =
863	if node.is_error {
864	TOOL_ERR_FG
865	} else {
866	SUBAGENT_BODY_FG
867	}
868	} else {
869	SUBAGENT_PENDING_BODY
870	};
871	let icon =
872	if node.is_error {
873	"✗"
874	} else {
875	"✓"
876	}
877	} else {
878	"⟳"
879	};
880
881	let mut rows
882	rows.push(box_header
883	if !node.done {
884	let status =
885	rows.push(subagent_row
886	}
887	if node.context.is_empty
888	rows.push(subagent_row
889	}
890	for line in &
891	for w in wrap_styled
892	rows.push(subagent_row
893	}
894	}
895	rows.push(subagent_row
896	bg,
897	body_fg,
898	&format!("{} lines · ↑/↓ scroll · Esc/Enter close
899	cols,
900	));
901	rows.push(subagent_bottom_row
902	rows
903	}
904
905	fn draw_task_view(&mut
906	let idx =
907	let rows =
908	let cols =
909	let height =
910	let (bg,
911	let node =
912	let bg =
913	if node.is_error {
914	} else {
915	SUBAGENT_PENDING_BG
916	};
917	let fg =
918	if node.is_error {
919	} else {
920	SUBAGENT_PENDING_BODY
921	};
922	(bg, fg)
923	};
924	let body_area =
925	let body: Vec
926	.get(1..rows
927	.unwrap_or(&[])
928	.iter()
929	.collect();
930	let max_scroll =
931	if self.task_view_scroll >
932	self.task_view_scroll = max_scroll
933	}
934	let mut out
935	write!(out,
936	if let Some
937	queue!(out,
938	out.write_all(h
939	write!(out,
940	queue!(out,
941	}
942	let mut used
943	for (i, row
944	let r =
945	queue!(out,
946	out.write_all(row
947	write!(out,
948	queue!(out,
949	used = r
950	}
951	for r in used
952	let filler =
953	queue!(out,
954	out.write_all(&filler
955	write!(out,
956	queue!(out,
957	}
958	if let Some
959	queue!(out,
960	out.write_all(b
961	write!(out,
962	queue!(out,
963	}
964	if self.task_view_scroll >
965	let indicator =
966	queue!(out,
967	write!(out,
968	write!(out,
969	queue!(out,
970	}
971	out.flush()?;
972	Ok(())
973	}
974
975	pub fn load_history(
976	self.normalize_size();
977	self.welcome = None
978	let mut pending
979	for m in messages
980	match m.role.as_str
981	"user" => {
982	let lines =
983	if !lines.is_empty
984	lines.push(spacer_row
985	}
986	let mut row
987	row.extend_from_slice(USER_BG
988	row.extend_from_slice(USER_FG
989	row.extend_from_slice(
990	format!("❯ {}"
991	);
992	lines.push(row
993	lines.push(spacer_row
994	let len =
995	self.user_msgs.push(
996	}
997	"assistant" => {
998	if let Some
999	&& let Ok
1000	{
1001	for t in &
1002	let name =
1003	let args =
1004	let is_task =
1005	let cols =
1006	let start =
1007	for l in if
1008	task_pending_lines(&task_desc(&
1009	} else {
1010	tool_pending_lines(&name,
1011	} {
1012	self.md.output_mut()
1013	}
1014	pending.push(PendingTool
1015	start,
1016	name,
1017	args,
1018	});
1019	}
1020	}
1021	if let Some
1022	&& !c.is_empty
1023	{
1024	self.md.text(
1025	}
1026	}
1027	"tool" => {
1028	let Some(
1029	continue;
1030	};
1031	let result =
1032	let is_error =
1033	let new_lines =
1034	subagent_done_lines(&task_desc(&
1035	} else {
1036	tool_done_lines(&p.name
1037	};
1038	let end =
1039	if p.start <=
1040	self.md.output_mut()
1041	}
1042	pending.remove(0);
1043	}
1044	_ => {}
1045	}
1046	}
1047	if let Some
1048	&& n > 0
1049	{
1050	let mut dock
1051	dock.extend_from_slice(b"
1052	dock.extend_from_slice(b"
1053	let text =
1054	format!(" {n
1055	} else {
1056	format!(" {n
1057	};
1058	dock.extend_from_slice(text
1059	self.md.output_mut()
1060	}
1061	self.redraw_after_output()
1062	}
1063
1064	fn normalize_size(&mut
1065	if self.rows <
1066	self.rows = 24;
1067	}
1068	if self.cols <
1069	self.cols = 80;
1070	}
1071	self.md.set_cols(
1072	}
1073
1074	fn region_rows(&self
1075	let dock_h =
1076	(self.rows as usize
1077	}
1078
1079	fn stream_redraw_due(&mut
1080	let now =
1081	let due =
1082	.last_stream_redraw
1083	.is_none_or(\|t\|
1084	if due {
1085	self.last_stream_redraw = Some
1086	}
1087	due
1088	}
1089
1090	fn redraw_after_output(&mut
1091	self.normalize_size();
1092	if self.auto_scroll {
1093	self.scroll = 0;
1094	}
1095	let footer =
1096	let model =
1097	let provider =
1098	self.redraw(&footer
1099	}
1100
1101	/// Show the welcome box. The box is rendered fresh on every redraw at the
1102	/// current terminal width, so it reflows correctly when the terminal is
1103	/// resized; it disappears once the first message is sent.
1104	pub fn welcome(
1105	self.normalize_size();
1106	self.welcome = Some
1107	self.last_model = model
1108	self.last_provider = provider
1109	self.redraw_after_output()
1110	}
1111
1112	pub fn prompt(
1113	&mut self,
1114	status: &[String
1115	model: &str
1116	provider: &str
1117	completer: &mut
1118	tick: &mut
1119	) -> anyhow::Result
1120	let mut buf
1121	if let Some
1122	buf.text = t
1123	}
1124	let mut cursor_idx
1125	let mut completions
1126	let mut hi
1127	let mut last_comp_input
1128
1129	loop {
1130	let single_line =
1131	if single_line
1132	&& buf.text.starts_with
1133	&& last_comp_input.as_deref()
1134	{
1135	let got =
1136	completions = if got
1137	hi = 0;
1138	last_comp_input = Some
1139	}
1140	if (!single_line \|\|
1141	completions.clear();
1142	last_comp_input = None
1143	hi = 0;
1144	}
1145	let comp_n =
1146	tick(self);
1147	self.redraw(status
1148
1149	if event::poll(
1150	match event::read()
1151	Event::Paste(
1152	if self.task_view.is_none
1153	self.sel = None
1154	self.paste_text(&mut
1155	last_comp_input = None
1156	}
1157	}
1158	Event::Resize(
1159	self.cols = c
1160	self.rows = r
1161	}
1162	Event::Mouse(
1163	if self.task_view.is_some
1164	match m.kind {
1165	MouseEventKind::ScrollUp
1166	self.task_view_scroll =
1167	self.task_view_scroll.saturating_add(
1168	}
1169	MouseEventKind::ScrollDown
1170	self.task_view_scroll =
1171	self.task_view_scroll.saturating_sub(
1172	}
1173	_ => {}
1174	}
1175	continue;
1176	}
1177	if self.menu.is_some
1178	if let MouseEventKind
1179	let opt =
1180	let menu =
1181	if let Some
1182	self.sel = None
1183	match i {
1184	0 => {
1185	return Ok(PromptResult
1186	user_idx: menu.user_idx
1187	action: MessageAction
1188	})
1189	}
1190	2 => {
1191	return Ok(PromptResult
1192	user_idx: menu.user_idx
1193	action: MessageAction
1194	})
1195	}
1196	_ => {
1197	let text =
1198	if !text.is_empty
1199	copy_to_clipboard(&text);
1200	}
1201	}
1202	}
1203	}
1204	}
1205	continue;
1206	}
1207	match m.kind {
1208	MouseEventKind::ScrollUp
1209	self.scroll = self
1210	}
1211	MouseEventKind::ScrollDown
1212	self.scroll = self
1213	}
1214	MouseEventKind::Down(
1215	let (mr,
1216	let dbl =
1217	Some((t,
1218	t.elapsed() <
1219	}
1220	None => false,
1221	};
1222	self.last_click = Some
1223	if dbl && self
1224	continue;
1225	}
1226	let pos =
1227	self.sel = Some
1228	anchor: pos,
1229	cur: pos,
1230	});
1231	}
1232	MouseEventKind::Drag(
1233	let pos =
1234	if let Some
1235	s.cur = pos
1236	} else {
1237	self.sel = Some
1238	anchor: pos,
1239	cur: pos,
1240	});
1241	}
1242	}
1243	MouseEventKind::Up(
1244	if let Some
1245	&& s.anchor !=
1246	{
1247	let text =
1248	if !text.is_empty
1249	copy_to_clipboard(&text);
1250	}
1251	} else {
1252	let pos =
1253	if let Some
1254	self.sel = None
1255	self.open_task_view(idx
1256	} else if let
1257	self.sel = None
1258	self.menu = Some
1259	}
1260	}
1261	}
1262	_ => {}
1263	}
1264	}
1265	Event::Key(
1266	// Kitty protocol / some terminals emit Release events —
1267	// ignore everything except Press (and Repeat for hold).
1268	if k.kind ==
1269	continue;
1270	}
1271	if self.task_view.is_some
1272	match k.code {
1273	KeyCode::Esc
1274	self.close_task_view();
1275	}
1276	KeyCode::Up
1277	self.task_view_scroll = self
1278	}
1279	KeyCode::Down
1280	self.task_view_scroll = self
1281	}
1282	KeyCode::PageUp
1283	self.task_view_scroll = self
1284	.saturating_add((self.rows
1285	}
1286	KeyCode::PageDown
1287	self.task_view_scroll = self
1288	.saturating_sub((self.rows
1289	}
1290	_ => {}
1291	}
1292	continue;
1293	}
1294	if let Some
1295	match k.code {
1296	KeyCode::Up
1297	KeyCode::Down
1298	KeyCode::Esc
1299	self.menu = None
1300	}
1301	KeyCode::Enter
1302	let m =
1303	self.sel = None
1304	match m.hi {
1305	0 => {
1306	return Ok(PromptResult
1307	user_idx: m.user_idx
1308	action: MessageAction
1309	})
1310	}
1311	2 => {
1312	return Ok(PromptResult
1313	user_idx: m.user_idx
1314	action: MessageAction
1315	})
1316	}
1317	_ => {
1318	let text =
1319	if !text.is_empty
1320	copy_to_clipboard(&text);
1321	}
1322	}
1323	}
1324	}
1325	_ => {}
1326	}
1327	continue;
1328	}
1329	self.sel = None
1330	match k.code {
1331	KeyCode::Char(
1332	if !completions.is_empty
1333	hi = (hi
1334	} else if buf
1335	last_comp_input = None
1336	}
1337	}
1338	KeyCode::Enter
1339	// Newline chords (Grok Build):
1340	// Shift+Enter / Alt+Enter (when the terminal reports
1341	// modifiers), or bare Enter while Shift/Option is
1342	// physically held (macOS CoreGraphics rescue for
1343	// Apple Terminal), or trailing `\` + Enter.
1344	if is_mod_enter(&k
1345	self.insert_char(&mut
1346	last_comp_input = None
1347	} else if try_backslash_continuation
1348	last_comp_input = None
1349	} else if let
1350	// Grok Build: Enter on a paste chip expands it.
1351	cursor_idx = expand_element(
1352	last_comp_input = None
1353	} else if !completions
1354	let choice =
1355	if !buf.text.
1356	if buf.text.ends_with
1357	buf.text.push_str(
1358	} else if choice
1359	if let Some
1360	buf.text = buf
1361	} else {
1362	buf.text.push_str(
1363	}
1364	} else {
1365	buf.text.push_str(
1366	}
1367	}
1368	let entry =
1369	if !entry.is_empty
1370	self.history.push(
1371	}
1372	self.hist_idx = None
1373	let text =
1374	return Ok(PromptResult
1375	text,
1376	images: std::mem
1377	});
1378	} else {
1379	let entry =
1380	if !entry.is_empty
1381	if !entry.is_empty
1382	self.history.push(
1383	}
1384	self.hist_idx = None
1385	let text =
1386	return Ok(PromptResult
1387	text,
1388	images: std::mem
1389	});
1390	}
1391	}
1392	}
1393	KeyCode::Tab
1394	if !completions.is_empty
1395	hi = (hi
1396	} else if buf
1397	last_comp_input = None
1398	}
1399	}
1400	KeyCode::Esc
1401	KeyCode::Char(
1402	let ctrl =
1403	if c == '
1404	buf.text.clear();
1405	buf.images.clear();
1406	clear_paste_elements(&mut buf
1407	cursor_idx = 0;
1408	} else if c
1409	if buf.text.is_empty
1410	return Ok(PromptResult
1411	}
1412	} else if c
1413	// Readline Ctrl+U / many terminals' remapping of
1414	// Cmd+Backspace: kill to beginning of line.
1415	cursor_idx = kill_to_line_start(
1416	} else if c
1417	// Readline Ctrl+K: kill to end of line.
1418	cursor_idx = kill_to_line_end(
1419	} else if c
1420	self.paste_into(&mut
1421	} else if c
1422	self.insert_char(&mut
1423	} else {
1424	self.insert_char(&mut
1425	}
1426	last_comp_input = None
1427	}
1428	KeyCode::Backspace
1429	// Cmd+Backspace / Ctrl+Backspace / (macOS) bare Bsp while
1430	// ⌘ held: kill cursor → beginning of line (Grok Build).
1431	// Many terminals remap Cmd+Bsp to Ctrl+U (also handled).
1432	if is_cmd_backspace(&k
1433	cursor_idx = kill_to_line_start(
1434	last_comp_input = None
1435	} else if cursor_idx
1436	// Atomic delete: if the previous char is inside a
1437	// chip, remove the whole chip.
1438	let prev =
1439	if let Some
1440	let start =
1441	let end =
1442	cursor_idx = delete_char_range(
1443	} else {
1444	cursor_idx = delete_char_range(
1445	}
1446	last_comp_input = None
1447	} else if buf
1448	last_comp_input = None
1449	}
1450	}
1451	KeyCode::Delete
1452	// Cmd+Delete (forward): kill whole current line.
1453	// Ctrl+Delete: kill to end of line.
1454	if is_cmd_delete(&k
1455	cursor_idx = kill_current_line(
1456	last_comp_input = None
1457	} else if k
1458	cursor_idx = kill_to_line_end(
1459	last_comp_input = None
1460	} else if cursor_idx
1461	if let Some
1462	let start =
1463	let end =
1464	cursor_idx = delete_char_range(
1465	} else {
1466	cursor_idx =
1467	delete_char_range(&mut buf
1468	}
1469	last_comp_input = None
1470	}
1471	}
1472	KeyCode::Left
1473	// Full-buffer motion (crosses newlines) with atomic
1474	// jumps over paste chips — Grok Build textarea model.
1475	cursor_idx = cursor_left(
1476	}
1477	KeyCode::Right
1478	cursor_idx = cursor_right(
1479	}
1480	KeyCode::Home
1481	if k.modifiers.contains
1482	cursor_idx = 0;
1483	} else {
1484	cursor_idx = line_start_idx(
1485	}
1486	// Don't land inside a chip.
1487	if let Some
1488	cursor_idx = buf.
1489	}
1490	}
1491	KeyCode::End
1492	if k.modifiers.contains
1493	cursor_idx = char_count(
1494	} else {
1495	cursor_idx = line_end_idx(
1496	}
1497	if let Some
1498	cursor_idx = buf.
1499	}
1500	}
1501	KeyCode::PageUp
1502	let comp_n =
1503	let step =
1504	self.scroll = self
1505	}
1506	KeyCode::PageDown
1507	let comp_n =
1508	let step =
1509	self.scroll = self
1510	}
1511	KeyCode::Up
1512	if !completions.is_empty
1513	hi = (hi
1514	} else if let
1515	cursor_idx = up;
1516	if let Some
1517	cursor_idx = buf.
1518	}
1519	} else if self
1520	self.scroll = self
1521	} else if cursor_idx
1522	&& !buf.text.
1523	&& !has_paste_elements(&buf
1524	&& !self.history.
1525	{
1526	// History recall only on a single-line prompt with the
1527	// cursor at the start; otherwise Up must never replace
1528	// the current multi-line input.
1529	self.hist_idx = Some
1530	None => self
1531	Some(i)
1532	});
1533	buf.text = self
1534	buf.images.clear();
1535	clear_paste_elements(&mut buf
1536	cursor_idx = char_count(
1537	last_comp_input = None
1538	} else {
1539	self.scroll = self
1540	}
1541	}
1542	KeyCode::Down
1543	if !completions.is_empty
1544	hi = (hi
1545	} else if let
1546	cursor_idx = down;
1547	if let Some
1548	cursor_idx = buf.
1549	}
1550	} else if self
1551	self.scroll = self
1552	} else if cursor_idx
1553	&& !buf.text.
1554	&& !has_paste_elements(&buf
1555	{
1556	match self.hist_idx {
1557	Some(i)
1558	self.hist_idx = Some
1559	buf.text = self
1560	buf.images.clear();
1561	clear_paste_elements(&mut buf
1562	}
1563	_ => {
1564	self.hist_idx = None
1565	buf.text.clear();
1566	buf.images.clear();
1567	clear_paste_elements(&mut buf
1568	}
1569	}
1570	cursor_idx = char_count(
1571	last_comp_input = None
1572	}
1573	}
1574	_ => {}
1575	}
1576	},
1577	_ => {}
1578	}
1579	}
1580	}
1581	}
1582
1583	fn insert_char(&mut
1584	// If the cursor sits on a chip, land after it first (can't type inside).
1585	if let Some
1586	*cursor_idx = buf
1587	}
1588	let b =
1589	buf.text.insert(
1590	shift_elements_after(buf, *
1591	*cursor_idx += 1;
1592	}
1593
1594	fn paste_into(
1595	&mut self,
1596	buf: &mut
1597	cursor_idx: &mut
1598	) -> anyhow::Result
1599	match paste_from_clipboard() {
1600	Some(PasteContent
1601	self.paste_text(buf
1602	}
1603	Some(PasteContent
1604	buf.images.push(
1605	}
1606	Some(PasteContent
1607	self.text("image too large (~6MB max) — not attached
1608	}
1609	None => {}
1610	}
1611	Ok(())
1612	}
1613
1614	fn paste_text(&mut
1615	let pasted =
1616	if pasted.is_empty()
1617	return;
1618	}
1619	// Repaste-to-expand (Grok Build): pasting the exact same payload while
1620	// the cursor is on/right-after a chip expands that chip.
1621	if let Some
1622	&& buf.elements[idx
1623	{
1624	*cursor_idx = expand_element
1625	return;
1626	}
1627	// If cursor is on a chip, insert after it.
1628	if let Some
1629	*cursor_idx = buf
1630	}
1631	if is_large_paste(&pasted
1632	*cursor_idx = insert_paste_element
1633	} else {
1634	let n =
1635	let b =
1636	buf.text.insert_str(
1637	shift_elements_after(buf, *
1638	*cursor_idx += n
1639	}
1640	}
1641
1642	/// Double-click on a paste chip expands it into plain text.
1643	fn expand_paste_at_screen(
1644	&mut self,
1645	row: usize
1646	buf: &mut
1647	comp_n: usize
1648	) -> bool
1649	if buf.elements.is_empty
1650	return false;
1651	}
1652	// Editor body starts at rows - 3 - comp_n - editor_height.
1653	let body_top =
1654	let body_bottom =
1655	if row < body_top
1656	return false;
1657	}
1658	// Expand the first chip whose label is on the clicked visual row.
1659	// For the compact single-line chip labels this is the row that holds
1660	// the chip text in the editor body.
1661	let rel =
1662	let cols =
1663	let spans =
1664	let Some(
1665	return false;
1666	};
1667	let char_at =
1668	let Some(
1669	.or_else(\|\| paste_element_near_cursor
1670	else {
1671	// Fallback: any chip whose range overlaps this visual row.
1672	let row_end =
1673	.get(rel)
1674	.map(\|&(s
1675	.unwrap_or(char_at);
1676	let Some(
1677	.elements
1678	.iter()
1679	.position(\|e\|
1680	else {
1681	return false;
1682	};
1683	expand_element(buf, idx
1684	return true;
1685	};
1686	expand_element(buf, idx
1687	true
1688	}
1689
1690	fn layout_rows(&mut
1691	let region_rows =
1692	let mut rows
1693	let mut map
1694	for (li, line
1695	for w in wrap_styled
1696	let blank =
1697	if blank
1698	&& rows
1699	.last()
1700	.is_some_and(\|last\|
1701	{
1702	continue;
1703	}
1704	rows.push(w
1705	map.push(li
1706	}
1707	}
1708	let scrolled =
1709	let disp_rows =
1710	let max_scroll =
1711	if self.scroll >
1712	self.scroll = max_scroll
1713	}
1714	let start =
1715	(rows, map,
1716	}
1717
1718	#[allow(clippy
1719	fn redraw(
1720	&mut self,
1721	footer: &[String
1722	model: &str
1723	provider: &str
1724	buf: &EditorBuffer
1725	cursor_idx: usize
1726	completions: &[(String
1727	comp_n: usize
1728	hi: usize
1729	) -> anyhow::Result
1730	self.normalize_size();
1731	let cols =
1732	self.update_editor_height(buf
1733	if self.task_view.is_some
1734	return self.draw_task_view();
1735	}
1736	let region_rows =
1737	let mut out
1738	write!(out,
1739
1740	if let Some
1741	let rows =
1742	for (i, row
1743	queue!(out,
1744	out.write_all(row
1745	write!(out,
1746	queue!(out,
1747	}
1748	for i in rows
1749	queue!(out,
1750	write!(out,
1751	}
1752	self.draw_dock(
1753	&mut out,
1754	footer,
1755	&model,
1756	&provider,
1757	buf,
1758	cursor_idx,
1759	completions,
1760	comp_n,
1761	hi,
1762	)?;
1763	self.draw_menu(&mut
1764	out.flush()?;
1765	return Ok(());
1766	}
1767
1768	let (mut rows
1769	let disp_rows =
1770	rows.drain(..start
1771	rows.truncate(disp_rows
1772	let scroll =
1773
1774	for (i, row
1775	let rng =
1776	let painted =
1777	queue!(out,
1778	out.write_all(&painted
1779	write!(out,
1780	queue!(out,
1781	}
1782	let mut next_row
1783	if scroll > 0
1784	let indicator =
1785	queue!(out,
1786	out.write_all(indicator
1787	write!(out,
1788	queue!(out,
1789	next_row += 1;
1790	}
1791	for i in next_row
1792	queue!(out,
1793	write!(out,
1794	}
1795
1796	self.draw_dock(
1797	&mut out,
1798	footer,
1799	model,
1800	provider,
1801	buf,
1802	cursor_idx,
1803	completions,
1804	comp_n,
1805	hi,
1806	)?;
1807	self.draw_menu(&mut
1808	out.flush()?;
1809	Ok(())
1810	}
1811
1812	/// Grow the editor box as the buffer wraps. Paste chips live inline in
1813	/// `buf.text` (one-line labels), so only image chips reserve an extra row.
1814	fn update_editor_height(&mut
1815	let text_rows =
1816	let extra =
1817	let h =
1818	text_rows.clamp(1,
1819	} else {
1820	let base =
1821	0
1822	} else {
1823	text_rows.clamp(1,
1824	};
1825	base + extra
1826	};
1827	self.editor_height = h
1828	}
1829
1830	fn disp_rows(&self
1831	self.region_rows(comp_n
1832	}
1833
1834	#[allow(clippy
1835	fn draw_dock(
1836	&mut self,
1837	out: &mut
1838	footer: &[String
1839	model: &str
1840	provider: &str
1841	buf: &EditorBuffer
1842	cursor_idx: usize
1843	completions: &[(String
1844	comp_n: usize
1845	hi: usize
1846	) -> io::Result
1847	let cols =
1848
1849	for (i, item
1850	let row =
1851	let (text,
1852	let selected =
1853	let prefix =
1854	queue!(out,
1855	if selected {
1856	queue!(out,
1857	}
1858	write!(out,
1859	if !desc.is_empty
1860	queue!(out,
1861	let left =
1862	write!(out,
1863	}
1864	queue!(out,
1865	write!(out,
1866	}
1867
1868	let top_border_row =
1869	self.rows.saturating_sub((
1870	let bottom_border_row =
1871	let body_top =
1872	let chips =
1873	let show_rows =
1874	// With no typed text, image chips own the top rows; the cursor block
1875	// sits at the start of the first chip instead of on an empty line.
1876	let cursor_only =
1877	let body_rows =
1878	Vec::new()
1879	} else {
1880	editor_rows(buf, cursor_idx
1881	};
1882
1883	queue!(out,
1884	write!(out,
1885	if cursor_only {
1886	let names: Vec
1887	.images
1888	.iter()
1889	.enumerate()
1890	.map(\|(i
1891	.collect();
1892	let mut line
1893	if line.chars()
1894	line = truncate(
1895	}
1896	line = format!
1897	queue!(out,
1898	write!(out,
1899	write!(out,
1900	} else {
1901	for (i, row
1902	queue!(out,
1903	out.write_all(row
1904	write!(out,
1905	}
1906	if chips == 1
1907	let names: Vec
1908	.images
1909	.iter()
1910	.enumerate()
1911	.map(\|(i
1912	.collect();
1913	let mut line
1914	if line.chars()
1915	line = truncate(
1916	}
1917	let row =
1918	queue!(out,
1919	write!(out,
1920	write!(out,
1921	}
1922	}
1923	queue!(out,
1924	write!(out,
1925	queue!(out,
1926
1927	for (i, line
1928	let row =
1929	queue!(out,
1930	write!(out,
1931	queue!(out,
1932	write!(out,
1933	}
1934
1935	if !model.is_empty
1936	self.last_model = model
1937	}
1938	if !provider.is_empty
1939	self.last_provider = provider
1940	}
1941	let model =
1942	self.last_model.as_str()
1943	} else {
1944	model
1945	};
1946	let provider =
1947	self.last_provider.as_str()
1948	} else {
1949	provider
1950	};
1951	// Provider sits immediately behind the model on the right edge so the
1952	// pair never floats mid-line when COLUMNS ≠ actual terminal width.
1953	let right =
1954	String::new()
1955	} else if provider
1956	model.to_string()
1957	} else {
1958	format!("({provider
1959	};
1960	if !right.is_empty
1961	let last_row =
1962	let label =
1963	let pad =
1964	queue!(out,
1965	write!(out,
1966	queue!(out,
1967	}
1968
1969	for i in 0
1970	self.last_footer[i]
1971	}
1972	Ok(())
1973	}
1974
1975	fn content_of_screen(
1976	&mut self,
1977	screen: (usize
1978	buf: &EditorBuffer
1979	comp_n: usize
1980	) -> (usize
1981	let (r,
1982	let cols =
1983	let disp_rows =
1984	let (_,
1985	if r < disp_rows
1986	return (start +
1987	}
1988	let region_rows =
1989	let body_start =
1990	let body_end =
1991	if r >= body_start
1992	let spans =
1993	let erow =
1994	if let Some
1995	let col =
1996	(EDITOR_ROW, start
1997	} else {
1998	(EDITOR_ROW, char_count(
1999	}
2000	} else {
2001	(EDITOR_ROW, 0)
2002	}
2003	}
2004
2005	#[allow(clippy
2006	fn selected_text(&mut
2007	let cols =
2008	let (rows,
2009	let (r1,
2010	let (r2,
2011	let (top,
2012
2013	let mut parts
2014	for cr in top
2015	let text =
2016	buf.text.clone()
2017	} else if cr
2018	String::from_utf8_lossy(
2019	} else {
2020	continue;
2021	};
2022	let text =
2023	let chars: Vec
2024	let (start,
2025	(c1.min(c2
2026	} else if cr
2027	(c1.min(c2
2028	} else if cr
2029	(0, c1.max
2030	} else {
2031	(0, usize::
2032	};
2033	let s =
2034	let e =
2035	if s < e
2036	parts.push(chars
2037	}
2038	}
2039	parts.join("\
2040	}
2041
2042	pub fn reset(
2043	self.md.output_mut()
2044	self.tool_pending = None
2045	self.task_nodes.clear();
2046	self.current_node = None
2047	self.task_view = None
2048	self.task_view_scroll = 0;
2049	self.auto_scroll = true;
2050	self.sel = None
2051	self.scroll = 0;
2052	self.user_msgs.clear();
2053	self.menu = None
2054	}
2055
2056	#[allow(dead_code
2057	pub fn set_input(
2058	self.next_input = Some
2059	}
2060
2061	pub fn set_revert_count(
2062	self.revert_count = Some
2063	}
2064
2065	fn user_msg_at(&mut
2066	if content_row == EDITOR_ROW
2067	return None;
2068	}
2069	let cols =
2070	let (_,
2071	let li =
2072	self.user_msgs.iter()
2073	}
2074
2075	fn user_text(&self
2076	let Some(
2077	return String::new
2078	};
2079	let Some(
2080	return String::new
2081	};
2082	let plain =
2083	plain.strip_prefix("❯
2084	}
2085
2086	fn menu_geometry(&self
2087	let cols =
2088	let rows =
2089	let inner_w =
2090	let width =
2091	let height =
2092	let left =
2093	let top =
2094	(left, top)
2095	}
2096
2097	fn menu_option_at(&self
2098	let (_,
2099	if row >= top
2100	Some(row
2101	} else {
2102	None
2103	}
2104	}
2105
2106	fn draw_menu(&self
2107	let Some(
2108	return Ok(());
2109	};
2110	let cols =
2111	let (left,
2112	let inner_w =
2113	let items: [(
2114	("Revert", "undo messages and file changes"
2115	("Copy", "message text to clipboard"
2116	("Fork", "create a new session"
2117	];
2118	let title =
2119
2120	let mut border
2121	border.push_str("┌─
2122	border.push_str(&"
2123	border.push_str("─┐
2124	queue!(out,
2125	write!(out,
2126	queue!(out,
2127
2128	let mut title_row
2129	title_row.push_str("│
2130	title_row.push_str(title
2131	title_row.push_str(&"
2132	title_row.push('│
2133	queue!(out,
2134	write!(out,
2135	queue!(out,
2136
2137	for (i, (
2138	let row =
2139	let selected =
2140	let mut line
2141	line.push_str("│
2142	line.push_str(if
2143	line.push('
2144	line.push_str(label
2145	if selected {
2146	queue!(out,
2147	} else {
2148	queue!(out,
2149	}
2150	write!(out,
2151	let used =
2152	let fill =
2153	if fill > 0
2154	write!(out,
2155	} else {
2156	write!(out,
2157	}
2158	queue!(out,
2159	write!(out,
2160	write!(out,
2161	queue!(out,
2162	}
2163
2164	let mut bottom
2165	bottom.push_str("└─
2166	bottom.push_str(&"
2167	bottom.push_str("─┘
2168	queue!(out,
2169	write!(out,
2170	queue!(out,
2171	Ok(())
2172	}
2173	}
2174
2175	fn sel_range(content_row:
2176	let (r1,
2177	let (r2,
2178	let (top,
2179	if content_row < top
2180	return None;
2181	}
2182	let (start,
2183	(c1.min(c2
2184	} else if content_row
2185	(c1.min(c2
2186	} else if content_row
2187	(0, c1.max
2188	} else {
2189	(0, usize::
2190	};
2191	Some((start,
2192	}
2193
2194	fn mouse_pos(m:
2195	(m.row as usize
2196	}
2197
2198	fn paint_selection(row:
2199	let Some((
2200	return row.to_vec();
2201	};
2202	if start >= end
2203	return row.to_vec();
2204	}
2205	let mut prefix
2206	let mut i
2207	while i < row
2208	i += 1;
2209	if i < row
2210	i += 1;
2211	while i < row
2212	i += 1;
2213	}
2214	if i < row
2215	i += 1;
2216	}
2217	} else if i
2218	i += 1;
2219	}
2220	prefix = &row
2221	}
2222
2223	let mut out
2224	let mut col
2225	let mut opened
2226	while i < row
2227	if row[i]
2228	let s =
2229	i += 1;
2230	if i < row
2231	i += 1;
2232	while i < row
2233	i += 1;
2234	}
2235	if i < row
2236	i += 1;
2237	}
2238	} else if i
2239	i += 1;
2240	}
2241	let seq =
2242	out.extend_from_slice(seq
2243	if opened && seq
2244	out.extend_from_slice(SEL_BG
2245	out.extend_from_slice(SEL_FG
2246	}
2247	continue;
2248	}
2249	let len =
2250	if i + len
2251	break;
2252	}
2253	let in_sel =
2254	if in_sel && !
2255	out.extend_from_slice(SEL_BG
2256	out.extend_from_slice(SEL_FG
2257	opened = true;
2258	} else if !in_sel
2259	out.extend_from_slice(b"
2260	out.extend_from_slice(prefix
2261	opened = false;
2262	}
2263	out.extend_from_slice(&row
2264	col += 1;
2265	i += len;
2266	}
2267	if opened {
2268	out.extend_from_slice(b"
2269	out.extend_from_slice(prefix
2270	}
2271	out
2272	}
2273
2274	fn copy_to_clipboard(text:
2275	use std::io
2276	use std::process
2277	let candidates: &
2278	&["pbcopy"]
2279	} else if cfg!
2280	&["wl-copy", "xclip
2281	} else {
2282	&[]
2283	};
2284	for cmd in candidates
2285	if let Ok
2286	.stdin(Stdio::piped
2287	.stdout(Stdio::null
2288	.stderr(Stdio::null
2289	.spawn()
2290	{
2291	if let Some
2292	let _ =
2293	}
2294	let _ =
2295	return;
2296	}
2297	}
2298	}
2299
2300	fn run_capture(args:
2301	let out =
2302	if !out.status.
2303	return None;
2304	}
2305	Some(out.
2306	}
2307
2308	fn paste_from_clipboard() -> Option
2309	if cfg!(target_os
2310	if let Some
2311	&& !bytes.is_empty
2312	&& let Some
2313	{
2314	return Some(paste
2315	}
2316	let text =
2317	let text =
2318	let trimmed =
2319	.strip_suffix('\n'
2320	.map(\|s\|
2321	.unwrap_or(&text);
2322	if trimmed.is_empty()
2323	return None;
2324	}
2325	return Some(PasteContent
2326	}
2327	if cfg!(target_os
2328	for cmd in [
2329	if let Some
2330	if let Some
2331	return Some(paste
2332	}
2333	if !out.is_empty
2334	let text =
2335	return Some(PasteContent
2336	text.trim_end_matches(['\
2337	));
2338	}
2339	}
2340	}
2341	}
2342	None
2343	}
2344
2345	/// Sniff clipboard bytes for a known image format. Returns `None` for bytes
2346	/// that don't look like an image so text paste can fall back to the text path.
2347	fn image_paste_from_bytes(bytes:
2348	let media_type =
2349	"image/png"
2350	} else if bytes
2351	"image/jpeg"
2352	} else {
2353	return None;
2354	};
2355	let data_base64 =
2356	if data_base64.len()
2357	return Some(PasteContent
2358	}
2359	Some(PasteContent
2360	media_type: media_type.to_string
2361	data_base64,
2362	}))
2363	}
2364
2365	fn base64_encode(data:
2366	const TABLE: &
2367	b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2368	let mut out
2369	for chunk in data
2370	let b0 =
2371	let b1 =
2372	let b2 =
2373	out.push(TABLE
2374	out.push(TABLE
2375	out.push(if
2376	TABLE[(((b1 &
2377	} else {
2378	'='
2379	});
2380	out.push(if
2381	TABLE[(b2 &
2382	} else {
2383	'='
2384	});
2385	}
2386	out
2387	}
2388
2389	fn strip_visible(bytes:
2390	crate::md::strip_ansi(
2391	}
2392
2393	fn tool_row(bg:
2394	let mut v
2395	v.extend_from_slice(bg
2396	v.extend_from_slice(fg
2397	v.extend_from_slice(text
2398	v
2399	}
2400
2401	fn split_run_command(clean:
2402	let body =
2403	if let Some
2404	&& let Some
2405	&& let Some
2406	&& let Ok
2407	{
2408	return (Some(parsed
2409	}
2410	(None, body
2411	}
2412
2413	fn spacer_row() -> Vec
2414	USER_FG.as_bytes().to_vec
2415	}
2416
2417	fn tool_label(name:
2418	if name == "
2419	let c =
2420	return (format!("
2421	}
2422	let get =
2423	let rest =
2424	"read_file" \| "write_file"
2425	"list_files" => {
2426	let p =
2427	let p =
2428	match args.get(
2429	Some(pat)
2430	_ => p,
2431	}
2432	}
2433	"search" => {
2434	let pat =
2435	match args.get(
2436	Some(pa)
2437	_ => pat,
2438	}
2439	}
2440	_ => String
2441	};
2442	(name.to_string(),
2443	}
2444
2445	fn tool_call_line(bg:
2446	let (label,
2447	let mut v
2448	bg.len() +
2449	);
2450	v.extend_from_slice(bg
2451	v.push(b'
2452	v.extend_from_slice(TOOL_TITLE_FG
2453	v.extend_from_slice(label
2454	if !rest.is_empty
2455	v.push(b'
2456	v.extend_from_slice(TOOL_CALL_FG
2457	v.extend_from_slice(rest
2458	}
2459	v
2460	}
2461
2462	fn tool_pending_lines(name:
2463	vec![spacer_row(),
2464	}
2465
2466	fn task_desc(args:
2467	args.get("description
2468	.and_then(\|v\|
2469	.map(\|s\|
2470	.filter(\|s\|
2471	.or_else(\|\| args
2472	.filter(\|s\|
2473	.unwrap_or_else(\|\| "sub-agent
2474	}
2475
2476	fn box_width(cols:
2477	cols.max(12)
2478	}
2479
2480	fn welcome_rows(model:
2481	let bg =
2482	let border =
2483	let title_fg =
2484	let body =
2485	let version =
2486	vec![
2487	spacer_row(),
2488	box_header(bg, border
2489	subagent_row(bg, body
2490	subagent_row(bg, body
2491	subagent_row(bg, body
2492	subagent_row(bg, body
2493	subagent_row(bg, body
2494	subagent_row(bg, body
2495	subagent_row(
2496	bg,
2497	body,
2498	" • Shift/Alt+Enter or \\+Enter newline · Ctrl+J too · Ctrl+V paste · double-click chip to expand",
2499	cols,
2500	),
2501	subagent_row(bg, body
2502	subagent_bottom_row(bg, border
2503	]
2504	}
2505
2506	/// Terminal column width of a single glyph. Emoji and CJK are double-width;
2507	/// geometric symbols like `◆` stay single-width (unlike a naive `> 0x1100`
2508	/// check, which made the welcome header one column short).
2509	fn glyph_cols(c:
2510	match c as u32
2511	0x1100..=0x115F // Hangul Jamo
2512	\| 0x2E80..=0xA4CF //
2513	\| 0xAC00..=0xD7A3 //
2514	\| 0xF900..=0xFAFF //
2515	\| 0xFE10..=0xFE19
2516	\| 0xFE30..=0xFE6F
2517	\| 0xFF00..=0xFF60 //
2518	\| 0xFFE0..=0xFFE6
2519	\| 0x1F000..=0x1FFFF //
2520	\| 0x20000..=0x3FFFF => 2
2521	0xFE0F \| 0x200D => 0
2522	_ => 1,
2523	}
2524	}
2525
2526	fn icon_cols(icon:
2527	icon.chars().map
2528	}
2529
2530	fn box_header(bg:
2531	let total =
2532	let iw =
2533	// Layout: "┌─ " (3) + icon (iw) + " " (1) + title + fill + "─┐" (2) = 6 + iw + tlen + fill.
2534	let overhead =
2535	let title =
2536	let tlen =
2537	let fill =
2538	let mut v
2539	v.extend_from_slice(title_fg
2540	v.extend_from_slice(title
2541	v.extend_from_slice(bg
2542	v.extend_from_slice(fg
2543	v.extend_from_slice(format!
2544	v
2545	}
2546
2547	fn subagent_row(bg:
2548	let total =
2549	let inner =
2550	let t =
2551	let pad =
2552	let text =
2553	tool_row(bg, fg
2554	}
2555
2556	fn subagent_bottom_row(bg:
2557	let total =
2558	let inner =
2559	let text =
2560	tool_row(bg, fg
2561	}
2562
2563	fn task_pending_lines(desc:
2564	vec![
2565	spacer_row(),
2566	box_header(
2567	SUBAGENT_PENDING_BG,
2568	SUBAGENT_PENDING_BORDER,
2569	SUBAGENT_PENDING_TITLE,
2570	"🔎",
2571	desc,
2572	cols,
2573	),
2574	]
2575	}
2576
2577	fn task_node_running_lines(desc:
2578	let status =
2579	"working…".to_string()
2580	} else {
2581	status.trim().to_string
2582	};
2583	vec![
2584	spacer_row(),
2585	box_header(
2586	SUBAGENT_PENDING_BG,
2587	SUBAGENT_PENDING_BORDER,
2588	SUBAGENT_PENDING_TITLE,
2589	"⟳",
2590	desc,
2591	cols,
2592	),
2593	subagent_row(SUBAGENT_PENDING_BG, SUBAGENT_PENDING_BODY
2594	]
2595	}
2596
2597	fn task_node_done_lines(desc:
2598	let bg =
2599	let border =
2600	let icon =
2601	vec![
2602	spacer_row(),
2603	box_header(bg, border
2604	subagent_row(bg, SUBAGENT_BODY_FG
2605	subagent_bottom_row(bg, border
2606	]
2607	}
2608
2609	fn subagent_done_lines(desc:
2610	let bg =
2611	let border =
2612	let icon =
2613	let mut lines
2614	spacer_row(),
2615	box_header(bg, border
2616	];
2617
2618	let clean =
2619	let mut out_lines
2620	while out_lines.last()
2621	out_lines.pop();
2622	}
2623	let hidden =
2624	for l in out_lines
2625	lines.push(subagent_row
2626	}
2627	if hidden > 0
2628	lines.push(subagent_row
2629	}
2630	if is_error {
2631	lines.push(subagent_row
2632	}
2633	lines.push(subagent_bottom_row
2634	lines
2635	}
2636
2637	fn tool_done_lines(name:
2638	let clean =
2639	let (exit,
2640	let cmd =
2641	split_run_command(&clean,
2642	} else {
2643	(None, clean
2644	};
2645	let is_error =
2646	is_error \|\| exit.
2647	} else {
2648	is_error
2649	};
2650
2651	let bg =
2652	let mut lines
2653
2654	let mut out_lines
2655	while out_lines.last()
2656	out_lines.pop();
2657	}
2658	let hidden =
2659	for l in out_lines
2660	lines.push(tool_row
2661	}
2662	if hidden > 0
2663	lines.push(tool_row
2664	}
2665	match exit {
2666	Some(c)
2667	_ if is_error
2668	_ => {}
2669	}
2670	lines
2671	}
2672
2673	fn wrap_styled(bytes:
2674	let cols =
2675	let mut rows
2676	let mut cur
2677	let mut style
2678	let mut vis
2679	let mut i
2680	while i < bytes
2681	if bytes[i]
2682	let start =
2683	i += 1;
2684	if i < bytes
2685	i += 1;
2686	while i < bytes
2687	i += 1;
2688	}
2689	if i < bytes
2690	i += 1;
2691	}
2692	} else if i
2693	i += 1;
2694	}
2695	let seq =
2696	if seq.last()
2697	if seq == b
2698	style.clear();
2699	} else {
2700	style.extend_from_slice(seq
2701	}
2702	}
2703	cur.extend_from_slice(seq
2704	continue;
2705	}
2706	let len =
2707	if i + len
2708	break;
2709	}
2710	if vis == cols
2711	rows.push(std
2712	cur.extend_from_slice(&style
2713	vis = 0;
2714	continue;
2715	}
2716	cur.extend_from_slice(&bytes
2717	vis += 1;
2718	i += len;
2719	}
2720	if !cur.is_empty
2721	rows.push(cur
2722	}
2723	rows
2724	}
2725
2726	fn utf8_len(b:
2727	match b {
2728	0x00..=0x7F => 1,
2729	0xC0..=0xDF => 2,
2730	0xE0..=0xEF => 3,
2731	_ => 4,
2732	}
2733	}
2734
2735	fn char_count(s:
2736	s.chars().count
2737	}
2738
2739	fn byte_index(s:
2740	s.char_indices().nth
2741	}
2742
2743	fn byte_to_char(s:
2744	s[..byte_idx.min
2745	}
2746
2747	/// Char index of the start of the logical line containing `cursor_idx`.
2748	fn line_start_idx(text:
2749	let bytes =
2750	let cursor_byte =
2751	if let Some
2752	char_count(&text[..=
2753	} else {
2754	0
2755	}
2756	}
2757
2758	/// Char index of the end (exclusive) of the logical line containing `cursor_idx`.
2759	fn line_end_idx(text:
2760	let bytes =
2761	let cursor_byte =
2762	if let Some
2763	char_count(&text[..
2764	} else {
2765	char_count(text)
2766	}
2767	}
2768
2769	/// Move one logical line up, keeping the column (clamped). `None` on the first
2770	/// line so history navigation can take over.
2771	fn cursor_up(text:
2772	let start =
2773	if start == 0
2774	return None;
2775	}
2776	let prev_end =
2777	let prev_start =
2778	let col =
2779	let prev_len =
2780	Some(prev_start
2781	}
2782
2783	/// Move one logical line down, keeping the column (clamped). `None` on the last
2784	/// line so history navigation can take over.
2785	fn cursor_down(text:
2786	let end =
2787	if end == char_count
2788	return None;
2789	}
2790	let next_start =
2791	let col =
2792	let next_len =
2793	Some(next_start
2794	}
2795
2796	fn truncate(s:
2797	if s.chars()
2798	s.to_string()
2799	} else {
2800	let t: String
2801	format!("{t}
2802	}
2803	}
2804
2805	/// Byte spans `(start, len_bytes)` of each visual (wrapped) row of the editor
2806	/// text, in top-to-bottom order. A trailing empty line is represented by a
2807	/// zero-length span so the cursor can rest on it.
2808	///
2809	/// Empty lines (leading, consecutive, or trailing newlines) must still advance
2810	/// `byte_off` past the `\n` that produced them — otherwise Shift+Enter on an
2811	/// empty prompt (`"\n"`) collapses every row onto byte 0 and the cursor/layout
2812	/// goes haywire.
2813	fn editor_row_spans(text:
2814	let width =
2815	let mut spans
2816	let mut byte_off
2817	let mut parts
2818	while let Some
2819	let chars: Vec
2820	if chars.is_empty()
2821	spans.push((byte_off
2822	} else {
2823	for chunk in chars
2824	let len =
2825	spans.push((byte_off
2826	byte_off += len;
2827	}
2828	}
2829	// Consume the `\n` that separated this part from the next (not present
2830	// after the final segment).
2831	if parts.peek()
2832	byte_off += 1;
2833	}
2834	}
2835	if spans.is_empty()
2836	spans.push((0,
2837	}
2838	spans
2839	}
2840
2841	/// Render the multi-line editor body: up to `show_rows` visual rows with the
2842	/// cursor shown as an inverted block. When the text is taller than the window,
2843	/// the window is kept centered on the cursor row. Rows are padded to exactly
2844	/// `show_rows` entries so the caller can paint a stable box.
2845	fn editor_rows(buf:
2846	let text =
2847	let spans =
2848	let cursor_byte =
2849	let c_row =
2850	.iter()
2851	.rposition(\|&(s
2852	.unwrap_or(0);
2853	let c_col =
2854
2855	let show_rows =
2856	let mut start_row
2857	if spans.len()
2858	start_row = c_row
2859	.saturating_sub(show_rows /
2860	.min(spans.len
2861	}
2862	let end_row =
2863
2864	let mut rows
2865	for (i, &
2866	let slice =
2867	let mut chars
2868	if i == c_row
2869	let before: String
2870	let cur =
2871	.get(c_col)
2872	.map(\|c\|
2873	.unwrap_or_else(\|\| "
2874	let after: String
2875	.get(c_col.saturating_add
2876	.unwrap_or(&[])
2877	.iter()
2878	.collect();
2879	chars = format!
2880	}
2881	let disp: String
2882	rows.push(disp
2883	}
2884	while rows.len()
2885	rows.push(String
2886	}
2887	rows
2888	}
2889
2890	#[cfg(test)]
2891	mod tests {
2892	use super::*;
2893	use serde_json::json;
2894
2895	fn join(lines:
2896	lines
2897	.iter()
2898	.map(\|l\|
2899	.collect::<Vec
2900	.join("\n"
2901	}
2902
2903	fn test_tui(cols:
2904	Tui {
2905	cols,
2906	rows,
2907	history: Vec
2908	hist_idx: None
2909	last_footer: Default
2910	last_model: String
2911	last_provider: String
2912	scroll: 0,
2913	tool_pending: None
2914	sel: None
2915	md: MarkdownStream
2916	user_msgs: Vec
2917	menu: None
2918	next_input: None
2919	revert_count: None
2920	last_stream_redraw: None
2921	task_nodes: Vec
2922	current_node: None
2923	task_view: None
2924	task_view_scroll: 0,
2925	auto_scroll: true,
2926	editor_height: 1,
2927	last_click: None
2928	welcome: None
2929	}
2930	}
2931
2932	fn plain_lines(t:
2933	t.md
2934	.output()
2935	.lines
2936	.iter()
2937	.map(\|l\|
2938	.collect()
2939	}
2940
2941	#[test]
2942	fn task_tool_preserves_text_ordering_around_node() {
2943	let mut t
2944	t.start_output("refactor main.rs
2945	// Main-agent text ends WITHOUT a trailing newline (common before a tool
2946	// call); the markdown stream holds it as a pending tail.
2947	t.feed_stream("Let me inspect the codebase
2948	t.tool_start("task
2949	t.tool_delta("→ read_file src/main.rs
2950
2951	// While the sub-agent runs, the compact node shows its current tool.
2952	let running =
2953	assert!(
2954	running.iter().any
2955	"running node header\n{}",
2956	running.join("\
2957	);
2958	assert!(
2959	running.iter().any
2960	"running node shows current tool\n{}",
2961	running.join("\
2962	);
2963
2964	t.tool_delta("scanning symbols
2965	t.tool_result("mapped 12 files
2966	t.feed_stream(" and now continuing the work
2967	t.finish_stream().unwrap
2968
2969	let plain =
2970	let joined =
2971	let text_pos =
2972	let node_pos =
2973	let cont_pos =
2974	assert!(
2975	text_pos < node_pos,
2976	"assistant text must appear BEFORE the sub-agent node\n{joined}"
2977	);
2978	assert!(
2979	cont_pos > node_pos,
2980	"continuing text must appear AFTER the node\n{joined}"
2981	);
2982	// The sub-agent's activity is captured in the node's context, not the
2983	// main transcript.
2984	let ctx =
2985	assert!(
2986	ctx.iter().any
2987	"tool activity captured in node context"
2988	);
2989	assert!(
2990	plain.iter().all
2991	"sub-agent text must not stream into the main transcript\n{joined}"
2992	);
2993	}
2994
2995	#[test]
2996	fn pending_block_has_bg_and_inline_args() {
2997	let args =
2998	let lines =
2999	let s =
3000	assert!(s.contains
3001	let plain =
3002	assert!(plain.contains
3003	assert!(!plain.
3004	assert!(!plain.
3005	}
3006
3007	#[test]
3008	fn run_command_title_is_dollar_command() {
3009	let args =
3010	let lines =
3011	let s =
3012	assert!(s.contains
3013	assert!(!s.
3014	}
3015
3016	#[test]
3017	fn list_files_shows_path_and_pattern_inline() {
3018	let args =
3019	let lines =
3020	let s =
3021	let plain =
3022	assert!(plain.contains
3023	assert!(!plain.
3024	}
3025
3026	#[test]
3027	fn success_block_uses_ok_bg_and_omits_error() {
3028	let args =
3029	let lines =
3030	let s =
3031	assert!(s.contains
3032	assert!(!s.
3033	assert!(!s.
3034	assert!(!s.
3035	}
3036
3037	#[test]
3038	fn error_block_uses_err_bg_and_exit_code() {
3039	let args =
3040	let lines =
3041	let s =
3042	assert!(s.contains
3043	assert!(s.contains
3044	}
3045
3046	#[test]
3047	fn generic_tool_error_marks_failed() {
3048	let args =
3049	let lines =
3050	let s =
3051	assert!(s.contains
3052	assert!(s.contains
3053	}
3054
3055	#[test]
3056	fn output_truncated_lines_capped() {
3057	let args =
3058	let result =
3059	let lines =
3060	let s =
3061	assert!(s.contains
3062	assert!(!s.
3063	}
3064
3065	#[test]
3066	fn task_pending_renders_search_box_header() {
3067	let cols =
3068	let lines =
3069	let s =
3070	let plain =
3071	assert!(s.contains
3072	assert!(s.contains
3073	assert!(plain.contains
3074	assert!(plain.contains
3075	assert!(plain.contains
3076	for l in &
3077	let w =
3078	assert!(w <=
3079	}
3080	}
3081
3082	#[test]
3083	fn task_done_renders_collapsed_check_box() {
3084	let cols =
3085	let lines =
3086	"scan the codebase",
3087	"Found 3 files:\nsrc/main.rs\nsrc/agent.rs\
3088	false,
3089	cols,
3090	);
3091	let s =
3092	let plain =
3093	assert!(s.contains
3094	assert!(plain.contains
3095	assert!(plain.contains
3096	assert!(plain.contains
3097	assert!(plain.contains
3098	assert!(plain.lines
3099	}
3100
3101	#[test]
3102	fn task_done_error_shows_failed_row() {
3103	let cols =
3104	let lines =
3105	let plain =
3106	assert!(plain.contains
3107	assert!(plain.contains
3108	assert!(plain.contains
3109	}
3110
3111	#[test]
3112	fn task_desc_falls_back_to_subagent_type() {
3113	let desc =
3114	assert_eq!(desc,
3115	let typed =
3116	assert_eq!(typed,
3117	let bare =
3118	assert_eq!(bare,
3119	}
3120
3121	#[test]
3122	fn task_node_running_is_compact_and_spinner() {
3123	let cols =
3124	let lines =
3125	let plain =
3126	assert!(plain.contains
3127	assert!(plain.contains
3128	assert!(plain.contains
3129	let non_empty =
3130	assert_eq!(non_empty,
3131	assert!(!plain.
3132	assert!(plain.lines
3133
3134	let busy =
3135	let busy_plain =
3136	assert!(busy_plain.
3137	}
3138
3139	#[test]
3140	fn task_node_done_hints_clickable_view() {
3141	let cols =
3142	let lines =
3143	let plain =
3144	assert!(plain.contains
3145	assert!(plain.contains
3146	assert!(plain.contains
3147	let err_lines =
3148	let err_plain =
3149	assert!(err_plain.
3150	assert!(plain.lines
3151	}
3152
3153	#[test]
3154	fn paint_selection_highlights_range() {
3155	let row =
3156	let painted =
3157	let s =
3158	assert!(s.contains
3159	assert!(s.contains
3160	let plain =
3161	assert_eq!(plain,
3162	let open =
3163	let after_open =
3164	let cd =
3165	assert!(cd >
3166	let close =
3167	assert!(close >
3168	assert!(after_open[
3169	}
3170
3171	#[test]
3172	fn paint_selection_noop_outside_range() {
3173	let row =
3174	assert_eq!(paint_selection(
3175	assert_eq!(paint_selection(
3176	}
3177
3178	#[test]
3179	fn paint_selection_restores_style_after() {
3180	let row =
3181	let painted =
3182	let plain =
3183	assert_eq!(plain,
3184	let c =
3185	assert_eq!(
3186	&painted[c..],
3187	"c\x1b[0m\x1b[48;2;52;53;65m\
3188	);
3189	}
3190
3191	#[test]
3192	fn editor_row_spans_split_lines_and_wrap() {
3193	assert_eq!(editor_row_spans(
3194	assert_eq!(editor_row_spans(
3195	assert_eq!(
3196	editor_row_spans("abc\nde
3197	vec![(0, 3
3198	"each logical line is one span"
3199	);
3200	assert_eq!(
3201	editor_row_spans("abcdefgh",
3202	vec![(0, 3
3203	"lines wrap into chunks of the content width"
3204	);
3205	// Shift+Enter on an empty prompt inserts "\n". Empty lines must keep
3206	// distinct byte offsets or the cursor lands on the wrong row.
3207	assert_eq!(
3208	editor_row_spans("\n",
3209	vec![(0, 0
3210	"lone newline → two empty rows"
3211	);
3212	assert_eq!(
3213	editor_row_spans("\n\n
3214	vec![(0, 0
3215	"consecutive newlines advance past each \\n"
3216	);
3217	assert_eq!(
3218	editor_row_spans("a\n\
3219	vec![(0, 1
3220	"empty middle line"
3221	);
3222	assert_eq!(
3223	editor_row_spans("hello\n"
3224	vec![(0, 5
3225	"trailing newline leaves a blank cursor row"
3226	);
3227	let rows =
3228	&EditorBuffer {
3229	text: "\n"
3230	elements: Vec::new
3231	images: Vec::new
3232	},
3233	1,
3234	20,
3235	2,
3236	);
3237	assert_eq!(rows.
3238	assert!(
3239	rows[1].contains
3240	"cursor on the blank line after Shift+Enter\n{rows:?}"
3241	);
3242	}
3243
3244	#[test]
3245	fn editor_rows_renders_multiline_cursor() {
3246	let buf =
3247	text: "abc\n
3248	elements: Vec
3249	images: Vec
3250	};
3251	let rows =
3252	assert_eq!(rows.
3253	assert_eq!(crate::md
3254	assert_eq!(crate::md
3255	assert!(
3256	rows[1].starts_with
3257	"cursor highlights the char under it\n{}",
3258	rows[1]
3259	);
3260	}
3261
3262	#[test]
3263	fn editor_rows_shows_cursor_on_empty_line_after_newline() {
3264	let buf =
3265	text: "abc\n
3266	elements: Vec
3267	images: Vec
3268	};
3269	let rows =
3270	assert_eq!(rows.
3271	assert_eq!(crate::md
3272	assert!(
3273	rows[1].contains
3274	"inverted blank cursor on the empty line\n{}",
3275	rows[1]
3276	);
3277	}
3278
3279	#[test]
3280	fn editor_height_counts_inline_paste_chip_as_text() {
3281	let mut t
3282	let mut buf
3283	let mut cursor
3284	t.paste_text(&mut
3285	// Chip label is a single line in the buffer.
3286	t.update_editor_height(&buf
3287	assert_eq!(t.editor_height
3288	buf.text.insert_str(
3289	// Shift elements after the inserted prefix.
3290	for e in &
3291	e.start += 6;
3292	e.end += 6;
3293	}
3294	t.update_editor_height(&buf
3295	assert_eq!(t.editor_height
3296	}
3297
3298	#[test]
3299	fn welcome_rows_puts_provider_behind_model() {
3300	let rows =
3301	let plain: Vec
3302	.iter()
3303	.map(\|r\|
3304	.collect();
3305	assert!(plain[2
3306	assert!(!plain[
3307	}
3308
3309	#[test]
3310	fn welcome_box_rows_share_full_width() {
3311	// The incomplete top-right corner was an off-by-one in box_header:
3312	// header was shorter than body/bottom so the right border looked broken.
3313	for cols in [
3314	let rows =
3315	let widths: Vec
3316	.iter()
3317	.skip(1) //
3318	.map(\|r\|
3319	.collect();
3320	assert!(
3321	widths.iter().all
3322	"cols={cols}: every box row must be full width, got {widths:?
3323	);
3324	}
3325	}
3326
3327	#[test]
3328	fn welcome_rows_reflow_to_terminal_width() {
3329	let wide =
3330	let narrow =
3331	let pw =
3332	let pn =
3333	assert!(pw >
3334	}
3335
3336	#[test]
3337	fn left_right_cross_newlines_in_buffer() {
3338	// Previously Left/Right were line-local, so after a multi-line paste the
3339	// cursor could not leave the last line.
3340	let text =
3341	let mut idx
3342	assert_eq!(idx,
3343	// Walk left across the whole buffer.
3344	let mut seen
3345	while idx > 0
3346	idx -= 1;
3347	seen.push(text
3348	}
3349	assert_eq!(seen,
3350	// Walk right back to the end.
3351	while idx < char_count
3352	idx += 1;
3353	}
3354	assert_eq!(idx,
3355	}
3356
3357	#[test]
3358	fn left_right_jump_over_paste_chip_atomically() {
3359	// Grok Build model: cursor never lands inside a chip; Left/Right jump it.
3360	let mut t
3361	let mut buf
3362	let mut cursor
3363	t.paste_text(&mut
3364	assert!(buf.elements
3365	t.paste_text(&mut
3366	assert_eq!(buf.elements
3367	let chip_start =
3368	let chip_end =
3369	assert_eq!(cursor,
3370	// Left jumps to chip start in one step.
3371	cursor = cursor_left(
3372	assert_eq!(cursor,
3373	// Right jumps back to chip end.
3374	cursor = cursor_right(
3375	assert_eq!(cursor,
3376	// Prefix chars still move one-by-one.
3377	cursor = cursor_left(
3378	cursor = cursor_left(
3379	assert_eq!(cursor,
3380	}
3381
3382	#[test]
3383	fn editor_rows_windows_over_overflowing_text() {
3384	let text =
3385	let buf =
3386	text: text.clone
3387	elements: Vec
3388	images: Vec
3389	};
3390	// Each "lineX" is 5 chars + '\n' = 6; line 5 starts at char 30, and a
3391	// 3-row window around it overflows both above and below.
3392	let cursor_idx =
3393	let rows =
3394	assert_eq!(rows.
3395	assert!(!rows[
3396	assert!(!rows[
3397	let plain: Vec
3398	assert_eq!(plain[1
3399	assert!(
3400	rows[1].starts_with
3401	"cursor highlights the first char of line5\n{}",
3402	rows[1]
3403	);
3404	}
3405
3406	#[test]
3407	fn editor_rows_pads_to_window_height() {
3408	let buf =
3409	text: "x".
3410	elements: Vec
3411	images: Vec
3412	};
3413	let rows =
3414	assert_eq!(rows.
3415	assert!(rows[1
3416	}
3417
3418	#[test]
3419	fn line_navigation_helpers_work_across_newlines() {
3420	let text =
3421	assert_eq!(line_start_idx(
3422	assert_eq!(line_end_idx(
3423	assert_eq!(cursor_up(
3424	assert_eq!(cursor_down(
3425	assert_eq!(cursor_up(
3426	assert_eq!(cursor_down(
3427	assert_eq!(cursor_up(
3428	}
3429
3430	#[test]
3431	fn base64_encode_matches_standard_vectors() {
3432	assert_eq!(base64_encode(
3433	assert_eq!(base64_encode(
3434	assert_eq!(base64_encode(
3435	assert_eq!(base64_encode(
3436	assert_eq!(base64_encode(
3437	assert_eq!(base64_encode(
3438	assert_eq!(base64_encode(
3439	assert_eq!(
3440	base64_encode(b"\x89PNG
3441	"iVBORw0KGgo=",
3442	"PNG magic bytes round-trip"
3443	);
3444	}
3445
3446	#[test]
3447	fn image_paste_sniffs_png_and_jpeg() {
3448	let png =
3449	match image_paste_from_bytes(png.
3450	Some(PasteContent
3451	assert_eq!(img.
3452	assert_eq!(img.
3453	}
3454	other => panic!
3455	}
3456	let jpeg =
3457	match image_paste_from_bytes(jpeg)
3458	Some(PasteContent
3459	other => panic!
3460	}
3461	assert!(image_paste_from_bytes(
3462	assert!(image_paste_from_bytes(
3463	}
3464
3465	#[test]
3466	fn image_paste_rejects_oversized_images() {
3467	let big =
3468	let mut prefix
3469	prefix.extend_from_slice(&big
3470	match image_paste_from_bytes(prefix)
3471	Some(PasteContent
3472	other => panic!
3473	}
3474	}
3475
3476	#[test]
3477	fn large_paste_classified_by_lines_and_bytes() {
3478	let multi =
3479	assert!(is_large_paste(
3480	assert!(is_large_paste(
3481	assert!(!is_large_paste
3482	let long_one_liner =
3483	assert!(is_large_paste(
3484	assert!(!is_large_paste
3485	assert!(!is_large_paste
3486	}
3487
3488	#[test]
3489	fn sanitize_paste_normalizes_endings_and_strips_control() {
3490	assert_eq!(sanitize_paste(
3491	assert_eq!(sanitize_paste(
3492	assert_eq!(sanitize_paste(
3493	assert_eq!(
3494	sanitize_paste("tab\there
3495	"tab\there[31mESCDELSOH"
3496	);
3497	assert_eq!(sanitize_paste(
3498	let unicode =
3499	assert_eq!(unicode,
3500	}
3501
3502	#[test]
3503	fn paste_label_counts_lines() {
3504	assert_eq!(paste_label(
3505	assert_eq!(paste_label(
3506	assert_eq!(
3507	paste_label(&(0..30
3508	"[Pasted: 30 lines]"
3509	);
3510	}
3511
3512	#[test]
3513	fn paste_label_shows_size_for_huge_paste() {
3514	let big =
3515	assert_eq!(paste_label(
3516	}
3517
3518	#[test]
3519	fn expand_paste_inlines_block_and_clears_chip() {
3520	let mut t
3521	let mut buf
3522	let mut cursor
3523	t.paste_text(&mut
3524	t.paste_text(&mut
3525	assert_eq!(buf.elements
3526	assert!(buf.text
3527	let end =
3528	assert!(buf.elements
3529	assert_eq!(buf.text
3530	assert_eq!(end,
3531	}
3532
3533	#[test]
3534	fn repaste_identical_payload_expands_chip() {
3535	let mut t
3536	let mut buf
3537	let mut cursor
3538	t.paste_text(&mut
3539	assert_eq!(buf.elements
3540	assert_eq!(buf.text
3541	assert_eq!(buf.elements
3542	// Cursor is right after the chip — repaste expands (Grok Build).
3543	t.paste_text(&mut
3544	assert!(buf.elements
3545	assert_eq!(buf.text
3546	}
3547
3548	#[test]
3549	fn double_click_row_expands_paste_chip() {
3550	let mut t
3551	let mut buf
3552	let mut cursor
3553	t.paste_text(&mut
3554	t.update_editor_height(&buf
3555	let body_top =
3556	assert!(t.expand_paste_at_screen
3557	assert!(buf.elements
3558	assert_eq!(buf.text
3559	assert!(!t.
3560	}
3561
3562	#[test]
3563	fn submit_text_substitutes_chip_content() {
3564	let plain =
3565	text: "hello".
3566	elements: Vec
3567	images: Vec
3568	};
3569	assert_eq!(submit_text(
3570	let mut t
3571	let mut buf
3572	let mut cursor
3573	t.paste_text(&mut
3574	t.paste_text(&mut
3575	assert_eq!(submit_text(
3576	buf = EditorBuffer
3577	cursor = 0;
3578	t.paste_text(&mut
3579	assert_eq!(submit_text(
3580	}
3581
3582	#[test]
3583	fn backspace_deletes_paste_chip_atomically() {
3584	let mut t
3585	let mut buf
3586	let mut cursor
3587	t.paste_text(&mut
3588	let start =
3589	let end =
3590	cursor = delete_char_range(
3591	assert_eq!(cursor,
3592	assert!(buf.text
3593	assert!(buf.elements
3594	}
3595
3596	#[test]
3597	fn is_mod_enter_accepts_shift_and_alt() {
3598	assert!(is_mod_enter(
3599	KeyCode::Enter,
3600	KeyModifiers::SHIFT
3601	)));
3602	assert!(is_mod_enter(
3603	KeyCode::Enter,
3604	KeyModifiers::ALT
3605	)));
3606	// Bare Enter without OS modifier is not a newline chord. (On macOS the
3607	// OS probe may still fire if the tester holds Shift — don't assert that
3608	// path here.)
3609	assert!(!is_mod_enter
3610	KeyCode::Enter,
3611	KeyModifiers::CONTROL
3612	)));
3613	assert!(!is_mod_enter
3614	KeyCode::Char('a
3615	KeyModifiers::SHIFT
3616	)));
3617	assert!(!is_mod_enter
3618	KeyCode::BackTab,
3619	KeyModifiers::SHIFT
3620	)));
3621	}
3622
3623	#[test]
3624	fn backslash_enter_inserts_newline() {
3625	let mut buf
3626	text: "hello\\
3627	elements: Vec
3628	images: Vec
3629	};
3630	let mut cursor
3631	assert!(try_backslash_continuation(
3632	assert_eq!(buf.text
3633	assert_eq!(cursor,
3634	// No trailing backslash → no-op.
3635	assert!(!try_backslash_continuation
3636	assert_eq!(buf.text
3637	}
3638
3639	#[test]
3640	fn kill_to_line_start_keeps_text_after_cursor() {
3641	// Grok Build / macOS Cmd+Backspace / readline Ctrl+U.
3642	let mut buf
3643	text: "hello world".
3644	elements: Vec
3645	images: Vec
3646	};
3647	let cursor =
3648	assert_eq!(buf.text
3649	assert_eq!(cursor,
3650	}
3651
3652	#[test]
3653	fn kill_to_line_start_on_multiline() {
3654	let mut buf
3655	text: "aaa\n
3656	elements: Vec
3657	images: Vec
3658	};
3659	// Cursor mid second line (on second 'b' → index 5).
3660	let cursor =
3661	assert_eq!(buf.text
3662	assert_eq!(cursor,
3663	// At BOL of second line: eat the preceding newline.
3664	let cursor =
3665	assert_eq!(buf.text
3666	assert_eq!(cursor,
3667	}
3668
3669	#[test]
3670	fn kill_to_line_end_and_current_line() {
3671	let mut buf
3672	text: "hello world".
3673	elements: Vec
3674	images: Vec
3675	};
3676	let cursor =
3677	assert_eq!(buf.text
3678	assert_eq!(cursor,
3679
3680	let mut buf
3681	text: "aaa\n
3682	elements: Vec
3683	images: Vec
3684	};
3685	// Kill whole middle line including its trailing newline.
3686	let cursor =
3687	assert_eq!(buf.text
3688	assert_eq!(cursor,
3689	}
3690
3691	#[test]
3692	fn is_cmd_backspace_matches_super_and_control() {
3693	assert!(is_cmd_backspace(
3694	KeyCode::Backspace,
3695	KeyModifiers::SUPER
3696	)));
3697	assert!(is_cmd_backspace(
3698	KeyCode::Backspace,
3699	KeyModifiers::CONTROL
3700	)));
3701	assert!(!is_cmd_backspace
3702	KeyCode::Backspace,
3703	KeyModifiers::NONE
3704	)));
3705	assert!(!is_cmd_backspace
3706	KeyCode::Delete,
3707	KeyModifiers::SUPER
3708	)));
3709	assert!(is_cmd_delete(
3710	KeyCode::Delete,
3711	KeyModifiers::SUPER
3712	)));
3713	}
3714	}