Skip to main content

glass_dev/tui/
state.rs

1use super::command;
2use crate::{ExperimentComparison, SharedDevelopmentWorkspace};
3use glass_browser::browser::policy::PolicyPreset;
4use glass_browser::browser_workspace::{
5    BrowserConnectionPhase, BrowserWorkspaceAction, BrowserWorkspaceAdapterKind,
6    BrowserWorkspaceController, BrowserWorkspaceEntity, BrowserWorkspaceIntent,
7    BrowserWorkspaceLayout, BrowserWorkspaceTarget,
8};
9use glass_browser::cli::args::TuiLayout;
10use glass_browser::terminal_graphics::AnsiCanvas;
11use glass_browser::tui::live_view::AnsiPane;
12use serde::{Deserialize, Serialize};
13use std::path::Path;
14use std::sync::atomic::{AtomicU64, Ordering};
15
16static NEXT_BROWSER_TOOL: AtomicU64 = AtomicU64::new(1);
17
18pub struct PendingConfirmation {
19    pub call: crate::development::ToolCall,
20    pub context: crate::tools::DevelopmentToolContext,
21    pub summary: String,
22}
23
24#[derive(Debug, Clone)]
25pub struct PendingAgentApproval {
26    pub agent_id: String,
27    pub frame_id: String,
28    pub tool_name: String,
29    pub arguments: serde_json::Value,
30}
31
32#[derive(Debug, Clone, Copy, PartialEq, Eq)]
33pub enum ChatMessageState {
34    Sending,
35    Sent,
36    Failed,
37}
38
39#[derive(Debug, Clone, PartialEq, Eq)]
40pub struct PendingChatMessage {
41    pub text: String,
42    pub state: ChatMessageState,
43    pub job_id: Option<u64>,
44    pub error: Option<String>,
45}
46
47/// In-TUI recovery choices offered when a browser start collides or fails.
48#[derive(Debug, Clone, PartialEq, Eq)]
49pub struct BrowserRecoveryOffer {
50    pub reason: String,
51    pub port: u16,
52    /// A healthy Chrome CDP endpoint answered on the preferred port.
53    pub compatible_endpoint: bool,
54}
55
56impl BrowserRecoveryOffer {
57    pub fn from_error(error: &str, port: u16) -> Self {
58        let lower = error.to_ascii_lowercase();
59        Self {
60            reason: error.to_string(),
61            port,
62            compatible_endpoint: ["attach", "devtools", "page target", "multiple page targets"]
63                .iter()
64                .any(|marker| lower.contains(marker)),
65        }
66    }
67
68    pub fn actions(&self) -> &'static [(&'static str, &'static str)] {
69        if self.compatible_endpoint {
70            &[
71                ("1", "attach after checking the running browser"),
72                ("2", "launch an isolated browser on an automatic free port"),
73                ("3", "retry the preferred port"),
74                ("Esc", "dismiss"),
75            ]
76        } else {
77            &[
78                ("1", "launch an isolated browser on an automatic free port"),
79                ("2", "retry the preferred port"),
80                ("Esc", "dismiss"),
81            ]
82        }
83    }
84
85    pub fn guidance(&self) -> &'static str {
86        let lower = self.reason.to_ascii_lowercase();
87        if self.compatible_endpoint {
88            "A DevTools endpoint answered. Attach only when its page is the intended browser; otherwise launch an isolated session."
89        } else if lower.contains("occup") || lower.contains("address") || lower.contains("port") {
90            "The preferred endpoint is busy or unavailable. Glass keeps the project and agent alive while you retry or move to an automatic free port."
91        } else {
92            "The browser did not become usable. Check Chrome/Chromium availability, then retry; the workspace remains intact."
93        }
94    }
95}
96
97#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
98pub enum DevSurface {
99    Trust,
100    Agent,
101    Code,
102    App,
103    Terminal,
104    Tasks,
105    Git,
106    Debug,
107    More,
108}
109
110impl DevSurface {
111    pub const ALL: [Self; 8] = [
112        Self::Agent,
113        Self::Code,
114        Self::App,
115        Self::Terminal,
116        Self::Tasks,
117        Self::Git,
118        Self::Debug,
119        Self::More,
120    ];
121
122    pub const PRIMARY: [Self; 8] = [
123        Self::Agent,
124        Self::Code,
125        Self::App,
126        Self::Terminal,
127        Self::Tasks,
128        Self::Git,
129        Self::Debug,
130        Self::More,
131    ];
132
133    pub const PHONE: [Self; 5] = [Self::Agent, Self::Code, Self::App, Self::Tasks, Self::More];
134
135    pub fn label(self) -> &'static str {
136        match self {
137            Self::Trust => "Trust",
138            Self::Agent => "Agent",
139            Self::Code => "Code",
140            Self::App => "App",
141            Self::Terminal => "Terminal",
142            Self::Tasks => "Tasks",
143            Self::Git => "Git",
144            Self::Debug => "Debug",
145            Self::More => "More",
146        }
147    }
148}
149
150#[derive(Debug, Clone, Copy, PartialEq, Eq)]
151pub enum ResponsiveClass {
152    Desktop,
153    Compact,
154    Phone,
155}
156
157#[derive(Debug, Clone, Copy, PartialEq, Eq)]
158pub enum EditorExitPrompt {
159    Clean,
160    Unsaved,
161}
162
163#[derive(Debug, Clone, Copy, PartialEq, Eq)]
164pub enum ProductMode {
165    Build,
166    Agent,
167    RunApp,
168    Debug,
169}
170
171impl ProductMode {
172    pub fn label(self) -> &'static str {
173        match self {
174            Self::Build => "build",
175            Self::Agent => "agent",
176            Self::RunApp => "run",
177            Self::Debug => "debug",
178        }
179    }
180}
181
182pub struct DevTuiState {
183    pub workspace: SharedDevelopmentWorkspace,
184    pub surface: DevSurface,
185    pub layout: TuiLayout,
186    /// Process-scoped unrestricted development mode from `glass --yolo`.
187    pub yolo_mode: bool,
188    pub quit_confirmation: bool,
189    pub quit: bool,
190    pub command_mode: bool,
191    pub command_input: String,
192    pub command_cursor: usize,
193    pub command_history: Vec<String>,
194    pub command_history_index: Option<usize>,
195    pub palette_error: Option<String>,
196    pub palette_scroll: u16,
197    /// Index in the filtered, arrow-selectable palette action list.
198    pub palette_selection: usize,
199    pub menu_open: bool,
200    pub menu_selection: usize,
201    pub help_open: bool,
202    pub help_scroll: u16,
203    pub composer_mode: bool,
204    pub composer_input: String,
205    pub composer_cursor: usize,
206    pub composer_steer: bool,
207    pub pending_chat_messages: Vec<PendingChatMessage>,
208    pub agent_send_job: Option<u64>,
209    pub selected_agent: Option<crate::AgentId>,
210    pub pending_confirmation: Option<PendingConfirmation>,
211    /// URL retained while the TUI launches a detached browser before navigation.
212    pub pending_browser_navigation: Option<String>,
213    pub pending_agent_approval: Option<PendingAgentApproval>,
214    pub editor_exit_prompt: Option<EditorExitPrompt>,
215    pub queued_tool_request: Option<(
216        crate::development::ToolCall,
217        crate::tools::DevelopmentToolContext,
218    )>,
219    pub running_tool_job: Option<u64>,
220    pub surface_scroll: std::collections::BTreeMap<DevSurface, usize>,
221    pub terminal_width: u16,
222    pub terminal_height: u16,
223    pub status: String,
224    pub snapshot_root: String,
225    pub snapshot_trust_label: String,
226    pub snapshot_trust_inspection: Vec<crate::customization::CustomizationInspectionItem>,
227    pub snapshot_project_revision: u64,
228    pub snapshot_generation: u64,
229    pub snapshot_skills_count: usize,
230    pub snapshot_tools_count: usize,
231    /// Wall-clock cost of the last background refresh pass.
232    pub refresh_latency_ms: u64,
233    /// Highest agent event sequence folded into the live conversation.
234    pub conversation_cursor: u64,
235    /// Index of the editor buffer focused by the Code surface.
236    pub editor_buffer_index: usize,
237    pub focused_editor_path: String,
238    /// Cached editor content used while the shared workspace is busy.
239    pub focused_editor_content: String,
240    pub focused_editor_dirty: bool,
241    pub focused_editor_line: u32,
242    pub focused_editor_column: u32,
243    pub focused_editor_selection: Option<crate::development::TextSelection>,
244    pub editor_comments: Vec<crate::development::EditorComment>,
245    pub editor_proposals: Vec<crate::development::EditorProposal>,
246    pub editor_checkpoints: Vec<crate::development::EditorCheckpoint>,
247    pub agents: String,
248    pub agent_readiness: String,
249    pub harnesses: String,
250    /// Set by an in-TUI login action; the event loop temporarily hands the
251    /// terminal to Pi so `/login` can receive interactive input.
252    pub agent_login_requested: bool,
253    /// Set by a palette action; the event loop hands the terminal to the
254    /// selected external harness and resumes Glass after it exits.
255    pub harness_launch_requested: Option<String>,
256    pub agent_conversation: String,
257    pub tasks: String,
258    pub editor: String,
259    pub files: Vec<String>,
260    pub selected_file: usize,
261    pub code_edit_mode: bool,
262    pub editor_soft_wrap: bool,
263    pub editor_scroll_line: usize,
264    pub editor_scroll_column: usize,
265    pub lsp: String,
266    pub processes: String,
267    pub git: String,
268    pub git_entries: Vec<crate::git::GitStatusEntry>,
269    pub github: crate::github::GitHubStatus,
270    pub github_review: String,
271    pub selected_git_file: usize,
272    pub git_diff_path: Option<String>,
273    pub git_diff: String,
274    pub git_diff_open: bool,
275    pub git_diff_requested: bool,
276    pub tests: String,
277    pub kernels: String,
278    pub debugger: String,
279    pub replay: String,
280    pub browser: String,
281    pub browser_detail: String,
282    pub browser_workspace: BrowserWorkspaceController,
283    pub browser_recovery: Option<BrowserRecoveryOffer>,
284    pub browser_target_picker: bool,
285    pub browser_target_picker_requested: bool,
286    pub browser_target_query: String,
287    pub browser_target_selection: usize,
288    pub browser_visual_live: bool,
289    pub browser_observe_pending: bool,
290    pub browser_ansi: AnsiCanvas,
291    pub browser_pane: Option<AnsiPane>,
292    pub workflow: String,
293    pub workspace_status: String,
294    pub experiment_comparison: Option<ExperimentComparison>,
295    pub experiments: String,
296    pub cockpit_url: String,
297    pub private_cockpit: Option<crate::development::LocalCockpit>,
298}
299
300impl DevTuiState {
301    /// Lock the shared workspace, mapping errors to strings for the palette.
302    pub fn ws(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
303        self.workspace.try_lock().map_err(|error| error.to_string())
304    }
305
306    /// Lock the shared workspace for mutation, mapping errors to strings.
307    pub fn ws_mut(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
308        self.workspace.try_lock().map_err(|error| error.to_string())
309    }
310
311    /// Lock the workspace for mutation inside UI callbacks; reports lock
312    /// failures through the status line instead of `?`.
313    fn locked<F, T>(&mut self, operation: F) -> Option<T>
314    where
315        F: FnOnce(&mut crate::DevelopmentWorkspace) -> T,
316    {
317        match self.workspace.try_lock() {
318            Ok(mut workspace) => Some(operation(&mut workspace)),
319            Err(error) => {
320                self.status = format!("Workspace lock failed: {error}");
321                None
322            }
323        }
324    }
325
326    pub fn product_mode(&self) -> ProductMode {
327        match self.surface {
328            DevSurface::Agent => ProductMode::Agent,
329            DevSurface::App => ProductMode::RunApp,
330            DevSurface::Debug => ProductMode::Debug,
331            _ => ProductMode::Build,
332        }
333    }
334    pub fn open(
335        root: impl AsRef<Path>,
336        layout: TuiLayout,
337    ) -> Result<Self, Box<dyn std::error::Error>> {
338        Self::open_internal(root, layout, true, false, PolicyPreset::Development)
339    }
340
341    /// Construct the interactive TUI without doing a full synchronous
342    /// projection pass. The snapshot worker fills resident projections after
343    /// the first frame, so a large repository can show the cockpit immediately.
344    pub fn open_for_tui(
345        root: impl AsRef<Path>,
346        layout: TuiLayout,
347    ) -> Result<Self, Box<dyn std::error::Error>> {
348        Self::open_internal(root, layout, false, false, PolicyPreset::Development)
349    }
350
351    /// Construct the TUI with an explicit process-scoped development mode.
352    pub fn open_for_tui_with_mode(
353        root: impl AsRef<Path>,
354        layout: TuiLayout,
355        yolo_mode: bool,
356    ) -> Result<Self, Box<dyn std::error::Error>> {
357        Self::open_for_tui_with_policy(root, layout, yolo_mode, PolicyPreset::Development)
358    }
359
360    /// Construct the TUI with explicit development and browser policies.
361    pub fn open_for_tui_with_policy(
362        root: impl AsRef<Path>,
363        layout: TuiLayout,
364        yolo_mode: bool,
365        policy_preset: PolicyPreset,
366    ) -> Result<Self, Box<dyn std::error::Error>> {
367        Self::open_internal(root, layout, false, yolo_mode, policy_preset)
368    }
369
370    fn open_internal(
371        root: impl AsRef<Path>,
372        layout: TuiLayout,
373        initial_refresh: bool,
374        yolo_mode: bool,
375        policy_preset: PolicyPreset,
376    ) -> Result<Self, Box<dyn std::error::Error>> {
377        let workspace = SharedDevelopmentWorkspace::open_with_policy(root, policy_preset)?;
378        if yolo_mode {
379            let mut workspace = workspace.lock()?;
380            workspace.agents().set_default_unrestricted(true);
381        }
382        let locked = workspace.lock()?;
383        let trust = locked.trust();
384        let trust_inspection = locked.trust_inspection();
385        let snapshot_root = locked.root().display().to_string();
386        let snapshot_project_revision = locked.project().revision();
387        let snapshot_generation = locked.generation();
388        let snapshot_skills_count = locked.customization().skills().count();
389        let snapshot_tools_count = locked.customization().config().tools.len();
390        let trust_prompt = trust == crate::WorkspaceTrust::Untrusted
391            && trust_inspection.iter().any(|item| item.trust_required);
392        drop(locked);
393        let agent_readiness = crate::pi_runtime::pi_readiness()
394            .map(|readiness| format_pi_readiness(&readiness))
395            .unwrap_or_else(|error| format!("Agent unavailable · {error}"));
396        let initial_status = if trust_prompt {
397            "Trust required · I inspect · O untrusted · 1 once · T project".to_string()
398        } else if agent_readiness.starts_with("✓ Ready") {
399            "Ready · describe a coding task".to_string()
400        } else {
401            "Pi setup required · press :actions or Enter to continue".to_string()
402        };
403        let mut state = Self {
404            workspace,
405            surface: if trust_prompt {
406                DevSurface::Trust
407            } else {
408                DevSurface::Agent
409            },
410            layout,
411            yolo_mode,
412            quit: false,
413            quit_confirmation: false,
414            command_mode: false,
415            command_input: String::new(),
416            command_cursor: 0,
417            command_history: Vec::new(),
418            command_history_index: None,
419            palette_error: None,
420            palette_scroll: 0,
421            palette_selection: 0,
422            menu_open: false,
423            menu_selection: 0,
424            help_open: false,
425            help_scroll: 0,
426            composer_mode: false,
427            composer_input: String::new(),
428            composer_cursor: 0,
429            composer_steer: false,
430            pending_chat_messages: Vec::new(),
431            agent_send_job: None,
432            selected_agent: None,
433            pending_confirmation: None,
434            editor_exit_prompt: None,
435            pending_agent_approval: None,
436            pending_browser_navigation: None,
437            queued_tool_request: None,
438            running_tool_job: None,
439            surface_scroll: std::collections::BTreeMap::new(),
440            terminal_width: 80,
441            terminal_height: 24,
442            snapshot_root,
443            snapshot_trust_label: trust.label().into(),
444            snapshot_trust_inspection: trust_inspection,
445            snapshot_project_revision,
446            snapshot_generation,
447            snapshot_skills_count,
448            snapshot_tools_count,
449            refresh_latency_ms: 0,
450            conversation_cursor: 0,
451            editor_buffer_index: 0,
452            focused_editor_path: String::new(),
453            focused_editor_content: String::new(),
454            focused_editor_dirty: false,
455            focused_editor_line: 0,
456            focused_editor_column: 0,
457            focused_editor_selection: None,
458            editor_comments: Vec::new(),
459            editor_proposals: Vec::new(),
460            editor_checkpoints: Vec::new(),
461            status: initial_status,
462            agents: String::new(),
463            agent_readiness,
464            harnesses: crate::harness::summary(),
465            agent_login_requested: false,
466            harness_launch_requested: None,
467            agent_conversation:
468                "No conversation yet. Press Enter or start typing to compose a message.".into(),
469            tasks: String::new(),
470            editor: String::new(),
471            files: Vec::new(),
472            selected_file: 0,
473            code_edit_mode: false,
474            editor_soft_wrap: false,
475            editor_scroll_line: 0,
476            editor_scroll_column: 0,
477            lsp: String::new(),
478            processes: String::new(),
479            git: String::new(),
480            git_entries: Vec::new(),
481            github: crate::github::GitHubStatus::default(),
482            github_review: "No GitHub review yet".into(),
483            selected_git_file: 0,
484            git_diff_path: None,
485            git_diff: String::new(),
486            git_diff_open: false,
487            git_diff_requested: false,
488            tests: String::new(),
489            kernels: String::new(),
490            debugger: String::new(),
491            replay: String::new(),
492            browser: String::new(),
493            browser_detail: "No browser observation yet".into(),
494            browser_workspace: BrowserWorkspaceController::for_adapter(
495                match layout {
496                    TuiLayout::Mobile => BrowserWorkspaceLayout::Phone,
497                    TuiLayout::Compact => BrowserWorkspaceLayout::Compact,
498                    TuiLayout::Auto | TuiLayout::Desktop => BrowserWorkspaceLayout::Desktop,
499                },
500                BrowserWorkspaceAdapterKind::EmbeddedDevelopment,
501            ),
502            browser_recovery: None,
503            browser_target_picker: false,
504            browser_target_picker_requested: false,
505            browser_target_query: String::new(),
506            browser_target_selection: 0,
507            browser_visual_live: false,
508            browser_observe_pending: false,
509            browser_ansi: AnsiCanvas::default(),
510            browser_pane: None,
511            workflow: "No workflow evidence yet".into(),
512            workspace_status: String::new(),
513            experiment_comparison: None,
514            experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
515            cockpit_url: String::new(),
516            private_cockpit: None,
517        };
518        if initial_refresh {
519            state.refresh();
520        }
521        Ok(state)
522    }
523
524    pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
525        match self.layout {
526            TuiLayout::Desktop => ResponsiveClass::Desktop,
527            TuiLayout::Compact => ResponsiveClass::Compact,
528            TuiLayout::Mobile => ResponsiveClass::Phone,
529            TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
530            TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
531            TuiLayout::Auto => ResponsiveClass::Desktop,
532        }
533    }
534
535    pub fn request_quit(&mut self) {
536        if self.quit {
537            return;
538        }
539        self.quit_confirmation = true;
540        self.status = "Quit confirmation · Enter exits · Esc stays".into();
541    }
542
543    pub fn confirm_quit(&mut self) {
544        self.quit_confirmation = false;
545        self.quit = true;
546        self.status = "Closing Glass Dev".into();
547    }
548
549    pub fn cancel_quit(&mut self) {
550        self.quit_confirmation = false;
551        self.status = "Quit dismissed · workspace remains open".into();
552    }
553
554    pub fn quit_menu_index(&self) -> usize {
555        self.surface_actions().len() + 1
556    }
557
558    /// Guided launchers for the current surface. `:actions` opens the command center.
559    pub fn surface_actions(&self) -> &'static [command::SurfaceAction] {
560        command::surface_actions(self.surface)
561    }
562
563    pub fn toggle_help(&mut self) {
564        self.help_open = !self.help_open;
565        self.help_scroll = 0;
566        self.status = if self.help_open {
567            "Help · j/k scroll · ? or Esc closes".into()
568        } else {
569            "Help closed".into()
570        };
571    }
572
573    pub fn scroll_help(&mut self, delta: i32) {
574        self.help_scroll = (self.help_scroll as i32 + delta).max(0) as u16;
575    }
576
577    pub fn open_menu(&mut self) {
578        self.menu_open = true;
579        self.menu_selection = 0;
580        self.status = format!("Command center · {}", self.surface.label());
581    }
582
583    pub fn close_menu(&mut self) {
584        self.menu_open = false;
585    }
586
587    pub fn start_private_cockpit(&mut self) -> Result<String, String> {
588        if let Some(cockpit) = self.private_cockpit.as_ref() {
589            return Ok(cockpit.local_url());
590        }
591        let cockpit = crate::development::LocalCockpit::start(self.workspace.clone())
592            .map_err(|error| error.to_string())?;
593        let url = cockpit.local_url();
594        self.cockpit_url = url.clone();
595        self.private_cockpit = Some(cockpit);
596        self.status = format!("Private cockpit ready · {url}");
597        Ok(url)
598    }
599
600    pub fn stop_private_cockpit(&mut self) {
601        if self.private_cockpit.take().is_some() {
602            self.cockpit_url.clear();
603            self.status = "Private cockpit stopped".into();
604        } else {
605            self.status = "Private cockpit is not running".into();
606        }
607    }
608
609    pub fn private_cockpit_status(&self) -> String {
610        self.private_cockpit
611            .as_ref()
612            .map(|cockpit| format!("running · {}", cockpit.local_url()))
613            .unwrap_or_else(|| "not running · use `cockpit start`".into())
614    }
615
616    /// Run the selected command-center launcher. Keyboard hints apply
617    /// directly; strings starting with `:` open the palette prefilled with
618    /// the command.
619    pub fn run_menu_action(&mut self) {
620        let search_index = self.surface_actions().len();
621        let quit_index = self.quit_menu_index();
622        if self.menu_selection == search_index {
623            self.menu_open = false;
624            self.open_palette();
625            return;
626        }
627        if self.menu_selection == quit_index {
628            self.menu_open = false;
629            self.request_quit();
630            return;
631        }
632        let Some(action) = self.surface_actions().get(self.menu_selection).copied() else {
633            return;
634        };
635        self.menu_open = false;
636        let name = action.label;
637        let hint = action.command;
638        if hint == "browser view" {
639            self.surface = DevSurface::App;
640            self.browser_visual_live = !self.browser_visual_live;
641            self.status = if self.browser_visual_live {
642                "Live view starting · command palette can stop it".into()
643            } else {
644                "Live view off · semantic inspection remains available".into()
645            };
646            return;
647        }
648        if hint == "process start dev" {
649            self.request_detected_dev();
650            return;
651        }
652        if hint == "git diff" && self.surface == DevSurface::Git {
653            self.git_diff_requested = true;
654            self.status = "Git diff queued · loading off-thread".into();
655            return;
656        }
657        if self.surface == DevSurface::Trust && matches!(hint, "I" | "O" | "1" | "T") {
658            self.handle_printable(hint.chars().next().expect("trust action hint is non-empty"));
659            return;
660        }
661        let prefix = action.key;
662        if prefix == ":" {
663            // Strip documentation placeholders from the editable command so
664            // users can type values immediately instead of backspacing
665            // `NAME`, `QUERY`, or `RUN_ID` out of the input line.
666            let prefill = hint
667                .split_whitespace()
668                .take_while(|token| {
669                    !token
670                        .chars()
671                        .all(|character| character.is_ascii_uppercase() || character == '_')
672                })
673                .collect::<Vec<_>>()
674                .join(" ");
675            if prefill.is_empty() || prefill == hint {
676                self.open_palette_with(hint);
677            } else {
678                self.open_palette_with(&format!("{prefill} "));
679            }
680        } else if hint == "i" {
681            if self.surface == DevSurface::Agent {
682                self.open_composer();
683            } else {
684                self.enter_code_edit();
685            }
686        } else if hint == "Enter" {
687            if self.surface == DevSurface::Code {
688                self.open_selected_file();
689            }
690        } else if hint == "Ctrl-S" && self.surface == DevSurface::Code {
691            self.edit_code_key(
692                crossterm::event::KeyCode::Char('s'),
693                crossterm::event::KeyModifiers::CONTROL,
694            );
695        } else {
696            self.status = format!("{name} is available from this surface");
697        }
698    }
699
700    pub fn move_menu_selection(&mut self, delta: i32) {
701        let count = self.surface_actions().len() as i32 + 2;
702        self.menu_selection =
703            (self.menu_selection as i32 + delta).rem_euclid(count.max(1)) as usize;
704    }
705
706    pub fn open_palette(&mut self) {
707        self.command_mode = true;
708        self.command_input.clear();
709        self.command_cursor = 0;
710        self.command_history_index = None;
711        self.palette_error = None;
712        self.palette_scroll = 0;
713        self.palette_selection = 0;
714        self.status = format!(
715            "Command search · {} actions · ↑↓ select · Enter run",
716            self.surface.label()
717        );
718    }
719
720    pub fn close_palette(&mut self) {
721        self.command_mode = false;
722        self.command_input.clear();
723        self.command_cursor = 0;
724        self.command_history_index = None;
725        self.palette_error = None;
726        self.palette_scroll = 0;
727        self.palette_selection = 0;
728        self.status = "Command palette closed · press : for guided launchers".into();
729    }
730
731    pub fn palette_action_indices(&self) -> Vec<usize> {
732        let query = self.command_input.trim();
733        self.surface_actions()
734            .iter()
735            .enumerate()
736            .filter_map(|(index, action)| {
737                let haystack =
738                    format!("{} {} {}", action.label, action.command, action.description);
739                fuzzy_contains(&haystack, query).then_some(index)
740            })
741            .collect()
742    }
743
744    pub fn selected_palette_action(&self) -> Option<command::SurfaceAction> {
745        let indices = self.palette_action_indices();
746        indices
747            .get(self.palette_selection)
748            .and_then(|index| self.surface_actions().get(*index))
749            .copied()
750    }
751
752    pub fn move_palette_selection(&mut self, delta: i32) {
753        let count = self.palette_action_indices().len();
754        if count == 0 {
755            return;
756        }
757        self.palette_selection =
758            (self.palette_selection as i32 + delta).rem_euclid(count as i32) as usize;
759        self.palette_error = None;
760        self.palette_scroll = 0;
761        if let Some(action) = self.selected_palette_action() {
762            self.status = format!("{} · Enter runs", action.label);
763        }
764    }
765
766    pub fn submit_palette(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
767        let typed = self.command_input.trim().to_string();
768        let command = match (typed.as_str(), self.selected_palette_action()) {
769            ("a" | "actions" | "help" | "?" | "q" | "quit", _) => {
770                self.command_mode = false;
771                self.command_input.clear();
772                self.command_cursor = 0;
773                self.command_history_index = None;
774                self.palette_scroll = 0;
775                self.palette_selection = 0;
776                Some(typed)
777            }
778            (_, Some(action)) => self.prepare_palette_action(action),
779            (_, None) if typed.is_empty() => {
780                self.status = "No matching palette action · Esc closes".into();
781                return;
782            }
783            (_, None) => {
784                self.command_mode = false;
785                self.command_input.clear();
786                self.command_cursor = 0;
787                self.command_history_index = None;
788                self.palette_scroll = 0;
789                self.palette_selection = 0;
790                Some(typed)
791            }
792        };
793
794        let Some(input) = command else {
795            if !self.command_mode {
796                self.submit_queued_tool(worker);
797                worker.request_refresh();
798            }
799            return;
800        };
801
802        if self.command_history.last() != Some(&input) {
803            self.command_history.push(input.clone());
804            if self.command_history.len() > 32 {
805                self.command_history.remove(0);
806            }
807        }
808        match command::execute(self, &input) {
809            Ok(message) => {
810                self.palette_error = None;
811                self.status = message;
812            }
813            Err(error) => {
814                self.palette_error = Some(error.clone());
815                self.status = format!("Error: {error}");
816            }
817        }
818        self.submit_queued_tool(worker);
819        worker.request_refresh();
820    }
821
822    fn prepare_palette_action(&mut self, action: command::SurfaceAction) -> Option<String> {
823        self.palette_error = None;
824        match action.command {
825            "i" => {
826                self.command_mode = false;
827                if self.surface == DevSurface::Agent {
828                    self.open_composer();
829                } else {
830                    self.enter_code_edit();
831                }
832                None
833            }
834            "Enter" => {
835                self.command_mode = false;
836                if self.surface == DevSurface::Code {
837                    self.open_selected_file();
838                }
839                None
840            }
841            "browser navigate URL" => {
842                self.surface = DevSurface::App;
843                self.open_palette_with("browser navigate ");
844                self.status =
845                    "Navigate · type a URL or domain (https:// optional), then press Enter".into();
846                None
847            }
848            "browser type TARGET TEXT" => {
849                self.surface = DevSurface::App;
850                self.open_palette_with("browser type ");
851                self.status = "Type · enter the target and text, then press Enter".into();
852                None
853            }
854            "browser view" => {
855                self.command_mode = false;
856                self.browser_visual_live = !self.browser_visual_live;
857                self.status = if self.browser_visual_live {
858                    "Live view starting · command palette can stop it".into()
859                } else {
860                    "Live view off · semantic inspection remains available".into()
861                };
862                None
863            }
864            "process start dev"
865                if matches!(self.surface, DevSurface::Terminal | DevSurface::More) =>
866            {
867                self.command_mode = false;
868                self.request_detected_dev();
869                None
870            }
871            "git diff" if self.surface == DevSurface::Git => {
872                self.command_mode = false;
873                self.git_diff_requested = true;
874                self.status = "Git diff queued · loading off-thread".into();
875                None
876            }
877            "1" | "T" | "I" | "O" => {
878                self.command_mode = false;
879                self.handle_printable(action.command.chars().next().unwrap());
880                None
881            }
882            "Ctrl-S" if self.surface == DevSurface::Code => {
883                self.command_mode = false;
884                self.edit_code_key(
885                    crossterm::event::KeyCode::Char('s'),
886                    crossterm::event::KeyModifiers::CONTROL,
887                );
888                None
889            }
890            command => {
891                let prefill = command
892                    .split_whitespace()
893                    .take_while(|token| {
894                        !token
895                            .chars()
896                            .all(|character| character.is_ascii_uppercase() || character == '_')
897                    })
898                    .collect::<Vec<_>>()
899                    .join(" ");
900                if prefill != command {
901                    self.open_palette_with(&format!("{prefill} "));
902                    self.status = format!(
903                        "{} · enter only the required value(s), then press Enter",
904                        action.label
905                    );
906                    None
907                } else {
908                    self.command_mode = false;
909                    self.command_input.clear();
910                    self.command_cursor = 0;
911                    self.command_history_index = None;
912                    self.palette_scroll = 0;
913                    self.palette_selection = 0;
914                    Some(command.into())
915                }
916            }
917        }
918    }
919
920    pub fn insert_palette_char(&mut self, character: char) {
921        self.command_input.insert(self.command_cursor, character);
922        self.command_cursor += character.len_utf8();
923        self.palette_error = None;
924        self.command_history_index = None;
925        self.palette_scroll = 0;
926        self.palette_selection = 0;
927    }
928
929    pub fn insert_palette_text(&mut self, text: &str) {
930        for character in text.replace(['\r', '\n'], " ").chars().take(8_192) {
931            self.insert_palette_char(character);
932        }
933    }
934
935    pub fn palette_backspace(&mut self) {
936        if self.command_cursor == 0 {
937            return;
938        }
939        let previous = self.command_input[..self.command_cursor]
940            .char_indices()
941            .next_back()
942            .map(|(index, _)| index)
943            .unwrap_or(0);
944        self.command_input.drain(previous..self.command_cursor);
945        self.command_cursor = previous;
946        self.command_history_index = None;
947        self.palette_scroll = 0;
948        self.palette_selection = 0;
949    }
950
951    fn palette_history_indices(&self) -> Vec<usize> {
952        let visible = command::palette_order(self.surface);
953        self.command_history
954            .iter()
955            .enumerate()
956            .filter_map(|(index, input)| {
957                let root = input.split_whitespace().next()?;
958                let root = match root {
959                    "?" => "help",
960                    "q" => "quit",
961                    "gh" => "github",
962                    "tasks" => "task",
963                    "tests" => "test",
964                    "experiments" => "experiment",
965                    "knowledge" => "memory",
966                    "surfaces" | "backend" => "surface",
967                    "tools" => "tool",
968                    _ => root,
969                };
970                visible.contains(&root).then_some(index)
971            })
972            .collect()
973    }
974
975    pub fn navigate_palette_history(&mut self, older: bool) {
976        let history = self.palette_history_indices();
977        if history.is_empty() {
978            return;
979        }
980        let position = self
981            .command_history_index
982            .and_then(|index| history.iter().position(|candidate| *candidate == index));
983        let next_position = match (position, older) {
984            (None, true) => history.len() - 1,
985            (None, false) => return,
986            (Some(position), true) => position.saturating_sub(1),
987            (Some(position), false) if position + 1 < history.len() => position + 1,
988            (Some(_), false) => {
989                self.command_history_index = None;
990                self.command_input.clear();
991                self.command_cursor = 0;
992                self.palette_scroll = 0;
993                self.palette_selection = 0;
994                return;
995            }
996        };
997        let index = history[next_position];
998        self.command_history_index = Some(index);
999        self.command_input.clone_from(&self.command_history[index]);
1000        self.command_cursor = self.command_input.len();
1001        self.palette_scroll = 0;
1002        self.palette_selection = 0;
1003    }
1004
1005    pub fn complete_palette(&mut self) {
1006        let Some(completion) = self.palette_matches().first().copied() else {
1007            return;
1008        };
1009        let suffix = self
1010            .command_input
1011            .find(char::is_whitespace)
1012            .map(|index| self.command_input[index..].to_string())
1013            .unwrap_or_default();
1014        self.command_input = format!("{completion}{suffix}");
1015        self.command_cursor = self.command_input.len();
1016        self.command_history_index = None;
1017        self.palette_scroll = 0;
1018        self.palette_selection = 0;
1019        self.status = format!("Completed `{completion}` · Enter runs · Ctrl-P/N history");
1020    }
1021
1022    pub fn open_palette_with(&mut self, prefix: &str) {
1023        self.open_palette();
1024        self.command_input = prefix.into();
1025        self.command_cursor = self.command_input.len();
1026    }
1027
1028    pub fn move_palette_cursor(&mut self, right: bool) {
1029        if right {
1030            self.command_cursor = self.command_input[self.command_cursor..]
1031                .char_indices()
1032                .nth(1)
1033                .map(|(offset, _)| self.command_cursor + offset)
1034                .unwrap_or(self.command_input.len());
1035        } else if self.command_cursor > 0 {
1036            self.command_cursor = self.command_input[..self.command_cursor]
1037                .char_indices()
1038                .next_back()
1039                .map(|(index, _)| index)
1040                .unwrap_or(0);
1041        }
1042    }
1043
1044    pub fn scroll_palette(&mut self, delta: i32) {
1045        self.move_palette_selection(delta.saturating_mul(5));
1046    }
1047
1048    pub fn palette_matches(&self) -> Vec<&'static str> {
1049        let query = self
1050            .command_input
1051            .split_whitespace()
1052            .next()
1053            .unwrap_or_default();
1054        command::palette_order(self.surface)
1055            .into_iter()
1056            .filter(|candidate| fuzzy_contains(candidate, query))
1057            .take(6)
1058            .collect()
1059    }
1060
1061    pub fn background_action_running(&self) -> bool {
1062        self.pending_confirmation.is_some()
1063            || self.pending_agent_approval.is_some()
1064            || self.running_tool_job.is_some()
1065            || self.queued_tool_request.is_some()
1066            || self.agent_send_job.is_some()
1067    }
1068
1069    pub fn agent_browser_context(&self) -> serde_json::Value {
1070        let semantic_summary = self.browser_workspace_summary();
1071        let state = self.browser_workspace.state();
1072        let selected_entity = state.selected().map(|entity| {
1073            serde_json::json!({
1074                "reference": entity.reference,
1075                "role": entity.role,
1076                "name": entity.name,
1077                "actionable": entity.actionable,
1078                "revision": entity.revision,
1079            })
1080        });
1081        let selected_target = state
1082            .targets
1083            .iter()
1084            .find(|target| target.selected)
1085            .map(|target| {
1086                serde_json::json!({
1087                    "id": target.id,
1088                    "title": target.title,
1089                    "url": safe_browser_url(&target.url),
1090                })
1091            });
1092        serde_json::json!({
1093            "schemaVersion": "glass.agent-context.v1",
1094            "browser": {
1095                "attached": state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected,
1096                "connection": serde_json::to_value(state.connection).unwrap_or(serde_json::Value::Null),
1097                "targetId": selected_target.as_ref().and_then(|target| target.get("id")).cloned(),
1098                "origin": page_origin(&state.url),
1099                "url": safe_browser_url(&state.url),
1100                "title": state.title,
1101                "browserRevision": state.browser_revision,
1102                "semanticSummary": semantic_summary,
1103                "selectedEntity": selected_entity,
1104                "workflowState": state.workflow,
1105                "inputOwner": serde_json::to_value(state.input_owner).unwrap_or(serde_json::Value::Null),
1106                "freshness": if state.semantic_invalidated { "stale" } else { "current" },
1107                "target": selected_target,
1108                "bootstrap": if state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected {
1109                    "attached; observe before acting"
1110                } else {
1111                    "detached; call glass.browser.start, then navigate and observe the requested URL"
1112                },
1113            },
1114            "authority": {
1115                "source": "Glass browser workspace",
1116                "mutationLeaseRequired": selected_entity.as_ref().is_some_and(|entity| {
1117                    entity.get("actionable").and_then(serde_json::Value::as_bool).unwrap_or(false)
1118                }),
1119            },
1120            "project": {
1121                "root": self.snapshot_root,
1122            },
1123        })
1124    }
1125    /// Snapshot the focused editor buffer for the shared workspace chat.
1126    ///
1127    /// Chat must see the same unsaved text the human sees, not only the
1128    /// on-disk file. Keep the attachment bounded; the agent can request the
1129    /// remainder through its file tools.
1130    pub fn agent_editor_context(&self) -> serde_json::Value {
1131        let buffer = self.focused_buffer();
1132        let focused = buffer.as_ref().map(|buffer| {
1133            let (content, truncated) = bounded_editor_content(&buffer.content);
1134            serde_json::json!({
1135                "path": buffer.path,
1136                "cursor": {
1137                    "line": buffer.cursor_line,
1138                    "column": buffer.cursor_column,
1139                },
1140                "selection": buffer.selection,
1141                "dirty": buffer.dirty,
1142                "actor": buffer.actor,
1143                "content": content,
1144                "contentTruncated": truncated,
1145            })
1146        });
1147        let project_revision = self
1148            .workspace
1149            .try_lock()
1150            .ok()
1151            .map(|workspace| workspace.project().revision());
1152        let comments = self
1153            .editor_comments
1154            .iter()
1155            .filter(|comment| {
1156                self.focused_editor_path.is_empty() || comment.path == self.focused_editor_path
1157            })
1158            .cloned()
1159            .collect::<Vec<_>>();
1160        let proposals = self
1161            .editor_proposals
1162            .iter()
1163            .filter(|proposal| {
1164                self.focused_editor_path.is_empty() || proposal.path == self.focused_editor_path
1165            })
1166            .cloned()
1167            .collect::<Vec<_>>();
1168        serde_json::json!({
1169            "focusedPath": self.focused_editor_path,
1170            "cursor": {
1171                "line": self.focused_editor_line,
1172                "column": self.focused_editor_column,
1173            },
1174            "dirty": self.focused_editor_dirty,
1175            "projectRevision": project_revision,
1176            "focusedBuffer": focused,
1177            "comments": comments,
1178            "proposals": proposals,
1179        })
1180    }
1181
1182    pub fn browser_chat_header(&self) -> String {
1183        let browser = self.browser_workspace.state();
1184        let page = if browser.url.is_empty() {
1185            "no page".to_string()
1186        } else {
1187            safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into())
1188        };
1189        let title = browser.title.trim();
1190        let include_title = !title.is_empty() && !title.eq_ignore_ascii_case(&page);
1191        let revision = browser
1192            .browser_revision
1193            .map_or_else(|| "—".to_string(), |revision| revision.to_string());
1194        let bootstrap = if browser.connection
1195            == glass_browser::browser_workspace::BrowserConnectionPhase::Connected
1196        {
1197            "observe before acting"
1198        } else {
1199            "ask `open <url>` to attach"
1200        };
1201        let mut header = format!("APP · {}", browser.connection_label());
1202        if include_title {
1203            header.push_str(" · ");
1204            header.push_str(title);
1205        }
1206        header.push_str(&format!(" · {} · rev {} · {}", page, revision, bootstrap));
1207        if let Some(entity) = browser.selected() {
1208            header.push_str(" · selected ");
1209            header.push_str(&entity.name);
1210        }
1211        header
1212    }
1213
1214    pub fn conversation_view(&self) -> String {
1215        let mut conversation = if self.agent_conversation.starts_with("No conversation yet.")
1216            && !self.pending_chat_messages.is_empty()
1217        {
1218            String::new()
1219        } else {
1220            self.agent_conversation.clone()
1221        };
1222        let mut observed = std::collections::BTreeMap::<String, usize>::new();
1223        for message in &self.pending_chat_messages {
1224            if message.state != ChatMessageState::Failed {
1225                let marker = format!("YOU\n{}", message.text);
1226                let seen = observed.entry(message.text.clone()).or_default();
1227                if *seen < conversation.matches(&marker).count() {
1228                    *seen += 1;
1229                    continue;
1230                }
1231            }
1232            if !conversation.is_empty() {
1233                conversation.push_str("\n\n");
1234            }
1235            conversation.push_str("YOU\n");
1236            conversation.push_str(&message.text);
1237            conversation.push('\n');
1238            match message.state {
1239                ChatMessageState::Sending => conversation.push_str("· sending…"),
1240                ChatMessageState::Sent => {
1241                    conversation.push_str("· sent · Glass Agent is thinking…")
1242                }
1243                ChatMessageState::Failed => {
1244                    conversation.push_str("× send failed");
1245                    if let Some(error) = message.error.as_deref() {
1246                        conversation.push_str(": ");
1247                        conversation.push_str(error);
1248                    }
1249                    conversation.push_str(" · press Enter to retry");
1250                }
1251            }
1252        }
1253        conversation
1254    }
1255
1256    fn reconcile_pending_chat(&mut self) {
1257        let conversation = self.agent_conversation.clone();
1258        let mut confirmed = std::collections::BTreeMap::<String, usize>::new();
1259        self.pending_chat_messages.retain(|message| {
1260            if message.state == ChatMessageState::Failed {
1261                return true;
1262            }
1263            let marker = format!("YOU\n{}", message.text);
1264            let observed = conversation.matches(&marker).count();
1265            let seen = confirmed.entry(message.text.clone()).or_default();
1266            if *seen < observed {
1267                *seen += 1;
1268                false
1269            } else {
1270                true
1271            }
1272        });
1273    }
1274    /// Start the shortest in-TUI path to a usable agent conversation.
1275    pub fn start_agent_interaction(&mut self) {
1276        if self.snapshot_trust_label == "untrusted" {
1277            self.surface = DevSurface::Trust;
1278            self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1279            return;
1280        }
1281        match crate::pi_runtime::pi_readiness() {
1282            Ok(readiness) if readiness.ready => self.open_composer(),
1283            Ok(readiness)
1284                if readiness.node.state != crate::pi_runtime::PiReadinessState::Ready
1285                    || readiness.sdk.state != crate::pi_runtime::PiReadinessState::Ready =>
1286            {
1287                self.request_agent_setup();
1288            }
1289            Ok(_) => {
1290                let _ = self.request_agent_login();
1291            }
1292            Err(error) => {
1293                self.status = format!("Pi readiness unavailable · use :agent setup: {error}");
1294            }
1295        }
1296    }
1297
1298    /// Select a resident agent without forcing the user through the command
1299    /// palette. The selected agent becomes the target for follow-up and
1300    /// session-control actions.
1301    pub fn cycle_agent_selection(&mut self, delta: i32) {
1302        let agents = match self.workspace.try_lock() {
1303            Ok(mut workspace) => match workspace.agents().list() {
1304                Ok(agents) => agents,
1305                Err(error) => {
1306                    self.status = format!("Agent list unavailable: {error}");
1307                    return;
1308                }
1309            },
1310            Err(error) => {
1311                self.status = format!("Agent list unavailable: {error}");
1312                return;
1313            }
1314        };
1315        if agents.is_empty() {
1316            self.selected_agent = None;
1317            self.status = "No resident agents · Enter starts the Glass Agent".into();
1318            return;
1319        }
1320        let current = self
1321            .selected_agent
1322            .as_ref()
1323            .and_then(|selected| agents.iter().position(|agent| &agent.id == selected))
1324            .unwrap_or(0);
1325        let next = if delta.is_negative() {
1326            (current + agents.len() - (delta.unsigned_abs() as usize % agents.len())) % agents.len()
1327        } else {
1328            (current + (delta as usize % agents.len())) % agents.len()
1329        };
1330        let selected = agents[next].id.clone();
1331        self.selected_agent = Some(selected.clone());
1332        self.status = format!(
1333            "Selected {} · Enter chats · ]/[ switches agent",
1334            selected.as_str()
1335        );
1336    }
1337
1338    pub fn open_composer(&mut self) {
1339        self.composer_mode = true;
1340        self.composer_cursor = self.composer_input.len();
1341        self.status = "Agent composer · Enter sends · draft stays open · Esc cancels".into();
1342    }
1343    /// Move from the native editor into the shared agent conversation with
1344    /// the focused buffer attached as unsaved, bounded context.
1345    pub fn prepare_editor_agent_prompt(&mut self) {
1346        let Some(buffer) = self.focused_buffer() else {
1347            self.status = "No open buffer · open a file before asking Pi".into();
1348            return;
1349        };
1350        let line = buffer
1351            .content
1352            .lines()
1353            .nth(buffer.cursor_line.saturating_sub(1) as usize)
1354            .unwrap_or_default()
1355            .trim();
1356        let line_preview = line.chars().take(240).collect::<String>();
1357        self.composer_input = format!(
1358            "Help me with {}:{}:{}.\nInspect the attached editor buffer and explain the safest minimal change. Current line: `{line_preview}`. Do not edit files until I approve a concrete proposal.",
1359            buffer.path, buffer.cursor_line, buffer.cursor_column
1360        );
1361        self.composer_cursor = self.composer_input.len();
1362        self.composer_steer = false;
1363        self.code_edit_mode = false;
1364        self.editor_exit_prompt = None;
1365        self.surface = DevSurface::Agent;
1366        self.open_composer();
1367        self.status = format!(
1368            "Editor context attached · {}:{} · review the prompt, then press Enter",
1369            buffer.path, buffer.cursor_line
1370        );
1371    }
1372
1373    /// Prepare an editable review prompt using the current workspace evidence.
1374    pub fn prepare_review_prompt(&mut self) {
1375        self.composer_input = "Review the current workspace changes. Inspect the Git diff, changed files, diagnostics, and latest test results. Report concrete correctness, security, regression, and missing-test risks. Do not edit files until I approve a fix.".into();
1376        self.composer_cursor = self.composer_input.len();
1377        self.composer_steer = false;
1378        self.open_composer();
1379        self.status =
1380            "Review prompt ready · edit it, then press Enter to ask the Glass Agent".into();
1381    }
1382
1383    pub fn toggle_composer_steer(&mut self) {
1384        self.composer_steer = !self.composer_steer;
1385        self.status = if self.composer_steer {
1386            "Steer mode · Enter interrupts the running agent".into()
1387        } else {
1388            "Follow-up mode · Enter sends during or after the current turn".into()
1389        };
1390    }
1391
1392    /// Queue the managed Pi SDK install behind the same one-use confirmation
1393    /// sheet used by every other mutating TUI action.
1394    pub fn request_agent_setup(&mut self) {
1395        self.request_agent_setup_mode(false);
1396    }
1397
1398    /// Queue a forced reinstall of the pinned managed Pi SDK.
1399    pub fn request_agent_update(&mut self) {
1400        self.request_agent_setup_mode(true);
1401    }
1402
1403    fn request_agent_setup_mode(&mut self, update: bool) {
1404        if self.background_action_running() {
1405            self.status = "Another background action is still running".into();
1406            return;
1407        }
1408        let (call, context) = match self.tool_request(
1409            "glass.agent.setup",
1410            serde_json::json!({"login": false, "update": update}),
1411            true,
1412        ) {
1413            Ok(request) => request,
1414            Err(error) => {
1415                self.status = if update {
1416                    format!("Pi update unavailable: {error}")
1417                } else {
1418                    format!("Pi setup unavailable: {error}")
1419                };
1420                return;
1421            }
1422        };
1423        let summary = if update {
1424            "Refresh the pinned managed Pi SDK"
1425        } else {
1426            "Install or repair the pinned managed Pi SDK"
1427        };
1428        let queued = match self.queue_or_confirm(call, context, summary.into()) {
1429            Ok(queued) => queued,
1430            Err(error) => {
1431                self.status = format!("Could not queue Pi setup: {error}");
1432                return;
1433            }
1434        };
1435        self.surface = DevSurface::Agent;
1436        if !queued {
1437            self.status = if update {
1438                "Pi update ready · Enter approves once · Esc cancels".into()
1439            } else {
1440                "Pi setup ready · Enter approves once · Esc cancels".into()
1441            };
1442        }
1443    }
1444
1445    /// Request an interactive Pi login; the outer TUI loop performs the
1446    /// terminal handoff because the login program must own stdin.
1447    pub fn request_agent_login(&mut self) -> Result<(), String> {
1448        if self.background_action_running() {
1449            let error = "Finish the current background action before signing in".to_string();
1450            self.status = error.clone();
1451            return Err(error);
1452        }
1453        self.agent_login_requested = true;
1454        self.surface = DevSurface::Agent;
1455        self.status = "Pi login will open in this terminal · exit Pi to return".into();
1456        Ok(())
1457    }
1458
1459    pub fn close_composer(&mut self) {
1460        self.composer_mode = false;
1461        self.composer_steer = false;
1462        self.status = "Composer closed".into();
1463    }
1464
1465    pub fn move_composer_cursor(&mut self, right: bool) {
1466        if right {
1467            self.composer_cursor = self.composer_input[self.composer_cursor..]
1468                .char_indices()
1469                .nth(1)
1470                .map(|(offset, _)| self.composer_cursor + offset)
1471                .unwrap_or(self.composer_input.len());
1472        } else if self.composer_cursor > 0 {
1473            self.composer_cursor = self.composer_input[..self.composer_cursor]
1474                .char_indices()
1475                .next_back()
1476                .map(|(index, _)| index)
1477                .unwrap_or(0);
1478        }
1479    }
1480
1481    pub fn delete_composer_word(&mut self) {
1482        let before = self.composer_input[..self.composer_cursor].trim_end();
1483        let start = before.len();
1484        let target = before[..start]
1485            .trim_end_matches(|c: char| c.is_whitespace())
1486            .char_indices()
1487            .rev()
1488            .find_map(|(index, character)| character.is_whitespace().then_some(index))
1489            .map(|index| before[..index].trim_end().len())
1490            .unwrap_or(0);
1491        self.composer_input.drain(target..self.composer_cursor);
1492        self.composer_cursor = target;
1493    }
1494
1495    pub fn abort_selected_agent(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1496        let Some(agent) = self.selected_agent.clone() else {
1497            self.status = "No active agent to abort".into();
1498            return;
1499        };
1500        let (call, context) = match self.tool_request(
1501            "glass.agent.abort",
1502            serde_json::json!({"agentId": agent.as_str()}),
1503            true,
1504        ) {
1505            Ok(request) => request,
1506            Err(error) => {
1507                self.status = format!("Abort unavailable: {error}");
1508                return;
1509            }
1510        };
1511        match worker.submit_tool(call, context) {
1512            Ok(id) => {
1513                self.running_tool_job = Some(id);
1514                self.status = format!("Stopping {} in background…", agent.as_str());
1515            }
1516            Err(error) => self.status = format!("Abort unavailable: {error}"),
1517        }
1518    }
1519
1520    pub fn insert_composer_text(&mut self, text: &str) {
1521        for character in text.chars().take(16_384) {
1522            self.composer_input.insert(self.composer_cursor, character);
1523            self.composer_cursor += character.len_utf8();
1524        }
1525    }
1526
1527    pub fn composer_backspace(&mut self) {
1528        if self.composer_cursor == 0 {
1529            return;
1530        }
1531        let previous = self.composer_input[..self.composer_cursor]
1532            .char_indices()
1533            .next_back()
1534            .map(|(index, _)| index)
1535            .unwrap_or(0);
1536        self.composer_input.drain(previous..self.composer_cursor);
1537        self.composer_cursor = previous;
1538    }
1539
1540    pub fn submit_composer(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1541        if self.background_action_running() {
1542            self.status = if self.agent_send_job.is_some() {
1543                "Sending the previous message · keep typing, then press Enter again".into()
1544            } else {
1545                "Background operation running · message kept in composer".into()
1546            };
1547            return;
1548        }
1549        if self.snapshot_trust_label == "untrusted" {
1550            self.composer_mode = false;
1551            self.surface = DevSurface::Trust;
1552            self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1553            return;
1554        }
1555        if !self.agent_readiness.starts_with("✓ Ready") {
1556            self.status = "Pi is not ready · use :agent setup or :agent setup login".into();
1557            return;
1558        }
1559        if self.composer_input.trim().is_empty() {
1560            self.status = "Message is empty · type a prompt, then press Enter".into();
1561            return;
1562        }
1563        let display_text = self.composer_input.clone();
1564        let text = std::mem::take(&mut self.composer_input);
1565        let steer = self.composer_steer;
1566        self.composer_cursor = 0;
1567        self.composer_steer = false;
1568        self.composer_mode = true;
1569        let mut context = self.agent_browser_context();
1570        context["editor"] = self.agent_editor_context();
1571        if context["browser"]["selectedEntity"].is_object() {
1572            self.browser_workspace.state_mut().input_owner =
1573                glass_browser::browser_workspace::BrowserInputOwner::Agent;
1574        }
1575        let mut arguments = serde_json::json!({
1576            "text": text,
1577            "mode": if steer { "steer" } else { "follow-up" },
1578            "context": context,
1579        });
1580        if let Some(agent) = self.selected_agent.as_ref() {
1581            arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1582        }
1583        let (call, context) = match self.tool_request("glass.agent.send", arguments, true) {
1584            Ok(request) => request,
1585            Err(error) => {
1586                self.composer_input = display_text;
1587                self.composer_cursor = self.composer_input.len();
1588                self.status = format!("Message unavailable · edit and retry: {error}");
1589                return;
1590            }
1591        };
1592        match worker.submit_tool(call, context) {
1593            Ok(id) => {
1594                self.agent_send_job = Some(id);
1595                self.pending_chat_messages.push(PendingChatMessage {
1596                    text: display_text,
1597                    state: ChatMessageState::Sending,
1598                    job_id: Some(id),
1599                    error: None,
1600                });
1601                self.status = if steer {
1602                    "Sent · steering Glass Agent…".into()
1603                } else {
1604                    "Sent · Glass Agent is thinking…".into()
1605                };
1606                worker.request_conversation();
1607            }
1608            Err(error) => {
1609                self.composer_input = display_text;
1610                self.composer_cursor = self.composer_input.len();
1611                self.status = format!("Message unavailable · edit and retry: {error}");
1612            }
1613        }
1614    }
1615
1616    pub fn approve_confirmation_async(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1617        let Some(pending) = self.pending_confirmation.take() else {
1618            return;
1619        };
1620        match worker.submit_tool(pending.call, pending.context) {
1621            Ok(id) => {
1622                self.running_tool_job = Some(id);
1623                self.status = format!(
1624                    "Running {} · Esc keeps the workspace responsive",
1625                    pending.summary
1626                );
1627            }
1628            Err(error) => self.status = format!("Could not queue mutation: {error}"),
1629        }
1630    }
1631
1632    pub fn resolve_agent_approval(
1633        &mut self,
1634        approved: bool,
1635        worker: &mut super::snapshot::SnapshotWorker,
1636    ) {
1637        let Some(pending) = self.pending_agent_approval.take() else {
1638            return;
1639        };
1640        let arguments = serde_json::json!({
1641            "agentId": pending.agent_id,
1642            "frameId": pending.frame_id,
1643            "approved": approved,
1644        });
1645        let (call, context) = match self.tool_request("glass.agent.approve", arguments, true) {
1646            Ok(request) => request,
1647            Err(error) => {
1648                self.pending_agent_approval = Some(pending);
1649                self.status = format!("Agent approval unavailable: {error}");
1650                return;
1651            }
1652        };
1653        match worker.submit_tool(call, context) {
1654            Ok(id) => {
1655                self.running_tool_job = Some(id);
1656                self.status = if approved {
1657                    format!("Approved {} · Glass Agent continues…", pending.tool_name)
1658                } else {
1659                    format!("Denied {} · Glass Agent continues…", pending.tool_name)
1660                };
1661            }
1662            Err(error) => {
1663                self.pending_agent_approval = Some(pending);
1664                self.status = format!("Could not queue agent approval: {error}");
1665            }
1666        }
1667    }
1668
1669    pub fn apply_visual_job_result(&mut self, result: super::snapshot::VisualJobResult) {
1670        self.apply_visual_job_result_with_fit(
1671            result,
1672            glass_browser::terminal_graphics::FrameFit::Contain,
1673        );
1674    }
1675
1676    pub fn apply_visual_job_result_with_fit(
1677        &mut self,
1678        result: super::snapshot::VisualJobResult,
1679        fit: glass_browser::terminal_graphics::FrameFit,
1680    ) {
1681        let png = match result.result {
1682            Ok(value) => {
1683                let Some(encoded) = value.get("base64").and_then(serde_json::Value::as_str) else {
1684                    self.browser_visual_live = false;
1685                    self.browser_workspace.state_mut().presentation_reason =
1686                        Some("screenshot payload did not contain base64 PNG data".into());
1687                    self.status = "Live view unavailable · screenshot payload was empty".into();
1688                    return;
1689                };
1690                use base64::Engine as _;
1691                match base64::engine::general_purpose::STANDARD.decode(encoded) {
1692                    Ok(png) => png,
1693                    Err(error) => {
1694                        self.browser_visual_live = false;
1695                        self.browser_workspace.state_mut().presentation_reason =
1696                            Some(format!("screenshot payload was not valid base64: {error}"));
1697                        self.status = "Live view unavailable · invalid screenshot payload".into();
1698                        return;
1699                    }
1700                }
1701            }
1702            Err(error) => {
1703                self.browser_visual_live = false;
1704                self.browser_workspace.state_mut().presentation_reason =
1705                    Some(format!("browser screenshot failed: {error}"));
1706                self.status = format!("Live view unavailable · {error}");
1707                return;
1708            }
1709        };
1710        match AnsiPane::from_png(
1711            &mut self.browser_ansi,
1712            &png,
1713            result.columns.clamp(8, 80),
1714            result.rows.clamp(4, 40),
1715            fit,
1716        ) {
1717            Ok(pane) => {
1718                self.browser_pane = Some(pane);
1719                let browser = self.browser_workspace.state_mut();
1720                browser.presentation =
1721                    glass_browser::browser_workspace::BrowserPresentationPath::Ansi;
1722                browser.frame_revision = browser.browser_revision;
1723                browser.presentation_reason = Some(
1724                    "bounded ANSI half-block frame · semantic controls remain authoritative".into(),
1725                );
1726                self.status = "Live view updated · ANSI half-block".into();
1727            }
1728            Err(error) => {
1729                self.browser_visual_live = false;
1730                self.browser_workspace.state_mut().presentation_reason = Some(error.to_string());
1731                self.status = format!("Live view unavailable: {error}");
1732            }
1733        }
1734    }
1735
1736    pub fn queue_tool_request(
1737        &mut self,
1738        call: crate::development::ToolCall,
1739        context: crate::tools::DevelopmentToolContext,
1740    ) -> Result<(), String> {
1741        if self.background_action_running() {
1742            return Err("another background tool is already running".into());
1743        }
1744        self.queued_tool_request = Some((call, context));
1745        Ok(())
1746    }
1747    pub(super) fn queue_or_confirm(
1748        &mut self,
1749        call: crate::development::ToolCall,
1750        context: crate::tools::DevelopmentToolContext,
1751        summary: String,
1752    ) -> Result<bool, String> {
1753        if self.yolo_mode {
1754            self.queue_tool_request(call, context)?;
1755            self.status = format!("YOLO · {summary} queued");
1756            Ok(true)
1757        } else {
1758            self.pending_confirmation = Some(PendingConfirmation {
1759                call,
1760                context,
1761                summary,
1762            });
1763            Ok(false)
1764        }
1765    }
1766
1767    pub fn submit_queued_tool(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1768        let Some((call, context)) = self.queued_tool_request.take() else {
1769            return;
1770        };
1771        match worker.submit_tool(call, context) {
1772            Ok(id) => {
1773                self.running_tool_job = Some(id);
1774                self.status.push_str(" · running in background");
1775            }
1776            Err(error) => self.status = format!("Could not queue tool: {error}"),
1777        }
1778    }
1779
1780    pub fn apply_tool_job_result(&mut self, result: super::snapshot::ToolJobResult) {
1781        if result.tool == "glass.agent.send" && self.agent_send_job == Some(result.id) {
1782            self.agent_send_job = None;
1783            match result.result {
1784                Ok(value) => {
1785                    let agent = value
1786                        .get("agentId")
1787                        .and_then(serde_json::Value::as_str)
1788                        .and_then(|value| crate::AgentId::parse(value).ok());
1789                    let restarted = value
1790                        .get("restarted")
1791                        .and_then(serde_json::Value::as_bool)
1792                        .unwrap_or(false);
1793                    if let Some(agent_id) = agent {
1794                        self.selected_agent = Some(agent_id.clone());
1795                        self.status = if restarted {
1796                            format!("Restarted {} · Glass Agent is thinking…", agent_id.as_str())
1797                        } else {
1798                            format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str())
1799                        };
1800                    } else {
1801                        self.status = if restarted {
1802                            "Restarted Glass Agent · thinking…".into()
1803                        } else {
1804                            "Sent · Glass Agent is thinking…".into()
1805                        };
1806                    }
1807                    if let Some(message) = self
1808                        .pending_chat_messages
1809                        .iter_mut()
1810                        .find(|message| message.job_id == Some(result.id))
1811                    {
1812                        message.state = ChatMessageState::Sent;
1813                        message.job_id = None;
1814                    }
1815                }
1816                Err(error) => {
1817                    let failed_text = self
1818                        .pending_chat_messages
1819                        .iter_mut()
1820                        .find(|message| message.job_id == Some(result.id))
1821                        .map(|message| {
1822                            message.state = ChatMessageState::Failed;
1823                            message.job_id = None;
1824                            message.error = Some(error.clone());
1825                            message.text.clone()
1826                        });
1827                    if self.composer_input.is_empty()
1828                        && let Some(text) = failed_text
1829                    {
1830                        self.composer_input = text;
1831                        self.composer_cursor = self.composer_input.len();
1832                    }
1833                    self.composer_mode = true;
1834                    self.status = format!("Could not send message · edit and retry: {error}");
1835                }
1836            }
1837            return;
1838        }
1839
1840        if self.running_tool_job != Some(result.id) {
1841            return;
1842        }
1843        self.running_tool_job = None;
1844        match result.result {
1845            Ok(value) => {
1846                if result.tool.starts_with("glass.browser") {
1847                    self.apply_browser_result(&result.tool, &value);
1848                    self.browser_detail = super::projection::browser_result(&result.tool, &value);
1849                    if result.tool == "glass.browser.act" || result.tool == "glass.browser.navigate"
1850                    {
1851                        self.browser_observe_pending = true;
1852                    }
1853                } else if result.tool == "glass.git.diff" {
1854                    let empty = value.as_str().is_none_or(|diff| diff.trim().is_empty());
1855                    self.git_diff = if empty {
1856                        self.git_diff_path
1857                            .as_deref()
1858                            .map(|path| format!("{path}\n\nNo tracked diff for this file."))
1859                            .unwrap_or_else(|| "Working tree clean · no diff to show".into())
1860                    } else {
1861                        value.as_str().unwrap_or_default().to_string()
1862                    };
1863                    self.git_diff_open = true;
1864                    self.status = self
1865                        .git_diff_path
1866                        .as_deref()
1867                        .map(|path| format!("Git diff · {path} · PgUp/PgDn scroll · Esc closes"))
1868                        .unwrap_or_else(|| "Git diff · PgUp/PgDn scroll · Esc closes".into());
1869                } else if result.tool == "glass.agent.setup" {
1870                    match self.refresh_agent_readiness() {
1871                        Ok(true) => {
1872                            self.open_composer();
1873                            self.status =
1874                                "Pi runtime ready · type a prompt, then press Enter".into();
1875                        }
1876                        Ok(false) => {
1877                            self.status =
1878                                "Pi runtime installed · use :agent setup login, then Enter to chat"
1879                                    .into();
1880                        }
1881                        Err(error) => self.status = format!("Pi readiness check failed: {error}"),
1882                    }
1883                } else if result.tool == "glass.agent.send" {
1884                    if let Some(agent_id) = value
1885                        .get("agentId")
1886                        .and_then(serde_json::Value::as_str)
1887                        .and_then(|value| crate::AgentId::parse(value).ok())
1888                    {
1889                        self.selected_agent = Some(agent_id.clone());
1890                        self.status =
1891                            format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str());
1892                    } else {
1893                        self.status = "Sent · Glass Agent is thinking…".into();
1894                    }
1895                } else if result.tool == "glass.agent.delegate" {
1896                    self.surface = DevSurface::Agent;
1897                    let harness = value
1898                        .get("harness")
1899                        .and_then(serde_json::Value::as_str)
1900                        .unwrap_or("external harness");
1901                    let outcome = if value.get("success").and_then(serde_json::Value::as_bool)
1902                        == Some(true)
1903                    {
1904                        "completed"
1905                    } else if value.get("timedOut").and_then(serde_json::Value::as_bool)
1906                        == Some(true)
1907                    {
1908                        "timed out"
1909                    } else {
1910                        "failed"
1911                    };
1912                    let detail = super::projection::external_agent_output(&value);
1913                    self.status = format!("Temporary {harness} {outcome} · {detail}");
1914                } else if result.tool == "glass.github.review" {
1915                    match serde_json::from_value::<crate::github::GitHubReview>(value) {
1916                        Ok(review) => {
1917                            self.github = crate::github::GitHubStatus {
1918                                repository: review.repository.clone(),
1919                                availability: review.availability,
1920                            };
1921                            self.github_review = review.display();
1922                            self.surface = DevSurface::Git;
1923                            self.status = "GitHub review refreshed".into();
1924                        }
1925                        Err(error) => {
1926                            self.status = format!("GitHub review response invalid: {error}");
1927                        }
1928                    }
1929                } else if result.tool == "glass.github.ship" {
1930                    self.surface = DevSurface::Git;
1931                    self.status = value
1932                        .get("url")
1933                        .and_then(serde_json::Value::as_str)
1934                        .map(|url| format!("Pull request created · {url}"))
1935                        .unwrap_or_else(|| "Pull request created · review GitHub status".into());
1936                } else if result.tool.starts_with("glass.lsp") {
1937                    self.editor = if result.tool == "glass.lsp.diagnostics" {
1938                        super::projection::lsp(Some(&value))
1939                    } else {
1940                        super::projection::first_meaningful(&value)
1941                    };
1942                }
1943                if !matches!(
1944                    result.tool.as_str(),
1945                    "glass.agent.send"
1946                        | "glass.agent.setup"
1947                        | "glass.agent.delegate"
1948                        | "glass.git.diff"
1949                        | "glass.github.review"
1950                        | "glass.github.ship"
1951                ) {
1952                    self.status = format!("Completed {} · workspace refreshed", result.tool);
1953                }
1954            }
1955            Err(error) => {
1956                if result.tool.starts_with("glass.browser") {
1957                    self.note_browser_failure(&result.tool, &error);
1958                }
1959                if result.tool == "glass.git.diff" {
1960                    self.git_diff = format!("Git diff unavailable: {error}");
1961                    self.git_diff_open = true;
1962                }
1963                self.status = format!("{} failed: {error}", result.tool);
1964            }
1965        }
1966    }
1967
1968    pub fn deny_confirmation(&mut self) {
1969        self.pending_browser_navigation = None;
1970        if let Some(pending) = self.pending_confirmation.take() {
1971            self.status = format!("Denied · {}", pending.summary);
1972        }
1973    }
1974
1975    /// Queue browser startup or a fresh observation as part of a requested navigation.
1976    pub fn prepare_browser_navigation(&mut self, url: &str) -> Result<String, String> {
1977        if self.background_action_running() {
1978            return Err("another browser action is already awaiting or running".into());
1979        }
1980        if self.browser_workspace.state().connection == BrowserConnectionPhase::Connected {
1981            let (call, context) =
1982                self.tool_request("glass.browser.observe", serde_json::json!({}), false)?;
1983            self.pending_browser_navigation = Some(url.to_string());
1984            self.queued_tool_request = Some((call, context));
1985            self.surface = DevSurface::App;
1986            return Ok("Browser connected · refreshing page before navigation".into());
1987        }
1988        let (call, context) =
1989            self.tool_request("glass.browser.start", serde_json::json!({}), true)?;
1990        self.pending_browser_navigation = Some(url.to_string());
1991        let queued = self.queue_or_confirm(
1992            call,
1993            context,
1994            format!("Start browser before navigating to {url}"),
1995        )?;
1996        self.surface = DevSurface::App;
1997        Ok(if queued {
1998            "Browser detached · launching; navigation continues automatically".into()
1999        } else {
2000            "Browser detached · Enter approves launch; navigation continues automatically".into()
2001        })
2002    }
2003
2004    pub fn handle_printable(&mut self, character: char) {
2005        if character == ':' {
2006            self.open_palette();
2007            return;
2008        }
2009        if character == 'a' && self.surface != DevSurface::Agent {
2010            self.open_menu();
2011            return;
2012        }
2013        if self.surface == DevSurface::Trust {
2014            let decision = match character {
2015                'i' | 'I' => {
2016                    self.status = "Inspecting exact repository configuration".into();
2017                    return;
2018                }
2019                'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
2020                '1' => Some(crate::LocalTrustDecision::TrustOnce),
2021                'T' => Some(crate::LocalTrustDecision::TrustProject),
2022                _ => None,
2023            };
2024            if let Some(decision) = decision {
2025                match self
2026                    .workspace
2027                    .try_lock()
2028                    .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
2029                {
2030                    Ok(trust) => {
2031                        self.surface = DevSurface::Agent;
2032                        self.snapshot_trust_label = trust.label().into();
2033                        self.status = format!("Workspace opened with {} authority", trust.label());
2034                    }
2035                    Err(error) => self.status = format!("Trust decision failed: {error}"),
2036                }
2037                return;
2038            }
2039        }
2040        if self.surface == DevSurface::Agent && self.snapshot_trust_label == "untrusted" {
2041            let decision = match character {
2042                't' => Some(crate::LocalTrustDecision::TrustOnce),
2043                'T' => Some(crate::LocalTrustDecision::TrustProject),
2044                _ => None,
2045            };
2046            if let Some(decision) = decision {
2047                match self
2048                    .workspace
2049                    .try_lock()
2050                    .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
2051                {
2052                    Ok(trust) => {
2053                        self.snapshot_trust_label = trust.label().into();
2054                        self.status = format!("Workspace opened with {} authority", trust.label());
2055                    }
2056                    Err(error) => self.status = format!("Trust decision failed: {error}"),
2057                }
2058                return;
2059            }
2060        }
2061
2062        // Agent text wins over navigation. The event loop reserves only
2063        // explicit modal controls and the `:` command prefix.
2064        if self.surface == DevSurface::Agent
2065            && self.snapshot_trust_label != "untrusted"
2066            && !character.is_ascii_digit()
2067        {
2068            if self.agent_readiness.starts_with("✓ Ready") {
2069                self.open_composer();
2070            } else {
2071                self.start_agent_interaction();
2072            }
2073            if self.composer_mode {
2074                self.insert_composer_text(&character.to_string());
2075            }
2076            return;
2077        }
2078
2079        if self.surface == DevSurface::Code && character == 'i' {
2080            self.enter_code_edit();
2081            return;
2082        }
2083        if self.responsive_class(self.terminal_width, self.terminal_height)
2084            == ResponsiveClass::Phone
2085        {
2086            let surface = match character {
2087                '1' => Some(DevSurface::Agent),
2088                '2' => Some(DevSurface::Code),
2089                '3' => Some(DevSurface::App),
2090                '4' => Some(DevSurface::Tasks),
2091                '5' => Some(DevSurface::More),
2092                _ => None,
2093            };
2094            if let Some(surface) = surface {
2095                self.surface = surface;
2096                self.status = format!("{} selected", surface.label());
2097                return;
2098            }
2099        }
2100        let surface = match character {
2101            '1' => Some(DevSurface::Agent),
2102            '2' | 'c' => Some(DevSurface::Code),
2103            '3' | 'v' => Some(DevSurface::App),
2104            '4' => Some(DevSurface::Terminal),
2105            '5' | 'w' => Some(DevSurface::Tasks),
2106            '6' | 'g' => Some(DevSurface::Git),
2107            '7' | 'd' => Some(DevSurface::Debug),
2108            '8' | 'm' => Some(DevSurface::More),
2109            _ => None,
2110        };
2111        if let Some(surface) = surface {
2112            self.surface = surface;
2113            self.status = format!("{} selected", surface.label());
2114        } else if self.surface == DevSurface::Agent && self.snapshot_trust_label != "untrusted" {
2115            self.open_composer();
2116            self.insert_composer_text(&character.to_string());
2117        }
2118    }
2119    /// Queue the project-detected development command without making users
2120    /// copy it from project inspection into the command palette.
2121    pub fn request_detected_dev(&mut self) {
2122        if self.background_action_running() {
2123            self.status = "Another background action is still running".into();
2124            return;
2125        }
2126        let command_result = {
2127            match self.ws() {
2128                Ok(workspace) => workspace
2129                    .project()
2130                    .detection()
2131                    .dev_command
2132                    .clone()
2133                    .ok_or_else(|| "no detected dev command".to_string()),
2134                Err(error) => Err(error),
2135            }
2136        };
2137        let command = match command_result {
2138            Ok(command) => command,
2139            Err(error) if error == "no detected dev command" => {
2140                self.status =
2141                    "No development command detected · use :process start NAME COMMAND".into();
2142                return;
2143            }
2144            Err(error) => {
2145                self.status = if error.to_string().contains("workspace busy") {
2146                    "Development suite unavailable: workspace refresh is still running · use :s again"
2147                        .into()
2148                } else {
2149                    format!("Development command unavailable: {error}")
2150                };
2151                return;
2152            }
2153        };
2154        let (call, context) = match self.tool_request(
2155            "glass.process.start",
2156            serde_json::json!({"name": "dev", "command": command}),
2157            true,
2158        ) {
2159            Ok(request) => request,
2160            Err(error) => {
2161                self.status = format!("Development suite unavailable: {error}");
2162                return;
2163            }
2164        };
2165        let queued = match self.queue_or_confirm(
2166            call,
2167            context,
2168            "Start the detected development suite".into(),
2169        ) {
2170            Ok(queued) => queued,
2171            Err(error) => {
2172                self.status = format!("Development suite unavailable: {error}");
2173                return;
2174            }
2175        };
2176        self.surface = DevSurface::Terminal;
2177        if !queued {
2178            self.status = "Development suite ready · Enter approves once · Esc cancels".into();
2179        }
2180    }
2181
2182    pub fn next_surface(&mut self) {
2183        let surfaces: &[DevSurface] = if self
2184            .responsive_class(self.terminal_width, self.terminal_height)
2185            == ResponsiveClass::Phone
2186        {
2187            &DevSurface::PHONE
2188        } else {
2189            &DevSurface::PRIMARY
2190        };
2191        let index = surfaces
2192            .iter()
2193            .position(|surface| *surface == self.surface)
2194            .unwrap_or(0);
2195        self.surface = surfaces[(index + 1) % surfaces.len()];
2196        self.status = format!("{} selected", self.surface.label());
2197    }
2198
2199    pub fn scroll_surface(&mut self, delta: i32) {
2200        let scroll = self.surface_scroll.entry(self.surface).or_default();
2201        *scroll = (*scroll as i64 + i64::from(delta)).max(0) as usize;
2202    }
2203
2204    pub fn scroll_home(&mut self) {
2205        self.surface_scroll.insert(self.surface, 0);
2206    }
2207
2208    pub fn scroll_end(&mut self) {
2209        let end = self.surface_content_height().saturating_sub(1);
2210        self.surface_scroll.insert(self.surface, end);
2211    }
2212
2213    /// Bounded logical height of the current surface's content, used for End.
2214    fn surface_content_height(&self) -> usize {
2215        if self.surface == DevSurface::Agent {
2216            return self.conversation_view().lines().count().max(1);
2217        }
2218        let content = match self.surface {
2219            DevSurface::Code => &self.editor,
2220            DevSurface::App => &self.browser,
2221            DevSurface::Terminal => &self.processes,
2222            DevSurface::Tasks => &self.tasks,
2223            DevSurface::Git => &self.git,
2224            DevSurface::Debug => &self.debugger,
2225            DevSurface::More | DevSurface::Trust => &self.workspace_status,
2226            DevSurface::Agent => unreachable!("agent content handled above"),
2227        };
2228        content.lines().count().max(1)
2229    }
2230
2231    pub fn current_scroll(&self) -> u16 {
2232        self.surface_scroll
2233            .get(&self.surface)
2234            .copied()
2235            .unwrap_or(0)
2236            .min(u16::MAX as usize) as u16
2237    }
2238
2239    pub fn move_file_selection(&mut self, delta: i32) {
2240        if self.files.is_empty() {
2241            self.selected_file = 0;
2242            return;
2243        }
2244        self.selected_file = (self.selected_file as i32 + delta)
2245            .clamp(0, self.files.len().saturating_sub(1) as i32)
2246            as usize;
2247    }
2248    pub fn move_git_selection(&mut self, delta: i32) {
2249        if self.git_entries.is_empty() {
2250            self.selected_git_file = 0;
2251            self.status = "No changed files selected".into();
2252            return;
2253        }
2254        self.selected_git_file = (self.selected_git_file as i32 + delta)
2255            .clamp(0, self.git_entries.len().saturating_sub(1) as i32)
2256            as usize;
2257        if let Some(entry) = self.git_entries.get(self.selected_git_file) {
2258            self.status = format!("{} · Enter diff", entry.path);
2259        }
2260    }
2261
2262    pub fn selected_git_entry(&self) -> Option<&crate::git::GitStatusEntry> {
2263        self.git_entries.get(self.selected_git_file)
2264    }
2265
2266    pub fn open_selected_file(&mut self) {
2267        let Some(path) = self.files.get(self.selected_file).cloned() else {
2268            self.status = "No project file selected".into();
2269            return;
2270        };
2271        let already_open = self
2272            .workspace
2273            .try_lock()
2274            .map(|workspace| workspace.project().buffer(&path).is_some())
2275            .unwrap_or(false);
2276        let result = if already_open {
2277            Ok(())
2278        } else {
2279            self.workspace.try_lock().and_then(|mut workspace| {
2280                workspace
2281                    .project_mut()
2282                    .open_buffer(&path, crate::development::Actor::local())
2283                    .map(|_| ())
2284            })
2285        };
2286        match result {
2287            Ok(()) => {
2288                self.editor_buffer_index = self
2289                    .workspace
2290                    .try_lock()
2291                    .ok()
2292                    .and_then(|workspace| {
2293                        workspace
2294                            .project()
2295                            .buffers()
2296                            .position(|buffer| buffer.path == path)
2297                    })
2298                    .unwrap_or(0);
2299                self.refresh_editor_projection();
2300                self.status = if already_open {
2301                    format!("Selected {path} · Enter opens the full-screen editor")
2302                } else {
2303                    format!("Opened {path} · Enter opens the full-screen editor")
2304                };
2305            }
2306            Err(error) => self.status = format!("Open failed: {error}"),
2307        }
2308    }
2309
2310    pub fn open_selected_file_for_edit(&mut self) {
2311        let selected_path = self.files.get(self.selected_file).cloned();
2312        self.open_selected_file();
2313        if selected_path.as_deref() == Some(self.focused_editor_path.as_str()) {
2314            self.surface = DevSurface::Code;
2315            self.enter_code_edit();
2316        }
2317    }
2318
2319    /// Load the current Git diff without blocking key handling.
2320    pub fn queue_git_diff(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2321        if self.background_action_running() {
2322            self.status = "Git diff waits for the current background operation".into();
2323            return;
2324        }
2325        let selected = self.selected_git_entry().map(|entry| {
2326            (
2327                entry.path.clone(),
2328                entry.untracked,
2329                entry.index_status,
2330                entry.worktree_status,
2331            )
2332        });
2333        if let Some((path, true, _, _)) = selected.as_ref() {
2334            self.git_diff_path = Some(path.clone());
2335            self.git_diff = format!(
2336                "{path}\n\nUntracked file · Git has no tracked diff yet.\nUse Enter on Code to inspect the file."
2337            );
2338            self.git_diff_open = true;
2339            self.surface_scroll.insert(DevSurface::Git, 0);
2340            self.status = format!("{path} is untracked · no Git diff to show");
2341            return;
2342        }
2343        let staged = selected
2344            .as_ref()
2345            .is_some_and(|(_, _, index, worktree)| *index != ' ' && *worktree == ' ');
2346        let mut arguments = serde_json::json!({"staged": staged});
2347        if let Some((path, _, _, _)) = selected.as_ref() {
2348            arguments["path"] = serde_json::Value::String(path.clone());
2349        }
2350        let (call, context) = match self.tool_request("glass.git.diff", arguments, false) {
2351            Ok(request) => request,
2352            Err(error) => {
2353                self.status = format!("Git diff unavailable: {error}");
2354                return;
2355            }
2356        };
2357        match worker.submit_tool(call, context) {
2358            Ok(id) => {
2359                self.running_tool_job = Some(id);
2360                self.git_diff_path = selected.map(|(path, _, _, _)| path);
2361                self.git_diff_open = true;
2362                self.surface_scroll.insert(DevSurface::Git, 0);
2363                self.git_diff = "Loading Git diff…".into();
2364                self.status = self
2365                    .git_diff_path
2366                    .as_deref()
2367                    .map(|path| format!("Loading diff for {path} in background…"))
2368                    .unwrap_or_else(|| "Loading full worktree diff in background…".into());
2369            }
2370            Err(error) => self.status = format!("Git diff unavailable: {error}"),
2371        }
2372    }
2373
2374    /// Synchronous helper retained for callers outside the terminal event loop.
2375    pub fn open_git_diff(&mut self) {
2376        let diff = self.workspace.try_lock().and_then(|workspace| {
2377            workspace
2378                .git()
2379                .ok_or_else(|| {
2380                    crate::development::DevelopmentError::NotFound("not a Git repository".into())
2381                })?
2382                .diff(false, None)
2383                .map_err(|error| crate::development::DevelopmentError::Process(error.to_string()))
2384        });
2385        self.git_diff_path = None;
2386        match diff {
2387            Ok(diff) if diff.trim().is_empty() => {
2388                self.git_diff = "Working tree clean · no diff to show".into();
2389                self.git_diff_open = true;
2390                self.surface_scroll.insert(DevSurface::Git, 0);
2391                self.status = "Git diff · no changes".into();
2392            }
2393            Ok(diff) => {
2394                self.git_diff = diff;
2395                self.git_diff_open = true;
2396                self.surface_scroll.insert(DevSurface::Git, 0);
2397                self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
2398            }
2399            Err(error) => self.status = format!("Git diff unavailable: {error}"),
2400        }
2401    }
2402
2403    pub fn close_git_diff(&mut self) {
2404        self.git_diff_open = false;
2405        self.git_diff_requested = false;
2406        self.git_diff_path = None;
2407        self.surface_scroll.insert(DevSurface::Git, 0);
2408        self.status = "Git status · select a file with ↑/↓".into();
2409    }
2410
2411    pub fn focused_buffer(&self) -> Option<crate::development::EditorBuffer> {
2412        self.workspace.try_lock().ok().and_then(|workspace| {
2413            workspace
2414                .project()
2415                .buffers()
2416                .nth(self.editor_buffer_index)
2417                .cloned()
2418        })
2419    }
2420
2421    pub fn refresh_editor_projection(&mut self) {
2422        let (buffers, comments, proposals, checkpoints) = self
2423            .workspace
2424            .lock()
2425            .map(|workspace| {
2426                (
2427                    workspace.project().buffers().cloned().collect::<Vec<_>>(),
2428                    workspace.project().editor_comments(None),
2429                    workspace.project().editor_proposals(),
2430                    workspace.project().editor_checkpoints(),
2431                )
2432            })
2433            .unwrap_or_default();
2434        self.editor_comments = comments;
2435        self.editor_proposals = proposals;
2436        self.editor_checkpoints = checkpoints;
2437        if let Some(buffer) = buffers.get(self.editor_buffer_index) {
2438            self.focused_editor_path = buffer.path.clone();
2439            self.focused_editor_content = buffer.content.clone();
2440            self.focused_editor_dirty = buffer.dirty;
2441            self.focused_editor_line = buffer.cursor_line;
2442            self.focused_editor_column = buffer.cursor_column;
2443            self.focused_editor_selection = buffer.selection.clone();
2444            self.ensure_editor_cursor_visible();
2445        } else {
2446            self.focused_editor_path.clear();
2447            self.focused_editor_content.clear();
2448            self.focused_editor_dirty = false;
2449            self.focused_editor_line = 0;
2450            self.focused_editor_column = 0;
2451            self.focused_editor_selection = None;
2452            self.editor_scroll_line = 0;
2453            self.editor_scroll_column = 0;
2454        }
2455        self.editor = format_editor_buffers(&buffers);
2456    }
2457
2458    pub fn editor_collaboration_summary(&self) -> String {
2459        let open_comments = self
2460            .editor_comments
2461            .iter()
2462            .filter(|comment| comment.state == crate::development::EditorCommentState::Open)
2463            .count();
2464        let pending = self
2465            .editor_proposals
2466            .iter()
2467            .filter(|proposal| proposal.state == crate::development::EditorProposalState::Pending)
2468            .count();
2469        format!(
2470            "comments {} open · proposals {} pending · checkpoints {}",
2471            open_comments,
2472            pending,
2473            self.editor_checkpoints.len()
2474        )
2475    }
2476
2477    pub fn cycle_editor_buffer(&mut self, delta: i32) {
2478        let count = self
2479            .workspace
2480            .lock()
2481            .map(|workspace| workspace.project().buffers().count())
2482            .unwrap_or(0);
2483        if count == 0 {
2484            self.status = "No open buffers · open a file from the list".into();
2485            return;
2486        }
2487        let index = self.editor_buffer_index as i32 + delta;
2488        self.editor_buffer_index = index.rem_euclid(count as i32) as usize;
2489        let name = self
2490            .workspace
2491            .lock()
2492            .ok()
2493            .and_then(|workspace| {
2494                workspace
2495                    .project()
2496                    .buffers()
2497                    .nth(self.editor_buffer_index)
2498                    .map(|buffer| buffer.path.clone())
2499            })
2500            .unwrap_or_default();
2501        self.refresh_editor_projection();
2502        self.status = format!("Buffer {}/{} · {name}", self.editor_buffer_index + 1, count);
2503    }
2504
2505    pub fn enter_code_edit(&mut self) {
2506        let has_buffer = self.focused_buffer().is_some();
2507        if !has_buffer {
2508            self.open_selected_file();
2509        }
2510        if self.focused_buffer().is_some() {
2511            self.surface = DevSurface::Code;
2512            self.code_edit_mode = true;
2513            self.editor_exit_prompt = None;
2514            self.ensure_editor_cursor_visible();
2515            self.status =
2516                "EDITING · arrows move · Shift+arrows select · Ctrl-S save · Alt-A ask Pi · Esc exit"
2517                    .into();
2518        }
2519    }
2520
2521    pub fn close_code_edit(&mut self) {
2522        self.code_edit_mode = false;
2523        self.editor_exit_prompt = None;
2524        self.surface = DevSurface::Code;
2525        self.status = "Code navigation · select a file and press Enter to edit".into();
2526    }
2527
2528    pub fn request_editor_exit(&mut self) {
2529        if !self.code_edit_mode {
2530            return;
2531        }
2532        self.refresh_editor_projection();
2533        let prompt = if self.focused_editor_dirty {
2534            EditorExitPrompt::Unsaved
2535        } else {
2536            EditorExitPrompt::Clean
2537        };
2538        self.editor_exit_prompt = Some(prompt);
2539        self.status = match prompt {
2540            EditorExitPrompt::Clean => "Exit editor? Enter leaves · Esc stays".into(),
2541            EditorExitPrompt::Unsaved => {
2542                "Unsaved changes · S save · D discard · Q discard and quit · Esc stays".into()
2543            }
2544        };
2545    }
2546
2547    pub fn cancel_editor_exit(&mut self) {
2548        self.editor_exit_prompt = None;
2549        self.status = "Still editing · Esc opens exit choices".into();
2550    }
2551
2552    pub fn handle_editor_exit_key(&mut self, code: crossterm::event::KeyCode) {
2553        let Some(prompt) = self.editor_exit_prompt else {
2554            return;
2555        };
2556        match prompt {
2557            EditorExitPrompt::Clean => match code {
2558                crossterm::event::KeyCode::Enter
2559                | crossterm::event::KeyCode::Char('q' | 'Q' | 'y' | 'Y') => {
2560                    self.close_code_edit();
2561                }
2562                crossterm::event::KeyCode::Esc | crossterm::event::KeyCode::Char('n' | 'N') => {
2563                    self.cancel_editor_exit()
2564                }
2565                _ => {}
2566            },
2567            EditorExitPrompt::Unsaved => match code {
2568                crossterm::event::KeyCode::Char('s' | 'S') => match self.save_editor_buffer() {
2569                    Ok(()) => {
2570                        let path = self.focused_editor_path.clone();
2571                        self.refresh_editor_projection();
2572                        self.close_code_edit();
2573                        self.status = format!("Saved {path} · editor closed");
2574                    }
2575                    Err(error) => {
2576                        self.status =
2577                            format!("Save failed: {error} · S retry · D discard · Q quit");
2578                    }
2579                },
2580                crossterm::event::KeyCode::Char('d' | 'D') => match self.discard_editor_buffer() {
2581                    Ok(()) => {
2582                        let path = self.focused_editor_path.clone();
2583                        self.refresh_editor_projection();
2584                        self.close_code_edit();
2585                        self.status = format!("Discarded changes in {path} · editor closed");
2586                    }
2587                    Err(error) => {
2588                        self.status =
2589                            format!("Discard failed: {error} · S save · D retry · Q quit");
2590                    }
2591                },
2592                crossterm::event::KeyCode::Char('q' | 'Q') => match self.discard_editor_buffer() {
2593                    Ok(()) => {
2594                        self.code_edit_mode = false;
2595                        self.editor_exit_prompt = None;
2596                        self.surface = DevSurface::Code;
2597                        self.quit = true;
2598                        self.status = "Changes discarded · closing Glass Dev".into();
2599                    }
2600                    Err(error) => {
2601                        self.status =
2602                            format!("Discard failed: {error} · S save · D retry · Q quit");
2603                    }
2604                },
2605                crossterm::event::KeyCode::Esc => self.cancel_editor_exit(),
2606                _ => {}
2607            },
2608        }
2609    }
2610
2611    fn save_editor_buffer(&mut self) -> Result<(), String> {
2612        let path = self.focused_editor_path.clone();
2613        self.workspace
2614            .try_lock()
2615            .map_err(|error| error.to_string())?
2616            .project_mut()
2617            .save_buffer(&path)
2618            .map(|_| ())
2619            .map_err(|error| error.to_string())
2620    }
2621
2622    fn discard_editor_buffer(&mut self) -> Result<(), String> {
2623        let path = self.focused_editor_path.clone();
2624        self.workspace
2625            .try_lock()
2626            .map_err(|error| error.to_string())?
2627            .project_mut()
2628            .open_buffer(&path, crate::development::Actor::local())
2629            .map(|_| ())
2630            .map_err(|error| error.to_string())
2631    }
2632
2633    fn ensure_editor_cursor_visible(&mut self) {
2634        if self.focused_editor_path.is_empty() {
2635            return;
2636        }
2637        let viewport_height = usize::from(self.terminal_height.saturating_sub(8).max(1));
2638        if self.editor_soft_wrap {
2639            let wrapped = super::file_view::render_editable_source_wrapped(
2640                &self.focused_editor_path,
2641                &self.focused_editor_content,
2642                self.focused_editor_line,
2643                self.focused_editor_column,
2644                self.focused_editor_selection.as_ref(),
2645                self.terminal_width.saturating_sub(4).max(1),
2646            );
2647            let Some(cursor) = wrapped.cursor else {
2648                return;
2649            };
2650            self.editor_scroll_column = 0;
2651            if cursor.row < self.editor_scroll_line {
2652                self.editor_scroll_line = cursor.row;
2653            } else if cursor.row >= self.editor_scroll_line + viewport_height {
2654                self.editor_scroll_line = cursor.row + 1 - viewport_height;
2655            }
2656            return;
2657        }
2658        let lines = self.focused_editor_content.split('\n').collect::<Vec<_>>();
2659        let cursor_line = self.focused_editor_line.saturating_sub(1) as usize;
2660        if cursor_line < self.editor_scroll_line {
2661            self.editor_scroll_line = cursor_line;
2662        } else if cursor_line >= self.editor_scroll_line + viewport_height {
2663            self.editor_scroll_line = cursor_line + 1 - viewport_height;
2664        }
2665        let gutter_width = lines.len().max(1).to_string().len().max(3);
2666        let viewport_width = usize::from(
2667            self.terminal_width
2668                .saturating_sub((gutter_width + 8).min(u16::MAX as usize) as u16)
2669                .max(1),
2670        );
2671        let cursor_column = self.focused_editor_column.saturating_sub(1) as usize;
2672        if cursor_column < self.editor_scroll_column {
2673            self.editor_scroll_column = cursor_column;
2674        } else if cursor_column >= self.editor_scroll_column + viewport_width {
2675            self.editor_scroll_column = cursor_column + 1 - viewport_width;
2676        }
2677    }
2678
2679    pub fn toggle_editor_soft_wrap(&mut self) {
2680        self.editor_soft_wrap = !self.editor_soft_wrap;
2681        self.editor_scroll_line = 0;
2682        self.editor_scroll_column = 0;
2683        self.ensure_editor_cursor_visible();
2684        self.status = if self.editor_soft_wrap {
2685            "Soft wrap ON · source lines reflow to the editor width".into()
2686        } else {
2687            "Soft wrap OFF · horizontal scrolling follows source columns".into()
2688        };
2689    }
2690
2691    pub fn edit_code_key(
2692        &mut self,
2693        code: crossterm::event::KeyCode,
2694        modifiers: crossterm::event::KeyModifiers,
2695    ) {
2696        if code == crossterm::event::KeyCode::Char('w')
2697            && modifiers.contains(crossterm::event::KeyModifiers::ALT)
2698        {
2699            self.toggle_editor_soft_wrap();
2700            return;
2701        }
2702        let Some(buffer) = self.focused_buffer() else {
2703            self.status = "No open buffer".into();
2704            return;
2705        };
2706        let path = buffer.path.clone();
2707        let result = match (code, modifiers) {
2708            (crossterm::event::KeyCode::Char('a'), value)
2709                if value.contains(crossterm::event::KeyModifiers::ALT) =>
2710            {
2711                self.prepare_editor_agent_prompt();
2712                Ok(())
2713            }
2714            (crossterm::event::KeyCode::Char('s'), value)
2715                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
2716            {
2717                self.locked(|workspace| workspace.project_mut().save_buffer(&path).map(|_| ()))
2718                    .unwrap_or_else(|| {
2719                        Err(crate::development::DevelopmentError::Conflict(
2720                            "workspace lock failed".into(),
2721                        ))
2722                    })
2723            }
2724            (crossterm::event::KeyCode::Char('z'), value)
2725                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
2726            {
2727                self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()))
2728                    .unwrap_or_else(|| {
2729                        Err(crate::development::DevelopmentError::Conflict(
2730                            "workspace lock failed".into(),
2731                        ))
2732                    })
2733            }
2734            (crossterm::event::KeyCode::Char('y'), value)
2735                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
2736            {
2737                self.locked(|workspace| workspace.project_mut().redo_buffer(&path).map(|_| ()))
2738                    .unwrap_or_else(|| {
2739                        Err(crate::development::DevelopmentError::Conflict(
2740                            "workspace lock failed".into(),
2741                        ))
2742                    })
2743            }
2744            (crossterm::event::KeyCode::Left, value) => self.move_editor_cursor(
2745                &path,
2746                0,
2747                -1,
2748                value.contains(crossterm::event::KeyModifiers::SHIFT),
2749            ),
2750            (crossterm::event::KeyCode::Right, value) => self.move_editor_cursor(
2751                &path,
2752                0,
2753                1,
2754                value.contains(crossterm::event::KeyModifiers::SHIFT),
2755            ),
2756            (crossterm::event::KeyCode::Up, value) => self.move_editor_cursor(
2757                &path,
2758                -1,
2759                0,
2760                value.contains(crossterm::event::KeyModifiers::SHIFT),
2761            ),
2762            (crossterm::event::KeyCode::Down, value) => self.move_editor_cursor(
2763                &path,
2764                1,
2765                0,
2766                value.contains(crossterm::event::KeyModifiers::SHIFT),
2767            ),
2768            (crossterm::event::KeyCode::Enter, _) => self.insert_editor_text(&path, "\n"),
2769            (crossterm::event::KeyCode::Backspace, _) => self.backspace_editor(&path),
2770            (crossterm::event::KeyCode::Char(character), _) => {
2771                self.insert_editor_text(&path, &character.to_string())
2772            }
2773            _ => Ok(()),
2774        };
2775        if let Err(error) = result {
2776            self.status = format!("Editor action failed: {error}");
2777        }
2778        self.refresh_editor_projection();
2779    }
2780
2781    fn move_editor_cursor(
2782        &mut self,
2783        path: &str,
2784        line_delta: i32,
2785        column_delta: i32,
2786        extend_selection: bool,
2787    ) -> crate::development::DevelopmentResult<()> {
2788        let buffer = self
2789            .workspace
2790            .try_lock()?
2791            .project()
2792            .buffer(path)
2793            .cloned()
2794            .ok_or_else(|| {
2795                crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
2796            })?;
2797        let lines = buffer.content.split('\n').collect::<Vec<_>>();
2798        let line =
2799            (buffer.cursor_line as i32 + line_delta).clamp(1, lines.len().max(1) as i32) as u32;
2800        let max_column = lines
2801            .get(line.saturating_sub(1) as usize)
2802            .map(|line| line.chars().count() + 1)
2803            .unwrap_or(1) as u32;
2804        let column = if line_delta != 0 {
2805            buffer.cursor_column.min(max_column)
2806        } else {
2807            (buffer.cursor_column as i32 + column_delta).clamp(1, max_column as i32) as u32
2808        };
2809        let anchor = if extend_selection {
2810            buffer
2811                .selection
2812                .map(|selection| selection.anchor)
2813                .unwrap_or(crate::development::TextPosition {
2814                    line: buffer.cursor_line,
2815                    column: buffer.cursor_column,
2816                })
2817        } else {
2818            crate::development::TextPosition { line, column }
2819        };
2820        let mut workspace = self.workspace.try_lock()?;
2821        workspace
2822            .project_mut()
2823            .set_buffer_cursor(path, line, column)?;
2824        workspace.project_mut().set_buffer_selection(
2825            path,
2826            extend_selection.then_some(crate::development::TextSelection {
2827                anchor,
2828                active: crate::development::TextPosition { line, column },
2829            }),
2830            crate::development::Actor::local(),
2831        )?;
2832        Ok(())
2833    }
2834
2835    fn insert_editor_text(
2836        &mut self,
2837        path: &str,
2838        text: &str,
2839    ) -> crate::development::DevelopmentResult<()> {
2840        let mut workspace = self.workspace.try_lock()?;
2841        let project = workspace.project_mut();
2842        let buffer = project.buffer(path).cloned().ok_or_else(|| {
2843            crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
2844        })?;
2845        if buffer
2846            .selection
2847            .as_ref()
2848            .is_some_and(|selection| !selection.is_empty())
2849        {
2850            project.replace_buffer_selection(
2851                path,
2852                text.to_string(),
2853                crate::development::Actor::local(),
2854            )?;
2855            return Ok(());
2856        }
2857        let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
2858        let mut content = buffer.content;
2859        content.insert_str(offset, text);
2860        let cursor =
2861            crate::development::editor::text_position_at_offset(&content, offset + text.len())
2862                .ok_or_else(|| {
2863                    crate::development::DevelopmentError::InvalidInput(
2864                        "inserted text ended at an invalid UTF-8 boundary".into(),
2865                    )
2866                })?;
2867        let actor = crate::development::Actor::local();
2868        project.edit_buffer(path, content, actor.clone())?;
2869        project.set_buffer_cursor(path, cursor.line, cursor.column)?;
2870        project.set_buffer_selection(path, None, actor)?;
2871        Ok(())
2872    }
2873
2874    fn backspace_editor(&mut self, path: &str) -> crate::development::DevelopmentResult<()> {
2875        let mut workspace = self.workspace.try_lock()?;
2876        let project = workspace.project_mut();
2877        let buffer = project.buffer(path).cloned().ok_or_else(|| {
2878            crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
2879        })?;
2880        if buffer
2881            .selection
2882            .as_ref()
2883            .is_some_and(|selection| !selection.is_empty())
2884        {
2885            project.replace_buffer_selection(
2886                path,
2887                String::new(),
2888                crate::development::Actor::local(),
2889            )?;
2890            return Ok(());
2891        }
2892        let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
2893        if offset == 0 {
2894            return Ok(());
2895        }
2896        let previous = buffer.content[..offset]
2897            .char_indices()
2898            .next_back()
2899            .map(|(index, _)| index)
2900            .unwrap_or(0);
2901        let mut content = buffer.content;
2902        content.drain(previous..offset);
2903        let cursor = crate::development::editor::text_position_at_offset(&content, previous)
2904            .ok_or_else(|| {
2905                crate::development::DevelopmentError::InvalidInput(
2906                    "backspace ended at an invalid UTF-8 boundary".into(),
2907                )
2908            })?;
2909        let actor = crate::development::Actor::local();
2910        project.edit_buffer(path, content, actor.clone())?;
2911        project.set_buffer_cursor(path, cursor.line, cursor.column)?;
2912        project.set_buffer_selection(path, None, actor)?;
2913        Ok(())
2914    }
2915
2916    pub fn previous_surface(&mut self) {
2917        let surfaces: &[DevSurface] = if self
2918            .responsive_class(self.terminal_width, self.terminal_height)
2919            == ResponsiveClass::Phone
2920        {
2921            &DevSurface::PHONE
2922        } else {
2923            &DevSurface::PRIMARY
2924        };
2925        let index = surfaces
2926            .iter()
2927            .position(|surface| *surface == self.surface)
2928            .unwrap_or(0);
2929        self.surface = surfaces[(index + surfaces.len() - 1) % surfaces.len()];
2930        self.status = format!("{} selected", self.surface.label());
2931    }
2932
2933    /// Apply one background snapshot without touching UI-only fields.
2934    pub fn apply_snapshot(&mut self, snapshot: &super::snapshot::DisplaySnapshot) {
2935        self.refresh_latency_ms = snapshot.duration.as_millis() as u64;
2936        let selected_agent_status = self.selected_agent.as_ref().and_then(|selected| {
2937            snapshot
2938                .agent_states
2939                .iter()
2940                .find(|(id, _)| id == selected)
2941                .map(|(_, status)| *status)
2942        });
2943        if let super::snapshot::BrowserHealth::Crashed {
2944            last_process_id,
2945            last_revision,
2946        } = &snapshot.browser_health
2947            && self.browser_recovery.is_none()
2948        {
2949            let pid_label = last_process_id
2950                .map(|pid| pid.to_string())
2951                .unwrap_or_else(|| "unknown".into());
2952            let revision_label = last_revision
2953                .map(|revision| revision.to_string())
2954                .unwrap_or_else(|| "none".into());
2955            self.surface = DevSurface::App;
2956            self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
2957                &format!(
2958                    "browser endpoint crashed unexpectedly (pid {pid_label}, last revision {revision_label})"
2959                ),
2960                9222,
2961            ));
2962            self.browser_workspace
2963                .disconnected("browser endpoint crashed".to_string(), true);
2964            self.status = "Browser endpoint crashed · recovery choices below".into();
2965        }
2966        self.harnesses = snapshot.harnesses.clone();
2967        self.agents = snapshot.agents.clone();
2968        self.agent_conversation = snapshot.agent_conversation.clone();
2969        self.reconcile_pending_chat();
2970        if self.agent_send_job.is_none()
2971            && self.pending_chat_messages.is_empty()
2972            && self.status.contains("Glass Agent is thinking")
2973        {
2974            match selected_agent_status {
2975                Some(crate::AgentStatus::Idle) => {
2976                    self.status = "Glass Agent ready · response received".into();
2977                }
2978                Some(crate::AgentStatus::Failed) => {
2979                    self.status = "Glass Agent failed · press Enter to retry".into();
2980                }
2981                Some(crate::AgentStatus::Cancelled) => {
2982                    self.status = "Glass Agent stopped · press Enter to retry".into();
2983                }
2984                Some(crate::AgentStatus::Waiting) => {
2985                    self.status = "Glass Agent waiting for approval".into();
2986                }
2987                _ => {}
2988            }
2989        }
2990        self.tasks = snapshot.tasks.clone();
2991        if !snapshot.editor.is_empty() {
2992            self.editor = snapshot.editor.clone();
2993        }
2994        self.lsp = snapshot.lsp.clone();
2995        self.processes = snapshot.processes.clone();
2996        self.git = snapshot.git.clone();
2997        self.git_entries = snapshot.git_entries.clone();
2998        self.github = snapshot.github.clone();
2999        self.github_review = snapshot.github_review.clone();
3000        if self.git_entries.is_empty() {
3001            self.selected_git_file = 0;
3002        } else {
3003            self.selected_git_file = self
3004                .selected_git_file
3005                .min(self.git_entries.len().saturating_sub(1));
3006        }
3007        self.tests = snapshot.tests.clone();
3008        self.kernels = snapshot.kernels.clone();
3009        self.debugger = snapshot.debugger.clone();
3010        self.replay = snapshot.replay.clone();
3011        self.workflow = snapshot.workflow.clone();
3012        self.workspace_status = snapshot.workspace_status.clone();
3013        self.browser = snapshot.browser.clone();
3014        self.snapshot_root = snapshot.root.clone();
3015        self.snapshot_trust_label = snapshot.trust_label.clone();
3016        self.snapshot_trust_inspection = snapshot.trust_inspection.clone();
3017        self.snapshot_project_revision = snapshot.project_revision;
3018        self.snapshot_generation = snapshot.generation;
3019        self.snapshot_skills_count = snapshot.skills_count;
3020        self.snapshot_tools_count = snapshot.tools_count;
3021        self.experiments = snapshot.experiments.clone();
3022        if !snapshot.files.is_empty() {
3023            self.files = snapshot.files.clone();
3024            if !self.files.is_empty() {
3025                self.selected_file = self.selected_file.min(self.files.len() - 1);
3026            }
3027        }
3028    }
3029
3030    pub fn set_terminal_size(&mut self, width: u16, height: u16) {
3031        self.terminal_width = width;
3032        self.terminal_height = height;
3033        self.ensure_editor_cursor_visible();
3034    }
3035
3036    pub fn refresh(&mut self) {
3037        self.harnesses = crate::harness::summary();
3038        let Ok(mut workspace) = self.workspace.try_lock() else {
3039            self.status = "Workspace lock failed".into();
3040            return;
3041        };
3042        self.files = workspace
3043            .project()
3044            .list_files()
3045            .map(|entries| {
3046                entries
3047                    .into_iter()
3048                    .filter(|entry| matches!(entry.kind, crate::development::FileKind::File))
3049                    .map(|entry| entry.path)
3050                    .take(512)
3051                    .collect()
3052            })
3053            .unwrap_or_default();
3054        if !self.files.is_empty() {
3055            self.selected_file = self.selected_file.min(self.files.len() - 1);
3056        }
3057        let agent_snapshots = workspace.agents().list();
3058        self.pending_agent_approval = pending_agent_approval(agent_snapshots.as_ref().ok());
3059        self.agents = match agent_snapshots {
3060            Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
3061            Ok(agents) => agents
3062                .iter()
3063                .map(|agent| {
3064                    format!(
3065                        "{}  {}  {} · {}\n  target {} · model {} · thinking {} · events {} · dropped {}{}\n  evidence {}",
3066                        agent.id.as_str(),
3067                        agent.status.label(),
3068                        agent.role,
3069                        agent.task,
3070                        agent.worktree.display(),
3071                        agent.model.as_deref().unwrap_or("default"),
3072                        agent.thinking.as_deref().unwrap_or("default"),
3073                        agent.event_count,
3074                        agent.dropped_event_count,
3075                        agent
3076                            .last_error
3077                            .as_deref()
3078                            .map(|error| format!(" · {error}"))
3079                            .unwrap_or_default(),
3080                        agent
3081                            .evidence
3082                            .iter()
3083                            .rev()
3084                            .take(3)
3085                            .map(|evidence| evidence.to_string())
3086                            .collect::<Vec<_>>()
3087                            .join(" · ")
3088                    )
3089                })
3090                .collect::<Vec<_>>()
3091                .join("\n\n"),
3092            Err(error) => format!("Agent registry failed: {error}"),
3093        };
3094        self.agent_conversation = match workspace.agents().history(0) {
3095            Ok(events) if events.is_empty() => {
3096                "No conversation yet. Press Enter or start typing to compose a message.".into()
3097            }
3098            Ok(events) => super::projection::conversation(
3099                &events
3100                    .iter()
3101                    .rev()
3102                    .take(40)
3103                    .rev()
3104                    .cloned()
3105                    .collect::<Vec<_>>(),
3106            ),
3107            Err(error) => format!("Conversation unavailable · {error}"),
3108        };
3109        self.tasks = match workspace.tasks() {
3110            Ok(tasks) if tasks.is_empty() => {
3111                "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
3112            }
3113            Ok(tasks) => tasks
3114                .iter()
3115                .map(|task| {
3116                    let glyph = match task.state {
3117                        crate::TaskState::Succeeded
3118                            if task.verification == crate::VerificationRequirement::Settled => "◇",
3119                        crate::TaskState::Succeeded => "✓",
3120                        crate::TaskState::Failed | crate::TaskState::Cancelled => "×",
3121                        crate::TaskState::Blocked => "!",
3122                        crate::TaskState::Running | crate::TaskState::Verifying => "●",
3123                        _ => "○",
3124                    };
3125                    format!(
3126                        "{} {}  {}  {}\n  goal {}\n  agent {} · attempt {} · model {} · thinking {}\n  depends {}\n  verification {}{}\n  evidence {}",
3127                        glyph,
3128                        task.id.as_str(),
3129                        task.state.label(),
3130                        task.title,
3131                        task.goal,
3132                        task.assigned_agent
3133                            .as_ref()
3134                            .map(|agent| agent.as_str())
3135                            .unwrap_or("unassigned"),
3136                        task.attempt,
3137                        task.model.as_deref().unwrap_or("default"),
3138                        task.thinking.as_deref().unwrap_or("default"),
3139                        task.dependencies
3140                            .iter()
3141                            .map(|dependency| dependency.as_str())
3142                            .collect::<Vec<_>>()
3143                            .join(", "),
3144                        serde_json::to_string(&task.verification).unwrap_or_default(),
3145                        task.last_error
3146                            .as_deref()
3147                            .map(|error| format!(" · {error}"))
3148                            .unwrap_or_default(),
3149                        task.evidence
3150                            .iter()
3151                            .rev()
3152                            .take(3)
3153                            .map(|evidence| {
3154                                format!(
3155                                    "{}={}",
3156                                    evidence.kind,
3157                                    evidence.passed.map_or("?".into(), |passed| passed.to_string())
3158                                )
3159                            })
3160                            .collect::<Vec<_>>()
3161                            .join(" · ")
3162                    )
3163                })
3164                .collect::<Vec<_>>()
3165                .join("\n\n"),
3166            Err(error) => format!("Task scheduler failed: {error}"),
3167        };
3168        self.processes = workspace
3169            .project_mut()
3170            .processes()
3171            .list_checked()
3172            .map(|items| {
3173                if items.is_empty() {
3174                    "No managed terminals. Start the detected development command from More.".into()
3175                } else {
3176                    items
3177                        .into_iter()
3178                        .map(|item| {
3179                            format!(
3180                                "{} {} · health {} · pid {} · {}\n  {}",
3181                                if matches!(item.health, crate::development::ProcessHealth::Healthy)
3182                                {
3183                                    "●"
3184                                } else {
3185                                    "○"
3186                                },
3187                                item.name,
3188                                item.health.label(),
3189                                item.pid.map_or_else(|| "—".into(), |pid| pid.to_string()),
3190                                if item.pty { "PTY" } else { "pipes" },
3191                                item.detected_urls
3192                                    .first()
3193                                    .map_or(item.command.as_str(), String::as_str),
3194                            )
3195                        })
3196                        .collect::<Vec<_>>()
3197                        .join("\n\n")
3198                }
3199            })
3200            .unwrap_or_else(|error| format!("Process state failed: {error}"));
3201        let buffers = workspace.project().buffers().cloned().collect::<Vec<_>>();
3202        self.editor = if buffers.is_empty() {
3203            "No file open. Select a file below and press Enter to open the full-screen editor."
3204                .into()
3205        } else {
3206            buffers
3207                .iter()
3208                .map(|buffer| {
3209                    // Viewport follows the cursor; long files stay editable.
3210                    let lines: Vec<&str> = buffer.content.lines().collect();
3211                    let cursor = buffer.cursor_line as usize;
3212                    let viewport_rows = 16;
3213                    let start = cursor
3214                        .saturating_sub(viewport_rows / 2)
3215                        .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
3216                    let end = (start + viewport_rows).min(lines.len());
3217                    let gutter_width = lines.len().to_string().len().max(3);
3218                    let viewport = lines[start..end]
3219                        .iter()
3220                        .enumerate()
3221                        .map(|(index, line)| {
3222                            let number = start + index + 1;
3223                            let marker = if number == cursor { "▶" } else { " " };
3224                            format!(
3225                                "{marker}{:>gutter_width$} │ {line}",
3226                                number,
3227                                gutter_width = gutter_width
3228                            )
3229                        })
3230                        .collect::<Vec<_>>()
3231                        .join("\n");
3232                    format!(
3233                        "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
3234                        if buffer.dirty { "● " } else { "○ " },
3235                        buffer.path,
3236                        buffer.cursor_line,
3237                        buffer.cursor_column,
3238                        buffer.actor.id,
3239                        lines.len(),
3240                        viewport
3241                    )
3242                })
3243                .collect::<Vec<_>>()
3244                .join("\n\n")
3245        };
3246        self.editor_comments = workspace.project().editor_comments(None);
3247        self.editor_proposals = workspace.project().editor_proposals();
3248        self.editor_checkpoints = workspace.project().editor_checkpoints();
3249        if let Some(buffer) = buffers.get(self.editor_buffer_index) {
3250            self.focused_editor_path = buffer.path.clone();
3251            self.focused_editor_dirty = buffer.dirty;
3252            self.focused_editor_line = buffer.cursor_line;
3253            self.focused_editor_column = buffer.cursor_column;
3254            self.focused_editor_selection = buffer.selection.clone();
3255        }
3256        self.lsp = {
3257            let language = workspace.language();
3258            let servers = language.names().collect::<Vec<_>>();
3259            let event_count = language.events(0).len();
3260            if servers.is_empty() {
3261                "No language server active · diagnostics unavailable".into()
3262            } else {
3263                format!("● {} · {} recent events", servers.join(" · "), event_count)
3264            }
3265        };
3266        let git_status = workspace.git().map(|git| git.status());
3267        self.git = match git_status {
3268            Some(Ok(status)) => {
3269                self.git_entries = status.entries.clone();
3270                let header = format!(
3271                    "branch {} · ↑{} ↓{} · upstream {}",
3272                    status.branch.as_deref().unwrap_or("detached"),
3273                    status.ahead,
3274                    status.behind,
3275                    status.upstream.as_deref().unwrap_or("none")
3276                );
3277                let entries = status
3278                    .entries
3279                    .iter()
3280                    .map(|entry| {
3281                        format!(
3282                            "{}{} {}{}",
3283                            if entry.untracked { "?" } else { "●" },
3284                            if status.conflicts.contains(&entry.path) {
3285                                "!"
3286                            } else {
3287                                " "
3288                            },
3289                            entry.index_status,
3290                            entry.path
3291                        )
3292                    })
3293                    .collect::<Vec<_>>();
3294                if entries.is_empty() {
3295                    format!("{header}\n✓ working tree clean")
3296                } else {
3297                    format!("{header}\n{}", entries.join("\n"))
3298                }
3299            }
3300            Some(Err(error)) => {
3301                self.git_entries.clear();
3302                format!("Git state failed: {error}")
3303            }
3304            None => {
3305                self.git_entries.clear();
3306                "Not a Git repository".into()
3307            }
3308        };
3309        if self.git_entries.is_empty() {
3310            self.selected_git_file = 0;
3311        } else {
3312            self.selected_git_file = self
3313                .selected_git_file
3314                .min(self.git_entries.len().saturating_sub(1));
3315        }
3316        let _ = workspace.tests_mut().poll();
3317        let test_runs = workspace
3318            .tests()
3319            .results()
3320            .rev()
3321            .take(32)
3322            .collect::<Vec<_>>();
3323        self.tests = if test_runs.is_empty() {
3324            "No test runs".into()
3325        } else {
3326            test_runs
3327                .iter()
3328                .map(|run| {
3329                    format!(
3330                        "{} {} · {} · {} ms · {} cases",
3331                        if run.exit_code == Some(0) {
3332                            "✓"
3333                        } else {
3334                            "×"
3335                        },
3336                        run.suite_id,
3337                        run.state.label(),
3338                        run.duration_ms.unwrap_or_default(),
3339                        run.cases.len()
3340                    )
3341                })
3342                .collect::<Vec<_>>()
3343                .join("\n")
3344        };
3345        let kernels = workspace.kernels().snapshots().collect::<Vec<_>>();
3346        self.kernels = if kernels.is_empty() {
3347            "No persistent kernels".into()
3348        } else {
3349            kernels
3350                .iter()
3351                .map(|kernel| {
3352                    format!(
3353                        "{} {} · {} · {} executions · rev {}",
3354                        if matches!(kernel.state, crate::kernels::KernelState::Ready) {
3355                            "●"
3356                        } else {
3357                            "○"
3358                        },
3359                        kernel.name,
3360                        kernel.kind.label(),
3361                        kernel.executions,
3362                        kernel.workspace_revision
3363                    )
3364                })
3365                .collect::<Vec<_>>()
3366                .join("\n")
3367        };
3368        let debugger_names = workspace
3369            .debugger_names()
3370            .map(str::to_string)
3371            .collect::<Vec<_>>();
3372        self.debugger = if debugger_names.is_empty() {
3373            "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
3374        } else {
3375            let snapshots: Result<Vec<_>, _> = debugger_names
3376                .iter()
3377                .map(|name| {
3378                    workspace
3379                        .debugger_mut(name)
3380                        .and_then(|debugger| debugger.snapshot())
3381                        .map(|snapshot| (name.to_string(), snapshot))
3382                })
3383                .collect();
3384            match snapshots {
3385                Ok(snapshots) => snapshots
3386                    .iter()
3387                    .map(|(name, snapshot)| {
3388                        format!(
3389                            "● {} · {} · pid {} · {} breakpoints · {} watches · {} threads/processes",
3390                            name,
3391                            match snapshot.state {
3392                                crate::debugger::DebugSessionState::Starting => "starting",
3393                                crate::debugger::DebugSessionState::Initialized => "initialized",
3394                                crate::debugger::DebugSessionState::Running => "running",
3395                                crate::debugger::DebugSessionState::Stopped => "stopped",
3396                                crate::debugger::DebugSessionState::Terminated => "terminated",
3397                                crate::debugger::DebugSessionState::Failed => "failed",
3398                            },
3399                            snapshot.adapter_process_id,
3400                            snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
3401                            snapshot.watches.len(),
3402                            snapshot.debuggee_processes.len()
3403                        )
3404                    })
3405                    .collect::<Vec<_>>()
3406                    .join("\n"),
3407                Err(error) => format!("Debugger state failed: {error}"),
3408            }
3409        };
3410        self.replay = workspace
3411            .intelligence()
3412            .replay(0, 128)
3413            .map(|events| {
3414                if events.is_empty() {
3415                    "No observable replay events".into()
3416                } else {
3417                    events
3418                        .iter()
3419                        .rev()
3420                        .take(24)
3421                        .rev()
3422                        .map(|event| {
3423                            format!(
3424                                "{} {} · {} · {} · rev {}",
3425                                event.sequence,
3426                                event.actor,
3427                                event.subsystem,
3428                                event.kind,
3429                                event.workspace_revision
3430                            )
3431                        })
3432                        .collect::<Vec<_>>()
3433                        .join("\n")
3434                }
3435            })
3436            .unwrap_or_else(|error| format!("Replay failed: {error}"));
3437        self.browser = match workspace.browser().state() {
3438            Ok(state) => {
3439                let connected = state
3440                    .get("connected")
3441                    .and_then(serde_json::Value::as_bool)
3442                    .unwrap_or(false);
3443                let revision = state
3444                    .get("browserRevision")
3445                    .and_then(serde_json::Value::as_u64);
3446                if connected {
3447                    if self.browser_workspace.state().connection
3448                        != BrowserConnectionPhase::Connected
3449                    {
3450                        self.browser_workspace.connected(true, None, revision);
3451                    } else if let Some(revision) = revision {
3452                        self.browser_workspace.state_mut().browser_revision = Some(revision);
3453                    }
3454                } else {
3455                    self.browser_workspace.state_mut().connection =
3456                        BrowserConnectionPhase::Detached;
3457                }
3458                self.browser_workspace_summary()
3459            }
3460            Err(error) => format!("Browser state failed: {error}"),
3461        };
3462        self.workflow = workspace
3463            .browser()
3464            .list_workflows()
3465            .map(|state| super::projection::workflow(Some(&state)))
3466            .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
3467        let root = workspace.root().display().to_string();
3468        let generation = workspace.generation();
3469        let project_revision = workspace.project().revision();
3470        let agent_count = workspace
3471            .agents()
3472            .list()
3473            .map(|items| items.len())
3474            .unwrap_or(0);
3475        let task_count = workspace.tasks().map(|items| items.len()).unwrap_or(0);
3476        let kernel_count = workspace.kernels().snapshots().count();
3477        let debugger_count = workspace.debugger_names().count();
3478        let detection = workspace.project().detection().clone();
3479        let trust = workspace.trust();
3480        let trust_ready = trust.permits_project_execution();
3481        let dev_hint = detection
3482            .dev_command
3483            .as_deref()
3484            .map(|command| format!("● run `{command}`"))
3485            .unwrap_or_else(|| "○ configure a dev command".into());
3486        let app_hint = detection
3487            .browser_url
3488            .as_deref()
3489            .map(|url| format!("● open App {url}"))
3490            .unwrap_or_else(|| "○ start App after a URL is detected".into());
3491        let project_line = if detection.languages.is_empty() {
3492            "○ project type unknown".to_string()
3493        } else {
3494            format!("✓ {} project", detection.languages.join("/"))
3495        };
3496        let workspace_line = format!("✓ workspace {}", trust.label());
3497        let agent_hint = if self.agent_readiness.starts_with("✓ Ready") {
3498            ":agent ready · type a message or press Enter to chat"
3499        } else {
3500            "○ Pi onboarding · use :agent setup or :agent setup login"
3501        };
3502        self.workspace_status = format!(
3503            "WELCOME · {}\n{}\n\n{}\n{}\n\nNEXT ACTIONS\n◆ :actions guided launchers · per-surface flows\n◆ type a message or press Enter to talk to Glass Agent\n◆ :process start dev · start the detected dev suite\n◆ Enter · open the selected file\n{}\n{}\n\nSTATE\nroot {}\ngeneration {} · project revision {} · trust {}\nresident: {} agents · {} tasks · {} kernels · {} debuggers",
3504            detection.git_branch.as_deref().unwrap_or("no branch"),
3505            project_line,
3506            agent_hint,
3507            workspace_line,
3508            dev_hint,
3509            app_hint,
3510            root,
3511            generation,
3512            project_revision,
3513            trust_ready,
3514            agent_count,
3515            task_count,
3516            kernel_count,
3517            debugger_count,
3518        );
3519        if workspace.trust().permits_project_execution()
3520            && let Ok(experiments) = workspace.experiments()
3521        {
3522            let snapshots = experiments.snapshots();
3523            self.experiments = if snapshots.is_empty() {
3524                "No experiments".into()
3525            } else {
3526                snapshots
3527                    .iter()
3528                    .map(|experiment| {
3529                        format!(
3530                            "{} {} · {} · port {} · agent {}",
3531                            if experiment.evidence.tests_failed == 0
3532                                && experiment.evidence.tests_passed > 0
3533                            {
3534                                "✓"
3535                            } else {
3536                                "○"
3537                            },
3538                            experiment.id,
3539                            experiment.state.label(),
3540                            experiment
3541                                .port
3542                                .map_or_else(|| "—".into(), |port| port.to_string()),
3543                            experiment
3544                                .agent_id
3545                                .as_ref()
3546                                .map(|id| id.as_str())
3547                                .unwrap_or("none")
3548                        )
3549                    })
3550                    .collect::<Vec<_>>()
3551                    .join("\n")
3552            };
3553            self.experiment_comparison = Some(experiments.compare());
3554        }
3555        drop(workspace);
3556        self.reconcile_pending_chat();
3557    }
3558
3559    pub fn apply_browser_result(&mut self, tool: &str, result: &serde_json::Value) {
3560        match tool {
3561            "glass.browser.observe" => {
3562                let revision = result
3563                    .pointer("/accessibility/revision")
3564                    .and_then(serde_json::Value::as_u64);
3565                let title = result
3566                    .pointer("/page/title")
3567                    .and_then(serde_json::Value::as_str)
3568                    .unwrap_or("Untitled");
3569                let url = result
3570                    .pointer("/page/url")
3571                    .and_then(serde_json::Value::as_str)
3572                    .unwrap_or_default();
3573                let loading = result
3574                    .pointer("/page/loading")
3575                    .and_then(serde_json::Value::as_bool)
3576                    .unwrap_or(false);
3577                if let Some(revision) = revision {
3578                    self.browser_workspace
3579                        .update_page(title, url, loading, Some(revision));
3580                    let entities = result
3581                        .pointer("/accessibility/interactive")
3582                        .and_then(serde_json::Value::as_array)
3583                        .into_iter()
3584                        .flatten()
3585                        .filter_map(|entity| {
3586                            Some(BrowserWorkspaceEntity {
3587                                reference: entity.get("reference")?.as_str()?.into(),
3588                                role: entity
3589                                    .get("role")
3590                                    .and_then(serde_json::Value::as_str)
3591                                    .unwrap_or("unknown")
3592                                    .into(),
3593                                name: entity
3594                                    .get("name")
3595                                    .and_then(serde_json::Value::as_str)
3596                                    .unwrap_or("unnamed")
3597                                    .into(),
3598                                actionable: entity
3599                                    .get("actionable")
3600                                    .and_then(serde_json::Value::as_bool)
3601                                    .unwrap_or(true),
3602                                revision,
3603                            })
3604                        })
3605                        .collect();
3606                    self.browser_workspace.replace_entities(revision, entities);
3607                }
3608            }
3609            "glass.browser.targets" => {
3610                let values = result
3611                    .get("targets")
3612                    .and_then(serde_json::Value::as_array)
3613                    .or_else(|| result.as_array());
3614                let targets = values
3615                    .into_iter()
3616                    .flatten()
3617                    .filter_map(|target| {
3618                        Some(BrowserWorkspaceTarget {
3619                            id: target.get("id")?.as_str()?.into(),
3620                            title: target
3621                                .get("title")
3622                                .and_then(serde_json::Value::as_str)
3623                                .unwrap_or("Untitled")
3624                                .into(),
3625                            url: target
3626                                .get("url")
3627                                .and_then(serde_json::Value::as_str)
3628                                .unwrap_or_default()
3629                                .into(),
3630                            selected: target
3631                                .get("active")
3632                                .and_then(serde_json::Value::as_bool)
3633                                .unwrap_or(false),
3634                        })
3635                    })
3636                    .collect();
3637                self.browser_workspace.replace_targets(targets);
3638                if self.browser_target_picker_requested {
3639                    self.browser_target_picker_requested = false;
3640                    self.browser_target_picker = true;
3641                    self.browser_target_selection = 0;
3642                    self.status = if self.browser_workspace.state().targets.is_empty() {
3643                        "No page targets found · Esc closes".into()
3644                    } else {
3645                        "Target picker · type to filter · j/k select · Enter choose · Esc close"
3646                            .into()
3647                    };
3648                }
3649            }
3650            "glass.browser.target.select" => {
3651                if let Some(target_id) = result
3652                    .pointer("/target/id")
3653                    .and_then(serde_json::Value::as_str)
3654                {
3655                    let mut targets = self.browser_workspace.state().targets.clone();
3656                    for target in &mut targets {
3657                        target.selected = target.id == target_id;
3658                    }
3659                    self.browser_workspace.replace_targets(targets);
3660                }
3661                if let Some(observation) = result.get("observation") {
3662                    self.apply_browser_result("glass.browser.observe", observation);
3663                }
3664            }
3665            "glass.browser.start" => {
3666                let connected = result
3667                    .get("connected")
3668                    .and_then(serde_json::Value::as_bool)
3669                    .unwrap_or(true);
3670                let revision = result
3671                    .get("browserRevision")
3672                    .and_then(serde_json::Value::as_u64);
3673                if connected {
3674                    self.browser_workspace.connected(true, None, revision);
3675                    self.browser_recovery = None;
3676                }
3677            }
3678            "glass.browser.stop" => {
3679                self.browser_workspace.state_mut().connection = BrowserConnectionPhase::Detached;
3680            }
3681            _ => {}
3682        }
3683        self.browser = self.browser_workspace_summary();
3684    }
3685
3686    pub fn browser_workspace_summary(&self) -> String {
3687        let browser = self.browser_workspace.state();
3688        let entities = if browser.entities.is_empty() {
3689            "No current semantic entities".into()
3690        } else {
3691            browser
3692                .entities
3693                .iter()
3694                .enumerate()
3695                .skip(browser.semantic_scroll)
3696                .take(24)
3697                .map(|(index, entity)| {
3698                    format!(
3699                        "{} {} · {} · {}",
3700                        if Some(index) == browser.selected_entity {
3701                            "◆"
3702                        } else {
3703                            "○"
3704                        },
3705                        entity.name,
3706                        entity.role,
3707                        entity.reference
3708                    )
3709                })
3710                .collect::<Vec<_>>()
3711                .join("\n")
3712        };
3713        let targets = if browser.targets.is_empty() {
3714            "No page targets loaded · use `browser targets`".into()
3715        } else {
3716            browser
3717                .targets
3718                .iter()
3719                .take(8)
3720                .map(|target| {
3721                    format!(
3722                        "{} {} · {}",
3723                        if target.selected { "◆" } else { "○" },
3724                        target.title,
3725                        safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into())
3726                    )
3727                })
3728                .collect::<Vec<_>>()
3729                .join("\n")
3730        };
3731        format!(
3732            "{} · rev {} · {} · owner {}\n{}\n{}\n\nTARGETS\n{}\n\nUNDERSTANDING\n{}\n\nWORKFLOW\n{}",
3733            browser.connection_label(),
3734            browser
3735                .browser_revision
3736                .map_or_else(|| "—".into(), |revision| revision.to_string()),
3737            browser.presentation_label(),
3738            browser.input_owner_label(),
3739            browser.title,
3740            safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into()),
3741            targets,
3742            entities,
3743            browser.workflow
3744        )
3745    }
3746
3747    pub fn queue_browser_targets(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3748        if self.background_action_running() {
3749            self.status = "Target picker waits for the current background operation".into();
3750            return;
3751        }
3752        if let Err(error) = self.request_browser_target_picker("") {
3753            self.status = format!("Could not load browser targets: {error}");
3754            return;
3755        }
3756        let Some((call, context)) = self.queued_tool_request.take() else {
3757            return;
3758        };
3759        match worker.submit_tool(call, context) {
3760            Ok(id) => {
3761                self.running_tool_job = Some(id);
3762                self.status = "Loading browser targets…".into();
3763            }
3764            Err(error) => {
3765                self.browser_target_picker_requested = false;
3766                self.status = format!("Could not load browser targets: {error}");
3767            }
3768        }
3769    }
3770
3771    pub fn request_browser_target_picker(
3772        &mut self,
3773        query: impl Into<String>,
3774    ) -> Result<(), String> {
3775        if self.background_action_running() {
3776            return Err("Target picker waits for the current background operation".into());
3777        }
3778        self.browser_target_query = query.into();
3779        self.browser_target_selection = 0;
3780        self.browser_target_picker = false;
3781        self.browser_target_picker_requested = true;
3782        let (call, context) =
3783            match self.tool_request("glass.browser.targets", serde_json::json!({}), false) {
3784                Ok(request) => request,
3785                Err(error) => {
3786                    self.browser_target_picker_requested = false;
3787                    return Err(error);
3788                }
3789            };
3790        self.queued_tool_request = Some((call, context));
3791        self.status = "Loading browser targets…".into();
3792        Ok(())
3793    }
3794
3795    pub fn close_browser_target_picker(&mut self) {
3796        self.browser_target_picker = false;
3797        self.browser_target_picker_requested = false;
3798        self.status = "Target picker closed".into();
3799    }
3800
3801    pub fn browser_target_matches(&self) -> Vec<usize> {
3802        let query = self.browser_target_query.to_ascii_lowercase();
3803        let terms = query.split_whitespace().collect::<Vec<_>>();
3804        self.browser_workspace
3805            .state()
3806            .targets
3807            .iter()
3808            .enumerate()
3809            .filter(|(_, target)| {
3810                terms.iter().all(|term| {
3811                    target.id.to_ascii_lowercase().contains(term)
3812                        || target.title.to_ascii_lowercase().contains(term)
3813                        || target.url.to_ascii_lowercase().contains(term)
3814                })
3815            })
3816            .map(|(index, _)| index)
3817            .collect()
3818    }
3819
3820    pub fn insert_browser_target_query(&mut self, character: char) {
3821        if self.browser_target_query.len() < 512 {
3822            self.browser_target_query.push(character);
3823            self.browser_target_selection = 0;
3824        }
3825    }
3826
3827    pub fn browser_target_backspace(&mut self) {
3828        self.browser_target_query.pop();
3829        self.browser_target_selection = 0;
3830    }
3831
3832    pub fn clear_browser_target_query(&mut self) {
3833        self.browser_target_query.clear();
3834        self.browser_target_selection = 0;
3835    }
3836
3837    pub fn move_browser_target_selection(&mut self, delta: i32) {
3838        let count = self.browser_target_matches().len();
3839        if count == 0 {
3840            self.browser_target_selection = 0;
3841            return;
3842        }
3843        self.browser_target_selection =
3844            (self.browser_target_selection as i32 + delta).rem_euclid(count as i32) as usize;
3845    }
3846
3847    pub fn select_browser_target(&mut self) {
3848        if self.background_action_running() {
3849            self.status = "Finish the current browser operation before selecting a target".into();
3850            return;
3851        }
3852        let matches = self.browser_target_matches();
3853        let Some(index) = matches.get(self.browser_target_selection).copied() else {
3854            self.status = "No matching browser target".into();
3855            return;
3856        };
3857        let Some(target) = self.browser_workspace.state().targets.get(index).cloned() else {
3858            self.status = "Selected browser target disappeared".into();
3859            return;
3860        };
3861        let (call, context) = match self.tool_request(
3862            "glass.browser.target.select",
3863            serde_json::json!({"targetId": target.id}),
3864            true,
3865        ) {
3866            Ok(request) => request,
3867            Err(error) => {
3868                self.status = format!("Target selection unavailable: {error}");
3869                return;
3870            }
3871        };
3872        self.browser_target_picker = false;
3873        let queued = match self.queue_or_confirm(
3874            call,
3875            context,
3876            format!("Select browser target · {}", target.title),
3877        ) {
3878            Ok(queued) => queued,
3879            Err(error) => {
3880                self.status = format!("Target selection unavailable: {error}");
3881                return;
3882            }
3883        };
3884        if !queued {
3885            self.status = "Target selection ready · Enter approves once · Esc cancels".into();
3886        }
3887    }
3888
3889    pub fn browser_target_picker_view(&self) -> String {
3890        let matches = self.browser_target_matches();
3891        let mut lines = vec![
3892            format!(
3893                "FILTER  {}",
3894                if self.browser_target_query.is_empty() {
3895                    "all pages"
3896                } else {
3897                    self.browser_target_query.as_str()
3898                }
3899            ),
3900            String::new(),
3901        ];
3902        if matches.is_empty() {
3903            lines.push("No matching page targets.".into());
3904        } else {
3905            for (position, index) in matches.iter().take(16).enumerate() {
3906                let Some(target) = self.browser_workspace.state().targets.get(*index) else {
3907                    continue;
3908                };
3909                let marker = if position == self.browser_target_selection {
3910                    "›"
3911                } else {
3912                    " "
3913                };
3914                let url = safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into());
3915                lines.push(format!(
3916                    "{marker} {} · {} · {}",
3917                    target.title, url, target.id
3918                ));
3919            }
3920        }
3921        lines.push(String::new());
3922        lines.push("Type filters · Backspace edits · Ctrl-U clears".into());
3923        lines.push("j/k or ↑/↓ selects · Enter chooses · Esc closes".into());
3924        lines.join("\n")
3925    }
3926
3927    pub fn queue_browser_observe(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3928        if !self.browser_observe_pending || self.background_action_running() {
3929            return;
3930        }
3931        self.browser_observe_pending = false;
3932        let (call, context) =
3933            match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
3934                Ok(request) => request,
3935                Err(error) => {
3936                    self.status = format!("Could not refresh browser evidence: {error}");
3937                    return;
3938                }
3939            };
3940        match worker.submit_tool(call, context) {
3941            Ok(id) => {
3942                self.running_tool_job = Some(id);
3943                self.status = "Refreshing semantic browser evidence…".into();
3944            }
3945            Err(error) => self.status = format!("Could not refresh browser evidence: {error}"),
3946        }
3947    }
3948
3949    /// Refresh the newly started page before issuing a revision-bound navigation.
3950    pub fn continue_pending_browser_navigation(
3951        &mut self,
3952        worker: &mut super::snapshot::SnapshotWorker,
3953    ) {
3954        let Some(url) = self.pending_browser_navigation.as_deref() else {
3955            return;
3956        };
3957        let (call, context) =
3958            match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
3959                Ok(request) => request,
3960                Err(error) => {
3961                    let url = self.pending_browser_navigation.take().unwrap_or_default();
3962                    self.open_palette_with(&format!("browser navigate {url}"));
3963                    self.status = format!("Browser ready · navigation retry required: {error}");
3964                    return;
3965                }
3966            };
3967        match worker.submit_tool(call, context) {
3968            Ok(id) => {
3969                self.running_tool_job = Some(id);
3970                self.status = format!("Browser ready · preparing navigation to {url}…");
3971            }
3972            Err(error) => {
3973                let url = self.pending_browser_navigation.take().unwrap_or_default();
3974                self.open_palette_with(&format!("browser navigate {url}"));
3975                self.status = format!("Browser ready · navigation retry required: {error}");
3976            }
3977        }
3978    }
3979
3980    /// Submit the retained navigation after its fresh page revision arrives.
3981    pub fn submit_pending_browser_navigation(
3982        &mut self,
3983        worker: &mut super::snapshot::SnapshotWorker,
3984    ) {
3985        let Some(url) = self.pending_browser_navigation.take() else {
3986            return;
3987        };
3988        let Some(revision) = self.browser_workspace.state().browser_revision else {
3989            self.open_palette_with(&format!("browser navigate {url}"));
3990            self.status = "Browser launch completed without a usable revision".into();
3991            return;
3992        };
3993        let (call, context) = match self.tool_request(
3994            "glass.browser.navigate",
3995            serde_json::json!({"url": url, "browserRevision": revision}),
3996            true,
3997        ) {
3998            Ok(request) => request,
3999            Err(error) => {
4000                self.open_palette_with(&format!("browser navigate {url}"));
4001                self.status = format!("Browser ready · navigation retry required: {error}");
4002                return;
4003            }
4004        };
4005        match worker.submit_tool(call, context) {
4006            Ok(id) => {
4007                self.running_tool_job = Some(id);
4008                self.status = format!("Browser ready · navigating to {url}…");
4009            }
4010            Err(error) => {
4011                self.open_palette_with(&format!("browser navigate {url}"));
4012                self.status = format!("Browser ready · navigation retry required: {error}");
4013            }
4014        }
4015    }
4016
4017    pub fn queue_browser_intent(&mut self, intent: BrowserWorkspaceIntent) {
4018        if self.background_action_running() {
4019            self.status = "Browser action waits for the current background operation".into();
4020            return;
4021        }
4022        let action = match self.browser_workspace.reduce(intent) {
4023            Ok(Some(action)) => action,
4024            Ok(None) => return,
4025            Err(error) => {
4026                self.status = format!("App action unavailable: {error}");
4027                return;
4028            }
4029        };
4030        let (tool, arguments) = match action {
4031            BrowserWorkspaceAction::Navigate {
4032                url,
4033                expected_revision,
4034            } => (
4035                "glass.browser.navigate",
4036                serde_json::json!({"url": url, "browserRevision": expected_revision}),
4037            ),
4038            BrowserWorkspaceAction::Back { expected_revision }
4039            | BrowserWorkspaceAction::Forward { expected_revision }
4040            | BrowserWorkspaceAction::Reload { expected_revision }
4041            | BrowserWorkspaceAction::StopLoading { expected_revision } => {
4042                let action = match action {
4043                    BrowserWorkspaceAction::Back { .. } => "back",
4044                    BrowserWorkspaceAction::Forward { .. } => "forward",
4045                    BrowserWorkspaceAction::Reload { .. } => "reload",
4046                    BrowserWorkspaceAction::StopLoading { .. } => "stopLoading",
4047                    _ => unreachable!(),
4048                };
4049                (
4050                    "glass.browser.act",
4051                    serde_json::json!({"action": action, "browserRevision": expected_revision}),
4052                )
4053            }
4054            BrowserWorkspaceAction::Click {
4055                target,
4056                expected_revision,
4057            } => (
4058                "glass.browser.act",
4059                serde_json::json!({"action":"click", "target": target, "browserRevision": expected_revision}),
4060            ),
4061            BrowserWorkspaceAction::Type {
4062                target,
4063                text,
4064                expected_revision,
4065            } => (
4066                "glass.browser.act",
4067                serde_json::json!({"action":"type", "target": target, "text": text, "browserRevision": expected_revision}),
4068            ),
4069            BrowserWorkspaceAction::Scroll {
4070                dx,
4071                dy,
4072                expected_revision,
4073            } => (
4074                "glass.browser.act",
4075                serde_json::json!({"action":"scroll", "dx": dx, "dy": dy, "browserRevision": expected_revision}),
4076            ),
4077            _ => return,
4078        };
4079        let (call, context) = match self.tool_request(tool, arguments, true) {
4080            Ok(request) => request,
4081            Err(error) => {
4082                self.status = format!("App action unavailable: {error}");
4083                return;
4084            }
4085        };
4086        let queued = match self.queue_or_confirm(
4087            call,
4088            context,
4089            format!("{tool} · browser revision guarded"),
4090        ) {
4091            Ok(queued) => queued,
4092            Err(error) => {
4093                self.status = format!("App action unavailable: {error}");
4094                return;
4095            }
4096        };
4097        if !queued {
4098            self.status = "Browser mutation ready · Enter approves once · Esc cancels".into();
4099        }
4100    }
4101
4102    pub(super) fn tool_request(
4103        &self,
4104        name: &str,
4105        arguments: serde_json::Value,
4106        mutating: bool,
4107    ) -> Result<
4108        (
4109            crate::development::ToolCall,
4110            crate::tools::DevelopmentToolContext,
4111        ),
4112        String,
4113    > {
4114        // Snapshot refresh owns the workspace lock while it performs filesystem
4115        // and process inspection. Cached revisions keep chat and actions
4116        // responsive; the executor still rejects stale guards before mutation.
4117        let expected_generation = self.snapshot_generation;
4118        let expected_project_revision = self.snapshot_project_revision;
4119        Ok((
4120            crate::development::ToolCall {
4121                id: format!(
4122                    "tui-browser-{}",
4123                    NEXT_BROWSER_TOOL.fetch_add(1, Ordering::Relaxed)
4124                ),
4125                name: name.into(),
4126                arguments,
4127            },
4128            crate::tools::DevelopmentToolContext {
4129                authorization: crate::development::ToolAuthorization {
4130                    actor: crate::development::Actor::local(),
4131                    allow_mutation: mutating,
4132                    confirmed: mutating,
4133                },
4134                initiator: None,
4135                expected_generation,
4136                expected_project_revision,
4137            },
4138        ))
4139    }
4140
4141    /// Offer in-TUI recovery whenever a browser tool fails with a launch or
4142    /// connection error, so a port collision never strands the session.
4143    pub fn note_browser_failure(&mut self, tool: &str, error: &str) {
4144        let lower = error.to_ascii_lowercase();
4145        if tool.contains("browser")
4146            && (lower.contains("occupied")
4147                || lower.contains("attach")
4148                || lower.contains("connect")
4149                || lower.contains("launch")
4150                || lower.contains("timeout")
4151                || lower.contains("devtools"))
4152        {
4153            self.browser_target_picker = false;
4154            self.browser_target_picker_requested = false;
4155            self.surface = DevSurface::App;
4156            self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
4157                error,
4158                self.browser_recovery
4159                    .as_ref()
4160                    .map_or(9222, |offer| offer.port),
4161            ));
4162            self.browser_workspace.disconnected(error.to_string(), true);
4163        }
4164    }
4165
4166    /// Queue a recovery choice without blocking the terminal on browser launch.
4167    pub fn accept_browser_recovery(
4168        &mut self,
4169        choice: usize,
4170        worker: &mut super::snapshot::SnapshotWorker,
4171    ) {
4172        let Some(offer) = self.browser_recovery.take() else {
4173            return;
4174        };
4175        let (port, attach) = match (offer.compatible_endpoint, choice) {
4176            (true, 0) => (offer.port, true),
4177            (true, 1) | (false, 0) => (free_local_port().unwrap_or(0), false),
4178            (true, 2) | (false, 1) => (offer.port, false),
4179            _ => {
4180                self.status = "Recovery dismissed · project and agent remain available".into();
4181                return;
4182            }
4183        };
4184        if port == 0 {
4185            self.status =
4186                "No free local port was available · retry or use an existing browser".into();
4187            return;
4188        }
4189        let (call, context) = match self.tool_request(
4190            "glass.browser.start",
4191            browser_recovery_arguments(port, attach),
4192            true,
4193        ) {
4194            Ok(request) => request,
4195            Err(error) => {
4196                self.status = format!("Could not queue recovery: {error}");
4197                return;
4198            }
4199        };
4200        match worker.submit_tool(call, context) {
4201            Ok(id) => {
4202                self.running_tool_job = Some(id);
4203                self.status = if attach {
4204                    format!("Attaching to browser on port {port} in background…")
4205                } else {
4206                    format!("Recovering browser on port {port} in background…")
4207                };
4208            }
4209            Err(error) => self.status = format!("Could not queue recovery: {error}"),
4210        }
4211    }
4212
4213    pub fn refresh_agent_readiness(&mut self) -> Result<bool, String> {
4214        let readiness = crate::pi_runtime::pi_readiness().map_err(|error| error.to_string())?;
4215        let ready = readiness.ready;
4216        self.agent_readiness = format_pi_readiness(&readiness);
4217        Ok(ready)
4218    }
4219}
4220
4221fn format_editor_buffers(buffers: &[crate::development::EditorBuffer]) -> String {
4222    if buffers.is_empty() {
4223        return "No file open. Select a file below and press Enter to open the full-screen editor."
4224            .into();
4225    }
4226    buffers
4227        .iter()
4228        .map(|buffer| {
4229            let lines: Vec<&str> = buffer.content.lines().collect();
4230            let cursor = buffer.cursor_line as usize;
4231            let viewport_rows = 16;
4232            let start = cursor
4233                .saturating_sub(viewport_rows / 2)
4234                .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
4235            let end = (start + viewport_rows).min(lines.len());
4236            let gutter_width = lines.len().to_string().len().max(3);
4237            let viewport = lines[start..end]
4238                .iter()
4239                .enumerate()
4240                .map(|(index, line)| {
4241                    let number = start + index + 1;
4242                    let marker = if number == cursor { "▶" } else { " " };
4243                    format!(
4244                        "{marker}{:>gutter_width$} │ {line}",
4245                        number,
4246                        gutter_width = gutter_width
4247                    )
4248                })
4249                .collect::<Vec<_>>()
4250                .join("\n");
4251            format!(
4252                "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
4253                if buffer.dirty { "● " } else { "○ " },
4254                buffer.path,
4255                buffer.cursor_line,
4256                buffer.cursor_column,
4257                buffer.actor.id,
4258                lines.len(),
4259                viewport
4260            )
4261        })
4262        .collect::<Vec<_>>()
4263        .join("\n\n")
4264}
4265
4266fn format_pi_readiness(readiness: &crate::PiReadiness) -> String {
4267    let provider = readiness.provider.as_deref().unwrap_or("not selected");
4268    let session = readiness.session.as_deref().unwrap_or("new session");
4269    let remediation = readiness
4270        .remediation
4271        .first()
4272        .map(|item| format!(" · next: {item}"))
4273        .unwrap_or_default();
4274    let state_line = format!(
4275        "{} · Node {} · SDK {} · auth {}",
4276        if readiness.ready {
4277            "✓ Ready"
4278        } else {
4279            "○ Needs setup"
4280        },
4281        component_label(&readiness.node),
4282        readiness.sdk.version.as_deref().unwrap_or("missing"),
4283        component_label(&readiness.authentication),
4284    );
4285    if readiness.ready {
4286        format!("{state_line}\nprovider {provider} · {session}")
4287    } else {
4288        format!(
4289            "{state_line}\nprovider {provider} · {session}{remediation}\n\nUse `:agent setup` to repair the pinned runtime · `:agent update` to refresh it · `:agent setup login` to open Pi `/login`"
4290        )
4291    }
4292}
4293
4294fn component_label(component: &crate::pi_runtime::PiReadinessComponent) -> String {
4295    match component.state {
4296        crate::pi_runtime::PiReadinessState::Ready => "✓".into(),
4297        crate::pi_runtime::PiReadinessState::Missing => "× missing".into(),
4298        crate::pi_runtime::PiReadinessState::Incompatible => "! incompatible".into(),
4299        crate::pi_runtime::PiReadinessState::Expired => "! expired".into(),
4300        crate::pi_runtime::PiReadinessState::Unknown => "? unknown".into(),
4301    }
4302}
4303
4304fn safe_browser_url(url: &str) -> Option<String> {
4305    let url = url.trim();
4306    if url.is_empty() {
4307        return None;
4308    }
4309    let sanitized = url
4310        .split(['?', '#'])
4311        .next()
4312        .unwrap_or(url)
4313        .chars()
4314        .take(2_048)
4315        .collect::<String>();
4316    (!sanitized.is_empty()).then_some(sanitized)
4317}
4318
4319fn page_origin(url: &str) -> Option<String> {
4320    let url = safe_browser_url(url)?;
4321    let scheme_end = url.find("://")?;
4322    let authority_start = scheme_end + 3;
4323    let authority_end = url[authority_start..]
4324        .find('/')
4325        .map(|offset| authority_start + offset)
4326        .unwrap_or(url.len());
4327    Some(url[..authority_end].to_string())
4328}
4329fn bounded_editor_content(content: &str) -> (String, bool) {
4330    const MAX_CONTEXT_BYTES: usize = 64 * 1024;
4331    if content.len() <= MAX_CONTEXT_BYTES {
4332        return (content.to_string(), false);
4333    }
4334    let mut end = MAX_CONTEXT_BYTES;
4335    while end > 0 && !content.is_char_boundary(end) {
4336        end -= 1;
4337    }
4338    (content[..end].to_string(), true)
4339}
4340
4341fn pending_agent_approval(
4342    agents: Option<&Vec<crate::AgentSnapshot>>,
4343) -> Option<PendingAgentApproval> {
4344    let agents = agents?;
4345    for agent in agents {
4346        let mut pending = None;
4347        for event in &agent.evidence {
4348            match event.get("type").and_then(serde_json::Value::as_str) {
4349                Some("glass_tool_approval_request") => {
4350                    let Some(frame_id) = event.get("frameId").and_then(serde_json::Value::as_str)
4351                    else {
4352                        continue;
4353                    };
4354                    pending = Some(PendingAgentApproval {
4355                        agent_id: agent.id.as_str().to_string(),
4356                        frame_id: frame_id.to_string(),
4357                        tool_name: event
4358                            .get("toolName")
4359                            .and_then(serde_json::Value::as_str)
4360                            .unwrap_or("unknown tool")
4361                            .to_string(),
4362                        arguments: event.get("arguments").cloned().unwrap_or_default(),
4363                    });
4364                }
4365                Some("glass_tool_approval_resolved") => {
4366                    let frame_id = event.get("frameId").and_then(serde_json::Value::as_str);
4367                    if pending
4368                        .as_ref()
4369                        .is_some_and(|approval| Some(approval.frame_id.as_str()) == frame_id)
4370                    {
4371                        pending = None;
4372                    }
4373                }
4374                _ => {}
4375            }
4376        }
4377        if pending.is_some() {
4378            return pending;
4379        }
4380    }
4381    None
4382}
4383
4384fn fuzzy_contains(candidate: &str, query: &str) -> bool {
4385    if query.is_empty() {
4386        return true;
4387    }
4388    let mut query = query
4389        .chars()
4390        .map(|character| character.to_ascii_lowercase());
4391    let mut expected = query.next();
4392    for character in candidate
4393        .chars()
4394        .map(|character| character.to_ascii_lowercase())
4395    {
4396        if Some(character) == expected {
4397            expected = query.next();
4398            if expected.is_none() {
4399                return true;
4400            }
4401        }
4402    }
4403    false
4404}
4405
4406fn browser_recovery_arguments(port: u16, attach: bool) -> serde_json::Value {
4407    serde_json::json!({
4408        "port": port,
4409        "attach": attach,
4410        "incognito": !attach,
4411    })
4412}
4413
4414/// Bind an ephemeral localhost port to discover a free one.
4415fn free_local_port() -> Option<u16> {
4416    std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
4417        .ok()
4418        .and_then(|listener| listener.local_addr().ok())
4419        .map(|address| address.port())
4420}
4421
4422fn editor_offset(content: &str, line: u32, column: u32) -> usize {
4423    let mut offset = 0;
4424    for (index, value) in content.split_inclusive('\n').enumerate() {
4425        if index + 1 == line as usize {
4426            let column_bytes = value
4427                .trim_end_matches('\n')
4428                .char_indices()
4429                .nth(column.saturating_sub(1) as usize)
4430                .map(|(offset, _)| offset)
4431                .unwrap_or_else(|| value.trim_end_matches('\n').len());
4432            return offset + column_bytes;
4433        }
4434        offset += value.len();
4435    }
4436    content.len()
4437}
4438
4439#[cfg(test)]
4440mod tests {
4441    use super::*;
4442
4443    #[test]
4444    fn quit_confirmation_requires_explicit_follow_through() {
4445        let root = std::env::temp_dir().join(format!("glass-tui-quit-{}", std::process::id()));
4446        std::fs::create_dir_all(&root).expect("create temporary workspace");
4447        let mut state =
4448            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4449
4450        state.request_quit();
4451        assert!(state.quit_confirmation);
4452        assert!(!state.quit);
4453        assert_eq!(state.status, "Quit confirmation · Enter exits · Esc stays");
4454
4455        state.cancel_quit();
4456        assert!(!state.quit_confirmation);
4457        assert!(!state.quit);
4458
4459        state.request_quit();
4460        state.confirm_quit();
4461        assert!(!state.quit_confirmation);
4462        assert!(state.quit);
4463        assert_eq!(state.status, "Closing Glass Dev");
4464
4465        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4466    }
4467    #[test]
4468    fn trust_action_menu_dispatches_keyboard_hints() {
4469        let root = std::env::temp_dir().join(format!("glass-trust-menu-{}", std::process::id()));
4470        std::fs::create_dir_all(&root).expect("create temporary workspace");
4471        let mut state =
4472            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4473        state.surface = DevSurface::Trust;
4474
4475        state.open_menu();
4476        state.menu_selection = 0;
4477        state.run_menu_action();
4478        assert!(!state.menu_open);
4479        assert!(
4480            state
4481                .status
4482                .contains("Inspecting exact repository configuration")
4483        );
4484
4485        state.open_menu();
4486        state.menu_selection = 1;
4487        state.run_menu_action();
4488        assert_eq!(state.surface, DevSurface::Agent);
4489        assert!(
4490            state
4491                .status
4492                .contains("Workspace opened with untrusted authority")
4493        );
4494
4495        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4496    }
4497
4498    #[test]
4499    fn browser_context_url_redaction_preserves_path_only() {
4500        assert_eq!(
4501            safe_browser_url("https://example.test/orders/7?token=secret#receipt"),
4502            Some("https://example.test/orders/7".into())
4503        );
4504        assert_eq!(
4505            page_origin("https://example.test/orders/7?token=secret"),
4506            Some("https://example.test".into())
4507        );
4508        assert_eq!(safe_browser_url(""), None);
4509    }
4510
4511    #[test]
4512    fn browser_recovery_offer_explains_port_collision_choices() {
4513        let offer = BrowserRecoveryOffer::from_error("address already in use on port 9222", 9222);
4514        assert!(!offer.compatible_endpoint);
4515        assert_eq!(offer.actions().len(), 3);
4516        assert!(offer.guidance().contains("preferred endpoint"));
4517
4518        let attach =
4519            BrowserRecoveryOffer::from_error("DevTools page target is available for attach", 9222);
4520        assert!(attach.compatible_endpoint);
4521        assert_eq!(attach.actions().len(), 4);
4522        assert!(attach.guidance().contains("Attach"));
4523    }
4524
4525    #[test]
4526    fn browser_recovery_attach_disables_incognito() {
4527        assert_eq!(
4528            browser_recovery_arguments(9222, true),
4529            serde_json::json!({
4530                "port": 9222,
4531                "attach": true,
4532                "incognito": false,
4533            })
4534        );
4535        assert_eq!(
4536            browser_recovery_arguments(42123, false),
4537            serde_json::json!({
4538                "port": 42123,
4539                "attach": false,
4540                "incognito": true,
4541            })
4542        );
4543    }
4544
4545    #[test]
4546    fn browser_target_picker_filters_and_redacts_urls() {
4547        let root = std::env::temp_dir().join(format!("glass-target-picker-{}", std::process::id()));
4548        std::fs::create_dir_all(&root).expect("create temporary workspace");
4549        let mut state =
4550            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4551        state.browser_workspace.replace_targets(vec![
4552            BrowserWorkspaceTarget {
4553                id: "page-docs".into(),
4554                title: "Project docs".into(),
4555                url: "https://example.test/docs?token=secret".into(),
4556                selected: false,
4557            },
4558            BrowserWorkspaceTarget {
4559                id: "page-app".into(),
4560                title: "Application".into(),
4561                url: "http://localhost:3000".into(),
4562                selected: false,
4563            },
4564        ]);
4565        state
4566            .request_browser_target_picker("docs")
4567            .expect("queue target picker");
4568        state.queued_tool_request = None;
4569        let matches = state.browser_target_matches();
4570        assert_eq!(matches, vec![0]);
4571        let view = state.browser_target_picker_view();
4572        assert!(view.contains("Project docs"));
4573        assert!(view.contains("https://example.test/docs"));
4574        assert!(!view.contains("token=secret"));
4575        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4576    }
4577    #[test]
4578    fn agent_typing_opens_composer_before_surface_aliases() {
4579        let root = std::env::temp_dir().join(format!("glass-agent-compose-{}", std::process::id()));
4580        std::fs::create_dir_all(&root).expect("create temporary workspace");
4581        let mut state =
4582            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4583        state.surface = DevSurface::Agent;
4584        state.snapshot_trust_label = "trusted".into();
4585        state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
4586
4587        state.handle_printable('c');
4588
4589        assert_eq!(state.surface, DevSurface::Agent);
4590        assert!(state.composer_mode);
4591        assert_eq!(state.composer_input, "c");
4592        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4593    }
4594
4595    #[test]
4596    fn leading_agent_message_characters_are_not_commands() {
4597        for character in ['a', 'q', 's', 'u', 'l', 'i', 'n'] {
4598            let root = std::env::temp_dir().join(format!(
4599                "glass-agent-leading-{character}-{}",
4600                std::process::id()
4601            ));
4602            std::fs::create_dir_all(&root).expect("create temporary workspace");
4603            let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
4604                .expect("open temporary workspace");
4605            state.surface = DevSurface::Agent;
4606            state.snapshot_trust_label = "trusted".into();
4607            state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
4608
4609            state.handle_printable(character);
4610
4611            assert!(
4612                state.composer_mode,
4613                "character {character:?} did not open composer"
4614            );
4615            assert_eq!(state.composer_input, character.to_string());
4616            std::fs::remove_dir_all(root).expect("remove temporary workspace");
4617        }
4618    }
4619    #[test]
4620    fn action_shortcut_opens_menu_without_stealing_ready_agent_text() {
4621        let root =
4622            std::env::temp_dir().join(format!("glass-action-shortcut-{}", std::process::id()));
4623        std::fs::create_dir_all(&root).expect("create temporary workspace");
4624        let mut state =
4625            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4626
4627        state.surface = DevSurface::Terminal;
4628        state.handle_printable('a');
4629        assert!(state.menu_open);
4630        state.close_menu();
4631
4632        state.surface = DevSurface::Agent;
4633        state.snapshot_trust_label = "trusted".into();
4634        state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
4635        state.handle_printable('a');
4636        assert!(state.composer_mode);
4637        assert_eq!(state.composer_input, "a");
4638
4639        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4640    }
4641
4642    #[test]
4643    fn colon_opens_palette_from_every_surface() {
4644        for surface in DevSurface::ALL {
4645            let root = std::env::temp_dir().join(format!(
4646                "glass-palette-surface-{}-{}",
4647                surface.label(),
4648                std::process::id()
4649            ));
4650            std::fs::create_dir_all(&root).expect("create temporary workspace");
4651            let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
4652                .expect("open temporary workspace");
4653            state.surface = surface;
4654
4655            state.handle_printable(':');
4656
4657            assert!(
4658                state.command_mode,
4659                "colon did not open palette on {surface:?}"
4660            );
4661            assert!(!state.composer_mode);
4662            std::fs::remove_dir_all(root).expect("remove temporary workspace");
4663        }
4664    }
4665    #[test]
4666    fn external_delegate_result_is_visible_in_tui_status() {
4667        let root =
4668            std::env::temp_dir().join(format!("glass-delegate-status-{}", std::process::id()));
4669        std::fs::create_dir_all(&root).expect("create temporary workspace");
4670        let mut state =
4671            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4672        state.running_tool_job = Some(7);
4673        state.apply_tool_job_result(super::super::snapshot::ToolJobResult {
4674            id: 7,
4675            tool: "glass.agent.delegate".into(),
4676            result: Ok(serde_json::json!({
4677                "harness": "codex",
4678                "success": true,
4679                "timedOut": false,
4680                "output": "REAL_RESULT\nsecond line\n",
4681                "stderr": "",
4682            })),
4683        });
4684        assert!(state.status.contains("Temporary codex completed"));
4685        assert!(state.status.contains("REAL_RESULT"));
4686        assert_eq!(state.surface, DevSurface::Agent);
4687        assert!(state.running_tool_job.is_none());
4688        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4689    }
4690
4691    #[test]
4692    fn agent_editor_context_attaches_unsaved_buffer_and_inline_prompt() {
4693        let root =
4694            std::env::temp_dir().join(format!("glass-editor-agent-context-{}", std::process::id()));
4695        std::fs::create_dir_all(root.join("src")).expect("create source directory");
4696        std::fs::write(root.join("src/main.rs"), "fn main() {}\n").expect("write source");
4697        let mut state =
4698            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4699        state
4700            .ws_mut()
4701            .expect("workspace lock")
4702            .project_mut()
4703            .open_buffer("src/main.rs", crate::development::Actor::local())
4704            .expect("open editor buffer");
4705        state
4706            .ws_mut()
4707            .expect("workspace lock")
4708            .project_mut()
4709            .edit_buffer(
4710                "src/main.rs",
4711                "fn main() {\n    println!(\"unsaved\");\n}\n".into(),
4712                crate::development::Actor::local(),
4713            )
4714            .expect("edit buffer");
4715        state.refresh_editor_projection();
4716
4717        let context = state.agent_editor_context();
4718        assert_eq!(context["focusedPath"], "src/main.rs");
4719        assert_eq!(
4720            context["focusedBuffer"]["content"],
4721            "fn main() {\n    println!(\"unsaved\");\n}\n"
4722        );
4723        assert_eq!(context["focusedBuffer"]["dirty"], true);
4724
4725        state.enter_code_edit();
4726        state.edit_code_key(
4727            crossterm::event::KeyCode::Char('a'),
4728            crossterm::event::KeyModifiers::ALT,
4729        );
4730        assert_eq!(state.surface, DevSurface::Agent);
4731        assert!(state.composer_mode);
4732        assert!(!state.code_edit_mode);
4733        assert!(state.composer_input.contains("src/main.rs:1:1"));
4734        assert!(state.composer_input.contains("Do not edit files"));
4735
4736        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4737    }
4738
4739    #[test]
4740    fn editor_soft_wrap_toggle_scrolls_visual_rows_and_resets_horizontal_scroll() {
4741        let root =
4742            std::env::temp_dir().join(format!("glass-editor-soft-wrap-{}", std::process::id()));
4743        std::fs::create_dir_all(root.join("src")).expect("create source directory");
4744        let content = format!("{}\n", "word ".repeat(80));
4745        std::fs::write(root.join("src/main.rs"), content).expect("write source");
4746        let mut state =
4747            DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open temporary workspace");
4748        state
4749            .ws_mut()
4750            .expect("workspace lock")
4751            .project_mut()
4752            .open_buffer("src/main.rs", crate::development::Actor::local())
4753            .expect("open editor buffer");
4754        state
4755            .ws_mut()
4756            .expect("workspace lock")
4757            .project_mut()
4758            .set_buffer_cursor("src/main.rs", 1, 180)
4759            .expect("set editor cursor");
4760        state.refresh_editor_projection();
4761        state.set_terminal_size(32, 16);
4762        state.enter_code_edit();
4763        state.edit_code_key(
4764            crossterm::event::KeyCode::Char('w'),
4765            crossterm::event::KeyModifiers::ALT,
4766        );
4767
4768        assert!(state.editor_soft_wrap);
4769        assert!(state.editor_scroll_line > 0);
4770        assert_eq!(state.editor_scroll_column, 0);
4771        assert!(state.status.contains("Soft wrap ON"));
4772
4773        state.edit_code_key(
4774            crossterm::event::KeyCode::Char('w'),
4775            crossterm::event::KeyModifiers::ALT,
4776        );
4777        assert!(!state.editor_soft_wrap);
4778        assert!(state.editor_scroll_column > 0);
4779        assert!(state.status.contains("Soft wrap OFF"));
4780        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4781    }
4782
4783    #[test]
4784    fn editor_cursor_scroll_matches_fullscreen_source_height() {
4785        let root =
4786            std::env::temp_dir().join(format!("glass-editor-viewport-{}", std::process::id()));
4787        std::fs::create_dir_all(root.join("src")).expect("create source directory");
4788        let content = (1..=30)
4789            .map(|line| format!("line {line}\n"))
4790            .collect::<String>();
4791        std::fs::write(root.join("src/main.rs"), content).expect("write source");
4792        let mut state =
4793            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4794        state
4795            .ws_mut()
4796            .expect("workspace lock")
4797            .project_mut()
4798            .open_buffer("src/main.rs", crate::development::Actor::local())
4799            .expect("open editor buffer");
4800        state
4801            .ws_mut()
4802            .expect("workspace lock")
4803            .project_mut()
4804            .set_buffer_cursor("src/main.rs", 23, 1)
4805            .expect("set editor cursor");
4806        state.refresh_editor_projection();
4807        state.editor_scroll_line = 0;
4808        state.set_terminal_size(100, 30);
4809
4810        assert_eq!(state.focused_editor_line, 23);
4811        assert_eq!(
4812            state.editor_scroll_line, 1,
4813            "line 23 must scroll into the 22-row source viewport"
4814        );
4815        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4816    }
4817
4818    #[test]
4819    fn editor_shift_selection_replaces_text_and_clears_anchor() {
4820        let root =
4821            std::env::temp_dir().join(format!("glass-editor-selection-{}", std::process::id()));
4822        std::fs::create_dir_all(root.join("src")).expect("create source directory");
4823        std::fs::write(root.join("src/main.rs"), "alpha\nbeta\n").expect("write source");
4824        let mut state =
4825            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4826        state
4827            .ws_mut()
4828            .expect("workspace lock")
4829            .project_mut()
4830            .open_buffer("src/main.rs", crate::development::Actor::local())
4831            .expect("open editor buffer");
4832        state.refresh_editor_projection();
4833        state.enter_code_edit();
4834        for _ in 0..5 {
4835            state.edit_code_key(
4836                crossterm::event::KeyCode::Right,
4837                crossterm::event::KeyModifiers::SHIFT,
4838            );
4839        }
4840        assert!(
4841            state
4842                .focused_editor_selection
4843                .as_ref()
4844                .is_some_and(|selection| !selection.is_empty())
4845        );
4846        state.edit_code_key(
4847            crossterm::event::KeyCode::Char('X'),
4848            crossterm::event::KeyModifiers::empty(),
4849        );
4850        let buffer = state.focused_buffer().expect("focused editor buffer");
4851        assert_eq!(buffer.content, "X\nbeta\n");
4852        assert_eq!((buffer.cursor_line, buffer.cursor_column), (1, 2));
4853        assert!(buffer.selection.is_none());
4854        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4855    }
4856
4857    #[test]
4858    fn editor_exit_prompts_save_discard_and_discard_quit() {
4859        let root = std::env::temp_dir().join(format!("glass-editor-exit-{}", std::process::id()));
4860        std::fs::create_dir_all(root.join("src")).expect("create source directory");
4861        let original = "fn main() {}\n";
4862        std::fs::write(root.join("src/main.rs"), original).expect("write source");
4863        let mut state =
4864            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4865        state
4866            .ws_mut()
4867            .expect("workspace lock")
4868            .project_mut()
4869            .open_buffer("src/main.rs", crate::development::Actor::local())
4870            .expect("open editor buffer");
4871        state.refresh_editor_projection();
4872        state.enter_code_edit();
4873        state.edit_code_key(
4874            crossterm::event::KeyCode::Char('#'),
4875            crossterm::event::KeyModifiers::NONE,
4876        );
4877        state.request_editor_exit();
4878        assert_eq!(state.editor_exit_prompt, Some(EditorExitPrompt::Unsaved));
4879        state.handle_editor_exit_key(crossterm::event::KeyCode::Char('d'));
4880        assert!(!state.code_edit_mode);
4881        assert_eq!(
4882            std::fs::read_to_string(root.join("src/main.rs")).expect("read source"),
4883            original
4884        );
4885
4886        state.enter_code_edit();
4887        state.edit_code_key(
4888            crossterm::event::KeyCode::Char('#'),
4889            crossterm::event::KeyModifiers::NONE,
4890        );
4891        state.request_editor_exit();
4892        state.handle_editor_exit_key(crossterm::event::KeyCode::Char('s'));
4893        assert!(!state.code_edit_mode);
4894        assert!(
4895            std::fs::read_to_string(root.join("src/main.rs"))
4896                .expect("read saved source")
4897                .starts_with('#')
4898        );
4899        let saved = std::fs::read_to_string(root.join("src/main.rs")).expect("read saved source");
4900
4901        state.enter_code_edit();
4902        state.edit_code_key(
4903            crossterm::event::KeyCode::Char('!'),
4904            crossterm::event::KeyModifiers::NONE,
4905        );
4906        state.request_editor_exit();
4907        state.handle_editor_exit_key(crossterm::event::KeyCode::Char('q'));
4908        assert!(state.quit);
4909        assert_eq!(
4910            std::fs::read_to_string(root.join("src/main.rs")).expect("read discarded source"),
4911            saved
4912        );
4913        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4914    }
4915
4916    #[test]
4917    fn conversation_view_does_not_echo_pending_message_after_snapshot() {
4918        let root = std::env::temp_dir().join(format!("glass-chat-merge-{}", std::process::id()));
4919        std::fs::create_dir_all(&root).expect("create temporary workspace");
4920        let mut state =
4921            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4922        state.agent_conversation = "YOU\ninspect the failing test\n\nGLASS AGENT\nworking".into();
4923        state.pending_chat_messages.push(PendingChatMessage {
4924            text: "inspect the failing test".into(),
4925            state: ChatMessageState::Sent,
4926            job_id: None,
4927            error: None,
4928        });
4929
4930        let view = state.conversation_view();
4931        assert_eq!(view.matches("YOU\ninspect the failing test").count(), 1);
4932        assert!(!view.contains("Glass Agent is thinking"));
4933
4934        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4935    }
4936
4937    #[test]
4938    fn palette_filters_actions_and_prefills_selected_arguments() {
4939        let root =
4940            std::env::temp_dir().join(format!("glass-palette-actions-{}", std::process::id()));
4941        std::fs::create_dir_all(&root).expect("create temporary workspace");
4942        let mut state =
4943            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4944        state.surface = DevSurface::Agent;
4945        state.open_palette();
4946        state.insert_palette_text("agent setup");
4947        assert_eq!(
4948            state.selected_palette_action().map(|action| action.label),
4949            Some("Setup Pi runtime")
4950        );
4951        state.move_palette_selection(1);
4952        assert_eq!(
4953            state.selected_palette_action().map(|action| action.label),
4954            Some("Authenticate")
4955        );
4956
4957        state.open_palette_with("agent rewind ENTRY_ID");
4958        let action = state.selected_palette_action().expect("rewind action");
4959        assert_eq!(action.label, "Rewind Pi session");
4960        assert!(state.prepare_palette_action(action).is_none());
4961        assert!(state.command_mode);
4962        assert_eq!(state.command_input, "agent rewind ");
4963        assert!(state.status.contains("required value"));
4964
4965        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4966    }
4967
4968    #[test]
4969    fn arrow_surface_cycle_matches_layout_order() {
4970        let root =
4971            std::env::temp_dir().join(format!("glass-surface-arrows-{}", std::process::id()));
4972        std::fs::create_dir_all(&root).expect("create temporary workspace");
4973        let mut desktop =
4974            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open desktop workspace");
4975        desktop.surface = DevSurface::Agent;
4976        desktop.next_surface();
4977        assert_eq!(desktop.surface, DevSurface::Code);
4978        assert_eq!(desktop.status, "Code selected");
4979        desktop.previous_surface();
4980        assert_eq!(desktop.surface, DevSurface::Agent);
4981        desktop.surface = DevSurface::Debug;
4982        desktop.next_surface();
4983        assert_eq!(desktop.surface, DevSurface::More);
4984        desktop.next_surface();
4985        assert_eq!(desktop.surface, DevSurface::Agent);
4986
4987        let mut phone =
4988            DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open phone workspace");
4989        phone.surface = DevSurface::Agent;
4990        phone.previous_surface();
4991        assert_eq!(phone.surface, DevSurface::More);
4992        assert_eq!(phone.status, "More selected");
4993        phone.next_surface();
4994        assert_eq!(phone.surface, DevSurface::Agent);
4995
4996        std::fs::remove_dir_all(root).expect("remove temporary workspace");
4997    }
4998}